gsd-pi 2.24.0 → 2.25.0

package/dist/resources/extensions/gsd/memory-store.ts

@@ -0,0 +1,441 @@
+// GSD Memory Store — CRUD, ranked queries, maintenance, and prompt formatting
+//
+// Storage layer for auto-learned project memories. Follows context-store.ts patterns.
+// All functions degrade gracefully: return empty results when DB unavailable, never throw.
+
+import { isDbAvailable, _getAdapter, transaction } from './gsd-db.js';
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export interface Memory {
+  seq: number;
+  id: string;
+  category: string;
+  content: string;
+  confidence: number;
+  source_unit_type: string | null;
+  source_unit_id: string | null;
+  created_at: string;
+  updated_at: string;
+  superseded_by: string | null;
+  hit_count: number;
+}
+
+export type MemoryActionCreate = {
+  action: 'CREATE';
+  category: string;
+  content: string;
+  confidence?: number;
+};
+
+export type MemoryActionUpdate = {
+  action: 'UPDATE';
+  id: string;
+  content: string;
+  confidence?: number;
+};
+
+export type MemoryActionReinforce = {
+  action: 'REINFORCE';
+  id: string;
+};
+
+export type MemoryActionSupersede = {
+  action: 'SUPERSEDE';
+  id: string;
+  superseded_by: string;
+};
+
+export type MemoryAction =
+  | MemoryActionCreate
+  | MemoryActionUpdate
+  | MemoryActionReinforce
+  | MemoryActionSupersede;
+
+// ─── Category Display Order ─────────────────────────────────────────────────
+
+const CATEGORY_PRIORITY: Record<string, number> = {
+  gotcha: 0,
+  convention: 1,
+  architecture: 2,
+  pattern: 3,
+  environment: 4,
+  preference: 5,
+};
+
+// ─── Row Mapping ────────────────────────────────────────────────────────────
+
+function rowToMemory(row: Record<string, unknown>): Memory {
+  return {
+    seq: row['seq'] as number,
+    id: row['id'] as string,
+    category: row['category'] as string,
+    content: row['content'] as string,
+    confidence: row['confidence'] as number,
+    source_unit_type: (row['source_unit_type'] as string) ?? null,
+    source_unit_id: (row['source_unit_id'] as string) ?? null,
+    created_at: row['created_at'] as string,
+    updated_at: row['updated_at'] as string,
+    superseded_by: (row['superseded_by'] as string) ?? null,
+    hit_count: row['hit_count'] as number,
+  };
+}
+
+// ─── Query Functions ────────────────────────────────────────────────────────
+
+/**
+ * Get all memories where superseded_by IS NULL.
+ * Returns [] if DB is not available. Never throws.
+ */
+export function getActiveMemories(): Memory[] {
+  if (!isDbAvailable()) return [];
+  const adapter = _getAdapter();
+  if (!adapter) return [];
+
+  try {
+    const rows = adapter.prepare('SELECT * FROM memories WHERE superseded_by IS NULL').all();
+    return rows.map(rowToMemory);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get active memories ordered by ranking score: confidence * (1 + hit_count * 0.1).
+ * Higher-scored memories are more relevant and frequently confirmed.
+ */
+export function getActiveMemoriesRanked(limit = 30): Memory[] {
+  if (!isDbAvailable()) return [];
+  const adapter = _getAdapter();
+  if (!adapter) return [];
+
+  try {
+    const rows = adapter.prepare(
+      `SELECT * FROM memories
+       WHERE superseded_by IS NULL
+       ORDER BY (confidence * (1.0 + hit_count * 0.1)) DESC
+       LIMIT :limit`,
+    ).all({ ':limit': limit });
+    return rows.map(rowToMemory);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Generate the next memory ID: MEM + zero-padded 3-digit from MAX(seq).
+ * Returns MEM001 if no memories exist.
+ */
+export function nextMemoryId(): string {
+  if (!isDbAvailable()) return 'MEM001';
+  const adapter = _getAdapter();
+  if (!adapter) return 'MEM001';
+
+  try {
+    const row = adapter
+      .prepare('SELECT MAX(seq) as max_seq FROM memories')
+      .get();
+    const maxSeq = row ? (row['max_seq'] as number | null) : null;
+    if (maxSeq == null || isNaN(maxSeq)) return 'MEM001';
+    const next = maxSeq + 1;
+    return `MEM${String(next).padStart(3, '0')}`;
+  } catch {
+    return 'MEM001';
+  }
+}
+
+// ─── Mutation Functions ─────────────────────────────────────────────────────
+
+/**
+ * Insert a new memory with auto-assigned ID.
+ * Returns the assigned ID, or null on failure.
+ */
+export function createMemory(fields: {
+  category: string;
+  content: string;
+  confidence?: number;
+  source_unit_type?: string;
+  source_unit_id?: string;
+}): string | null {
+  if (!isDbAvailable()) return null;
+  const adapter = _getAdapter();
+  if (!adapter) return null;
+
+  try {
+    const id = nextMemoryId();
+    const now = new Date().toISOString();
+    adapter.prepare(
+      `INSERT INTO memories (id, category, content, confidence, source_unit_type, source_unit_id, created_at, updated_at)
+       VALUES (:id, :category, :content, :confidence, :source_unit_type, :source_unit_id, :created_at, :updated_at)`,
+    ).run({
+      ':id': id,
+      ':category': fields.category,
+      ':content': fields.content,
+      ':confidence': fields.confidence ?? 0.8,
+      ':source_unit_type': fields.source_unit_type ?? null,
+      ':source_unit_id': fields.source_unit_id ?? null,
+      ':created_at': now,
+      ':updated_at': now,
+    });
+    return id;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Update a memory's content and optionally its confidence.
+ */
+export function updateMemoryContent(id: string, content: string, confidence?: number): boolean {
+  if (!isDbAvailable()) return false;
+  const adapter = _getAdapter();
+  if (!adapter) return false;
+
+  try {
+    const now = new Date().toISOString();
+    if (confidence != null) {
+      adapter.prepare(
+        'UPDATE memories SET content = :content, confidence = :confidence, updated_at = :updated_at WHERE id = :id',
+      ).run({ ':content': content, ':confidence': confidence, ':updated_at': now, ':id': id });
+    } else {
+      adapter.prepare(
+        'UPDATE memories SET content = :content, updated_at = :updated_at WHERE id = :id',
+      ).run({ ':content': content, ':updated_at': now, ':id': id });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Reinforce a memory: increment hit_count, update timestamp.
+ */
+export function reinforceMemory(id: string): boolean {
+  if (!isDbAvailable()) return false;
+  const adapter = _getAdapter();
+  if (!adapter) return false;
+
+  try {
+    adapter.prepare(
+      'UPDATE memories SET hit_count = hit_count + 1, updated_at = :updated_at WHERE id = :id',
+    ).run({ ':updated_at': new Date().toISOString(), ':id': id });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Mark a memory as superseded by another.
+ */
+export function supersedeMemory(oldId: string, newId: string): boolean {
+  if (!isDbAvailable()) return false;
+  const adapter = _getAdapter();
+  if (!adapter) return false;
+
+  try {
+    adapter.prepare(
+      'UPDATE memories SET superseded_by = :new_id, updated_at = :updated_at WHERE id = :old_id',
+    ).run({ ':new_id': newId, ':updated_at': new Date().toISOString(), ':old_id': oldId });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─── Processed Unit Tracking ────────────────────────────────────────────────
+
+/**
+ * Check if a unit has already been processed for memory extraction.
+ */
+export function isUnitProcessed(unitKey: string): boolean {
+  if (!isDbAvailable()) return false;
+  const adapter = _getAdapter();
+  if (!adapter) return false;
+
+  try {
+    const row = adapter.prepare(
+      'SELECT 1 FROM memory_processed_units WHERE unit_key = :key',
+    ).get({ ':key': unitKey });
+    return row != null;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Record that a unit has been processed for memory extraction.
+ */
+export function markUnitProcessed(unitKey: string, activityFile: string): boolean {
+  if (!isDbAvailable()) return false;
+  const adapter = _getAdapter();
+  if (!adapter) return false;
+
+  try {
+    adapter.prepare(
+      `INSERT OR IGNORE INTO memory_processed_units (unit_key, activity_file, processed_at)
+       VALUES (:key, :file, :at)`,
+    ).run({ ':key': unitKey, ':file': activityFile, ':at': new Date().toISOString() });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─── Maintenance ────────────────────────────────────────────────────────────
+
+/**
+ * Reduce confidence for memories not updated within the last N processed units.
+ * "Stale" = updated_at is older than the Nth most recent processed_at.
+ */
+export function decayStaleMemories(thresholdUnits = 20): void {
+  if (!isDbAvailable()) return;
+  const adapter = _getAdapter();
+  if (!adapter) return;
+
+  try {
+    // Find the timestamp of the Nth most recent processed unit
+    const row = adapter.prepare(
+      `SELECT processed_at FROM memory_processed_units
+       ORDER BY processed_at DESC
+       LIMIT 1 OFFSET :offset`,
+    ).get({ ':offset': thresholdUnits - 1 });
+
+    if (!row) return; // not enough processed units yet
+
+    const cutoff = row['processed_at'] as string;
+    adapter.prepare(
+      `UPDATE memories
+       SET confidence = MAX(0.1, confidence - 0.1), updated_at = :now
+       WHERE superseded_by IS NULL AND updated_at < :cutoff AND confidence > 0.1`,
+    ).run({ ':now': new Date().toISOString(), ':cutoff': cutoff });
+  } catch {
+    // non-fatal
+  }
+}
+
+/**
+ * Supersede lowest-ranked memories when count exceeds cap.
+ */
+export function enforceMemoryCap(max = 50): void {
+  if (!isDbAvailable()) return;
+  const adapter = _getAdapter();
+  if (!adapter) return;
+
+  try {
+    const countRow = adapter.prepare(
+      'SELECT count(*) as cnt FROM memories WHERE superseded_by IS NULL',
+    ).get();
+    const count = (countRow?.['cnt'] as number) ?? 0;
+    if (count <= max) return;
+
+    const excess = count - max;
+    // Find the IDs of the lowest-ranked active memories
+    const rows = adapter.prepare(
+      `SELECT id FROM memories
+       WHERE superseded_by IS NULL
+       ORDER BY (confidence * (1.0 + hit_count * 0.1)) ASC
+       LIMIT :limit`,
+    ).all({ ':limit': excess });
+
+    const now = new Date().toISOString();
+    for (const row of rows) {
+      adapter.prepare(
+        'UPDATE memories SET superseded_by = :reason, updated_at = :now WHERE id = :id',
+      ).run({ ':reason': 'CAP_EXCEEDED', ':now': now, ':id': row['id'] as string });
+    }
+  } catch {
+    // non-fatal
+  }
+}
+
+// ─── Action Application ─────────────────────────────────────────────────────
+
+/**
+ * Process an array of memory actions in a transaction.
+ * Calls enforceMemoryCap at the end.
+ */
+export function applyMemoryActions(
+  actions: MemoryAction[],
+  unitType?: string,
+  unitId?: string,
+): void {
+  if (!isDbAvailable() || actions.length === 0) return;
+
+  try {
+    transaction(() => {
+      for (const action of actions) {
+        switch (action.action) {
+          case 'CREATE':
+            createMemory({
+              category: action.category,
+              content: action.content,
+              confidence: action.confidence,
+              source_unit_type: unitType,
+              source_unit_id: unitId,
+            });
+            break;
+          case 'UPDATE':
+            updateMemoryContent(action.id, action.content, action.confidence);
+            break;
+          case 'REINFORCE':
+            reinforceMemory(action.id);
+            break;
+          case 'SUPERSEDE':
+            supersedeMemory(action.id, action.superseded_by);
+            break;
+        }
+      }
+      enforceMemoryCap();
+    });
+  } catch {
+    // non-fatal — transaction will have rolled back
+  }
+}
+
+// ─── Prompt Formatting ──────────────────────────────────────────────────────
+
+/**
+ * Format memories as categorized markdown for system prompt injection.
+ * Truncates to token budget (~4 chars per token).
+ */
+export function formatMemoriesForPrompt(memories: Memory[], tokenBudget = 2000): string {
+  if (memories.length === 0) return '';
+
+  const charBudget = tokenBudget * 4;
+  const header = '## Project Memory (auto-learned)\n';
+  let output = header;
+  let remaining = charBudget - header.length;
+
+  // Group by category
+  const grouped = new Map<string, Memory[]>();
+  for (const m of memories) {
+    const list = grouped.get(m.category) ?? [];
+    list.push(m);
+    grouped.set(m.category, list);
+  }
+
+  // Sort categories by priority
+  const sortedCategories = [...grouped.keys()].sort(
+    (a, b) => (CATEGORY_PRIORITY[a] ?? 99) - (CATEGORY_PRIORITY[b] ?? 99),
+  );
+
+  for (const category of sortedCategories) {
+    const items = grouped.get(category)!;
+    const catHeader = `\n### ${category.charAt(0).toUpperCase() + category.slice(1)}\n`;
+
+    if (remaining < catHeader.length + 10) break;
+    output += catHeader;
+    remaining -= catHeader.length;
+
+    for (const item of items) {
+      const bullet = `- ${item.content}\n`;
+      if (remaining < bullet.length) break;
+      output += bullet;
+      remaining -= bullet.length;
+    }
+  }
+
+  return output.trimEnd();
+}

package/dist/resources/extensions/gsd/migrate/command.ts

@@ -151,7 +151,7 @@ export async function handleMigrate(
   }
 
   // ── Confirmation via showNextAction ────────────────────────────────────────
-  const choice = await showNextAction(ctx as any, {
+  const choice = await showNextAction(ctx, {
     title: "Migration preview",
     summary: lines,
     actions: [
@@ -187,7 +187,7 @@ export async function handleMigrate(
   );
 
   // ── Post-write review offer ────────────────────────────────────────────────
-  const reviewChoice = await showNextAction(ctx as any, {
+  const reviewChoice = await showNextAction(ctx, {
     title: "Migration written",
     summary: [
       `${result.paths.length} files written to .gsd/`,

package/dist/resources/extensions/gsd/prompts/complete-slice.md

@@ -28,7 +28,7 @@ Then:
 7. Write `{{sliceUatPath}}` — a concrete UAT script with real test cases derived from the slice plan and task summaries. Include preconditions, numbered steps with expected outcomes, and edge cases. This must NOT be a placeholder or generic template — tailor every test case to what this slice actually built.
 8. Review task summaries for `key_decisions`. Append any significant decisions to `.gsd/DECISIONS.md` if missing.
 9. Mark {{sliceId}} done in `{{roadmapPath}}` (change `[ ]` to `[x]`)
-10. Do not commit or squash-merge manually — the system auto-commits your changes and handles the merge after this unit succeeds.
+10. Do not run git commands — the system commits your changes and handles any merge after this unit succeeds.
 11. Update `.gsd/PROJECT.md` if it exists — refresh current state if needed.
 12. Update `.gsd/STATE.md`
 

package/dist/resources/extensions/gsd/prompts/discuss-headless.md

@@ -51,7 +51,7 @@ Use these templates exactly:
 5. Write `{{roadmapPath}}` (using Roadmap template) — decompose into demoable vertical slices with checkboxes, risk, depends, demo sentences, proof strategy, verification classes, milestone definition of done, requirement coverage, and a boundary map. If the milestone crosses multiple runtime boundaries, include an explicit final integration slice.
 6. Seed `.gsd/DECISIONS.md` (using Decisions template)
 7. Update `.gsd/STATE.md`
-8. Commit: `docs({{milestoneId}}): context, requirements, and roadmap`
+8. {{commitInstruction}}
 9. Say exactly: "Milestone {{milestoneId}} ready."
 
 **For multi-milestone**, write in this order:
@@ -71,7 +71,7 @@ Use these templates exactly:
    ```
    Each context file should be rich enough that a future agent — with no memory of this conversation — can understand the intent, constraints, dependencies, what the milestone unlocks, and what "done" looks like.
 8. Update `.gsd/STATE.md`
-9. Commit: `docs: project plan — N milestones`
+9. {{multiMilestoneCommitInstruction}}
 10. Say exactly: "Milestone {{milestoneId}} ready."
 
 ## Critical Rules

package/dist/resources/extensions/gsd/prompts/discuss.md

@@ -201,9 +201,9 @@ When writing context.md, preserve the user's exact terminology, emphasis, and sp
 5. Write `{{roadmapPath}}` — use the **Roadmap** output template below. Decompose into demoable vertical slices with checkboxes, risk, depends, demo sentences, proof strategy, verification classes, milestone definition of done, requirement coverage, and a boundary map. If the milestone crosses multiple runtime boundaries, include an explicit final integration slice that proves the assembled system works end-to-end in a real environment.
 6. Seed `.gsd/DECISIONS.md` — use the **Decisions** output template below. Append rows for any architectural or pattern decisions made during discussion.
 7. Update `.gsd/STATE.md`
-8. Commit: `docs({{milestoneId}}): context, requirements, and roadmap`
+8. {{commitInstruction}}
 
-After writing the files and committing, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
+After writing the files, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
 
 ### Multi-Milestone
 
@@ -271,8 +271,8 @@ For single-milestone projects, do NOT write this file — it is only for multi-m
 #### Phase 4: Finalize
 
 7. Update `.gsd/STATE.md`
-8. Commit: `docs: project plan — N milestones` (replace N with the actual milestone count)
+8. {{multiMilestoneCommitInstruction}}
 
-After writing the files and committing, say exactly: "Milestone M001 ready." — nothing else. Auto-mode will start automatically.
+After writing the files, say exactly: "Milestone M001 ready." — nothing else. Auto-mode will start automatically.
 
 {{inlinedTemplates}}

package/dist/resources/extensions/gsd/prompts/execute-task.md

@@ -63,7 +63,7 @@ Then:
 14. Read the template at `~/.gsd/agent/extensions/gsd/templates/task-summary.md`
 15. Write `{{taskSummaryPath}}`
 16. Mark {{taskId}} done in `{{planPath}}` (change `[ ]` to `[x]`)
-17. Do not commit manually — the system auto-commits your changes after this unit completes.
+17. Do not run git commands — the system reads your task summary after completion and creates a meaningful commit from it (type inferred from title, message from your one-liner, key files from frontmatter). Write a clear, specific one-liner in the summary — it becomes the commit message.
 18. Update `.gsd/STATE.md`
 
 All work stays in your working directory: `{{workingDirectory}}`.

package/dist/resources/extensions/gsd/prompts/guided-discuss-milestone.md

@@ -104,5 +104,5 @@ Once the user confirms depth:
 1. Use the **Context** output template below
 2. `mkdir -p` the milestone directory if needed
 3. Write `{{milestoneId}}-CONTEXT.md` — preserve the user's exact terminology, emphasis, and framing. Do not paraphrase nuance into generic summaries. The context file is downstream agents' only window into this conversation.
-4. Commit: `git add {{milestoneId}}-CONTEXT.md && git commit -m "docs({{milestoneId}}): milestone context from discuss"`
+4. {{commitInstruction}}
 5. Say exactly: `"{{milestoneId}} context written."` — nothing else.

package/dist/resources/extensions/gsd/prompts/guided-discuss-slice.md

@@ -55,7 +55,7 @@ Once the user is ready to wrap up:
    - **Constraints** — anything the user flagged as a hard constraint
    - **Integration Points** — what this slice consumes and produces
    - **Open Questions** — anything still unresolved, with current thinking
-4. Commit: `git -C {{projectRoot}} add {{contextPath}} && git -C {{projectRoot}} commit -m "docs({{milestoneId}}/{{sliceId}}): slice context from discuss"`
+4. {{commitInstruction}}
 5. Say exactly: `"{{sliceId}} context written."` — nothing else.
 
 {{inlinedTemplates}}

package/dist/resources/extensions/gsd/prompts/plan-slice.md

@@ -59,7 +59,7 @@ Then:
     - **Scope sanity:** Target 2–5 steps and 3–8 files per task. 10+ steps or 12+ files — must split. Each task must be completable in a single fresh context window.
     - **Feature completeness:** Every task produces real, user-facing progress — not just internal scaffolding.
 9. If planning produced structural decisions, append them to `.gsd/DECISIONS.md`
-10. Commit: `docs({{sliceId}}): add slice plan`
+10. {{commitInstruction}}
 11. Update `.gsd/STATE.md`
 
 The slice directory and tasks/ subdirectory already exist. Do NOT mkdir. All work stays in your working directory: `{{workingDirectory}}`.

package/dist/resources/extensions/gsd/prompts/queue.md

@@ -96,7 +96,7 @@ Then, after all milestone directories and context files are written:
 4. If `.gsd/REQUIREMENTS.md` exists and the queued work introduces new in-scope capabilities or promotes Deferred items, update it.
 5. If discussion produced decisions relevant to existing work, append to `.gsd/DECISIONS.md`.
 6. Append to `.gsd/QUEUE.md`.
-7. Commit: `docs: queue <milestone list>`
+7. {{commitInstruction}}
 
 **Do NOT write roadmaps for queued milestones.**
 **Do NOT update `.gsd/STATE.md`.**

package/dist/resources/extensions/gsd/prompts/reassess-roadmap.md

@@ -57,7 +57,7 @@ Write `{{assessmentPath}}` with a brief confirmation that roadmap coverage still
 1. Rewrite the remaining (unchecked) slices in `{{roadmapPath}}`. Keep completed slices exactly as they are (`[x]`). Update the boundary map for changed slices. Update the proof strategy if risks changed. Update requirement coverage if ownership or scope changed.
 2. Write `{{assessmentPath}}` explaining what changed and why — keep it brief and concrete.
 3. If `.gsd/REQUIREMENTS.md` exists and requirement ownership or status changed, update it.
-4. Commit: `docs({{milestoneId}}): reassess roadmap after {{completedSliceId}}`
+4. {{commitInstruction}}
 
 **You MUST write the file `{{assessmentPath}}` before finishing.**
 

package/dist/resources/extensions/gsd/tests/auto-recovery.test.ts

@@ -17,6 +17,8 @@ import {
   loadPersistedKeys,
 } from "../auto-recovery.ts";
 import { parseRoadmap, clearParseCache } from "../files.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { deriveState, invalidateStateCache } from "../state.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
@@ -584,3 +586,55 @@ test("selfHealRuntimeRecords clears stale record when artifact exists at worktre
     cleanup(mainBase);
   }
 });
+
+// ─── #793: invalidateAllCaches unblocks skip-loop ─────────────────────────
+// When the skip-loop breaker fires, it must call invalidateAllCaches() (not
+// just invalidateStateCache()) to clear path/parse caches that deriveState
+// depends on. Without this, even after cache invalidation, deriveState reads
+// stale directory listings and returns the same unit, looping forever.
+test("#793: invalidateAllCaches clears all caches so deriveState sees fresh disk state", async () => {
+  const base = makeTmpBase();
+  try {
+    const mid = "M001";
+    const sid = "S01";
+    const planDir = join(base, ".gsd", "milestones", mid, "slices", sid);
+    const tasksDir = join(planDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    mkdirSync(join(base, ".gsd", "milestones", mid), { recursive: true });
+
+    writeFileSync(
+      join(base, ".gsd", "milestones", mid, `${mid}-ROADMAP.md`),
+      `# M001: Test Milestone\n\n**Vision:** test.\n\n## Slices\n\n- [ ] **${sid}: Slice One** \`risk:low\` \`depends:[]\`\n  > After this: done.\n`,
+    );
+    const planUnchecked = `# ${sid}: Slice One\n\n**Goal:** test.\n\n## Tasks\n\n- [ ] **T01: Task One** \`est:10m\`\n- [ ] **T02: Task Two** \`est:10m\`\n`;
+    writeFileSync(join(planDir, `${sid}-PLAN.md`), planUnchecked);
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01: Task One\n\n**Goal:** t\n\n## Steps\n- step\n\n## Verification\n- v\n");
+    writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02: Task Two\n\n**Goal:** t\n\n## Steps\n- step\n\n## Verification\n- v\n");
+
+    // Warm all caches
+    const state1 = await deriveState(base);
+    assert.equal(state1.activeTask?.id, "T01", "initial: T01 is active");
+
+    // Simulate task completion on disk (what the LLM does)
+    const planChecked = `# ${sid}: Slice One\n\n**Goal:** test.\n\n## Tasks\n\n- [x] **T01: Task One** \`est:10m\`\n- [ ] **T02: Task Two** \`est:10m\`\n`;
+    writeFileSync(join(planDir, `${sid}-PLAN.md`), planChecked);
+    writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "---\nid: T01\n---\n# Summary\n");
+
+    // invalidateStateCache alone: _stateCache cleared but path/parse caches warm
+    invalidateStateCache();
+
+    // invalidateAllCaches: all caches cleared — deriveState must re-read disk
+    invalidateAllCaches();
+    const state2 = await deriveState(base);
+
+    // After full invalidation, T01 should be complete and T02 should be next
+    assert.notEqual(state2.activeTask?.id, "T01", "#793: T01 not re-dispatched after full invalidation");
+
+    // Verify the caches are truly cleared by calling clearParseCache and clearPathCache
+    // do not throw (they should be no-ops after invalidateAllCaches already cleared them)
+    clearParseCache(); // no-op, but should not throw
+    assert.ok(true, "clearParseCache after invalidateAllCaches is safe");
+  } finally {
+    cleanup(base);
+  }
+});