gsd-pi 2.78.1-dev.e9d88a536 → 2.78.1-dev.eccf86e27

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,33 +299,39 @@ test('write-gate: deep root PROJECT/REQUIREMENTS final saves require verified ap
 });
 
 test('write-gate: reopening a gate revokes its previous verified approval', () => {
-  clearDiscussionFlowState();
-
-  markApprovalGateVerified('depth_verification_project_confirm');
-  assert.strictEqual(
-    shouldBlockRootArtifactSaveInSnapshot(
-      loadWriteGateSnapshot(),
-      'PROJECT',
-      { requireVerifiedApproval: true },
-    ).block,
-    false,
-    'precondition: verified approval unlocks the final project artifact',
-  );
-
-  setPendingGate('depth_verification_project_confirm');
-  clearPendingGate();
-
-  assert.strictEqual(
-    shouldBlockRootArtifactSaveInSnapshot(
-      loadWriteGateSnapshot(),
-      'PROJECT',
-      { requireVerifiedApproval: true },
-    ).block,
-    true,
-    'a re-asked gate must require a fresh approval',
-  );
+  const base = join(tmpdir(), `gsd-write-gate-reopen-${randomUUID()}`);
+  mkdirSync(base, { recursive: true });
 
-  clearDiscussionFlowState();
+  try {
+    clearDiscussionFlowState(base);
+
+    markApprovalGateVerified('depth_verification_project_confirm', base);
+    assert.strictEqual(
+      shouldBlockRootArtifactSaveInSnapshot(
+        loadWriteGateSnapshot(base),
+        'PROJECT',
+        { requireVerifiedApproval: true },
+      ).block,
+      false,
+      'precondition: verified approval unlocks the final project artifact',
+    );
+
+    setPendingGate('depth_verification_project_confirm', base);
+    clearPendingGate(base);
+
+    assert.strictEqual(
+      shouldBlockRootArtifactSaveInSnapshot(
+        loadWriteGateSnapshot(base),
+        'PROJECT',
+        { requireVerifiedApproval: true },
+      ).block,
+      true,
+      'a re-asked gate must require a fresh approval',
+    );
+  } finally {
+    clearDiscussionFlowState(base);
+    rmSync(base, { recursive: true, force: true });
+  }
 });
 
 // ═══════════════════════════════════════════════════════════════════════
@@ -357,26 +363,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 +396,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 +411,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 +470,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 +679,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/workflow-mcp.ts

@@ -349,9 +349,9 @@ export function getRequiredWorkflowToolsForAutoUnit(unitType: string): string[]
     case "execute-task":
     case "execute-task-simple":
     case "reactive-execute":
-      return ["gsd_complete_task"];
+      return ["gsd_task_complete"];
     case "complete-slice":
-      return ["gsd_complete_slice"];
+      return ["gsd_slice_complete"];
     case "replan-slice":
       return ["gsd_replan_slice"];
     case "reassess-roadmap":

package/src/resources/extensions/gsd/workspace.ts

@@ -0,0 +1,95 @@
+// GSD-2 + Workspace handle: single source of truth for path resolution per milestone
+
+import { join, resolve } from "node:path";
+import { type GsdPathContract, resolveGsdPathContract, normalizeRealPath } from "./paths.js";
+import { isGsdWorktreePath, resolveWorktreeProjectRoot } from "./worktree-root.js";
+
+export type GsdWorkspaceMode = "project" | "worktree";
+
+export interface GsdWorkspace {
+  readonly projectRoot: string;          // realpath-normalized absolute
+  readonly worktreeRoot: string | null;  // realpath-normalized absolute, null when no worktree
+  readonly mode: GsdWorkspaceMode;
+  readonly contract: GsdPathContract;    // pre-resolved, frozen
+  readonly identityKey: string;          // canonical key (realpath of projectRoot) for dedup/cache
+  readonly lockRoot: string;             // where auto.lock and {MID}-META.json live (always projectRoot)
+}
+
+export interface MilestoneScope {
+  readonly workspace: GsdWorkspace;
+  readonly milestoneId: string;
+  // path methods:
+  readonly contextFile: () => string;
+  readonly roadmapFile: () => string;
+  readonly stateFile: () => string;
+  readonly dbPath: () => string;
+  readonly milestoneDir: () => string;
+  readonly metaJson: () => string;       // {MID}-META.json on lockRoot
+}
+
+function tryRealpath(p: string): string {
+  return normalizeRealPath(p);
+}
+
+/**
+ * Create an immutable GsdWorkspace handle from a raw base path.
+ * Resolves both the project root and (when applicable) the worktree root,
+ * normalizes them via realpath, and freezes the result.
+ */
+export function createWorkspace(rawBasePath: string): GsdWorkspace {
+  const resolvedBase = resolve(rawBasePath);
+  const isWorktree = isGsdWorktreePath(resolvedBase);
+
+  const projectRootRaw = resolveWorktreeProjectRoot(resolvedBase);
+  const projectRoot = tryRealpath(resolve(projectRootRaw));
+
+  const worktreeRoot = isWorktree ? tryRealpath(resolvedBase) : null;
+
+  // Derive a canonical base from the already-realpath-normalized paths so that
+  // resolveGsdPathContract always receives a canonical path. Using the raw
+  // resolvedBase here can produce a non-canonical projectGsd when the input
+  // path contains symlinks, causing contract.projectGsd to diverge from the
+  // realpath-normalized projectRoot / identityKey.
+  const canonicalBase = isWorktree ? (worktreeRoot ?? resolvedBase) : projectRoot;
+  const contract = Object.freeze(resolveGsdPathContract(canonicalBase));
+
+  const identityKey = tryRealpath(projectRoot);
+
+  const mode: GsdWorkspaceMode = isWorktree ? "worktree" : "project";
+
+  const workspace: GsdWorkspace = Object.freeze({
+    projectRoot,
+    worktreeRoot,
+    mode,
+    contract,
+    identityKey,
+    lockRoot: projectRoot,
+  });
+
+  return workspace;
+}
+
+/**
+ * Bind a milestoneId to a workspace, producing an immutable MilestoneScope
+ * with path-returning closures that resolve via the authoritative projectGsd.
+ *
+ * All milestone-content paths route to contract.projectGsd (canonical),
+ * since that is the authoritative source of truth regardless of worktree mode.
+ */
+export function scopeMilestone(workspace: GsdWorkspace, milestoneId: string): MilestoneScope {
+  const { contract } = workspace;
+  const gsd = contract.projectGsd;
+
+  const scope: MilestoneScope = Object.freeze({
+    workspace,
+    milestoneId,
+    contextFile: () => join(gsd, "milestones", milestoneId, `${milestoneId}-CONTEXT.md`),
+    roadmapFile: () => join(gsd, "milestones", milestoneId, `${milestoneId}-ROADMAP.md`),
+    stateFile: () => join(gsd, "STATE.md"),
+    dbPath: () => contract.projectDb,
+    milestoneDir: () => join(gsd, "milestones", milestoneId),
+    metaJson: () => join(gsd, `${milestoneId}-META.json`),
+  });
+
+  return scope;
+}