gsd-pi 2.81.0 → 2.82.0-dev.20138ae42

package/src/resources/extensions/gsd/tests/auto-worktree-registry.test.ts

@@ -2,7 +2,7 @@
 
 import { describe, test, beforeEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
@@ -13,6 +13,7 @@ import {
   _resetAutoWorktreeOriginalBaseForTests,
   createAutoWorktree,
   enterAutoWorktree,
+  mergeMilestoneToMain,
   teardownAutoWorktree,
 } from "../auto-worktree.ts";
 
@@ -173,4 +174,71 @@ describe("auto-worktree workspace registry", () => {
     teardownAutoWorktree(dir2, "M020");
     try { process.chdir(savedCwd); } catch { /* ignore */ }
   });
+
+  test("mergeMilestoneToMain cleans up when milestone branch was already regular-merged", (t) => {
+    const tempDir = createTempRepo(t);
+    const msDir = join(tempDir, ".gsd", "milestones", "M003");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M003 Context\n");
+    git(["add", "."], tempDir);
+    git(["commit", "-m", "add milestone"], tempDir);
+
+    createAutoWorktree(tempDir, "M003");
+    const wtDir = join(tempDir, ".gsd", "worktrees", "M003");
+    writeFileSync(join(wtDir, "feature.txt"), "implemented\n");
+    git(["add", "feature.txt"], wtDir);
+    git(["commit", "-m", "feat: implement M003"], wtDir);
+
+    process.chdir(tempDir);
+    git(["merge", "--no-ff", "milestone/M003", "-m", "merge M003"], tempDir);
+
+    process.chdir(wtDir);
+    const result = mergeMilestoneToMain(tempDir, "M003", "# M003\n- [x] **S01: Done**\n");
+
+    assert.equal(result.codeFilesChanged, true);
+    assert.equal(result.pushed, false);
+    assert.equal(result.prCreated, false);
+    assert.equal(existsSync(wtDir), false, "worktree directory is removed");
+    assert.throws(
+      () => git(["rev-parse", "--verify", "milestone/M003"], tempDir),
+      /Command failed/,
+      "already-merged milestone branch is deleted",
+    );
+    try { process.chdir(savedCwd); } catch { /* ignore */ }
+  });
+
+  test("mergeMilestoneToMain cleans up already-merged milestone after main advances", (t) => {
+    const tempDir = createTempRepo(t);
+    const msDir = join(tempDir, ".gsd", "milestones", "M004");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M004 Context\n");
+    git(["add", "."], tempDir);
+    git(["commit", "-m", "add milestone"], tempDir);
+
+    createAutoWorktree(tempDir, "M004");
+    const wtDir = join(tempDir, ".gsd", "worktrees", "M004");
+    writeFileSync(join(wtDir, "feature.txt"), "implemented\n");
+    git(["add", "feature.txt"], wtDir);
+    git(["commit", "-m", "feat: implement M004"], wtDir);
+
+    process.chdir(tempDir);
+    git(["merge", "--no-ff", "milestone/M004", "-m", "merge M004"], tempDir);
+    writeFileSync(join(tempDir, "hotfix.txt"), "later main work\n");
+    git(["add", "hotfix.txt"], tempDir);
+    git(["commit", "-m", "fix: advance main"], tempDir);
+
+    process.chdir(wtDir);
+    const result = mergeMilestoneToMain(tempDir, "M004", "# M004\n- [x] **S01: Done**\n");
+
+    assert.equal(result.codeFilesChanged, true);
+    assert.equal(result.pushed, false);
+    assert.equal(result.prCreated, false);
+    assert.equal(existsSync(wtDir), false, "worktree directory is removed");
+    assert.throws(
+      () => git(["rev-parse", "--verify", "milestone/M004"], tempDir),
+      /Command failed/,
+      "already-merged milestone branch is deleted",
+    );
+    try { process.chdir(savedCwd); } catch { /* ignore */ }
+  });
 });

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

@@ -0,0 +1,89 @@
+// GSD-2 + /gsd brief command behavior tests
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { GSD_COMMAND_DESCRIPTION, getGsdArgumentCompletions } from "../commands/catalog.ts";
+import { handleCoreCommand, showHelp } from "../commands/handlers/core.ts";
+import { VISUAL_BRIEF_USAGE } from "../../visual-brief/prompts.ts";
+
+function createMockCtx() {
+  const notifications: { message: string; level: string }[] = [];
+  return {
+    notifications,
+    ui: {
+      notify(message: string, level: string) {
+        notifications.push({ message, level });
+      },
+      custom: async () => undefined,
+    },
+  };
+}
+
+function createMockPi() {
+  const sentMessages: string[] = [];
+  return {
+    sentMessages,
+    sendUserMessage(content: string) {
+      sentMessages.push(content);
+    },
+  };
+}
+
+test("/gsd brief appears in the command description and top-level completions", () => {
+  assert.match(GSD_COMMAND_DESCRIPTION, /brief/);
+
+  const completions = getGsdArgumentCompletions("br");
+  const entry = completions.find((completion) => completion.value === "brief");
+
+  assert.ok(entry, "brief should appear in top-level completions");
+  assert.match(entry.description, /visual HTML brief/i);
+});
+
+test("/gsd brief exposes Visual Brief mode completions", () => {
+  const completions = getGsdArgumentCompletions("brief d");
+
+  assert.ok(
+    completions.some((completion) => completion.value === "brief diagram"),
+    "diagram should be suggested as a /gsd brief mode",
+  );
+  assert.ok(
+    getGsdArgumentCompletions("brief ").some((completion) => completion.value === "brief diff"),
+    "diff should be suggested after /gsd brief",
+  );
+});
+
+test("/gsd brief sends a Visual Brief prompt for valid args", async () => {
+  const ctx = createMockCtx();
+  const pi = createMockPi();
+
+  const handled = await handleCoreCommand("brief diagram extension loading lifecycle", ctx as any, pi as any);
+
+  assert.equal(handled, true);
+  assert.equal(ctx.notifications.length, 0);
+  assert.equal(pi.sentMessages.length, 1);
+  assert.match(pi.sentMessages[0], /Mode: diagram/);
+  assert.match(pi.sentMessages[0], /Subject: extension loading lifecycle/);
+  assert.match(pi.sentMessages[0], /Output directory:/);
+});
+
+test("/gsd brief reports usage for empty args instead of sending a prompt", async () => {
+  const ctx = createMockCtx();
+  const pi = createMockPi();
+
+  const handled = await handleCoreCommand("brief", ctx as any, pi as any);
+
+  assert.equal(handled, true);
+  assert.equal(pi.sentMessages.length, 0);
+  assert.deepEqual(ctx.notifications, [{ message: VISUAL_BRIEF_USAGE, level: "info" }]);
+});
+
+test("/gsd help full lists brief separately from visualize", () => {
+  const ctx = createMockCtx();
+
+  showHelp(ctx as any, "full");
+
+  const help = ctx.notifications.at(0)?.message ?? "";
+  assert.match(help, /\/gsd visualize\s+Interactive 10-tab TUI/);
+  assert.match(help, /\/gsd brief <mode>\s+Generate a visual HTML brief/);
+});

package/src/resources/extensions/gsd/tests/browser-tools-compatibility-declarations.test.ts

@@ -0,0 +1,62 @@
+// GSD-2 — ADR-005 Phase 2: Verify browser tool compatibility declarations.
+//
+// Locks in the declarations that always-image-producing browser tools
+// (browser_screenshot, browser_zoom_region) carry `producesImages: true` so
+// the model-router filters them out on providers without imageToolResults
+// (OpenAI completions/responses, Azure, Mistral, Ollama). Conditional-image
+// browser tools (navigation, forms, refs, intent, interaction) must NOT
+// declare producesImages — they only attach error screenshots and filtering
+// them would lose the whole tool surface for OpenAI users.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+
+import { registerScreenshotTools } from "../../browser-tools/tools/screenshot.ts";
+import { registerZoomTools } from "../../browser-tools/tools/zoom.ts";
+
+interface CapturedToolDef {
+  name: string;
+  compatibility?: { producesImages?: boolean; schemaFeatures?: string[] };
+}
+
+function makeCapturingPi(): { pi: ExtensionAPI; tools: CapturedToolDef[] } {
+  const tools: CapturedToolDef[] = [];
+  const pi = {
+    registerTool(def: CapturedToolDef): void {
+      tools.push({ name: def.name, compatibility: def.compatibility });
+    },
+  } as unknown as ExtensionAPI;
+  return { pi, tools };
+}
+
+// Browser tool registration functions accept a `deps` object. None of the
+// declarations under test reach for these deps at registration time — they
+// only run inside execute(), which we never invoke. A bare object satisfies
+// the type signature.
+const stubDeps = {} as Parameters<typeof registerScreenshotTools>[1];
+
+test("browser_screenshot declares producesImages: true", () => {
+  const { pi, tools } = makeCapturingPi();
+  registerScreenshotTools(pi, stubDeps);
+  const screenshot = tools.find((t) => t.name === "browser_screenshot");
+  assert.ok(screenshot, "browser_screenshot should be registered");
+  assert.equal(
+    screenshot.compatibility?.producesImages,
+    true,
+    "browser_screenshot must declare producesImages so it is filtered on providers without imageToolResults",
+  );
+});
+
+test("browser_zoom_region declares producesImages: true", () => {
+  const { pi, tools } = makeCapturingPi();
+  registerZoomTools(pi, stubDeps);
+  const zoom = tools.find((t) => t.name === "browser_zoom_region");
+  assert.ok(zoom, "browser_zoom_region should be registered");
+  assert.equal(
+    zoom.compatibility?.producesImages,
+    true,
+    "browser_zoom_region must declare producesImages so it is filtered on providers without imageToolResults",
+  );
+});

package/src/resources/extensions/gsd/tests/clean-root-preflight.test.ts

@@ -8,7 +8,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, realpathSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -208,8 +208,8 @@ test("postflightPopStash conflict warning names the exact stash ref", () => {
     assert.match(postflight.message, /failed after merge of milestone M005C/);
 
     const warning = notifications.find((n) => n.level === "warning")?.msg ?? "";
-    assert.match(warning, /git stash pop stash@\{\d+\}/);
     assert.match(warning, /git stash apply stash@\{\d+\}/);
+    assert.match(warning, /git stash drop stash@\{\d+\}/);
   } finally {
     try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
   }
@@ -279,3 +279,108 @@ test("postflightPopStash falls back to milestone marker prefix when exact marker
     try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
   }
 });
+
+test("postflightPopStash preserves stash when untracked collision differs from merged file", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "tests.txt"), "local preflight test\n");
+    const preflight = preflightCleanRoot(repo, "M009", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash untracked file");
+
+    writeFileSync(join(repo, "tests.txt"), "merged milestone test\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add merged test"', repo);
+
+    const notifications: Array<{ msg: string; level: string }> = [];
+    const postflight = postflightPopStash(repo, "M009", preflight.stashMarker, (msg, level) => {
+      notifications.push({ msg, level });
+    });
+
+    assert.equal(postflight.needsManualRecovery, false, "different already-present untracked files must not stop auto-mode");
+    assert.equal(postflight.resolution, "already-present-preserved");
+    assert.deepEqual(postflight.collidedPaths, ["tests.txt"]);
+    assert.equal(readFileSync(join(repo, "tests.txt"), "utf-8"), "merged milestone test\n");
+    assert.equal(run("git status --porcelain", repo), "", "merged file must stay clean");
+
+    const stashList = run("git stash list", repo);
+    assert.ok(preflight.stashMarker && stashList.includes(preflight.stashMarker), "stash backup must be preserved");
+    assert.ok(
+      notifications.some((n) => n.level === "warning" && n.msg.includes("preserving")),
+      "user must be warned that the stash was preserved as backup",
+    );
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash drops stash when untracked collision is identical to merged file", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "tests.txt"), "same test content\n");
+    const preflight = preflightCleanRoot(repo, "M010", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash untracked file");
+
+    writeFileSync(join(repo, "tests.txt"), "same test content\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add same test"', repo);
+
+    const postflight = postflightPopStash(repo, "M010", preflight.stashMarker, () => {});
+
+    assert.equal(postflight.needsManualRecovery, false, "identical already-present files must not stop auto-mode");
+    assert.equal(postflight.resolution, "already-present-dropped");
+    assert.equal(readFileSync(join(repo, "tests.txt"), "utf-8"), "same test content\n");
+
+    const stashList = run("git stash list", repo);
+    assert.ok(!stashList.includes(preflight.stashMarker ?? ""), "identical stash must be dropped");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash requires manual recovery for mixed tracked changes and untracked collision", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "README.md"), "# local tracked work\n");
+    writeFileSync(join(repo, "tests.txt"), "local untracked work\n");
+    const preflight = preflightCleanRoot(repo, "M011", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash mixed changes");
+
+    writeFileSync(join(repo, "tests.txt"), "merged milestone test\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add merged test"', repo);
+
+    const postflight = postflightPopStash(repo, "M011", preflight.stashMarker, () => {});
+
+    assert.equal(postflight.needsManualRecovery, true, "tracked stash payload must still require manual recovery");
+    assert.equal(postflight.resolution, "manual-recovery");
+    const stashList = run("git stash list", repo);
+    assert.ok(preflight.stashMarker && stashList.includes(preflight.stashMarker), "mixed stash must be preserved");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash requires manual recovery when an untracked stash path is missing after collision", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "tests.txt"), "local untracked work\n");
+    writeFileSync(join(repo, "other-tests.txt"), "other local untracked work\n");
+    const preflight = preflightCleanRoot(repo, "M012", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash untracked files");
+
+    writeFileSync(join(repo, "tests.txt"), "merged milestone test\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add one merged test"', repo);
+
+    const postflight = postflightPopStash(repo, "M012", preflight.stashMarker, () => {});
+
+    assert.equal(postflight.needsManualRecovery, true, "partial untracked restores must still require manual recovery");
+    assert.equal(postflight.resolution, "manual-recovery");
+    assert.equal(existsSync(join(repo, "other-tests.txt")), true, "git may partially restore the non-colliding path");
+    assert.match(run("git status --porcelain", repo), /\?\? other-tests\.txt/, "partial restore must leave manual recovery visible");
+    const stashList = run("git stash list", repo);
+    assert.ok(preflight.stashMarker && stashList.includes(preflight.stashMarker), "stash must remain for manual recovery");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});

package/src/resources/extensions/gsd/tests/clear-stale-autostart.test.ts

@@ -17,6 +17,15 @@ import {
   setPendingAutoStart,
 } from "../guided-flow.ts";
 
+function pendingInput(basePath: string, milestoneId: string) {
+  return {
+    basePath,
+    milestoneId,
+    ctx: { ui: { notify: () => undefined } } as any,
+    pi: { sendMessage: () => undefined } as any,
+  };
+}
+
 afterEach(() => {
   clearPendingAutoStart();
 });
@@ -28,7 +37,7 @@ describe("clear stale pending auto-start (#3667)", () => {
     mkdirSync(join(base, ".gsd"), { recursive: true });
     const before = Date.now();
 
-    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+    setPendingAutoStart(base, pendingInput(base, "M001"));
 
     const entry = _getPendingAutoStart(base);
     assert.ok(entry);
@@ -41,7 +50,7 @@ describe("clear stale pending auto-start (#3667)", () => {
     t.after(() => rmSync(base, { recursive: true, force: true }));
     mkdirSync(join(base, ".gsd"), { recursive: true });
 
-    setPendingAutoStart(base, { basePath: base, milestoneId: "M001", createdAt: 123 });
+    setPendingAutoStart(base, { ...pendingInput(base, "M001"), createdAt: 123 });
 
     assert.equal(_getPendingAutoStart(base)?.createdAt, 123);
   });

package/src/resources/extensions/gsd/tests/closeout-git-deferral.test.ts

@@ -0,0 +1,16 @@
+// Project/App: GSD-2
+// File Purpose: Tests closeout git action deferral policy for auto-mode units.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { shouldDeferCloseoutGitAction } from "../auto-post-unit.ts";
+
+test("execute-task defers closeout git action until verification passes", () => {
+  assert.equal(shouldDeferCloseoutGitAction("execute-task"), true);
+});
+
+test("non execute-task units keep pre-verification closeout git action", () => {
+  assert.equal(shouldDeferCloseoutGitAction("plan-slice"), false);
+  assert.equal(shouldDeferCloseoutGitAction("complete-slice"), false);
+});

package/src/resources/extensions/gsd/tests/complete-milestone.test.ts

@@ -645,7 +645,7 @@ describe("complete-milestone", () => {
     assert.strictEqual(sanitized.triggerReason, undefined);
   });
 
-  test("rendered SUMMARY.md uses placeholder text for empty enrichment fields", async () => {
+  test("rendered SUMMARY.md uses empty frontmatter lists for empty key fields", async () => {
     const { handleCompleteMilestone } = await import("../tools/complete-milestone.ts");
     const base = createFixtureBase();
     const mid = "M001";
@@ -678,6 +678,9 @@ describe("complete-milestone", () => {
       assert.match(summary, /## Success Criteria Results\n\nNot provided\./);
       assert.match(summary, /## Definition of Done Results\n\nNot provided\./);
       assert.match(summary, /## Requirement Outcomes\n\nNot provided\./);
+      assert.match(summary, /key_decisions:\s*\[\]/);
+      assert.match(summary, /key_files:\s*\[\]/);
+      assert.doesNotMatch(summary, /key_(?:decisions|files):\n  - \(none\)/);
       assert.match(summary, /## Deviations\n\nNone\./);
       assert.match(summary, /## Follow-ups\n\nNone\./);
     } finally {

package/src/resources/extensions/gsd/tests/complete-slice.test.ts

@@ -408,10 +408,10 @@ console.log('\n=== complete-slice: handler with missing roadmap ===');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// complete-slice: step 13 specifies write tool for PROJECT.md (#2946)
+// complete-slice: PROJECT refresh uses DB-backed artifact tool.
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== complete-slice: step 13 specifies write tool for PROJECT.md (#2946) ===');
+console.log('\n=== complete-slice: PROJECT refresh uses gsd_summary_save ===');
 {
   const promptPath = path.join(
     path.dirname(new URL(import.meta.url).pathname),
@@ -419,13 +419,9 @@ console.log('\n=== complete-slice: step 13 specifies write tool for PROJECT.md (
   );
   const prompt = fs.readFileSync(promptPath, 'utf-8');
 
-  // Step 13 must explicitly name the `write` tool so the LLM doesn't
-  // confuse it with `edit` (which requires path + oldText + newText).
-  // See: https://github.com/gsd-build/gsd-2/issues/2946
-  const mentionsWriteTool =
-    /PROJECT\.md.*\bwrite\b/i.test(prompt) ||
-    /\bwrite\b.*PROJECT\.md/i.test(prompt);
-  assertTrue(mentionsWriteTool, 'step 13 must name the `write` tool when updating PROJECT.md');
+  assertTrue(prompt.includes('gsd_summary_save'), 'PROJECT refresh must use gsd_summary_save');
+  assertTrue(prompt.includes('artifact_type: "PROJECT"'), 'PROJECT refresh must use artifact_type PROJECT');
+  assertTrue(!/with a full `write`/i.test(prompt), 'prompt must not instruct direct PROJECT.md writes');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════

package/src/resources/extensions/gsd/tests/complete-task.test.ts

@@ -491,7 +491,9 @@ console.log('\n=== complete-task: minimal params (no keyFiles, keyDecisions, ver
     assertTrue(fs.existsSync(result.summaryPath), 'summary file should be written with minimal params');
     const summaryContent = fs.readFileSync(result.summaryPath, 'utf-8');
     assertMatch(summaryContent, /blocker_discovered:\s*false/, 'blocker_discovered should default to false');
-    assertMatch(summaryContent, /\(none\)/, 'key_files/key_decisions should show (none) placeholder');
+    assertMatch(summaryContent, /key_files:\s*\[\]/, 'key_files should render as an empty frontmatter list');
+    assertMatch(summaryContent, /key_decisions:\s*\[\]/, 'key_decisions should render as an empty frontmatter list');
+    assertTrue(!summaryContent.includes('  - (none)'), 'empty frontmatter lists should not render (none) as a list item');
   }
 
   cleanupDir(basePath);