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

package/src/resources/extensions/gsd/tests/workflow-mcp-auto-prep.test.ts

@@ -15,7 +15,7 @@ test("shouldAutoPrepareWorkflowMcp enables prep for externalCli local transport"
   assert.equal(result, true);
 });
 
-test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is ready", () => {
+test("shouldAutoPrepareWorkflowMcp stays disabled for non-Claude active provider even when claude-code is ready", () => {
   const result = shouldAutoPrepareWorkflowMcp({
     model: { provider: "openai", baseUrl: "https://api.openai.com" },
     modelRegistry: {
@@ -24,10 +24,10 @@ test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is rea
     },
   });
 
-  assert.equal(result, true);
+  assert.equal(result, false);
 });
 
-test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is registered", () => {
+test("shouldAutoPrepareWorkflowMcp stays disabled for non-Claude active provider even when claude-code is registered", () => {
   const result = shouldAutoPrepareWorkflowMcp({
     model: { provider: "openai", baseUrl: "https://api.openai.com" },
     modelRegistry: {
@@ -36,7 +36,7 @@ test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is reg
     },
   });
 
-  assert.equal(result, true);
+  assert.equal(result, false);
 });
 
 test("shouldAutoPrepareWorkflowMcp stays disabled when neither transport nor provider readiness match", () => {

package/src/resources/extensions/gsd/tests/workflow-mcp.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
@@ -30,6 +30,17 @@ function readSrc(file: string): string {
   return readFileSync(join(gsdDir, file), "utf-8");
 }
 
+function listTsFiles(dir: string): string[] {
+  const out: string[] = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    const stat = statSync(full);
+    if (stat.isDirectory()) out.push(...listTsFiles(full));
+    else if (entry.endsWith(".ts")) out.push(full);
+  }
+  return out;
+}
+
 function extractElicitPayload(request: unknown): ElicitPayload {
   const payload = (request as { params?: unknown }).params ?? request;
   return payload as ElicitPayload;
@@ -39,8 +50,8 @@ test("guided execute-task requires canonical task completion tool", () => {
   assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("execute-task"), ["gsd_task_complete"]);
 });
 
-test("auto execute-task requires legacy completion alias until prompt contract is aligned", () => {
-  assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("execute-task"), ["gsd_complete_task"]);
+test("auto execute-task requires canonical task completion tool", () => {
+  assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("execute-task"), ["gsd_task_complete"]);
 });
 
 test("deep project setup units declare required workflow MCP tools", () => {
@@ -772,3 +783,15 @@ test("workflow transport error guidance includes /gsd mcp init hint", () => {
   const src = readSrc("workflow-mcp.ts");
   assert.match(src, /Please run \/gsd mcp init \./);
 });
+
+test("buildWorkflowMcpServers is only imported by tests or Claude Code MCP boundary code", () => {
+  const offenders: string[] = [];
+  for (const file of listTsFiles(gsdDir)) {
+    const rel = file.slice(gsdDir.length + 1).replace(/\\/g, "/");
+    if (rel === "workflow-mcp.ts" || rel.startsWith("tests/")) continue;
+    const src = readFileSync(file, "utf-8");
+    if (/\bimport\b[\s\S]*\bbuildWorkflowMcpServers\b/.test(src)) offenders.push(rel);
+  }
+
+  assert.deepEqual(offenders, []);
+});

package/src/resources/extensions/gsd/tests/workflow-tool-executors.test.ts

@@ -677,7 +677,7 @@ test("executeSummarySave removes sibling CONTEXT-DRAFT when writing milestone CO
       "CONTEXT-DRAFT.md should be removed after final CONTEXT.md is written",
     );
   } finally {
-    clearDiscussionFlowState();
+    clearDiscussionFlowState(base);
     closeDatabase();
     cleanup(base);
   }
@@ -741,9 +741,7 @@ test("executeSummarySave blocks final root artifacts while approval gate is pend
   const base = makeTmpBase();
   try {
     openTestDb(base);
-    await inProjectDir(base, async () => {
-      setPendingGate("depth_verification_requirements_confirm");
-    });
+    setPendingGate("depth_verification_requirements_confirm", base);
 
     const result = await inProjectDir(base, () => executeSummarySave({
       artifact_type: "REQUIREMENTS",
@@ -762,7 +760,7 @@ test("executeSummarySave blocks final root artifacts while approval gate is pend
     assert.equal(draft.isError, undefined);
     assert.ok(existsSync(join(base, ".gsd", "REQUIREMENTS-DRAFT.md")));
   } finally {
-    clearDiscussionFlowState();
+    clearDiscussionFlowState(base);
     closeDatabase();
     cleanup(base);
   }
@@ -784,9 +782,7 @@ test("executeSummarySave requires verified root approval in deep mode", async ()
     assert.match(blocked.content[0].text, /fail-closed/);
     assert.equal(existsSync(join(base, ".gsd", "PROJECT.md")), false);
 
-    await inProjectDir(base, async () => {
-      markApprovalGateVerified("depth_verification_project_confirm", base);
-    });
+    markApprovalGateVerified("depth_verification_project_confirm", base);
 
     const unblocked = await inProjectDir(base, () => executeSummarySave({
       artifact_type: "PROJECT",
@@ -797,7 +793,7 @@ test("executeSummarySave requires verified root approval in deep mode", async ()
     assert.equal(unblocked.details.path, "PROJECT.md");
     assert.ok(existsSync(join(base, ".gsd", "PROJECT.md")));
   } finally {
-    clearDiscussionFlowState();
+    clearDiscussionFlowState(base);
     closeDatabase();
     cleanup(base);
   }
@@ -807,9 +803,7 @@ test("executeSummarySave renders final REQUIREMENTS from the DB source of truth"
   const base = makeTmpBase();
   try {
     openTestDb(base);
-    await inProjectDir(base, async () => {
-      markApprovalGateVerified("depth_verification_requirements_confirm", base);
-    });
+    markApprovalGateVerified("depth_verification_requirements_confirm", base);
 
     upsertRequirement({
       id: "R001",
@@ -882,7 +876,7 @@ test("executeSummarySave renders final REQUIREMENTS from the DB source of truth"
       .get("REQUIREMENTS.md") as Record<string, unknown>;
     assert.equal(artifact.full_content, content);
   } finally {
-    clearDiscussionFlowState();
+    clearDiscussionFlowState(base);
     closeDatabase();
     cleanup(base);
   }
@@ -992,7 +986,7 @@ test("executeSummarySave CONTEXT HARD BLOCK clears after write-gate state file i
   process.env.GSD_PERSIST_WRITE_GATE_STATE = "1";
   try {
     openTestDb(base);
-    clearDiscussionFlowState();
+    clearDiscussionFlowState(base);
 
     // First call: CONTEXT artifact without depth verification → HARD BLOCK
     const blocked = await inProjectDir(base, () => executeSummarySave({
@@ -1043,7 +1037,7 @@ test("executeSummarySave CONTEXT HARD BLOCK clears after write-gate state file i
     } else {
       process.env.GSD_PERSIST_WRITE_GATE_STATE = originalEnv;
     }
-    clearDiscussionFlowState();
+    clearDiscussionFlowState(base);
     closeDatabase();
     cleanup(base);
   }

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

@@ -0,0 +1,190 @@
+// GSD-2 + Workspace handle tests: createWorkspace and scopeMilestone
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  rmSync,
+  realpathSync,
+  symlinkSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { createWorkspace, scopeMilestone } from "../workspace.ts";
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function makeProjectDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-ws-test-")));
+  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+  return dir;
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe("createWorkspace", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("from a project root produces mode=project and worktreeRoot=null", () => {
+    const ws = createWorkspace(projectDir);
+    assert.equal(ws.mode, "project");
+    assert.equal(ws.worktreeRoot, null);
+    assert.equal(ws.projectRoot, realpathSync(projectDir));
+  });
+
+  test("from a worktree path produces mode=worktree, worktreeRoot=realpath, projectRoot=realpath of project", () => {
+    // Construct a worktree path: <projectDir>/.gsd/worktrees/M001
+    const worktreePath = join(projectDir, ".gsd", "worktrees", "M001");
+    mkdirSync(worktreePath, { recursive: true });
+
+    const ws = createWorkspace(worktreePath);
+    assert.equal(ws.mode, "worktree");
+    assert.equal(ws.worktreeRoot, realpathSync(worktreePath));
+    assert.equal(ws.projectRoot, realpathSync(projectDir));
+  });
+
+  test("normalizes /foo and /foo/ to identical identityKey", () => {
+    const wsTrailing = createWorkspace(projectDir + "/");
+    const wsNoTrailing = createWorkspace(projectDir);
+    assert.equal(wsTrailing.identityKey, wsNoTrailing.identityKey);
+  });
+
+  test("follows symlinks — identityKey matches realpath of target", (t) => {
+    const linkPath = join(tmpdir(), `gsd-ws-link-${Date.now()}`);
+    symlinkSync(projectDir, linkPath);
+    t.after(() => {
+      try { rmSync(linkPath); } catch { /* ignore */ }
+    });
+
+    const ws = createWorkspace(linkPath);
+    assert.equal(ws.identityKey, realpathSync(projectDir));
+  });
+});
+
+describe("GsdWorkspace and MilestoneScope are frozen", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("workspace is frozen", () => {
+    const ws = createWorkspace(projectDir);
+    assert.ok(Object.isFrozen(ws), "workspace should be frozen");
+    assert.throws(() => {
+      (ws as { mode: string }).mode = "worktree";
+    }, /Cannot assign/);
+  });
+
+  test("scope is frozen", () => {
+    const ws = createWorkspace(projectDir);
+    const scope = scopeMilestone(ws, "M001");
+    assert.ok(Object.isFrozen(scope), "scope should be frozen");
+    assert.throws(() => {
+      (scope as { milestoneId: string }).milestoneId = "M999";
+    }, /Cannot assign/);
+  });
+
+  test("contract inside workspace is frozen", () => {
+    const ws = createWorkspace(projectDir);
+    assert.ok(Object.isFrozen(ws.contract), "contract should be frozen");
+  });
+});
+
+describe("scopeMilestone path methods", () => {
+  let projectDir: string;
+  const MID = "M001";
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("produces correct paths for a known milestone ID", () => {
+    const ws = createWorkspace(projectDir);
+    const scope = scopeMilestone(ws, MID);
+    const gsd = ws.contract.projectGsd;
+
+    assert.equal(scope.milestoneId, MID);
+    assert.equal(scope.contextFile(), join(gsd, "milestones", MID, `${MID}-CONTEXT.md`));
+    assert.equal(scope.roadmapFile(), join(gsd, "milestones", MID, `${MID}-ROADMAP.md`));
+    assert.equal(scope.stateFile(), join(gsd, "STATE.md"));
+    assert.equal(scope.dbPath(), ws.contract.projectDb);
+    assert.equal(scope.milestoneDir(), join(gsd, "milestones", MID));
+    assert.equal(scope.metaJson(), join(gsd, `${MID}-META.json`));
+  });
+
+  test("two scopes from same workspace + same MID produce identical paths", () => {
+    const ws = createWorkspace(projectDir);
+    const scope1 = scopeMilestone(ws, MID);
+    const scope2 = scopeMilestone(ws, MID);
+
+    assert.equal(scope1.contextFile(), scope2.contextFile());
+    assert.equal(scope1.roadmapFile(), scope2.roadmapFile());
+    assert.equal(scope1.stateFile(), scope2.stateFile());
+    assert.equal(scope1.dbPath(), scope2.dbPath());
+    assert.equal(scope1.milestoneDir(), scope2.milestoneDir());
+    assert.equal(scope1.metaJson(), scope2.metaJson());
+  });
+});
+
+describe("createWorkspace: contract.projectGsd is realpath-canonicalized when basePath is a symlink", () => {
+  let projectDir: string;
+  let linkPath: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    linkPath = join(tmpdir(), `gsd-ws-symlink-${Date.now()}`);
+    symlinkSync(projectDir, linkPath);
+  });
+
+  afterEach(() => {
+    try { rmSync(linkPath); } catch { /* ignore */ }
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("contract.projectGsd matches realpath of projectRoot when workspace is created via symlink", () => {
+    const ws = createWorkspace(linkPath);
+
+    const canonicalProjectRoot = realpathSync(projectDir);
+
+    // identityKey must be the realpath of the canonical project root
+    assert.equal(ws.identityKey, canonicalProjectRoot);
+    assert.equal(ws.projectRoot, canonicalProjectRoot);
+
+    // contract.projectGsd must start with the canonical project root —
+    // not with the symlink path. If the bug is present, contract.projectGsd
+    // would be linkPath + "/.gsd" instead of canonicalProjectRoot + "/.gsd".
+    assert.ok(
+      ws.contract.projectGsd.startsWith(canonicalProjectRoot),
+      `contract.projectGsd ("${ws.contract.projectGsd}") must be under the realpath'd projectRoot ("${canonicalProjectRoot}"), not the symlink path`,
+    );
+  });
+
+  test("contract.projectDb matches realpath of projectRoot when workspace is created via symlink", () => {
+    const ws = createWorkspace(linkPath);
+    const canonicalProjectRoot = realpathSync(projectDir);
+
+    assert.ok(
+      ws.contract.projectDb.startsWith(canonicalProjectRoot),
+      `contract.projectDb ("${ws.contract.projectDb}") must be under the realpath'd projectRoot ("${canonicalProjectRoot}")`,
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/worktree-db-same-file.test.ts

@@ -15,6 +15,7 @@ import {
   existsSync,
   mkdirSync,
   mkdtempSync,
+  readFileSync,
   rmSync,
   symlinkSync,
   writeFileSync,
@@ -157,6 +158,18 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
   });
 });
 
+test("merge-time DB reconciliation only runs when legacy worktree DB exists", () => {
+  const src = readFileSync(join(import.meta.dirname, "..", "auto-worktree.ts"), "utf-8");
+  const reconcileIdx = src.indexOf("reconcileWorktreeDb(mainDbPath, worktreeDbPath)");
+  assert.ok(reconcileIdx !== -1, "merge-time reconcile call exists");
+  const guardWindow = src.slice(Math.max(0, reconcileIdx - 240), reconcileIdx);
+
+  assert.ok(
+    guardWindow.includes("existsSync(worktreeDbPath)") && guardWindow.includes("!isSamePath(worktreeDbPath, mainDbPath)"),
+    "merge-time reconcile requires a real legacy worktree DB and distinct DB paths",
+  );
+});
+
 // ─── Fix 3: infrastructure error classification ─────────────────────
 
 describe("#2823: malformed DB classified as infrastructure error", () => {