gsd-pi 2.67.0-dev.43b0159 → 2.67.0-dev.4fb8afe

package/src/resources/extensions/gsd/tests/ensure-db-open.test.ts

@@ -77,6 +77,36 @@ describe('ensure-db-open', () => {
     }
   });
 
+  test('ensureDbOpen: explicit basePath opens target project without cwd override', async () => {
+    const tmpDir = makeTmpDir();
+    const gsdDir = path.join(tmpDir, '.gsd');
+    fs.mkdirSync(gsdDir, { recursive: true });
+    fs.writeFileSync(path.join(gsdDir, 'DECISIONS.md'), `# Decisions
+
+| # | When | Scope | Decision | Choice | Rationale | Revisable |
+|---|------|-------|----------|--------|-----------|-----------|
+| D777 | M001 | architecture | Use explicit basePath | BasePath | Avoid cwd coupling | Yes |
+`);
+
+    try {
+      closeDatabase();
+    } catch { /* ok */ }
+
+    const originalCwd = process.cwd();
+    try {
+      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
+      const result = await ensureDbOpen(tmpDir);
+
+      assert.ok(result === true, 'ensureDbOpen should honor explicit basePath');
+      assert.equal(process.cwd(), originalCwd, 'ensureDbOpen should not mutate process.cwd');
+      assert.ok(isDbAvailable(), 'DB should be available after explicit open');
+      assert.ok(getDecisionById('D777') !== null, 'explicit basePath DB should be opened');
+    } finally {
+      closeDatabase();
+      cleanupDir(tmpDir);
+    }
+  });
+
   // ═══════════════════════════════════════════════════════════════════════════
   // ensureDbOpen returns false when no .gsd/ exists
   // ═══════════════════════════════════════════════════════════════════════════
@@ -159,6 +189,42 @@ describe('ensure-db-open', () => {
     }
   });
 
+  test('ensureDbOpen: switches open database when basePath changes', async () => {
+    const firstDir = makeTmpDir();
+    const secondDir = makeTmpDir();
+    fs.mkdirSync(path.join(firstDir, '.gsd'), { recursive: true });
+    fs.mkdirSync(path.join(secondDir, '.gsd'), { recursive: true });
+    fs.writeFileSync(path.join(firstDir, '.gsd', 'DECISIONS.md'), `# Decisions
+
+| # | When | Scope | Decision | Choice | Rationale | Revisable |
+|---|------|-------|----------|--------|-----------|-----------|
+| D101 | M001 | architecture | First DB | First | First rationale | Yes |
+`);
+    fs.writeFileSync(path.join(secondDir, '.gsd', 'DECISIONS.md'), `# Decisions
+
+| # | When | Scope | Decision | Choice | Rationale | Revisable |
+|---|------|-------|----------|--------|-----------|-----------|
+| D202 | M001 | architecture | Second DB | Second | Second rationale | Yes |
+`);
+
+    try {
+      closeDatabase();
+    } catch { /* ok */ }
+
+    try {
+      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
+      assert.equal(await ensureDbOpen(firstDir), true);
+      assert.ok(getDecisionById('D101') !== null, 'first DB should be active');
+      assert.equal(await ensureDbOpen(secondDir), true);
+      assert.ok(getDecisionById('D202') !== null, 'second DB should be active after switch');
+      assert.equal(getDecisionById('D101'), null, 'first DB should no longer be active after switch');
+    } finally {
+      closeDatabase();
+      cleanupDir(firstDir);
+      cleanupDir(secondDir);
+    }
+  });
+
   // ═══════════════════════════════════════════════════════════════════════════
 
 });

package/src/resources/extensions/gsd/tests/integration/doctor-git.test.ts

@@ -661,9 +661,10 @@ describe('doctor-git', async () => {
         env: { ...process.env, GIT_COMMITTER_DATE: pastDate },
       });
 
-      // Modify an already-tracked file (nativeAddTracked uses git add -u,
-      // which only stages tracked files — new untracked files are not staged)
+      // Modify a tracked file and create a new untracked file. The snapshot
+      // must preserve both, not just tracked changes.
       writeFileSync(join(dir, "README.md"), "# test\nmodified content\n");
+      writeFileSync(join(dir, "new-untracked.ts"), "export const preserved = true;\n");
 
       const detect = await runGSDDoctor(dir);
       const staleIssues = detect.issues.filter(i => i.code === "stale_uncommitted_changes");
@@ -681,6 +682,12 @@ describe('doctor-git', async () => {
       // Verify the snapshot commit was created with the gsd snapshot tag
       const log = run("git log -1 --oneline", dir);
       assert.ok(log.includes("gsd snapshot"), "commit is tagged with gsd snapshot");
+
+      const files = run("git show --name-only --format= HEAD", dir);
+      assert.ok(files.includes("README.md"), "snapshot keeps tracked modifications");
+      assert.ok(files.includes("new-untracked.ts"), "snapshot also includes new untracked files");
+      const status = run("git status --short", dir);
+      assert.ok(!status.includes("new-untracked.ts"), "snapshot does not leave the new source file untracked");
     });
 
     // ─── Test: stale_uncommitted_changes NOT flagged when recent commit ──

package/src/resources/extensions/gsd/tests/integration/doctor-proactive.test.ts

@@ -219,6 +219,39 @@ describe('doctor-proactive', async () => {
       assert.ok(result.fixesApplied.some((f: string) => f.includes("STATE.md")), "reports STATE.md status as info");
     });
 
+    test('health gate: pre-dispatch snapshot includes new untracked files', async () => {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      const pastDate = new Date(Date.now() - 45 * 60 * 1000).toISOString();
+      run(`git commit --amend --no-edit --date="${pastDate}"`, dir);
+      execSync(`git commit --amend --no-edit`, {
+        cwd: dir,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: { ...process.env, GIT_COMMITTER_DATE: pastDate },
+      });
+
+      writeFileSync(join(dir, "README.md"), "# test\nmodified content\n");
+      writeFileSync(join(dir, "new-untracked.ts"), "export const preserved = true;\n");
+
+      const result = await preDispatchHealthGate(dir);
+      assert.ok(result.proceed, "dispatch still proceeds after snapshotting");
+      assert.ok(
+        result.fixesApplied.some((f: string) => f.includes("gsd snapshot")),
+        "pre-dispatch gate creates a snapshot commit",
+      );
+
+      const log = run("git log -1 --oneline", dir);
+      assert.ok(log.includes("gsd snapshot"), "snapshot commit is created");
+
+      const files = run("git show --name-only --format= HEAD", dir);
+      assert.ok(files.includes("README.md"), "snapshot keeps tracked modifications");
+      assert.ok(files.includes("new-untracked.ts"), "snapshot also includes new untracked files");
+      const status = run("git status --short", dir);
+      assert.ok(!status.includes("new-untracked.ts"), "snapshot does not leave the new source file untracked");
+    });
+
     test('health gate: stale crash lock auto-cleared', async () => {
       const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-proactive-")));
       cleanups.push(dir);

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -35,6 +35,13 @@ test("workflow-start prompt defaults to autonomy instead of per-phase confirmati
   assert.doesNotMatch(prompt, /Gate between phases/i);
 });
 
+test("system prompt references CODEBASE.md and /gsd codebase", () => {
+  const prompt = readPrompt("system");
+  assert.match(prompt, /CODEBASE\.md/);
+  assert.match(prompt, /\/gsd codebase \[generate\|update\|stats\]/);
+  assert.match(prompt, /auto-refreshes it when tracked files change/i);
+});
+
 test("discuss prompt allows implementation questions when they materially matter", () => {
   const prompt = readPrompt("discuss");
   assert.match(prompt, /Lead with experience, but ask implementation when it materially matters/i);

package/src/resources/extensions/gsd/tests/update-command.test.ts

@@ -65,3 +65,22 @@ test("/gsd update is listed in completions with correct description", () => {
     "completion description should mention updating",
   );
 });
+
+test("/gsd codebase appears in top-level completions", () => {
+  const pi = createMockPi();
+  registerGSDCommand(pi as any);
+
+  const gsd = pi.commands.get("gsd");
+  const completions = gsd.getArgumentCompletions("code");
+  const codebaseEntry = completions.find((c: any) => c.value === "codebase");
+  assert.ok(codebaseEntry, "codebase should appear in completions");
+  assert.match(codebaseEntry.description, /codebase map cache/i);
+});
+
+test("/gsd codebase appears in help description", () => {
+  const pi = createMockPi();
+  registerGSDCommand(pi as any);
+
+  const gsd = pi.commands.get("gsd");
+  assert.ok(gsd?.description?.includes("codebase"), "description should mention codebase");
+});

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

@@ -0,0 +1,301 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  buildWorkflowMcpServers,
+  detectWorkflowMcpLaunchConfig,
+  getWorkflowTransportSupportError,
+  getRequiredWorkflowToolsForAutoUnit,
+  getRequiredWorkflowToolsForGuidedUnit,
+  usesWorkflowMcpTransport,
+} from "../workflow-mcp.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const gsdDir = join(__dirname, "..");
+
+function readSrc(file: string): string {
+  return readFileSync(join(gsdDir, file), "utf-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("detectWorkflowMcpLaunchConfig prefers explicit env override", () => {
+  const launch = detectWorkflowMcpLaunchConfig("/tmp/project", {
+    GSD_WORKFLOW_MCP_NAME: "workflow-tools",
+    GSD_WORKFLOW_MCP_COMMAND: "node",
+    GSD_WORKFLOW_MCP_ARGS: JSON.stringify(["dist/cli.js"]),
+    GSD_WORKFLOW_MCP_ENV: JSON.stringify({ FOO: "bar" }),
+    GSD_WORKFLOW_MCP_CWD: "/tmp/project",
+    GSD_CLI_PATH: "/tmp/gsd",
+  });
+
+  assert.deepEqual(launch, {
+    name: "workflow-tools",
+    command: "node",
+    args: ["dist/cli.js"],
+    cwd: "/tmp/project",
+    env: {
+      FOO: "bar",
+      GSD_CLI_PATH: "/tmp/gsd",
+      GSD_PERSIST_WRITE_GATE_STATE: "1",
+      GSD_WORKFLOW_PROJECT_ROOT: "/tmp/project",
+    },
+  });
+});
+
+test("buildWorkflowMcpServers mirrors explicit launch config", () => {
+  const servers = buildWorkflowMcpServers("/tmp/project", {
+    GSD_WORKFLOW_MCP_COMMAND: "node",
+    GSD_WORKFLOW_MCP_ARGS: JSON.stringify(["dist/cli.js"]),
+  });
+
+  assert.deepEqual(servers, {
+    "gsd-workflow": {
+      command: "node",
+      args: ["dist/cli.js"],
+      env: {
+        GSD_PERSIST_WRITE_GATE_STATE: "1",
+        GSD_WORKFLOW_PROJECT_ROOT: "/tmp/project",
+      },
+    },
+  });
+});
+
+test("usesWorkflowMcpTransport matches local externalCli providers", () => {
+  assert.equal(usesWorkflowMcpTransport("externalCli", "local://claude-code"), true);
+  assert.equal(usesWorkflowMcpTransport("externalCli", "https://api.example.com"), false);
+  assert.equal(usesWorkflowMcpTransport("oauth", "local://custom"), false);
+});
+
+test("transport compatibility passes when required tools fit current MCP surface", () => {
+  const error = getWorkflowTransportSupportError(
+    "claude-code",
+    ["gsd_task_complete"],
+    {
+      projectRoot: "/tmp/project",
+      env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+      surface: "guided flow",
+      unitType: "execute-task",
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+    },
+  );
+
+  assert.equal(error, null);
+});
+
+test("transport compatibility fails cleanly when MCP server is unavailable", () => {
+  const error = getWorkflowTransportSupportError(
+    "claude-code",
+    ["gsd_task_complete"],
+    {
+      projectRoot: "/tmp/project",
+      env: {},
+      surface: "auto-mode",
+      unitType: "execute-task",
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+    },
+  );
+
+  assert.match(error ?? "", /workflow MCP server is not configured or discoverable/);
+});
+
+test("transport compatibility now allows auto execute-task over workflow MCP surface", () => {
+  const error = getWorkflowTransportSupportError(
+    "claude-code",
+    ["gsd_complete_task"],
+    {
+      projectRoot: "/tmp/project",
+      env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+      surface: "auto-mode",
+      unitType: "execute-task",
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+    },
+  );
+
+  assert.equal(error, null);
+});
+
+test("transport compatibility ignores API-backed providers", () => {
+  const error = getWorkflowTransportSupportError(
+    "openai-codex",
+    ["gsd_plan_slice"],
+    {
+      projectRoot: "/tmp/project",
+      env: {},
+      surface: "auto-mode",
+      unitType: "plan-slice",
+      authMode: "oauth",
+      baseUrl: "https://api.openai.com",
+    },
+  );
+
+  assert.equal(error, null);
+});
+
+test("transport compatibility now allows plan-slice over workflow MCP surface", () => {
+  const error = getWorkflowTransportSupportError(
+    "claude-code",
+    ["gsd_plan_slice"],
+    {
+      projectRoot: "/tmp/project",
+      env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+      surface: "auto-mode",
+      unitType: "plan-slice",
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+    },
+  );
+
+  assert.equal(error, null);
+});
+
+test("transport compatibility now allows complete-slice over workflow MCP surface", () => {
+  const error = getWorkflowTransportSupportError(
+    "claude-code",
+    ["gsd_complete_slice"],
+    {
+      projectRoot: "/tmp/project",
+      env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+      surface: "auto-mode",
+      unitType: "complete-slice",
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+    },
+  );
+
+  assert.equal(error, null);
+});
+
+test("transport compatibility now allows reassess-roadmap over workflow MCP surface", () => {
+  const error = getWorkflowTransportSupportError(
+    "claude-code",
+    ["gsd_milestone_status", "gsd_reassess_roadmap"],
+    {
+      projectRoot: "/tmp/project",
+      env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+      surface: "auto-mode",
+      unitType: "reassess-roadmap",
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+    },
+  );
+
+  assert.equal(error, null);
+});
+
+test("transport compatibility now allows gate-evaluate over workflow MCP surface", () => {
+  const error = getWorkflowTransportSupportError(
+    "claude-code",
+    ["gsd_save_gate_result"],
+    {
+      projectRoot: "/tmp/project",
+      env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+      surface: "auto-mode",
+      unitType: "gate-evaluate",
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+    },
+  );
+
+  assert.equal(error, null);
+});
+
+test("transport compatibility now allows validate-milestone over workflow MCP surface", () => {
+  const error = getWorkflowTransportSupportError(
+    "claude-code",
+    ["gsd_milestone_status", "gsd_validate_milestone"],
+    {
+      projectRoot: "/tmp/project",
+      env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+      surface: "auto-mode",
+      unitType: "validate-milestone",
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+    },
+  );
+
+  assert.equal(error, null);
+});
+
+test("transport compatibility now allows complete-milestone over workflow MCP surface", () => {
+  const error = getWorkflowTransportSupportError(
+    "claude-code",
+    ["gsd_milestone_status", "gsd_complete_milestone"],
+    {
+      projectRoot: "/tmp/project",
+      env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+      surface: "auto-mode",
+      unitType: "complete-milestone",
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+    },
+  );
+
+  assert.equal(error, null);
+});
+
+test("transport compatibility now allows replan-slice over workflow MCP surface", () => {
+  const error = getWorkflowTransportSupportError(
+    "claude-code",
+    ["gsd_replan_slice"],
+    {
+      projectRoot: "/tmp/project",
+      env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+      surface: "auto-mode",
+      unitType: "replan-slice",
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+    },
+  );
+
+  assert.equal(error, null);
+});
+
+test("transport compatibility still blocks units whose MCP tools are not exposed", () => {
+  const error = getWorkflowTransportSupportError(
+    "claude-code",
+    ["gsd_skip_slice"],
+    {
+      projectRoot: "/tmp/project",
+      env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+      surface: "auto-mode",
+      unitType: "skip-slice",
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+    },
+  );
+
+  assert.match(error ?? "", /requires gsd_skip_slice/);
+  assert.match(error ?? "", /currently exposes only/);
+});
+
+test("guided-flow source enforces workflow compatibility preflight", () => {
+  const src = readSrc("guided-flow.ts");
+  assert.match(src, /getRequiredWorkflowToolsForGuidedUnit/);
+  assert.match(src, /getWorkflowTransportSupportError/);
+});
+
+test("auto direct dispatch source enforces workflow compatibility preflight", () => {
+  const src = readSrc("auto-direct-dispatch.ts");
+  assert.match(src, /getRequiredWorkflowToolsForAutoUnit/);
+  assert.match(src, /getWorkflowTransportSupportError/);
+});
+
+test("auto phases source enforces workflow compatibility preflight", () => {
+  const src = readSrc(join("auto", "phases.ts"));
+  assert.match(src, /getRequiredWorkflowToolsForAutoUnit/);
+  assert.match(src, /getWorkflowTransportSupportError/);
+  assert.match(src, /workflow-capability/);
+});