@opengsd/gsd-pi 1.3.0 → 1.4.0

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

@@ -2,7 +2,7 @@
 // File Purpose: Tests auto-mode artifact verification and recovery behavior.
 import test, { afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { chmodSync, mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -964,6 +964,45 @@ function makeGitBase(): string {
   return base;
 }
 
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+function withLoggedGitCommands<T>(base: string, action: () => T): { result: T; commands: string[] } {
+  const realGit = execFileSync("which", ["git"], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+  }).trim().split(/\r?\n/)[0];
+  if (!realGit) throw new Error("Unable to resolve git executable for invocation logging test");
+  const binDir = join(base, ".git-wrapper-bin");
+  const logFile = join(base, "git-invocations.log");
+  mkdirSync(binDir, { recursive: true });
+  const wrapper = join(binDir, "git");
+  writeFileSync(
+    wrapper,
+    [
+      "#!/usr/bin/env bash",
+      `printf '%s\\n' "$1" >> ${shellQuote(logFile)}`,
+      `exec ${shellQuote(realGit)} "$@"`,
+      "",
+    ].join("\n"),
+  );
+  chmodSync(wrapper, 0o755);
+
+  const originalPath = process.env.PATH;
+  process.env.PATH = originalPath ? `${binDir}:${originalPath}` : binDir;
+  try {
+    const result = action();
+    const commands = existsSync(logFile)
+      ? readFileSync(logFile, "utf-8").split(/\r?\n/).filter(Boolean)
+      : [];
+    return { result, commands };
+  } finally {
+    if (originalPath === undefined) delete process.env.PATH;
+    else process.env.PATH = originalPath;
+  }
+}
+
 test("hasImplementationArtifacts returns false when only .gsd/ files committed (#1703)", () => {
   const base = makeGitBase();
   try {
@@ -1344,6 +1383,77 @@ test("hasImplementationArtifacts finds implementation commits when .gsd/ is giti
   }
 });
 
+test("hasImplementationArtifacts scans GSD-tagged history without per-commit diff-tree forks (#892)", { skip: process.platform === "win32" }, () => {
+  const base = makeGitBase();
+  try {
+    writeFileSync(join(base, ".git", "info", "exclude"), ".gsd/\n");
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
+      "# Summary",
+    );
+
+    mkdirSync(join(base, "src"), { recursive: true });
+    for (let i = 0; i < 3; i++) {
+      writeFileSync(join(base, "src", `feature-${i}.ts`), `export const feature${i} = true;\n`);
+      execFileSync("git", ["add", "src"], { cwd: base, stdio: "ignore" });
+      execFileSync(
+        "git",
+        ["commit", "-m", `feat: materialize M001 evidence ${i}\n\nGSD-Task: S01/T01`],
+        { cwd: base, stdio: "ignore" },
+      );
+    }
+
+    const { result, commands } = withLoggedGitCommands(base, () => hasImplementationArtifacts(base, "M001"));
+    assert.equal(result, "present", "milestone-tagged commits should still prove implementation evidence");
+    assert.ok(commands.includes("log"), "milestone evidence fallback should scan history with git log");
+    assert.equal(commands.filter((command) => command === "diff-tree").length, 0);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts backfill scans commit records without per-commit diff-tree forks (#892)", { skip: process.platform === "win32" }, () => {
+  const base = makeGitBase();
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+      keyFiles: ["src/expected-0.ts", "src/expected-1.ts"],
+      planning: { files: ["src/expected-0.ts", "src/expected-1.ts"] },
+    });
+
+    mkdirSync(join(base, "src"), { recursive: true });
+    for (let i = 0; i < 2; i++) {
+      writeFileSync(join(base, "src", `expected-${i}.ts`), `export const expected${i} = true;\n`);
+      execFileSync("git", ["add", "src"], { cwd: base, stdio: "ignore" });
+      execFileSync("git", ["commit", "-m", `feat: untagged implementation ${i}`], { cwd: base, stdio: "ignore" });
+    }
+
+    const { result, commands } = withLoggedGitCommands(base, () => hasImplementationArtifacts(base, "M001"));
+    assert.equal(result, "present", "completed task file hints should still backfill untagged commits");
+    assert.equal(getMilestoneCommitAttributionShas("M001").length, 2);
+    assert.ok(commands.includes("log"), "backfill should scan commit records with git log");
+    assert.equal(commands.filter((command) => command === "diff-tree").length, 0);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("hasImplementationArtifacts binds GSD-Task trailer to milestone via DB state when .gsd/ is gitignored", () => {
   const base = makeGitBase();
   try {
@@ -1807,6 +1917,41 @@ test("#57: writeReactiveExecuteBlocker reconciles batch task statuses and append
   }
 });
 
+test("#1088: writeReactiveExecuteBlocker preserves deferred batch task statuses", () => {
+  const base = makeTmpBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+    insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "One", status: "deferred" });
+    insertTask({ id: "T02", milestoneId: "M001", sliceId: "S01", title: "Two", status: "deferred" });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
+      "# T01 Summary\n",
+      "utf-8",
+    );
+
+    const recovery = writeReactiveExecuteBlocker(
+      "M001/S01/reactive+T01,T02",
+      base,
+      "verification retries exhausted",
+    );
+
+    assert.ok(recovery, "recovery should run with DB available");
+    assert.deepEqual(recovery!.completedTaskIds, []);
+    assert.deepEqual(recovery!.skippedTaskIds, []);
+    assert.deepEqual(recovery!.unchangedTaskIds, ["T01", "T02"]);
+    assert.equal(getTask("M001", "S01", "T01")?.status, "deferred");
+    assert.equal(getTask("M001", "S01", "T02")?.status, "deferred");
+
+    const events = readEvents(join(base, ".gsd", "event-log.jsonl"));
+    assert.equal(events.some((e) => e.params.taskId === "T01" || e.params.taskId === "T02"), false);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("#4414: verifyExpectedArtifact parallel-research succeeds when all research-ready slices have RESEARCH", () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/auto-retry-mcp-churn-fixes.test.ts

@@ -15,15 +15,21 @@
 
 import { describe, it, beforeEach } from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import {
   resetEvidence,
   getEvidence,
   recordToolCall,
   recordToolResult,
+  saveEvidenceToDisk,
   type BashEvidence,
 } from "../safety/evidence-collector.js";
 
+const waitForMtimeTick = () => new Promise(resolve => setTimeout(resolve, 25));
+
 describe("evidence-collector: toolCallId-based matching (A-3)", () => {
   beforeEach(() => {
     resetEvidence();
@@ -119,4 +125,28 @@ describe("evidence-collector: toolCallId-based matching (A-3)", () => {
     assert.equal(entries[1].kind, "bash");
     assert.equal(entries[1].command, "rg TODO");
   });
+
+  it("skips byte-identical evidence file rewrites", async (t) => {
+    const base = mkdtempSync(join(tmpdir(), "gsd-evidence-dedupe-"));
+    t.after(() => rmSync(base, { recursive: true, force: true }));
+
+    recordToolCall("tc-bash-1", "bash", { command: "pnpm test" });
+    saveEvidenceToDisk(base, "M001", "S01", "T03");
+
+    const evidenceFile = join(base, ".gsd", "safety", "evidence-M001-S01-T03.json");
+    const firstMtime = statSync(evidenceFile, { bigint: true }).mtimeNs;
+
+    await waitForMtimeTick();
+    saveEvidenceToDisk(base, "M001", "S01", "T03");
+    const secondMtime = statSync(evidenceFile, { bigint: true }).mtimeNs;
+
+    assert.equal(secondMtime, firstMtime, "unchanged evidence must not rewrite the evidence file");
+
+    await waitForMtimeTick();
+    recordToolResult("tc-bash-1", "bash", "Command exited with code 0\nok\n", false);
+    saveEvidenceToDisk(base, "M001", "S01", "T03");
+    const thirdMtime = statSync(evidenceFile, { bigint: true }).mtimeNs;
+
+    assert.ok(thirdMtime > secondMtime, "changed evidence must still be persisted");
+  });
 });

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

@@ -47,6 +47,23 @@ describe("isSafeToAutoResolve", () => {
     assert.ok(isSafeToAutoResolve("out/bundle.css.map"));
   });
 
+  // ─── Regenerable dependency lockfiles ────────────────────────────────────
+  test("returns true for common lockfiles", () => {
+    assert.ok(isSafeToAutoResolve("pnpm-lock.yaml"));
+    assert.ok(isSafeToAutoResolve("packages/app/pnpm-lock.yaml"));
+    assert.ok(isSafeToAutoResolve("package-lock.json"));
+    assert.ok(isSafeToAutoResolve("npm-shrinkwrap.json"));
+    assert.ok(isSafeToAutoResolve("yarn.lock"));
+    assert.ok(isSafeToAutoResolve("bun.lockb"));
+    assert.ok(isSafeToAutoResolve("bun.lock"));
+    assert.ok(isSafeToAutoResolve("Cargo.lock"));
+    assert.ok(isSafeToAutoResolve("crates/core/Cargo.lock"));
+    assert.ok(isSafeToAutoResolve("composer.lock"));
+    assert.ok(isSafeToAutoResolve("Gemfile.lock"));
+    assert.ok(isSafeToAutoResolve("Pipfile.lock"));
+    assert.ok(isSafeToAutoResolve("poetry.lock"));
+  });
+
   // ─── Real source files (should NOT be auto-resolved) ─────────────────────
   test("returns false for .ts source files", () => {
     assert.ok(!isSafeToAutoResolve("src/index.ts"));

package/src/resources/extensions/gsd/tests/codebase-generator.test.ts

@@ -697,23 +697,27 @@ test("ensureCodebaseMapFresh: does not rewrite expired metadata when fingerprint
   }
 });
 
-test("ensureCodebaseMapFresh: detects file changes within the TTL window", () => {
+test("ensureCodebaseMapFresh: uses TTL cache before enumerating files", () => {
   const base = makeTmpRepo();
   try {
     addFile(base, "src/main.ts");
-    // Generate initial map with a long TTL so the cache is still active.
     const initial = ensureCodebaseMapFresh(base, undefined, { ttlMs: 60_000 });
     assert.equal(initial.status, "generated");
 
-    // Add a new tracked file while the TTL is still active.
-    addFile(base, "src/new.ts");
-
-    // Must detect the change even though the TTL has not expired.
-    const refreshed = ensureCodebaseMapFresh(base, undefined, { ttlMs: 60_000 });
-    assert.equal(refreshed.status, "updated");
-    assert.equal(refreshed.reason, "files-changed");
-    const written = readCodebaseMap(base);
-    assert.ok(written?.includes("`src/new.ts`"));
+    const emptyBin = join(base, "empty-bin");
+    mkdirSync(emptyBin);
+    const originalPath = process.env.PATH;
+    try {
+      process.env.PATH = emptyBin;
+
+      const cached = ensureCodebaseMapFresh(base, undefined, { ttlMs: 60_000 });
+      assert.equal(cached.status, "generated");
+      assert.equal(cached.fingerprint, initial.fingerprint);
+      assert.equal(cached.fileCount, 1);
+    } finally {
+      if (originalPath === undefined) delete process.env.PATH;
+      else process.env.PATH = originalPath;
+    }
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/commands-context.test.ts

@@ -101,6 +101,32 @@ test("analyzeSessionContext buckets injections, tool results, and loaded skills"
   assert.equal(result.subagentSpawns, 1);
 });
 
+test("analyzeSessionContext bounds large assistant tool-call arguments", () => {
+  const result = analyzeSessionContext(sessionEntries({
+    role: "assistant",
+    content: [
+      {
+        type: "toolCall",
+        id: "tc-save",
+        name: "gsd_summary_save",
+        arguments: {
+          path: ".gsd/milestones/M001/M001-SUMMARY.md",
+          artifact_type: "SUMMARY",
+          content: "x".repeat(20_000),
+        },
+      },
+    ],
+    timestamp: TS,
+  }), PROVIDER);
+
+  const assistant = result.conversationSections.find((section) => section.label === "Assistant responses");
+  assert.ok(assistant);
+  assert.ok(
+    assistant.tokens < 200,
+    `assistant tool-call arguments should be redacted before token counting, got ${assistant.tokens} tokens`,
+  );
+});
+
 test("formatContextReport lists skills and subagents", () => {
   const report = buildContextBreakdown({
     modelLabel: "claude-code/claude-sonnet-4-6",

package/src/resources/extensions/gsd/tests/commands-dispatcher-unmerged-milestone.test.ts

@@ -191,6 +191,24 @@ test("dispatcher blocks workflow-advancing commands while completed branch is un
     "start",
     "workflow run release",
     "do mark all complete",
+    "audit-fix --severity high",
+    "code-review --fix",
+    "docs-update",
+    "review-backlog",
+    "import --from plan.md",
+    "ingest-docs docs/",
+    "secure-phase",
+    "validate-phase",
+    "plan-phase",
+    "execute-phase --milestone M009",
+    "autonomous --from 1",
+    "phase add M009",
+    "phase create M009",
+    "phase new M009",
+    "phase insert M009 after M008",
+    "phase remove M008",
+    "phase edit M008",
+    "workstreams create",
   ];
 
   for (const command of blockedCommands) {
@@ -214,6 +232,77 @@ test("dispatcher blocks workflow-advancing commands while completed branch is un
   }
 });
 
+test("dispatcher keeps manager read-only while completed branch is unmerged", async () => {
+  const base = makeTempRepo("gsd-dispatch-unmerged-");
+  try {
+    seedCompletedUnmergedMilestone(base);
+    const { ctx, calls } = makeMockCtx(base);
+    const { pi, messages } = makeMockPi();
+
+    await handleGSDCommand("manager", ctx, pi);
+
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].kind, "info");
+    assert.equal(messages.length, 1);
+    assert.equal(messages[0].customType, "gsd-manager");
+    assert.match(messages[0].content, /read-only/i);
+    assert.match(messages[0].content, /M008 is complete but not merged/);
+    assert.doesNotMatch(messages[0].content, /Start\/stop auto-mode/);
+    assert.doesNotMatch(messages[0].content, /Run parallel milestones/);
+    assert.doesNotMatch(messages[0].content, /Act on the selection/);
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+test("dispatcher allows read-only workstreams routes while completed branch is unmerged", async () => {
+  const commands = ["workstreams list", "workstreams status", "workstreams progress"];
+
+  for (const command of commands) {
+    const base = makeTempRepo("gsd-dispatch-unmerged-");
+    try {
+      seedCompletedUnmergedMilestone(base);
+      const { ctx } = makeMockCtx(base);
+      const { pi, messages } = makeMockPi();
+
+      await handleGSDCommand(command, ctx, pi);
+
+      assert.equal(messages.length, 1, command);
+      assert.equal(messages[0].customType, "gsd-parallel", command);
+      assert.match(messages[0].content, /No parallel orchestration/, command);
+      assert.doesNotMatch(messages[0].content, /cannot start new workflow work/, command);
+    } finally {
+      closeDatabase();
+      invalidateStateCache();
+      cleanup(base);
+    }
+  }
+});
+
+test("dispatcher allows audit-fix dry-run while completed branch is unmerged", async () => {
+  const base = makeTempRepo("gsd-dispatch-unmerged-");
+  try {
+    seedCompletedUnmergedMilestone(base);
+    const { ctx, calls } = makeMockCtx(base);
+    const { pi, messages } = makeMockPi();
+
+    await handleGSDCommand("audit-fix --dry-run", ctx, pi);
+
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].kind, "info");
+    assert.match(calls[0].message, /audit-fix/);
+    assert.equal(messages.length, 1);
+    assert.equal(messages[0].customType, "gsd-audit-fix");
+    assert.doesNotMatch(messages[0].content, /cannot start new workflow work/);
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
 test("dispatcher recovers a completed unmerged milestone through complete-milestone dispatch", async () => {
   const base = makeTempRepo("gsd-dispatch-unmerged-");
   try {

package/src/resources/extensions/gsd/tests/commands-dispatcher-validation-block.test.ts

@@ -140,6 +140,11 @@ test("dispatcher blocks workflow-advancing aliases while validation is blocked",
     "auto",
     "do mark all complete",
     "dispatch complete",
+    "plan-phase",
+    "execute-phase --milestone M009",
+    "autonomous --from 1",
+    "workstreams resume",
+    "workstreams complete",
     "workflow resume",
     "workflow release-checklist",
   ];
@@ -156,7 +161,13 @@ test("dispatcher blocks workflow-advancing aliases while validation is blocked",
       assert.equal(calls.length, 0, command);
       assert.equal(messages.length, 1, command);
       assert.equal(messages[0].display, true, command);
-      assert.match(messages[0].content, new RegExp(`/gsd ${command.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")} cannot run`), command);
+      let blockedLabel = command;
+      if (command === "workstreams resume") {
+        blockedLabel = "parallel resume";
+      } else if (command === "workstreams complete") {
+        blockedLabel = "parallel merge";
+      }
+      assert.match(messages[0].content, new RegExp(`/gsd ${blockedLabel.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")} cannot run`), command);
     } finally {
       closeDatabase();
       invalidateStateCache();
@@ -165,6 +176,31 @@ test("dispatcher blocks workflow-advancing aliases while validation is blocked",
   }
 });
 
+test("dispatcher keeps manager read-only while validation is blocked", async () => {
+  const base = makeBase();
+  try {
+    seedValidationBlockedMilestone(base);
+    const { ctx, calls } = makeMockCtx(base);
+    const { pi, messages } = makeMockPi();
+
+    await handleGSDCommand("manager", ctx, pi);
+
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].kind, "info");
+    assert.equal(messages.length, 1);
+    assert.equal(messages[0].customType, "gsd-manager");
+    assert.match(messages[0].content, /read-only/i);
+    assert.match(messages[0].content, /active milestone is blocked by validation/);
+    assert.doesNotMatch(messages[0].content, /Start\/stop auto-mode/);
+    assert.doesNotMatch(messages[0].content, /Run parallel milestones/);
+    assert.doesNotMatch(messages[0].content, /Act on the selection/);
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
 test("dispatcher allows reassess dispatch while validation needs remediation", async () => {
   const base = makeBase();
   try {