@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.eed73bea

package/src/resources/extensions/gsd/tests/auto-paused-session-validation.test.ts

@@ -36,7 +36,12 @@ test("resolveMilestonePath returns null for missing milestone", (t) => {
 
 test("resolveMilestonePath returns path for existing milestone", (t) => {
   const base = makeTmpBase();
-  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  const mDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(mDir, { recursive: true });
+  // A content-bearing legacy milestone dir requires at least one non-META file
+  // (dirIsContentBearingLegacyMilestone); an empty dir is now treated as a
+  // metadata-only placeholder left by git-service.ts and is not legacy layout.
+  writeFileSync(join(mDir, "M001-CONTEXT.md"), "# M001\n");
   t.after(() => cleanup(base));
 
   const result = resolveMilestonePath(base, "M001");
@@ -93,7 +98,11 @@ test("stale milestone: completed (has SUMMARY) means paused session should be di
 
 test("valid milestone: exists and has no SUMMARY means paused session is valid", (t) => {
   const base = makeTmpBase();
-  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  const mDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(mDir, { recursive: true });
+  // A content-bearing legacy milestone dir requires at least one non-META file;
+  // use CONTEXT as the existing content, with no SUMMARY (milestone still active).
+  writeFileSync(join(mDir, "M001-CONTEXT.md"), "# M001\n");
   t.after(() => cleanup(base));
 
   const dir = resolveMilestonePath(base, "M001");

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -5,12 +5,19 @@ import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
 import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { cleanupAfterLoopExit, pauseAuto, rerootCommandSession, stopAuto } from "../auto.ts";
+import { join, dirname } from "node:path";
+
+import {
+  anchorProcessCwdForAutoResume,
+  cleanupAfterLoopExit,
+  pauseAuto,
+  rerootCommandSession,
+  stopAuto,
+} from "../auto.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 import { getAutoWorker, registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease, getMilestoneLease } from "../db/milestone-leases.ts";
 import { readPausedSessionMetadata } from "../interrupted-session.ts";
 import { WorktreeLifecycle } from "../worktree-lifecycle.ts";
 
@@ -107,6 +114,42 @@ test("cleanupAfterLoopExit preserves paused worktree session and visible failure
   }
 });
 
+test("anchorProcessCwdForAutoResume recovers when current cwd was deleted", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-resume-cwd-anchor-"));
+  const deletedCwd = join(base, ".gsd-worktrees", "M002");
+  const previousCwd = process.cwd();
+
+  mkdirSync(deletedCwd, { recursive: true });
+
+  try {
+    process.chdir(deletedCwd);
+    rmSync(deletedCwd, { recursive: true, force: true });
+
+    assert.equal(anchorProcessCwdForAutoResume(base), true);
+    assert.equal(realpathSync(process.cwd()), realpathSync(base));
+  } finally {
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("anchorProcessCwdForAutoResume falls back when primary basePath is missing", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-resume-cwd-anchor-fallback-"));
+  const missingWorktree = join(base, ".gsd-worktrees", "M002");
+  const previousCwd = process.cwd();
+
+  mkdirSync(base, { recursive: true });
+  mkdirSync(dirname(missingWorktree), { recursive: true });
+
+  try {
+    assert.equal(anchorProcessCwdForAutoResume(missingWorktree, [base]), true);
+    assert.equal(realpathSync(process.cwd()), realpathSync(base));
+  } finally {
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("cleanupAfterLoopExit clears status and progress widget without replacing outcome surface", async () => {
   const statusCalls: unknown[] = [];
   const widgetCalls: unknown[] = [];
@@ -276,6 +319,56 @@ test("pauseAuto marks active worker as stopping and clears workerId", async () =
   }
 });
 
+test("pauseAuto preserves worker lease across transient provider auto-resume pauses", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-pause-provider-lease-"));
+  const previousCwd = process.cwd();
+  const dbPath = join(base, ".gsd", "gsd.db");
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.originalBasePath = base;
+  autoSession.currentMilestoneId = "M001";
+
+  try {
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001", title: "Milestone 1", status: "active" });
+    const workerId = registerAutoWorker({ projectRootRealpath: base });
+    const lease = claimMilestoneLease(workerId, "M001");
+    assert.equal(lease.ok, true);
+    if (!lease.ok) return;
+
+    autoSession.workerId = workerId;
+    autoSession.milestoneLeaseToken = lease.token;
+    process.chdir(base);
+
+    await pauseAuto(undefined, undefined, {
+      message: "Provider error: socket closed",
+      category: "provider",
+      isTransient: true,
+    });
+
+    assert.equal(autoSession.paused, true);
+    assert.equal(autoSession.workerId, workerId);
+    assert.equal(autoSession.milestoneLeaseToken, lease.token);
+    assert.equal(getAutoWorker(workerId)?.status, "active");
+    const row = getMilestoneLease("M001");
+    assert.equal(row?.worker_id, workerId);
+    assert.equal(row?.status, "held");
+    assert.equal(row?.fencing_token, lease.token);
+  } finally {
+    autoSession.reset();
+    try {
+      closeDatabase();
+    } catch {
+      /* noop */
+    }
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("pauseAuto records the expected worktree path when paused from project root", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-pause-worktree-path-"));
   const previousCwd = process.cwd();
@@ -306,7 +399,9 @@ test("pauseAuto records the expected worktree path when paused from project root
 
     const meta = readPausedSessionMetadata(base);
     assert.ok(meta);
-    assert.equal(meta.worktreePath, join(base, ".gsd", "worktrees", "M001"));
+    // No worktree exists yet, so the recorded path is the canonical
+    // .gsd-worktrees/ creation location (worktree-placement seam).
+    assert.equal(meta.worktreePath, join(base, ".gsd-worktrees", "M001"));
   } finally {
     autoSession.reset();
     try {
@@ -767,7 +862,7 @@ test("stopAuto completion closeout emits a headless terminal notification withou
       "headless completion closeout must emit the terminal stop notification headless waits for",
     );
     assert.equal(
-      typeof widgetCalls.filter(([key]) => key === "gsd-progress").at(-1)?.[1],
+      typeof widgetCalls.filter(([key]) => key === "gsd-outcome").at(-1)?.[1],
       "function",
       "headless completion closeout must still leave the final roll-up widget installed",
     );

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

@@ -7,7 +7,8 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { resolveDispatchRecoveryAttempts, runFinalize } from "../auto/phases.ts";
+import { resolveDispatchRecoveryAttempts } from "../auto/unit-phase.ts";
+import { runFinalize } from "../auto/finalize.ts";
 import { AutoSession } from "../auto/session.ts";
 import { readUnitRuntimeRecord, writeUnitRuntimeRecord } from "../unit-runtime.ts";
 import { captureRootDirtySnapshot } from "../root-write-leak-guard.ts";

package/src/resources/extensions/gsd/tests/auto-post-unit-evidence-crossref-4909.test.ts

@@ -88,3 +88,49 @@ test("detects session execution tools supported by the evidence collector", () =
 
   assert.equal(_hasExecutionToolCallsInSessionForTest(entries), true);
 });
+
+test("detects execution tool calls in bare agent-end messages (no session-entry wrapper)", () => {
+  // The auto loop passes opts.agentEndMessages as bare {role, content}
+  // messages — not {type: "message", message} session-manager entries.
+  const entries = [
+    {
+      role: "assistant",
+      content: [
+        {
+          type: "toolCall",
+          name: "Bash",
+          arguments: { command: "test -s index.html && grep -q localStorage index.html" },
+        },
+      ],
+    },
+  ];
+
+  assert.equal(_hasExecutionToolCallsInSessionForTest(entries), true);
+});
+
+test("does not suppress for bare agent-end messages without execution tools", () => {
+  const entries = [
+    {
+      role: "assistant",
+      content: [
+        { type: "text", text: "Task complete." },
+        { type: "toolCall", name: "Write", arguments: { file_path: "index.html" } },
+      ],
+    },
+  ];
+
+  assert.equal(_hasExecutionToolCallsInSessionForTest(entries), false);
+});
+
+test("ignores bare user messages with toolCall-shaped content", () => {
+  const entries = [
+    {
+      role: "user",
+      content: [
+        { type: "toolCall", name: "bash", arguments: { command: "echo hi" } },
+      ],
+    },
+  ];
+
+  assert.equal(_hasExecutionToolCallsInSessionForTest(entries), false);
+});

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 {

package/src/resources/extensions/gsd/tests/auto-remote-session-lock-cleanup.test.ts

@@ -1,12 +1,13 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { checkRemoteAutoSession } from "../auto.ts";
+import { checkRemoteAutoSession, forceStopAutoRemote } from "../auto.ts";
 import { openDatabase, closeDatabase, _getAdapter } from "../gsd-db.ts";
-import { registerAutoWorker } from "../db/auto-workers.ts";
+import { getAutoWorker, registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease, getMilestoneLease } from "../db/milestone-leases.ts";
 import { normalizeRealPath } from "../paths.ts";
 import { readCrashLock } from "../crash-recovery.ts";
 
@@ -35,6 +36,29 @@ function setWorkerPid(workerId: string, pid: number): void {
   ).run({ ":pid": pid, ":worker_id": workerId });
 }
 
+function insertMilestone(id: string): void {
+  const db = _getAdapter()!;
+  db.prepare(
+    `INSERT INTO milestones (id, title, status, created_at)
+     VALUES (:id, :title, 'active', :created_at)`,
+  ).run({
+    ":id": id,
+    ":title": id,
+    ":created_at": new Date().toISOString(),
+  });
+}
+
+function writeLegacyLock(base: string, pid: number): void {
+  const now = new Date().toISOString();
+  writeFileSync(join(base, ".gsd", "auto.lock"), JSON.stringify({
+    pid,
+    startedAt: now,
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: now,
+  }));
+}
+
 function findDeadPidCandidate(): number {
   const candidates = [99_999, 199_999, 299_999, 399_999];
   for (const pid of candidates) {
@@ -62,3 +86,41 @@ test("checkRemoteAutoSession clears stale lock state when lock PID is dead", (t)
   assert.deepEqual(remote, { running: false });
   assert.equal(readCrashLock(base), null, "stale lock should be cleared by remote session check");
 });
+
+test("forceStopAutoRemote escalates a live remote PID and releases worker state", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const workerId = registerAutoWorker({ projectRootRealpath: normalizeRealPath(base) });
+  const pid = 424_242;
+  setWorkerPid(workerId, pid);
+  insertMilestone("M001");
+  writeLegacyLock(base, pid);
+  const lease = claimMilestoneLease(workerId, "M001");
+  assert.equal(lease.ok, true, "precondition: worker holds a milestone lease");
+
+  const signals: Array<NodeJS.Signals | 0> = [];
+  const originalKill = process.kill;
+  process.kill = ((target: number, signal?: NodeJS.Signals | number) => {
+    assert.equal(target, pid);
+    signals.push((signal ?? 0) as NodeJS.Signals | 0);
+    return true;
+  }) as typeof process.kill;
+  t.after(() => {
+    process.kill = originalKill;
+  });
+
+  const result = forceStopAutoRemote(base);
+
+  assert.deepEqual(result, { found: true, pid });
+  assert.ok(signals.includes("SIGTERM"), "force stop should request graceful termination first");
+  assert.ok(signals.includes("SIGKILL"), "force stop should escalate when the PID is still alive");
+  assert.equal(getAutoWorker(workerId)?.status, "stopping");
+  assert.equal(
+    getMilestoneLease("M001")?.status,
+    "released",
+    "force stop should release held milestone leases",
+  );
+  assert.equal(readCrashLock(base), null, "force stop should remove the visible remote lock");
+});

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

@@ -6,12 +6,15 @@ import assert from "node:assert/strict";
 
 import {
   autoSession,
+  clearAutoToolSurfaceSnapshot,
   clearToolInvocationError,
   getAutoRuntimeSnapshot,
+  recordAutoToolSurfaceSnapshot,
 } from "../auto-runtime-state.ts";
 
 test("getAutoRuntimeSnapshot includes orchestration phase when available", () => {
   autoSession.reset();
+  clearAutoToolSurfaceSnapshot();
   autoSession.active = true;
   autoSession.basePath = "/tmp/project";
   autoSession.orchestration = {
@@ -33,10 +36,40 @@ test("getAutoRuntimeSnapshot includes orchestration phase when available", () =>
   assert.equal(snap.orchestrationPhase, "running");
   assert.equal(snap.orchestrationTransitionCount, 3);
   assert.equal(snap.orchestrationLastTransitionAt, 123);
+  assert.equal(snap.toolSurface, null);
 
   autoSession.reset();
 });
 
+test("getAutoRuntimeSnapshot includes the active typed tool-surface snapshot", () => {
+  autoSession.reset();
+  clearAutoToolSurfaceSnapshot();
+  autoSession.active = true;
+
+  recordAutoToolSurfaceSnapshot({
+    source: "dispatch-scope",
+    unitType: "run-uat",
+    modelFacingToolNames: ["read", "read", "gsd_uat_exec"],
+    registeredToolNames: ["read", "browser_navigate"],
+    scopedToolNames: ["read", "browser_navigate"],
+    presentedToolNames: ["gsd_uat_exec"],
+    capturedAt: 123,
+  });
+
+  const snap = getAutoRuntimeSnapshot();
+
+  assert.equal(snap.toolSurface?.source, "dispatch-scope");
+  assert.equal(snap.toolSurface?.unitType, "run-uat");
+  assert.deepEqual(snap.toolSurface?.modelFacingToolNames, ["read", "gsd_uat_exec"]);
+  assert.deepEqual(snap.toolSurface?.registeredToolNames, ["read", "browser_navigate"]);
+  assert.deepEqual(snap.toolSurface?.scopedToolNames, ["read", "browser_navigate"]);
+  assert.deepEqual(snap.toolSurface?.presentedToolNames, ["gsd_uat_exec"]);
+  assert.equal(snap.toolSurface?.capturedAt, 123);
+
+  autoSession.reset();
+  clearAutoToolSurfaceSnapshot();
+});
+
 test("clearToolInvocationError clears stale tool error state for active auto sessions", () => {
   autoSession.reset();
   autoSession.active = true;
@@ -56,4 +89,5 @@ test("getAutoRuntimeSnapshot omits orchestration phase when seam not wired", ()
   assert.equal(snap.orchestrationPhase, undefined);
   assert.equal(snap.orchestrationTransitionCount, undefined);
   assert.equal(snap.orchestrationLastTransitionAt, undefined);
+  assert.equal(snap.toolSurface, null);
 });