help

<skill id="help">

<purpose>

Quick reference for KERNEL v9.11.0.

One primitive: skills (methodology, workflows, state transitions, validators,

operators). Agents, manifests, philosophy, and current plugin status.

</purpose>

<host_invocation>

Claude Code invokes skills as /kernel:<name>. Codex invokes them as

$kernel:<name>. Tables below use Claude Code syntax; Codex users replace the

leading slash with a dollar sign.

</host_invocation>

<on_start>

Before showing help, check the actual state of the plugin as loaded in your context:

1. Is the session-start hook output visible? (Look for "# KERNEL" at conversation start)
2. Which profile is active? (local, github, github-oss, github-production)
3. Are there active contracts or pending reviews in AgentDB?
4. Report what you see, don't just recite docs.

agentdb recall "<feature> <subsystem> <files/symbols> <error/outcome>" --global

</on_start>

<getting_started>

| What you want | What to type |

|---------------|--------------|

| Set up a new project | /kernel:init |

| Start working on anything | /kernel:ingest + describe task |

| Run autonomously overnight | /kernel:forge + describe goal |

| Explore approaches creatively | /kernel:dream + describe problem |

| Debug something broken | /kernel:debug + describe symptom |

| Save progress before stopping | /kernel:handoff |

</getting_started>

<skills_reference>

Core Workflow (kind: workflow)

| Skill | Purpose | When to use |

|-------|---------|-------------|

| /kernel:ingest | Guided entry, classify, scope, execute | Default for any task. Human confirms each phase. |

| /kernel:forge | Autonomous engine, heat/hammer/quench/anneal | Run overnight. Iterates until antifragile or reports why not. |

| /kernel:dream | Creative exploration, 3 perspectives + stress test | When you need competing approaches before committing. |

| /kernel:debug | Diagnosis before prescription | Bugs, regressions, or mapping a refactor. Bug mode and refactor mode. |

| /kernel:simplify | Cut cyclomatic complexity with AST-aware budgets, regression diffs, and a project gate | Jungle code, god functions, after any AI-written branchy function. A number, not an opinion. |

Quality & Review (kind: validator)

| Skill | Purpose | When to use |

|-------|---------|-------------|

| /kernel:validate | Pre-commit gates, build, lint, test, security | Before every commit. Blocks on failure. |

| /kernel:tearitapart | Critical pre-implementation review | Before tier 2+ work. Verdict: PROCEED/REVISE/RETHINK. |

| /kernel:review | Code review for PRs or staged changes | Before merging. >80% confidence threshold. |

Learning & Observability

| Skill | Purpose | When to use |

|-------|---------|-------------|

| /kernel:retrospective | Cross-session learning synthesis | When 5+ learnings accumulated. Clusters, deduplicates, promotes patterns into project hooks/agents/skills. |

| /kernel:metrics | Observability dashboard | Check session stats, agent success rates, hook health, learning utilization. |

State Operations (kind: state_transition) — json-first

| Skill | Emits | When to use |

|-------|-------|-------------|

| /kernel:handoff | kernel.handoff/v1 json manifest | Ending a session. Pins provenance, decisions, phases, context policy + budget. |

| /kernel:checkpoint | kernel.checkpoint/v1 json manifest | MID-task save: safe context reset without full handoff ceremony. |

| /kernel:retrospective | kernel.retrospective-result/v1 mutation record | 5+ learnings accumulated; promotes via artifact ladder. |

| /kernel:ingest (resume) | kernel.context-receipt/v1 | Resuming: validates the manifest, checks divergence, compiles bounded context. |

Manifest CLI: orchestration/manifest/kernel-manifest (validate | latest | divergence |

preflight | compile | resume | activate | deactivate). Context policies: sealed (hook-blocked

forbidden globs) | bounded (extra loads ledgered) | advisory. Details: docs/MIGRATION-8.md.

Setup

| Skill | Purpose | When to use |

|-------|---------|-------------|

| /kernel:init | Confirm Vaults, create missing data dirs and three safe helper links | Once per machine, or helper-link recovery. |

| /kernel:help | This help | When you need a reminder. |

</skills_reference>

<flow_examples>

Typical flows, skills chain together:

New feature:

ingest → (dream if complex) → tearitapart → execute → validate → review → handoff

Bug fix:

diagnose → ingest (with diagnosis) → validate → review

Overnight autonomous:

forge (runs heat/hammer/quench/anneal loop, ships when antifragile)

End of session:

retrospective (if learnings accumulated) → handoff

Long task, context filling up:

checkpoint → /clear → ingest (auto-discovers the checkpoint, resumes bounded)

</flow_examples>

<tiers>

Tier by reversibility x silence x blast radius; file count is only a weak hint.

| Tier | Risk profile | Your Role | Skills involved |

|------|--------------|-----------|-------------------|

| 1 | easy to undo, loud if wrong | Execute directly | ingest → validate |

| 2 | persistent or moderately quiet | Orchestrate, spawn surgeon | ingest → tearitapart → validate → review |

| 3 | hard to undo, quiet, wide blast | Orchestrate, surgeon + adversary | ingest → tearitapart → validate → review |

</tiers>

<agents>

These are Claude Code agent definitions. Codex does not register the files as native

agents; KERNEL applies the role contracts to available Codex subagents.

| Agent | Role |

|-------|------|

| Surgeon | Minimal diff implementation. Only touches contract-listed files. |

| Adversary | QA, assumes broken, finds edge cases, proves with evidence. |

| Reviewer | Code review with APPROVE/REQUEST CHANGES/COMMENT verdict. |

| Researcher | Finds proven solutions and anti-patterns before coding. |

| Scout | Codebase reconnaissance, maps structure, detects tooling. |

| Validator | Pre-commit quality gate, build, types, lint, tests, security. |

| Dreamer | Multi-perspective debate, minimalist/maximalist/pragmatist. |

</agents>

<lifecycle>

Claude Code runs the full declared plugin lifecycle. Codex runs supported synchronous

events, including SessionStart and write guards, but skips asynchronous command hooks

and has no plugin SessionEnd event. In Codex, use $kernel:handoff explicitly when

durable end-of-session state is required.

</lifecycle>

<philosophy>

<principle id="research_first">Research anti-patterns before solutions. Most problems are already solved.</principle>

<principle id="tests_first">Define success before coding. Tests before implementation.</principle>

<principle id="agentdb">Recall task context before acting. Recall again as the task changes. Write at end.</principle>

<principle id="big5">Big 5: input validation, edge cases, error handling, duplication, complexity.</principle>

<principle id="builtin">Built-in beats library. Library beats custom. Prove you need complexity.</principle>

</philosophy>

<tips>

• Be specific: "Add rate limiting to /api/upload" > "make it more secure"
• Use the right skill: diagnose for bugs, dream for design, ingest for everything else
• Check metrics: /kernel:metrics shows if learnings are being used or ignored
• Save deliberately: /kernel:checkpoint mid-task or /kernel:handoff before a session boundary
• Run retrospective: After several sessions, synthesize what you've learned

</tips>

</skill>