gsd-pi 2.78.1-dev.b0759e59b → 2.78.1-dev.d8826a445

package/src/resources/extensions/gsd/tests/write-gate-predicates.test.ts

@@ -24,38 +24,38 @@ import {
 // ─── shouldBlockQueueExecution ────────────────────────────────────────────
 
 test('shouldBlockQueueExecution: queue inactive → allow write to user source', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setQueuePhaseActive(false);
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setQueuePhaseActive(false, process.cwd());
   const r = shouldBlockQueueExecution('write', 'src/main.ts', false);
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockQueueExecution: queue active → block write to user source', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setQueuePhaseActive(true);
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setQueuePhaseActive(true, process.cwd());
   const r = shouldBlockQueueExecution('write', 'src/main.ts', true);
   assert.strictEqual(r.block, true);
   assert.ok(r.reason);
 });
 
 test('shouldBlockQueueExecution: queue active → allow write to .gsd/ path', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setQueuePhaseActive(true);
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setQueuePhaseActive(true, process.cwd());
   const r = shouldBlockQueueExecution('write', '.gsd/milestones/M001/M001-CONTEXT.md', true);
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockQueueExecution: queue active → block mutating bash', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setQueuePhaseActive(true);
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setQueuePhaseActive(true, process.cwd());
   const r = shouldBlockQueueExecution('bash', 'npm run build', true);
   assert.strictEqual(r.block, true);
   assert.ok(r.reason);
 });
 
 test('shouldBlockQueueExecution: queue active → allow read-only bash', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setQueuePhaseActive(true);
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setQueuePhaseActive(true, process.cwd());
   const r = shouldBlockQueueExecution('bash', 'git log --oneline -5', true);
   assert.strictEqual(r.block, false);
 });
@@ -63,30 +63,30 @@ test('shouldBlockQueueExecution: queue active → allow read-only bash', (t) =>
 // ─── shouldBlockPendingGate ───────────────────────────────────────────────
 
 test('shouldBlockPendingGate: no pending gate → allow any tool', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  clearPendingGate();
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  clearPendingGate(process.cwd());
   const r = shouldBlockPendingGate('write', 'M001');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockPendingGate: pending gate → block write', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setPendingGate('depth_verification_M001');
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setPendingGate('depth_verification_M001', process.cwd());
   const r = shouldBlockPendingGate('write', 'M001');
   assert.strictEqual(r.block, true);
   assert.ok(r.reason?.includes('depth_verification_M001'));
 });
 
 test('shouldBlockPendingGate: pending gate → allow ask_user_questions', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setPendingGate('depth_verification_M001');
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setPendingGate('depth_verification_M001', process.cwd());
   const r = shouldBlockPendingGate('ask_user_questions', 'M001');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockPendingGate: pending gate → block read so approval question stays visible', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setPendingGate('depth_verification_M001');
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setPendingGate('depth_verification_M001', process.cwd());
   const r = shouldBlockPendingGate('read', 'M001');
   assert.strictEqual(r.block, true);
   assert.ok(r.reason?.includes('already asked for user confirmation'));
@@ -95,31 +95,31 @@ test('shouldBlockPendingGate: pending gate → block read so approval question s
 // ─── shouldBlockPendingGateBash ───────────────────────────────────────────
 
 test('shouldBlockPendingGateBash: no pending gate → allow mutating bash', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  clearPendingGate();
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  clearPendingGate(process.cwd());
   const r = shouldBlockPendingGateBash('npm run build', 'M001');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockPendingGateBash: pending gate → block mutating bash', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setPendingGate('depth_verification_M001');
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setPendingGate('depth_verification_M001', process.cwd());
   const r = shouldBlockPendingGateBash('npm run build', 'M001');
   assert.strictEqual(r.block, true);
   assert.ok(r.reason?.includes('depth_verification_M001'));
 });
 
 test('shouldBlockPendingGateBash: pending gate → block read-only bash (cat)', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setPendingGate('depth_verification_M001');
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setPendingGate('depth_verification_M001', process.cwd());
   const r = shouldBlockPendingGateBash('cat README.md', 'M001');
   assert.strictEqual(r.block, true);
   assert.ok(r.reason?.includes('already asked for user confirmation'));
 });
 
 test('shouldBlockPendingGateBash: pending gate → block read-only bash (git log)', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setPendingGate('depth_verification_M001');
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setPendingGate('depth_verification_M001', process.cwd());
   const r = shouldBlockPendingGateBash('git log --oneline -10', 'M001');
   assert.strictEqual(r.block, true);
 });
@@ -127,26 +127,26 @@ test('shouldBlockPendingGateBash: pending gate → block read-only bash (git log
 // ─── shouldBlockContextWrite ──────────────────────────────────────────────
 
 test('shouldBlockContextWrite: non-write tool → allow', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   const r = shouldBlockContextWrite('read', '.gsd/milestones/M001/M001-CONTEXT.md', 'M001');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockContextWrite: write to non-CONTEXT file → allow', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   const r = shouldBlockContextWrite('write', 'src/index.ts', 'M001');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockContextWrite: write to CONTEXT.md without verification → block', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   const r = shouldBlockContextWrite('write', '.gsd/milestones/M007/M007-CONTEXT.md', 'M007');
   assert.strictEqual(r.block, true);
   assert.ok(r.reason);
 });
 
 test('shouldBlockContextWrite: write to CONTEXT.md after verification → allow', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   markDepthVerified('M008');
   const r = shouldBlockContextWrite('write', '.gsd/milestones/M008/M008-CONTEXT.md', 'M008');
   assert.strictEqual(r.block, false);
@@ -155,33 +155,33 @@ test('shouldBlockContextWrite: write to CONTEXT.md after verification → allow'
 // ─── shouldBlockContextArtifactSave ───────────────────────────────────────
 
 test('shouldBlockContextArtifactSave: non-CONTEXT artifact type → allow', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   const r = shouldBlockContextArtifactSave('CONTEXT-DRAFT', 'M001');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockContextArtifactSave: slice-level CONTEXT → allow', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   const r = shouldBlockContextArtifactSave('CONTEXT', 'M001', 'S01');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockContextArtifactSave: milestone CONTEXT without verification → block', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   const r = shouldBlockContextArtifactSave('CONTEXT', 'M009');
   assert.strictEqual(r.block, true);
   assert.ok(r.reason?.includes('M009'));
 });
 
 test('shouldBlockContextArtifactSave: milestone CONTEXT after verification → allow', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   markDepthVerified('M010');
   const r = shouldBlockContextArtifactSave('CONTEXT', 'M010');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockContextArtifactSave: CONTEXT with no milestoneId → block', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   const r = shouldBlockContextArtifactSave('CONTEXT', null);
   assert.strictEqual(r.block, true);
   assert.ok(r.reason);

package/src/resources/extensions/gsd/tests/write-gate.test.ts

@@ -9,14 +9,16 @@
  *   (e) else → block with actionable reason
  */
 
-import test from 'node:test';
+import test, { afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdirSync, writeFileSync, unlinkSync, existsSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { randomUUID } from 'node:crypto';
 import {
+  isDepthVerified,
   isDepthConfirmationAnswer,
+  isQueuePhaseActive,
   shouldBlockContextWrite,
   setQueuePhaseActive,
 } from '../index.ts';
@@ -32,6 +34,10 @@ import {
   loadWriteGateSnapshot,
 } from '../bootstrap/write-gate.ts';
 
+afterEach(() => {
+  clearDiscussionFlowState(process.cwd());
+});
+
 // ─── Scenario 1: Blocks CONTEXT.md write during discussion without depth verification (absolute path) ──
 
 test('write-gate: blocks CONTEXT.md write during discussion without depth verification (absolute path)', () => {
@@ -61,7 +67,7 @@ test('write-gate: blocks CONTEXT.md write during discussion without depth verifi
 // ─── Scenario 3: Allows CONTEXT.md write after depth verification ──
 
 test('write-gate: allows CONTEXT.md write after depth verification', () => {
-  clearDiscussionFlowState();
+  clearDiscussionFlowState(process.cwd());
   markDepthVerified('M001');
   const result = shouldBlockContextWrite(
     'write',
@@ -70,7 +76,6 @@ test('write-gate: allows CONTEXT.md write after depth verification', () => {
   );
   assert.strictEqual(result.block, false, 'should not block after depth verification');
   assert.strictEqual(result.reason, undefined, 'should have no reason');
-  clearDiscussionFlowState();
 });
 
 // ─── Scenario 4: Ambiguous session context no longer bypasses the gate ──
@@ -154,7 +159,7 @@ test('write-gate: blocks CONTEXT.md write in queue mode without depth verificati
 // ─── Scenario 9: Queue mode allows CONTEXT.md write after depth verification ──
 
 test('write-gate: allows CONTEXT.md write in queue mode after depth verification', () => {
-  clearDiscussionFlowState();
+  clearDiscussionFlowState(process.cwd());
   markDepthVerified('M001');
   const result = shouldBlockContextWrite(
     'write',
@@ -163,13 +168,12 @@ test('write-gate: allows CONTEXT.md write in queue mode after depth verification
     true,   // queue phase active
   );
   assert.strictEqual(result.block, false, 'should not block in queue mode after depth verification');
-  clearDiscussionFlowState();
 });
 
 // ─── Scenario 10: depth verification is scoped per milestone, not global ──
 
 test('write-gate: markDepthVerified unlocks only the matching milestone', () => {
-  clearDiscussionFlowState();
+  clearDiscussionFlowState(process.cwd());
   markDepthVerified('M001');
 
   const allowed = shouldBlockContextWrite(
@@ -187,14 +191,12 @@ test('write-gate: markDepthVerified unlocks only the matching milestone', () =>
   assert.strictEqual(blockedOther.block, true, 'other milestones should remain blocked');
   assert.strictEqual(isMilestoneDepthVerified('M001'), true);
   assert.strictEqual(isMilestoneDepthVerified('M002'), false);
-
-  clearDiscussionFlowState();
 });
 
 // ─── Scenario 11: gsd_summary_save CONTEXT contract is milestone-scoped ──
 
 test('write-gate: gsd_summary_save only blocks final milestone CONTEXT writes', () => {
-  clearDiscussionFlowState();
+  clearDiscussionFlowState(process.cwd());
 
   assert.strictEqual(
     shouldBlockContextArtifactSave('CONTEXT-DRAFT', 'M001').block,
@@ -218,8 +220,6 @@ test('write-gate: gsd_summary_save only blocks final milestone CONTEXT writes',
     false,
     'final milestone CONTEXT should pass after verification',
   );
-
-  clearDiscussionFlowState();
 });
 
 test('write-gate: root PROJECT/REQUIREMENTS final saves block behind pending approval gate', () => {
@@ -299,12 +299,12 @@ test('write-gate: deep root PROJECT/REQUIREMENTS final saves require verified ap
 });
 
 test('write-gate: reopening a gate revokes its previous verified approval', () => {
-  clearDiscussionFlowState();
+  clearDiscussionFlowState(process.cwd());
 
   markApprovalGateVerified('depth_verification_project_confirm');
   assert.strictEqual(
     shouldBlockRootArtifactSaveInSnapshot(
-      loadWriteGateSnapshot(),
+      loadWriteGateSnapshot(process.cwd()),
       'PROJECT',
       { requireVerifiedApproval: true },
     ).block,
@@ -312,20 +312,18 @@ test('write-gate: reopening a gate revokes its previous verified approval', () =
     'precondition: verified approval unlocks the final project artifact',
   );
 
-  setPendingGate('depth_verification_project_confirm');
-  clearPendingGate();
+  setPendingGate('depth_verification_project_confirm', process.cwd());
+  clearPendingGate(process.cwd());
 
   assert.strictEqual(
     shouldBlockRootArtifactSaveInSnapshot(
-      loadWriteGateSnapshot(),
+      loadWriteGateSnapshot(process.cwd()),
       'PROJECT',
       { requireVerifiedApproval: true },
     ).block,
     true,
     'a re-asked gate must require a fresh approval',
   );
-
-  clearDiscussionFlowState();
 });
 
 // ═══════════════════════════════════════════════════════════════════════
@@ -357,26 +355,26 @@ test('write-gate: isGateQuestionId recognizes all gate patterns', () => {
 // ─── Scenario 20: setPendingGate / getPendingGate / clearPendingGate lifecycle ──
 
 test('write-gate: pending gate lifecycle (set, get, clear)', () => {
-  clearDiscussionFlowState();
+  clearDiscussionFlowState(process.cwd());
   assert.strictEqual(getPendingGate(), null, 'starts null');
 
-  setPendingGate('depth_verification');
+  setPendingGate('depth_verification', process.cwd());
   assert.strictEqual(getPendingGate(), 'depth_verification', 'set correctly');
 
-  clearPendingGate();
+  clearPendingGate(process.cwd());
   assert.strictEqual(getPendingGate(), null, 'cleared correctly');
 
   // clearDiscussionFlowState also clears pending gate
-  setPendingGate('depth_verification_M002');
-  clearDiscussionFlowState();
+  setPendingGate('depth_verification_M002', process.cwd());
+  clearDiscussionFlowState(process.cwd());
   assert.strictEqual(getPendingGate(), null, 'clearDiscussionFlowState clears pending gate');
 });
 
 // ─── Scenario 21: shouldBlockPendingGate blocks non-safe tools when gate is pending ──
 
 test('write-gate: shouldBlockPendingGate blocks write/edit during pending gate', () => {
-  clearDiscussionFlowState();
-  setPendingGate('depth_verification');
+  clearDiscussionFlowState(process.cwd());
+  setPendingGate('depth_verification', process.cwd());
 
   // write should be blocked during discussion
   const writeResult = shouldBlockPendingGate('write', 'M001', false);
@@ -390,15 +388,13 @@ test('write-gate: shouldBlockPendingGate blocks write/edit during pending gate',
   // gsd tools should be blocked
   const gsdResult = shouldBlockPendingGate('gsd_plan_milestone', 'M001', false);
   assert.strictEqual(gsdResult.block, true, 'gsd tools should be blocked');
-
-  clearDiscussionFlowState();
 });
 
 // ─── Scenario 22: shouldBlockPendingGate allows only re-asking when gate is pending ──
 
 test('write-gate: shouldBlockPendingGate blocks read-only tools and allows ask_user_questions during pending gate', () => {
-  clearDiscussionFlowState();
-  setPendingGate('depth_verification');
+  clearDiscussionFlowState(process.cwd());
+  setPendingGate('depth_verification', process.cwd());
 
   // ask_user_questions is always safe (model needs to re-ask)
   assert.strictEqual(shouldBlockPendingGate('ask_user_questions', 'M001').block, false);
@@ -407,67 +403,57 @@ test('write-gate: shouldBlockPendingGate blocks read-only tools and allows ask_u
   assert.strictEqual(shouldBlockPendingGate('grep', 'M001').block, true);
   assert.strictEqual(shouldBlockPendingGate('glob', 'M001').block, true);
   assert.strictEqual(shouldBlockPendingGate('ls', 'M001').block, true);
-
-  clearDiscussionFlowState();
 });
 
 // ─── Scenario 23: shouldBlockPendingGate still blocks when the session is ambiguous ──
 
 test('write-gate: shouldBlockPendingGate blocks outside discussion when a gate is pending', () => {
-  clearDiscussionFlowState();
-  setPendingGate('depth_verification');
+  clearDiscussionFlowState(process.cwd());
+  setPendingGate('depth_verification', process.cwd());
 
   // No milestoneId and no queue phase — still block because the gate is pending
   const result = shouldBlockPendingGate('write', null, false);
   assert.strictEqual(result.block, true, 'should block even when milestoneId is null');
-
-  clearDiscussionFlowState();
 });
 
 // ─── Scenario 24: shouldBlockPendingGate blocks in queue mode ──
 
 test('write-gate: shouldBlockPendingGate blocks in queue mode when gate is pending', () => {
-  clearDiscussionFlowState();
-  setQueuePhaseActive(true);
-  setPendingGate('depth_verification');
+  clearDiscussionFlowState(process.cwd());
+  setQueuePhaseActive(true, process.cwd());
+  setPendingGate('depth_verification', process.cwd());
 
   const result = shouldBlockPendingGate('write', null, true);
   assert.strictEqual(result.block, true, 'should block in queue mode');
-
-  clearDiscussionFlowState();
 });
 
 // ─── Scenario 25: shouldBlockPendingGateBash blocks read-only commands ──
 
 test('write-gate: shouldBlockPendingGateBash blocks read-only commands during pending gate', () => {
-  clearDiscussionFlowState();
-  setPendingGate('depth_verification');
+  clearDiscussionFlowState(process.cwd());
+  setPendingGate('depth_verification', process.cwd());
 
   assert.strictEqual(shouldBlockPendingGateBash('cat file.txt', 'M001').block, true);
   assert.strictEqual(shouldBlockPendingGateBash('git log --oneline', 'M001').block, true);
   assert.strictEqual(shouldBlockPendingGateBash('grep -r pattern .', 'M001').block, true);
   assert.strictEqual(shouldBlockPendingGateBash('ls -la', 'M001').block, true);
-
-  clearDiscussionFlowState();
 });
 
 // ─── Scenario 26: shouldBlockPendingGateBash blocks mutating commands ──
 
 test('write-gate: shouldBlockPendingGateBash blocks mutating commands during pending gate', () => {
-  clearDiscussionFlowState();
-  setPendingGate('depth_verification');
+  clearDiscussionFlowState(process.cwd());
+  setPendingGate('depth_verification', process.cwd());
 
   const result = shouldBlockPendingGateBash('npm run build', 'M001');
   assert.strictEqual(result.block, true, 'mutating bash should be blocked');
   assert.ok(result.reason!.includes('depth_verification'));
-
-  clearDiscussionFlowState();
 });
 
 // ─── Scenario 27: no pending gate means no blocking ──
 
 test('write-gate: no pending gate means no blocking', () => {
-  clearDiscussionFlowState();
+  clearDiscussionFlowState(process.cwd());
 
   assert.strictEqual(shouldBlockPendingGate('write', 'M001').block, false);
   assert.strictEqual(shouldBlockPendingGateBash('npm run build', 'M001').block, false);
@@ -476,11 +462,40 @@ test('write-gate: no pending gate means no blocking', () => {
 // ─── Scenario 28: resetWriteGateState clears pending gate ──
 
 test('write-gate: resetWriteGateState clears pending gate', () => {
-  setPendingGate('depth_verification');
-  resetWriteGateState();
+  setPendingGate('depth_verification', process.cwd());
+  resetWriteGateState(process.cwd());
   assert.strictEqual(getPendingGate(), null);
 });
 
+test('write-gate: in-memory state is scoped by basePath', () => {
+  const workspaceA = join(tmpdir(), `gsd-write-gate-isolation-a-${randomUUID()}`);
+  const workspaceB = join(tmpdir(), `gsd-write-gate-isolation-b-${randomUUID()}`);
+
+  try {
+    clearDiscussionFlowState(workspaceA);
+    clearDiscussionFlowState(workspaceB);
+
+    setPendingGate('depth_verification_M777', workspaceA);
+    assert.strictEqual(getPendingGate(workspaceA), 'depth_verification_M777', 'workspace A should see its pending gate');
+    assert.strictEqual(getPendingGate(workspaceB), null, 'workspace B should not see workspace A pending gate');
+
+    clearPendingGate(workspaceA);
+    setQueuePhaseActive(true, workspaceA);
+    assert.strictEqual(isQueuePhaseActive(workspaceA), true, 'workspace A should see queue mode active');
+    assert.strictEqual(isQueuePhaseActive(workspaceB), false, 'workspace B should not see workspace A queue mode');
+
+    markDepthVerified('M777', workspaceA);
+    assert.strictEqual(isMilestoneDepthVerified('M777', workspaceA), true, 'workspace A should see its verified milestone');
+    assert.strictEqual(isMilestoneDepthVerified('M777', workspaceB), false, 'workspace B should not see workspace A milestone verification');
+    assert.strictEqual(isDepthVerified(workspaceB), false, 'workspace B should have no verified depth state');
+  } finally {
+    clearDiscussionFlowState(workspaceA);
+    clearDiscussionFlowState(workspaceB);
+    rmSync(workspaceA, { recursive: true, force: true });
+    rmSync(workspaceB, { recursive: true, force: true });
+  }
+});
+
 // ─── Standard options fixture used across depth confirmation tests ──
 
 const STANDARD_OPTIONS = [
@@ -656,7 +671,7 @@ test('write-gate: loadWriteGateSnapshot returns empty default when persist file
     } else {
       process.env.GSD_PERSIST_WRITE_GATE_STATE = originalEnv;
     }
-    clearDiscussionFlowState();
+    clearDiscussionFlowState(base);
     try {
       rmSync(base, { recursive: true, force: true });
     } catch { /* swallow */ }

package/src/resources/extensions/gsd/tests/write-intercept.test.ts

@@ -71,6 +71,6 @@ test('write-intercept: BLOCKED_WRITE_ERROR is a non-empty string', () => {
 });
 
 test('write-intercept: BLOCKED_WRITE_ERROR mentions engine tool calls', () => {
-  assert.ok(BLOCKED_WRITE_ERROR.includes('gsd_complete_task'), 'should mention gsd_complete_task');
+  assert.ok(BLOCKED_WRITE_ERROR.includes('gsd_task_complete'), 'should mention gsd_task_complete');
   assert.ok(BLOCKED_WRITE_ERROR.includes('engine tool calls'), 'should mention engine tool calls');
 });

package/src/resources/extensions/gsd/tools/complete-milestone.ts

@@ -56,6 +56,7 @@ export interface CompleteMilestoneParams {
 export interface CompleteMilestoneResult {
   milestoneId: string;
   summaryPath: string;
+  stale?: boolean;
 }
 
 function renderMilestoneSummaryMarkdown(params: CompleteMilestoneParams): string {
@@ -206,15 +207,15 @@ export async function handleCompleteMilestone(
   // This handles re-dispatch scenarios (DB/disk state divergence) where a prior
   // completion already wrote the file. Overwriting would silently destroy the
   // richer content the agent produced during the original completion run.
+  let projectionStale = false;
   if (!existsSync(summaryPath)) {
     try {
       await saveFile(summaryPath, summaryMd);
     } catch (renderErr) {
-      // Disk render failed — roll back DB status so state stays consistent
-      logWarning("tool", `complete_milestone — disk render failed, rolling back DB status: ${(renderErr as Error).message}`);
-      updateMilestoneStatus(params.milestoneId, 'active', null);
-      invalidateStateCache();
-      return { error: `disk render failed: ${(renderErr as Error).message}` };
+      projectionStale = true;
+      logWarning("projection", `complete_milestone projection write failed for ${params.milestoneId}; DB completion remains committed`, {
+        error: (renderErr as Error).message,
+      });
     }
   }
 
@@ -252,5 +253,6 @@ export async function handleCompleteMilestone(
   return {
     milestoneId: params.milestoneId,
     summaryPath,
+    ...(projectionStale ? { stale: true } : {}),
   };
 }

package/src/resources/extensions/gsd/tools/complete-slice.ts

@@ -4,7 +4,8 @@
  * Validates inputs, checks all tasks are complete, writes slice row to DB in
  * a transaction, then (outside the transaction) renders SUMMARY.md + UAT.md
  * to disk, toggles the roadmap checkbox, stores rendered markdown in DB for
- * D004 recovery, and invalidates caches.
+ * D004 recovery, and invalidates caches. Projection write failures are stale
+ * projection diagnostics and do not roll back committed DB state.
  */
 
 import { join } from "node:path";
@@ -277,7 +278,6 @@ export async function handleCompleteSlice(
 
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   const completedAt = new Date().toISOString();
-  const originalSliceStatus = getSlice(params.milestoneId, params.sliceId)?.status ?? "pending";
   let guardError: string | null = null;
 
   transaction(() => {
@@ -349,10 +349,6 @@ export async function handleCompleteSlice(
     return { error: guardError };
   }
 
-  // ── Filesystem operations (outside transaction) ─────────────────────────
-  // If disk render fails, roll back the DB status so deriveState() and
-  // verifyExpectedArtifact() stay consistent (both say "not done").
-
   // Render summary markdown
   const summaryMd = renderSliceSummaryMarkdown(params);
 
@@ -371,6 +367,8 @@ export async function handleCompleteSlice(
 
   const uatMd = renderUatMarkdown(params);
   const uatPath = summaryPath.replace(/-SUMMARY\.md$/, "-UAT.md");
+  setSliceSummaryMd(params.milestoneId, params.sliceId, summaryMd, uatMd);
+  let projectionStale = false;
 
   try {
     await saveFile(summaryPath, summaryMd);
@@ -382,16 +380,10 @@ export async function handleCompleteSlice(
       logWarning("tool", `complete_slice — could not find roadmap for ${params.milestoneId}, skipping checkbox toggle`);
     }
   } catch (renderErr) {
-    // Disk render failed — roll back DB status so state stays consistent
-    logWarning("tool", `complete_slice — disk render failed for ${params.milestoneId}/${params.sliceId}, rolling back DB status`, { error: (renderErr as Error).message });
-    updateSliceStatus(params.milestoneId, params.sliceId, originalSliceStatus);
-    invalidateStateCache();
-    return { error: `disk render failed: ${(renderErr as Error).message}` };
+    projectionStale = true;
+    logWarning("projection", `complete_slice projection write failed for ${params.milestoneId}/${params.sliceId}; DB completion remains committed`, { error: (renderErr as Error).message });
   }
 
-  // Store rendered markdown in DB for D004 recovery
-  setSliceSummaryMd(params.milestoneId, params.sliceId, summaryMd, uatMd);
-
   // ── Close gates owned by complete-slice (Q8) ───────────────────────────
   // Each owned gate maps to a specific summary section via the registry.
   // If the caller populated the corresponding field, record `pass`; if the
@@ -493,5 +485,6 @@ export async function handleCompleteSlice(
     milestoneId: params.milestoneId,
     summaryPath,
     uatPath,
+    ...(projectionStale ? { stale: true } : {}),
   };
 }