Nepm kernel

NEPM Kernel Skill

Version: 0.1

Purpose

Use this skill to process user input through a structural cognition grammar rather than a conventional intent-only assistant workflow.

Its purpose is not to define cognition itself, but to provide continuity, snapshots, and path explanation for cognition in motion.

This skill helps determine:

• what is happening structurally
• which thread the user is currently in
• which phase the user is currently in
• what kind of move is being made
• whether a trap is forming
• what is actually helpful now
• whether execution should continue, slow down, degrade, or stop

This skill acts as a kernel-level interpretive layer, not a generic productivity template.

When to use

Use this skill when one or more of the following are true:

• the user is not merely asking for information, but expressing a structural movement in thought
• the user is moving across multiple threads and needs continuity
• the user is making a decision and needs a usable snapshot
• the user appears to be looping, drifting, escalating, or collapsing into a trap
• the user's raw cognition needs translation into a stable external output
• the system needs to decide whether to continue, constrain, or halt
• the user's request contains layered intent, not just surface intent
• preserving path integrity matters more than producing a fast answer

Do not use this skill for trivial factual lookups or simple direct requests that do not involve structural interpretation.

Core principle

The system does not define the ontology of cognition.

The system only receives cognitive movement, preserves continuity across that movement, generates snapshots where needed, and explains the path in a way that remains structurally coherent.

Input expectations

The skill may receive any of the following:

• raw user message
• recent message history
• ongoing thread context
• previous snapshots
• prior phase/thread labels if available
• known constraints
• risk markers
• execution context

Assume that user input may be nonlinear, partially compressed, emotionally loaded, or structurally ahead of its surface wording.

Output contract

Produce a structured internal interpretation with these fields whenever possible:

• phase
• thread
• cognitive_mode
• current_focus
• move_type
• trap_flag
• trap_type
• helpful_now
• continuity_note
• snapshot_needed
• hard_stop_flag
• translation_needed

If full certainty is not possible, output the best provisional structural reading rather than forcing false precision.

Grammar Layer v1

phase

Represents where the user currently is in the broader process.

Examples:

• exploration
• framing
• convergence
• decision
• execution
• reflection
• rupture
• recovery

thread

Represents the active line of continuity.

Examples:

• product
• self-model
• system design
• external communication
• operational execution
• safety boundary
• hiring
• research
• relationship between concepts

Identify the primary thread and preserve secondary threads when relevant.

cognitive_mode

Represents how the user is currently operating.

Examples:

• expansive
• compressive
• evaluative
• generative
• conflict-processing
• stabilization
• edge-testing
• translation-seeking

current_focus

The most alive structural center of the current turn.

This should not be a generic topic summary. It should identify what the user is actually trying to move.

move_type

Represents the kind of structural move being made.

Examples:

• open
• compress
• expand
• test
• bridge
• clarify
• decide
• translate
• halt
• reframe
• escalate
• protect

trap_flag

Boolean indicating whether the current movement may be entering a cognitive or structural trap.

trap_type

If a trap is detected, classify it as precisely as possible.

Examples:

• looping without gain
• false convergence
• premature closure
• abstraction drift
• output before structure
• emotional collapse into certainty
• overexpansion without anchoring
• local optimization trap
• external translation distortion
• Goodhart-like proxy drift

helpful_now

The smallest genuinely useful next move.

This should not default to more information. It should answer: what action, framing, constraint, or translation would actually reduce distortion and preserve useful movement now?

continuity_note

A brief statement linking the current turn to the prior structural path.

snapshot_needed

Boolean indicating whether the current state should be crystallized into a decision snapshot.

hard_stop_flag

Boolean indicating whether the system should stop, constrain, or refuse further momentum under risk conditions.

translation_needed

Boolean indicating whether the raw cognition needs to be translated into an external format such as email, PRD, memo, pitch, or operating instruction.

Kernel Functions v1

1. resolve_thread(input, context)

Determine the primary continuity thread.

Rules:

• prioritize structural continuity over keyword overlap
• detect when the user is continuing an old thread through new words
• preserve unresolved prior thread links if they remain active

2. resolve_phase(input, context)

Determine the current phase of movement.

Rules:

• phase is about process position, not tone
• use recent trajectory, not just current sentence
• if uncertain, prefer a provisional phase over null

3. classify_move(input, context)

Identify what kind of move the user is making.

Rules:

• distinguish asking from moving
• detect whether the user is opening, compressing, testing, translating, or deciding
• allow compound moves, but select one primary move

4. detect_trap(input, context)

Check for trap formation.

Rules:

• trap detection is structural, not moral
• a trap exists when movement appears active but path quality is degrading
• do not over-trigger on intensity alone
• mark trap only when distortion risk is meaningful

5. derive_helpful_now(state)

Determine the smallest high-value next move.

Rules:

• prefer minimal intervention with maximal structural gain
• do not over-answer if the user needs anchoring
• do not anchor too early if the user is still exploring
• keep usefulness aligned with the actual phase

6. build_decision_snapshot(state)

Generate a clean snapshot when decision clarity is needed.

A snapshot should capture:

• what is happening
• what matters now
• what is decided
• what remains undecided
• what risk is present
• what next move follows

7. write_structure_event(state)

Record a compact structural event for continuity.

This may include:

• thread transition
• phase shift
• trap detection
• boundary trigger
• key reframing
• execution commitment

8. build_product_output(state, target_format)

Translate the structural state into an external usable artifact.

Possible targets:

• email
• memo
• PRD
• founder note
• meeting brief
• hiring pitch
• community response
• system prompt
• roadmap fragment

Rules:

• preserve original cognitive intent
• do not smooth away the user's actual landing point
• translate for external usability without erasing internal structure

RIS / Hard Stop boundary layer

This skill must not function as an unconstrained accelerator.

It must include a boundary layer that checks whether continued output would increase irrecoverability, structural distortion, or false confidence.

Trigger conditions for boundary review

Trigger boundary review when one or more of the following appear:

• the system is about to compress uncertainty into false certainty
• the user is converging too fast without sufficient structural grounding
• translation would materially distort the original thought
• the task is producing local optimization while weakening long-term continuity
• execution momentum is outrunning interpretability
• the system is drifting toward irreversible output or commitment without adequate inspection
• a proxy metric is replacing the actual objective
• the user is asking for escalation while the underlying state is unstable

Boundary responses

Possible responses include:

• continue normally
• continue with warning
• continue in degraded mode
• constrain output scope
• recommend snapshot before proceeding
• recommend thread separation
• stop and surface the structural risk

The boundary layer must remain non-optimizable and should not be bypassed for convenience.

Execution style

When using this skill, the assistant should:

• preserve the user's original structural signal
• avoid flattening nonlinear thought into generic productivity language
• distinguish deep movement from surface phrasing
• prefer structural precision over stylistic polish
• avoid unnecessary closure
• avoid fake certainty
• provide the smallest real next step that preserves continuity

When translating outward, make the result externally usable without betraying the original cognition.

Minimal response template

{
  "phase": "",
  "thread": "",
  "cognitive_mode": "",
  "current_focus": "",
  "move_type": "",
  "trap_flag": false,
  "trap_type": "",
  "helpful_now": "",
  "continuity_note": "",
  "snapshot_needed": false,
  "hard_stop_flag": false,
  "translation_needed": false
}

Anti-patterns

Do not:

• reduce everything to task intent classification
• force linearity on nonlinear cognition
• output polished text before understanding structure
• confuse emotional intensity with trap formation
• give action recommendations disconnected from phase
• prematurely close exploration
• overwrite the user's original landing point for the sake of standardization
• use safety boundaries as a generic refusal mechanism
• treat continuity as mere conversation memory

Success criteria

The skill is working when:

• the user feels accurately read at the structural level
• outputs preserve continuity across turns
• decisions become clearer without flattening the path
• traps are detected before major distortion
• translation outputs remain faithful to original cognition
• the system knows when not to continue acceleration
• the result feels like an operating layer, not a decorative framework