feat: add strategies/knowledge capture, mid-session writing, and dedup

Part A — Strategies & Knowledge capture:
- Add strategies.md ledger with extractStrategyEntries(), appendStrategy(),
  getRelevantStrategies() and CLI/validation wiring
- Add Knowledge section to SUMMARY_PROMPT with extractKnowledgeEntries(),
  appendKnowledge(), getRelevantKnowledge()
- Enhance SUMMARY_PROMPT: format enforcement, broader decision criteria,
  user-question signal for "should we..."/"what if we..." patterns
- Add isValidSummary() to reject unstructured summaries in background
- Inject strategies + knowledge at session start via hooks
- Include strategies in continuity block

Part B — Unified knowledge format:
- Rewrite buildKnowledge() for entry consolidation/dedup instead of
  free-form regeneration
- Add migrateKnowledge() for auto-migrating old free-form knowledge.md
- Update injectKnowledge() to render entries grouped by area
- Update genesis() to produce structured entries
- Include strategies in knowledge build and brief context

Part C — Mid-session knowledge writing:
- Add ghost decision/mistake/strategy/knowledge CLI commands for
  persisting entries during a session (not just at session end)
- Add isDuplicateEntry() and dedup option to all append helpers
- Pass dedup flag in background extraction to prevent double-writes
- Update Ghost briefing to instruct Claude when to call each command
- Update CLAUDE.md header with mid-session command table

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: notkurt

src/background.ts

@@ -15,14 +15,16 @@ import {
   addFrontmatterField,
   addTags,
   appendDecision,
+  appendKnowledge,
   appendMistake,
+  appendStrategy,
   checkpoint,
   deriveArea,
   detectCorrections,
   extractModifiedFiles,
   parseFrontmatter,
 } from "./session.js";
-import { extractSections, summarize } from "./summarize.js";
+import { extractSections, isValidSummary, summarize } from "./summarize.js";
 
 const [repoRoot, sessionPath, sessionId] = process.argv.slice(2) as [string, string, string];
 
@@ -92,7 +94,16 @@ try {
     log("Summarization complete, appending to session file");
     appendFileSync(sessionPath, `\n## Summary\n\n${summary}\n`);
 
-    // 2. Extract tags, decisions, mistakes
+    // Validate summary format
+    const validFormat = isValidSummary(summary);
+    if (!validFormat) {
+      log("Summary has unstructured format — marking in frontmatter, skipping knowledge extraction");
+      const currentContent = readFileSync(sessionPath, "utf8");
+      const updated = addFrontmatterField(currentContent, "summary_format", "unstructured");
+      writeFileSync(sessionPath, updated);
+    }
+
+    // 2. Extract tags, decisions, mistakes, strategies, knowledge
     const sections = extractSections(summary);
 
     // Check if AI flagged this session as not relevant for knowledge
@@ -109,7 +120,7 @@ try {
       log(`Tagged: ${sections.tags.join(", ")}`);
     }
 
-    if (!sections.skipKnowledge) {
+    if (!sections.skipKnowledge && validFormat) {
       // Read session data for context
       const sessionContent = readFileSync(sessionPath, "utf8");
       const { frontmatter } = parseFrontmatter(sessionContent);
@@ -121,37 +132,93 @@ try {
         const { title, description } = parseTitleDescription(decision.text);
         if (isJunkEntry(title)) continue;
         const files = decision.files.length > 0 ? decision.files : modifiedFiles.slice(0, 5);
-        appendDecision(repoRoot, {
-          title,
-          description,
-          sessionId,
-          commitSha,
-          files,
-          area: deriveArea(files),
-          date: sessionDate,
-          tried: decision.tried,
-          rule: decision.rule,
-        });
+        appendDecision(
+          repoRoot,
+          {
+            title,
+            description,
+            sessionId,
+            commitSha,
+            files,
+            area: deriveArea(files),
+            date: sessionDate,
+            tried: decision.tried,
+            rule: decision.rule,
+          },
+          { dedup: true },
+        );
       }
       if (sections.decisions.length > 0) {
         log(`Logged ${sections.decisions.length} decision(s)`);
       }
 
+      for (const strategy of sections.strategies) {
+        const { title, description } = parseTitleDescription(strategy.text);
+        if (isJunkEntry(title)) continue;
+        const files = strategy.files.length > 0 ? strategy.files : modifiedFiles.slice(0, 5);
+        appendStrategy(
+          repoRoot,
+          {
+            title,
+            description,
+            sessionId,
+            commitSha,
+            files,
+            area: deriveArea(files),
+            date: sessionDate,
+            tried: strategy.tried,
+            rule: strategy.rule,
+          },
+          { dedup: true },
+        );
+      }
+      if (sections.strategies.length > 0) {
+        log(`Logged ${sections.strategies.length} strategy(ies)`);
+      }
+
+      for (const knowledge of sections.knowledge) {
+        const { title, description } = parseTitleDescription(knowledge.text);
+        if (isJunkEntry(title)) continue;
+        const files = knowledge.files.length > 0 ? knowledge.files : modifiedFiles.slice(0, 5);
+        appendKnowledge(
+          repoRoot,
+          {
+            title,
+            description,
+            sessionId,
+            commitSha,
+            files,
+            area: deriveArea(files),
+            date: sessionDate,
+            tried: knowledge.tried,
+            rule: knowledge.rule,
+          },
+          { dedup: true },
+        );
+      }
+      if (sections.knowledge.length > 0) {
+        log(`Logged ${sections.knowledge.length} knowledge entry(ies)`);
+      }
+
       for (const mistake of sections.mistakes) {
         const { title, description } = parseTitleDescription(mistake.text);
         if (isJunkEntry(title)) continue;
         const files = mistake.files.length > 0 ? mistake.files : modifiedFiles.slice(0, 5);
-        appendMistake(repoRoot, {
-          title,
-          description,
-          sessionId,
-          commitSha,
-          files,
-          area: deriveArea(files),
-          date: sessionDate,
-          tried: mistake.tried,
-          rule: mistake.rule,
-        });
+        appendMistake(
+          repoRoot,
+          {
+            title,
+            description,
+            sessionId,
+            commitSha,
+            files,
+            area: deriveArea(files),
+            date: sessionDate,
+            tried: mistake.tried,
+            rule: mistake.rule,
+          },
+          { dedup: true },
+        );
       }
       if (sections.mistakes.length > 0) {
         log(`Logged ${sections.mistakes.length} mistake(s)`);
@@ -166,17 +233,21 @@ try {
         }
         for (const [file, count] of Object.entries(fileCounts)) {
           if (count >= 2) {
-            appendMistake(repoRoot, {
-              title: `Repeated modifications to ${file}`,
-              description: `File was modified across multiple consecutive turns — may indicate the AI struggled with this file. Review session ${sessionId} for the correct approach.`,
-              sessionId,
-              commitSha,
-              files: [file],
-              area: deriveArea([file]),
-              date: sessionDate,
-              tried: [],
-              rule: "",
-            });
+            appendMistake(
+              repoRoot,
+              {
+                title: `Repeated modifications to ${file}`,
+                description: `File was modified across multiple consecutive turns — may indicate the AI struggled with this file. Review session ${sessionId} for the correct approach.`,
+                sessionId,
+                commitSha,
+                files: [file],
+                area: deriveArea([file]),
+                date: sessionDate,
+                tried: [],
+                rule: "",
+              },
+              { dedup: true },
+            );
             log(`Auto-detected correction pattern for ${file}`);
           }
         }

src/hooks.ts

@@ -16,7 +16,9 @@ import {
   generateContinuityBlock,
   getCoModifiedFiles,
   getRelevantDecisions,
+  getRelevantKnowledge,
   getRelevantMistakes,
+  getRelevantStrategies,
 } from "./session.js";
 
 // =============================================================================
@@ -77,15 +79,31 @@ export async function handleSessionStart(input: SessionStartInput): Promise<stri
     // Non-critical — skip silently
   }
 
-  // 4. Inject relevant decisions
+  // 4. Inject relevant strategies
+  try {
+    const strategies = getRelevantStrategies(root, relevantFiles);
+    if (strategies) parts.push(strategies);
+  } catch {
+    // Non-critical — skip silently
+  }
+
+  // 5. Inject relevant decisions
   try {
     const decisions = getRelevantDecisions(root, relevantFiles);
     if (decisions) parts.push(decisions);
   } catch {
     // Non-critical — skip silently
   }
 
-  // 5. Inject co-modified file warnings
+  // 6. Inject relevant knowledge
+  try {
+    const knowledge = getRelevantKnowledge(root, relevantFiles);
+    if (knowledge) parts.push(knowledge);
+  } catch {
+    // Non-critical — skip silently
+  }
+
+  // 7. Inject co-modified file warnings
   try {
     const graph = buildCoModGraph(root);
     const coMod = getCoModifiedFiles(graph, relevantFiles, 10);
@@ -98,7 +116,7 @@ export async function handleSessionStart(input: SessionStartInput): Promise<stri
     // Non-critical — skip silently
   }
 
-  // 6. Always inject Ghost briefing so Claude understands how to work with Ghost
+  // 8. Always inject Ghost briefing so Claude understands how to work with Ghost
   parts.push(
     `> **Ghost is recording this session.** Prompts, file changes, and decisions are captured automatically.
 > At session end, Ghost extracts decisions, mistakes, and open items from your summary and stores them
@@ -108,6 +126,13 @@ export async function handleSessionStart(input: SessionStartInput): Promise<stri
 > per-session. Writing to CLAUDE.md bypasses Ghost's relevance scoring and creates stale, bloated context.
 > If asked to document something, put it where it belongs: code comments, README, or dedicated docs.
 >
+> **Persist important knowledge mid-session** — don't wait for session end:
+> - \`ghost decision "Title: reasoning"\` — When the user makes a technical decision
+> - \`ghost mistake "Title: what went wrong"\` — When something fails or the user flags a mistake
+> - \`ghost knowledge "Title: what was learned"\` — When you confirm how something works or learn a pattern
+> - \`ghost strategy "Title: approaches considered"\` — When trade-offs or alternatives are discussed
+> Write entries as they happen so knowledge survives context compaction. Use \`Title: detail\` format.
+>
 > **ALWAYS search Ghost before reading code or grepping.** When a user asks about a feature, bug, scenario,
 > or component — your FIRST action must be searching Ghost, not the codebase. Past sessions contain
 > architecture decisions, dead ends, failed approaches, and reasoning that code cannot reveal.