@soleri/forge 5.13.1 → 5.14.1

package/src/templates/inject-claude-md.ts

@@ -16,27 +16,27 @@ export function generateInjectClaudeMd(config: AgentConfig): string {
     "import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';",
     "import { homedir } from 'node:os';",
     "import { join } from 'node:path';",
-    "import { getClaudeMdContent, getClaudeMdMarker } from './claude-md-content.js';",
+    "import { getClaudeMdContent, getClaudeMdMarker, getEngineRulesContent, getEngineRulesMarker } from './claude-md-content.js';",
     '',
     'export interface InjectResult {',
     '  injected: boolean;',
     '  path: string;',
     "  action: 'created' | 'updated' | 'appended';",
+    '  engineRules?: boolean;',
     '}',
     '',
     '/**',
-    ' * Inject into a specific CLAUDE.md file path.',
-    ' * Shared logic for both project-level and global injection.',
+    ' * Inject a marker-delimited block into a file.',
+    ' * If the marker already exists, replaces the content between markers.',
+    ' * Otherwise appends (or creates the file).',
     ' */',
-    'function injectIntoFile(filePath: string): InjectResult {',
-    '  const content = getClaudeMdContent();',
-    '  const marker = getClaudeMdMarker();',
+    "function injectBlock(filePath: string, content: string, marker: string): 'created' | 'updated' | 'appended' | 'skipped' {",
     `  const startMarker = '<!-- ' + marker + ' -->';`,
     `  const endMarker = '<!-- /' + marker + ' -->';`,
     '',
     '  if (!existsSync(filePath)) {',
     "    writeFileSync(filePath, content + '\\n', 'utf-8');",
-    "    return { injected: true, path: filePath, action: 'created' };",
+    "    return 'created';",
     '  }',
     '',
     "  const existing = readFileSync(filePath, 'utf-8');",
@@ -47,30 +47,52 @@ export function generateInjectClaudeMd(config: AgentConfig): string {
     '    if (endIdx === -1) {',
     "      const updated = existing.slice(0, startIdx) + content + '\\n' + existing.slice(startIdx + startMarker.length);",
     "      writeFileSync(filePath, updated, 'utf-8');",
-    "      return { injected: true, path: filePath, action: 'updated' };",
+    "      return 'updated';",
     '    }',
     '    const updated = existing.slice(0, startIdx) + content + existing.slice(endIdx + endMarker.length);',
     "    writeFileSync(filePath, updated, 'utf-8');",
-    "    return { injected: true, path: filePath, action: 'updated' };",
+    "    return 'updated';",
     '  }',
     '',
     "  const separator = existing.endsWith('\\n') ? '\\n' : '\\n\\n';",
     "  writeFileSync(filePath, existing + separator + content + '\\n', 'utf-8');",
-    "  return { injected: true, path: filePath, action: 'appended' };",
+    "  return 'appended';",
+    '}',
+    '',
+    '/**',
+    ' * Inject engine rules + agent block into a CLAUDE.md file.',
+    ' *',
+    ' * Engine rules (shared, prefix-free) are injected ONCE under',
+    ' * `<!-- soleri:engine-rules -->`. If already present, they are updated.',
+    ' * Agent block (identity + facade table) is injected under',
+    ` * \`<!-- ${marker} -->\`.`,
+    ' */',
+    'function injectIntoFile(filePath: string): InjectResult {',
+    '  // Step 1: Engine rules — shared across all agents',
+    '  const engineAction = injectBlock(filePath, getEngineRulesContent(), getEngineRulesMarker());',
+    '',
+    '  // Step 2: Agent-specific block',
+    '  const agentAction = injectBlock(filePath, getClaudeMdContent(), getClaudeMdMarker());',
+    '',
+    '  return {',
+    '    injected: true,',
+    '    path: filePath,',
+    "    action: agentAction === 'skipped' ? 'appended' : agentAction,",
+    "    engineRules: engineAction !== 'skipped',",
+    '  };',
     '}',
     '',
     '/**',
     ' * Inject agent CLAUDE.md section into a project.',
-    ' * - If no CLAUDE.md exists: creates one',
-    ' * - If markers found: replaces content between them (update)',
-    ' * - If no markers: appends section to end',
+    ' * - Engine rules: injected once, updated if already present',
+    ' * - Agent block: created, updated, or appended',
     ' */',
     'export function injectClaudeMd(projectPath: string): InjectResult {',
     "  return injectIntoFile(join(projectPath, 'CLAUDE.md'));",
     '}',
     '',
     '/**',
-    ' * Inject agent CLAUDE.md section into the global ~/.claude/CLAUDE.md.',
+    ' * Inject into the global ~/.claude/CLAUDE.md.',
     " * Creates ~/.claude/ directory if it doesn't exist.",
     ' * This makes the activation phrase work in any project.',
     ' */',
@@ -83,39 +105,48 @@ export function generateInjectClaudeMd(config: AgentConfig): string {
     '}',
     '',
     '/**',
-    ' * Remove agent section from a specific CLAUDE.md file.',
-    ' * Returns true if the section was found and removed.',
+    ' * Remove a marker-delimited block from a file.',
     ' */',
-    'function removeFromFile(filePath: string): { removed: boolean; path: string } {',
-    '  if (!existsSync(filePath)) return { removed: false, path: filePath };',
+    'function removeBlock(filePath: string, marker: string): boolean {',
+    '  if (!existsSync(filePath)) return false;',
     "  const existing = readFileSync(filePath, 'utf-8');",
-    '  const marker = getClaudeMdMarker();',
     `  const startMarker = '<!-- ' + marker + ' -->';`,
     `  const endMarker = '<!-- /' + marker + ' -->';`,
     '  const startIdx = existing.indexOf(startMarker);',
-    '  if (startIdx === -1) return { removed: false, path: filePath };',
+    '  if (startIdx === -1) return false;',
     '  const endIdx = existing.indexOf(endMarker);',
-    '  if (endIdx === -1) return { removed: false, path: filePath };',
+    '  if (endIdx === -1) return false;',
     "  const before = existing.slice(0, startIdx).replace(/\\n+$/, '');",
     "  const after = existing.slice(endIdx + endMarker.length).replace(/^\\n+/, '');",
     "  const cleaned = before + (before && after ? '\\n\\n' : '') + after;",
     "  writeFileSync(filePath, cleaned || '', 'utf-8');",
-    '  return { removed: true, path: filePath };',
+    '  return true;',
     '}',
     '',
     '/**',
     ' * Remove agent section from the global ~/.claude/CLAUDE.md.',
-    ' * Called on deactivation to clean up after test agents.',
+    ' * Only removes the agent block, NOT the shared engine rules',
+    ' * (other agents may depend on them).',
     ' */',
     'export function removeClaudeMdGlobal(): { removed: boolean; path: string } {',
-    "  return removeFromFile(join(homedir(), '.claude', 'CLAUDE.md'));",
+    "  const filePath = join(homedir(), '.claude', 'CLAUDE.md');",
+    '  return { removed: removeBlock(filePath, getClaudeMdMarker()), path: filePath };',
     '}',
     '',
     '/**',
     ' * Remove agent section from a project CLAUDE.md.',
     ' */',
     'export function removeClaudeMd(projectPath: string): { removed: boolean; path: string } {',
-    "  return removeFromFile(join(projectPath, 'CLAUDE.md'));",
+    "  const filePath = join(projectPath, 'CLAUDE.md');",
+    '  return { removed: removeBlock(filePath, getClaudeMdMarker()), path: filePath };',
+    '}',
+    '',
+    '/**',
+    ' * Remove shared engine rules from a file.',
+    ' * Use only when NO agents remain in the file.',
+    ' */',
+    'export function removeEngineRules(filePath: string): boolean {',
+    '  return removeBlock(filePath, getEngineRulesMarker());',
     '}',
     '',
     '/**',
@@ -126,5 +157,14 @@ export function generateInjectClaudeMd(config: AgentConfig): string {
     "  const content = readFileSync(filePath, 'utf-8');",
     `  return content.includes('<!-- ${marker} -->');`,
     '}',
+    '',
+    '/**',
+    ' * Check if engine rules are already present in a CLAUDE.md file.',
+    ' */',
+    'export function hasEngineRules(filePath: string): boolean {',
+    '  if (!existsSync(filePath)) return false;',
+    "  const content = readFileSync(filePath, 'utf-8');",
+    "  return content.includes('<!-- ' + getEngineRulesMarker() + ' -->');",
+    '}',
   ].join('\n');
 }

package/src/templates/shared-rules.ts

@@ -1,126 +1,264 @@
 /**
- * Shared behavioral rules that every Soleri agent ships with.
+ * Shared Soleri engine rules — agent-agnostic.
  *
- * These rules are agent-agnostic and mirror the quality of Salvador's
- * hand-crafted CLAUDE.md behavioral sections. They cover:
- * - Vault-first knowledge protocol
- * - Planning enforcement (two-gate approval)
- * - Output formatting (plan metadata tables, drift reports)
- * - Knowledge capture discipline
- * - Intent routing
- * - Session lifecycle
+ * These rules are injected ONCE into global ~/.claude/CLAUDE.md under
+ * the `<!-- soleri:engine-rules -->` marker. They describe behavioral
+ * rules WITHOUT tool prefixes. The active agent's facade table (in its
+ * own `<!-- agent-id:mode -->` block) maps op names to actual tools.
+ *
+ * Uses op:name syntax — the active agent provides the tool prefix.
  */
 
-/** Returns markdown lines for all shared behavioral sections. */
-export function getSharedRules(toolPrefix: string): string[] {
-  const bt = '`';
-
-  return [
-    // ─── Vault-First Protocol ────────────────────────────────
-    '## Vault as Source of Truth',
-    '',
-    'Before every decision — planning, design, architecture, problem-solving — consult the vault.',
-    '',
-    '**Lookup order:**',
-    `1. Vault — ${bt}${toolPrefix}_core op:search_intelligent params:{ query: "..." }${bt}`,
-    '2. Codebase — only if vault has nothing',
-    '3. Web / training knowledge — last resort',
-    '',
-    'If the vault has a pattern, follow it. If it has an anti-pattern, avoid it.',
-    '',
-
-    // ─── Planning Enforcement ────────────────────────────────
-    '## Planning',
-    '',
-    'For multi-step tasks, use the planning system. **Never skip gates.**',
-    '',
-    '**Lifecycle:**',
-    `${bt}draft → approved (Gate 1) → tasks approved (Gate 2) → executing → reconciling → completed${bt}`,
-    '',
-    '**Sequence:**',
-    `1. Create: ${bt}${toolPrefix}_core op:create_plan params:{ objective: "...", scope: "...", tasks: [...] }${bt}`,
-    `2. Approve plan (Gate 1): ${bt}${toolPrefix}_core op:approve_plan params:{ planId: "..." }${bt}`,
-    `3. Split tasks (Gate 2): ${bt}${toolPrefix}_core op:plan_split params:{ planId: "..." }${bt}`,
-    `4. Track: ${bt}${toolPrefix}_core op:update_task params:{ planId: "...", taskId: "...", status: "completed" }${bt}`,
-    `5. Reconcile: ${bt}${toolPrefix}_core op:plan_reconcile params:{ planId: "..." }${bt}`,
-    `6. Complete: ${bt}${toolPrefix}_core op:plan_complete_lifecycle params:{ planId: "..." }${bt}`,
-    '',
-    'Wait for explicit user approval before proceeding past each gate.',
-    'Check activation response for recovered plans in `executing` state — remind the user.',
-    '',
-    '**Exceptions:** Read-only operations, user says "just do it", single-line fixes.',
-    '',
-
-    // ─── Output Formatting ───────────────────────────────────
-    '## Output Formatting',
-    '',
-    '**Plan metadata** — always show at top of every plan summary:',
-    '',
-    '| Field | Value |',
-    '|-------|-------|',
-    '| **Plan ID** | {planId} |',
-    '| **Check ID** | {checkId} |',
-    '| **Grade** | {grade} ({score}/100) |',
-    '| **Status** | {status} |',
-    '',
-    '**Drift reports:**',
-    '',
-    '| Field | Value |',
-    '|-------|-------|',
-    '| **Accuracy** | {accuracyScore}/100 |',
-    '| **Drift Items** | {count} |',
-    '',
-    '| Type | Description | Impact |',
-    '|------|-------------|--------|',
-    '| skipped | ... | medium |',
-    '',
-
-    // ─── Knowledge Capture ───────────────────────────────────
-    '## Knowledge Capture',
-    '',
-    "When learning something that should persist, capture it — don't just promise to remember.",
-    '',
-    `- Domain knowledge: ${bt}${toolPrefix}_core op:capture_quick params:{ title: "...", description: "..." }${bt}`,
-    `- Batch capture: ${bt}${toolPrefix}_core op:capture_knowledge params:{ entries: [...] }${bt}`,
-    `- Intelligent search: ${bt}${toolPrefix}_core op:search_intelligent params:{ query: "..." }${bt}`,
-    '',
-
-    // ─── Intent Detection ────────────────────────────────────
-    '## Intent Detection',
-    '',
-    'A UserPromptSubmit hook auto-classifies prompts. When you see a `[MODE-NAME]` indicator:',
-    '',
-    `1. Call ${bt}${toolPrefix}_core op:route_intent params:{ prompt: "<user message>" }${bt}`,
-    '2. Follow the returned behavior rules',
-    '3. Briefly acknowledge mode changes',
-    '',
-    '| Signal | Intent |',
-    '|--------|--------|',
-    '| Problem described ("broken", "janky", "weird") | FIX |',
-    '| Need expressed ("I need", "we should have") | BUILD |',
-    '| Quality questioned ("is this right?") | REVIEW |',
-    '| Advice sought ("how should I", "best way") | PLAN |',
-    '| Improvement requested ("make it faster") | IMPROVE |',
-    '| Ready to ship ("deploy", "release") | DELIVER |',
-    '',
-
-    // ─── Session Lifecycle ───────────────────────────────────
-    '## Session Lifecycle',
-    '',
-    'A PreCompact hook calls `session_capture` before context compaction.',
-    `Manual capture: ${bt}${toolPrefix}_core op:session_capture params:{ summary: "..." }${bt}`,
-    '',
-
-    // ─── Orchestration ───────────────────────────────────────
-    '## Orchestration',
-    '',
-    'For complex workflows, use the orchestration layer instead of manual planning:',
-    '',
-    `1. Plan: ${bt}${toolPrefix}_core op:orchestrate_plan params:{ prompt: "...", projectPath: "." }${bt}`,
-    `2. Execute: ${bt}${toolPrefix}_core op:orchestrate_execute params:{ planId: "..." }${bt}`,
-    `3. Complete: ${bt}${toolPrefix}_core op:orchestrate_complete params:{ planId: "..." }${bt}`,
-    '',
-    'The orchestrator handles vault lookup, brain recommendations, and knowledge capture automatically.',
-    '',
-  ];
+const ENGINE_MARKER = 'soleri:engine-rules';
+
+export function getEngineMarker(): string {
+  return ENGINE_MARKER;
 }
+
+/** Returns the full engine rules markdown content (with markers). */
+export function getEngineRulesContent(): string {
+  return ENGINE_RULES_LINES.join('\n');
+}
+
+const ENGINE_RULES_LINES: string[] = [
+  `<!-- ${ENGINE_MARKER} -->`,
+  '',
+  '# Soleri Engine Rules',
+  '',
+  "Shared behavioral rules for all Soleri agents. The active agent's facade table provides tool names.",
+  '',
+
+  // ─── Response Integrity ─────────────────────────────────
+  '## Response Integrity',
+  '<!-- soleri:response-integrity -->',
+  '',
+  '- If you\'re not confident in your answer, say "I\'m not sure" and explain why. Never guess.',
+  '- After every response, rate your confidence from 1 to 10. Anything below 7, flag it.',
+  '',
+
+  // ─── Memory Quality Gate ───────────────────────────────
+  '## Memory Quality Gate',
+  '<!-- soleri:memory-quality -->',
+  '',
+  '**MANDATORY** before writing to auto memory: apply the **"Will I hit this again?"** test.',
+  '',
+  '**SAVE** — recurring bugs, non-obvious gotchas, structural issues, behavioral quirks that will resurface.',
+  "**NEVER SAVE** — one-time config, solved-and-done fixes, values already persisted in files, setup steps that won't repeat, anything where the fix is already in the codebase.",
+  '',
+  "If in doubt, don't save. Less memory with high signal beats more memory with noise.",
+  '',
+
+  // ─── Vault-First Protocol ────────────────────────────────
+  '## Vault as Source of Truth',
+  '<!-- soleri:vault-protocol -->',
+  '',
+  '- **MANDATORY**: Consult the vault BEFORE every decision — planning, design, architecture, patterns, problem-solving.',
+  '- Lookup order: 1) VAULT (`op:search_intelligent`) → 2) MEMORY (`op:memory_search`) → 3) CODEBASE → 4) WEB/TRAINING.',
+  '- If the vault has a pattern, follow it. If it has an anti-pattern, avoid it.',
+  '- Persist lessons: call `op:capture_knowledge` — don\'t just promise "I will remember this".',
+  '- Exceptions: runtime errors with stack traces → codebase first; user explicitly asks to search web.',
+  '',
+
+  // ─── Planning ────────────────────────────────────────────
+  '## Planning',
+  '<!-- soleri:planning -->',
+  '',
+  '- Use `op:create_plan` before writing ANY code. Show the plan, wait for approval.',
+  '- Two-gate approval: Gate 1 (`op:approve_plan`), Gate 2 (`op:plan_split`). Never skip either.',
+  '- Wait for explicit "yes" / "approve" before proceeding past each gate.',
+  '- After execution: `op:plan_reconcile` (drift report) then `op:plan_complete_lifecycle` (knowledge capture, archive).',
+  '- Never let a plan stay in `executing` or `reconciling` state without reminding the user.',
+  '- On session start: check for plans in `executing`/`reconciling` state and remind.',
+  '- Exceptions: read-only operations, user says "just do it", single-line fixes.',
+  '',
+  '### Lifecycle States',
+  '',
+  '| State | Expires | Next Action |',
+  '|-------|---------|-------------|',
+  '| `draft` | 30 min | `op:create_plan` (iterate) |',
+  '| `approved` | 30 min | `op:plan_split` |',
+  '| `executing` | Never | `op:plan_reconcile` |',
+  '| `reconciling` | Never | `op:plan_complete_lifecycle` |',
+  '| `completed` | — | Done |',
+  '',
+  '### Plan Presentation',
+  '',
+  'Every plan summary MUST include this format:',
+  '',
+  '```',
+  '## Plan: [Short Title]',
+  '',
+  '| Field | Value |',
+  '|-------|-------|',
+  '| **Plan ID** | {planId} |',
+  '| **Check ID** | {checkId} |',
+  '| **Grade** | {grade} ({score}/100) |',
+  '| **Status** | {status} |',
+  '| **Lifecycle** | {lifecycleStatus} |',
+  '',
+  '**Objective:** [One sentence]',
+  '',
+  '**Scope:**',
+  '| Included | Excluded |',
+  '|----------|----------|',
+  '| item 1   | item 1   |',
+  '',
+  '**Approach:**',
+  '| Step | Task |',
+  '|------|------|',
+  '| 1 | Description |',
+  '```',
+  '',
+  'Without visible IDs, users cannot resume, reference, or approve plans.',
+  '',
+  '### Drift Report',
+  '',
+  '```',
+  '| Field | Value |',
+  '|-------|-------|',
+  '| **Accuracy** | {accuracyScore}/100 |',
+  '| **Drift Items** | {count} |',
+  '',
+  '| Type | Description | Impact | Rationale |',
+  '|------|-------------|--------|-----------|',
+  '| skipped | ... | medium | ... |',
+  '```',
+  '',
+
+  // ─── Output Formatting ───────────────────────────────────
+  '## Output Formatting',
+  '<!-- soleri:output-formatting -->',
+  '',
+  '**MANDATORY**: Present tool outputs in human-readable format, NOT raw JSON.',
+  '',
+  '**Tasks** — show as numbered table:',
+  '```',
+  '| # | Type | Task | Complexity |',
+  '|---|------|------|------------|',
+  '| 1 | Impl | ... | High |',
+  '```',
+  '',
+  '**Completion** — show outcome, knowledge captured count, archive path.',
+  '',
+  '**Status lines** — `Persisted: X plans, Y tasks, Z checks` / `Recovered: X plans, Y tasks`',
+  '',
+
+  // ─── Clean Commits ───────────────────────────────────────
+  '## Clean Commits',
+  '<!-- soleri:clean-commits -->',
+  '',
+  '**MANDATORY**: No AI attribution in commit messages.',
+  '',
+  'Blocked patterns:',
+  '- `Co-Authored-By: Claude` (any variant)',
+  '- `noreply@anthropic.com`',
+  '- `Generated with Claude`, `AI-generated`',
+  '- Any mention of `Anthropic`, `Claude Opus`, `Claude Sonnet`, `Claude Haiku`',
+  '',
+  'Use conventional commits:',
+  '```',
+  'feat: add user authentication',
+  'fix: resolve login timeout issue',
+  'refactor: simplify data fetching logic',
+  '```',
+  '',
+
+  // ─── Knowledge Capture ───────────────────────────────────
+  '## Knowledge Capture',
+  '<!-- soleri:knowledge-capture -->',
+  '',
+  "**MANDATORY**: Persist lessons, don't just promise them.",
+  '',
+  'When you learn something that should persist:',
+  '1. **DON\'T** just say "I will remember this"',
+  '2. **DO** call `op:capture_knowledge` to persist to vault',
+  "3. **DO** update relevant files if it's a behavioral change",
+  '',
+  '| Type | Op | Persists To |',
+  '|------|-----|-------------|',
+  '| Patterns/Anti-patterns | `op:capture_knowledge` | vault |',
+  '| Quick capture | `op:capture_quick` | vault |',
+  '| Session summaries | `op:session_capture` | memory |',
+  '',
+
+  // ─── Work Task Routing ───────────────────────────────────
+  '## Work Task Routing',
+  '<!-- soleri:task-routing -->',
+  '',
+  'Use the orchestration layer for ALL work tasks:',
+  '- `op:orchestrate_plan` → vault + brain + structured plan.',
+  '- `op:orchestrate_execute` → execution tracking.',
+  '- `op:orchestrate_complete` → epilogue (vault, session).',
+  '',
+  'The orchestrator handles vault lookup, brain recommendations, and knowledge capture automatically.',
+  '',
+
+  // ─── Intent Detection ────────────────────────────────────
+  '## Intent Detection',
+  '<!-- soleri:intent-detection -->',
+  '',
+  '**Semantic-First**: Analyze user MEANING before calling `op:route_intent`.',
+  '',
+  '| Signal | Intent |',
+  '|--------|--------|',
+  '| Problem described ("broken", "janky", "weird") | FIX |',
+  '| Need expressed ("I need", "we should have") | BUILD |',
+  '| Quality questioned ("is this right?") | REVIEW |',
+  '| Advice sought ("how should I", "best way") | PLAN |',
+  '| Improvement requested ("make it faster") | IMPROVE |',
+  '| Ready to ship ("deploy", "release") | DELIVER |',
+  '',
+  'Use `op:route_intent` only to CONFIRM your analysis or when meaning is unclear.',
+  '',
+
+  // ─── Validation Loop ─────────────────────────────────────
+  '## Iterative Validation Loop',
+  '<!-- soleri:validation-loop -->',
+  '',
+  '- When a user gives a **work task**, start a loop: `op:loop_start params:{ prompt: "<task>", mode: "custom" }`',
+  '- Do NOT start loops for: questions, explanations, status checks, git operations, exploration, simple one-line fixes.',
+  '',
+  '| Mode | Op | Target | Max Iter |',
+  '|------|-----|--------|----------|',
+  '| `plan-iteration` | `op:create_plan` | grade >= A | 10 |',
+  '| `custom` | user-defined | promise-based | 20 |',
+  '',
+
+  // ─── Brain-Informed Work ─────────────────────────────────
+  '## Brain-Informed Work',
+  '<!-- soleri:brain -->',
+  '',
+  '- Brain patterns surface at session start. For relevant patterns, pull rules just-in-time from the vault.',
+  '- Brain tells you **which** patterns matter (names + strength scores). Vault tells you **what** they are (rules, examples).',
+  "- Pull only what's relevant to the current task — don't load everything at session start.",
+  '',
+
+  // ─── Cross-Project Memory ────────────────────────────────
+  '## Cross-Project Memory',
+  '<!-- soleri:cross-project -->',
+  '',
+  '- Use `crossProject: true` in `op:memory_search` for patterns across related projects.',
+  '- Promote universal patterns to global pool with `op:memory_promote_to_global`.',
+  '',
+
+  // ─── Session Lifecycle ───────────────────────────────────
+  '## Session Lifecycle',
+  '<!-- soleri:session -->',
+  '',
+  '### Session Start Protocol',
+  '',
+  'On EVERY new session:',
+  '1. Register project: `op:register params:{ projectPath: "." }`',
+  '2. Check activation response for `persistence.status`, `vault.connected`, `project.registered`.',
+  '3. Check for plans awaiting reconciliation via `op:check_persistence`:',
+  '   - `executing` → Remind user to call `op:plan_reconcile`.',
+  '   - `reconciling` → Remind user to call `op:plan_complete_lifecycle`.',
+  '',
+  '### Context Compaction',
+  '',
+  'A PreCompact hook calls `op:session_capture` before context compaction.',
+  'Manual capture: `op:session_capture params:{ summary: "..." }`',
+  '',
+
+  `<!-- /${ENGINE_MARKER} -->`,
+];