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

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/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;
+}

package/src/resources/extensions/gsd/worktree-resolver.ts

@@ -1,3 +1,4 @@
+// GSD-2 — WorktreeResolver: encapsulates worktree path state and merge/exit lifecycle.
 /**
  * WorktreeResolver — encapsulates worktree path state and merge/exit lifecycle.
  *
@@ -23,7 +24,20 @@ import { emitJournalEvent } from "./journal.js";
 import { emitWorktreeCreated, emitWorktreeMerged } from "./worktree-telemetry.js";
 import { getCollapseCadence, getMilestoneResquash, resquashMilestoneOnMain } from "./slice-cadence.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { resolveWorktreeProjectRoot } from "./worktree-root.js";
+import { resolveWorktreeProjectRoot, normalizeWorktreePathForCompare } from "./worktree-root.js";
+
+// ─── Path Comparison Helper ────────────────────────────────────────────────
+/**
+ * Compare two paths for physical identity, tolerating trailing slashes,
+ * symlink differences, and case variations on case-insensitive volumes.
+ *
+ * Used in place of string `===` / `!==` wherever one operand may be
+ * realpath-normalised (e.g. from the workspace registry) and the other
+ * may not be (e.g. a raw caller-supplied basePath).
+ */
+function isSamePath(a: string, b: string): boolean {
+  return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
+}
 
 // ─── Dependency Interface ──────────────────────────────────────────────────
 
@@ -589,7 +603,7 @@ export class WorktreeResolver {
         milestoneId,
         "ROADMAP",
       );
-      if (!roadmapPath && this.s.basePath !== originalBase) {
+      if (!roadmapPath && !isSamePath(this.s.basePath, originalBase)) {
         roadmapPath = this.deps.resolveMilestoneFile(
           this.s.basePath,
           milestoneId,

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

@@ -91,9 +91,9 @@ function matchesBlockedPattern(path: string): boolean {
  * Directs the agent to use engine tool calls instead.
  */
 export const BLOCKED_WRITE_ERROR = `Direct writes to .gsd/STATE.md and .gsd/gsd.db are blocked. Use engine tool calls instead:
-- To complete a task: call gsd_complete_task(milestone_id, slice_id, task_id, summary)
-- To complete a slice: call gsd_complete_slice(milestone_id, slice_id, summary, uat_result)
-- To save a decision: call gsd_save_decision(scope, decision, choice, rationale)
+- To complete a task: call gsd_task_complete(milestone_id, slice_id, task_id, summary)
+- To complete a slice: call gsd_slice_complete(milestone_id, slice_id, summary, uat_result)
+- To save a decision: call gsd_decision_save(scope, decision, choice, rationale)
 - To start a task: call gsd_start_task(milestone_id, slice_id, task_id)
 - To record verification: call gsd_record_verification(milestone_id, slice_id, task_id, evidence)
 - To report a blocker: call gsd_report_blocker(milestone_id, slice_id, task_id, description)`;