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

package/src/resources/extensions/gsd/tests/status-guards.test.ts

@@ -9,7 +9,10 @@ import {
   isDeferredStatus,
   isInactiveStatus,
   isSkippedForDispatch,
+  toStatus,
+  RAW_CLOSED_STATUSES,
 } from '../status-guards.ts';
+import { TERMINAL_STATUS_SQL } from '../db/sql-constants.ts';
 
 test('isClosedStatus: "complete" returns true', () => {
   assert.equal(isClosedStatus('complete'), true);
@@ -95,3 +98,38 @@ test('isSkippedForDispatch does NOT skip pending/active/planned', () => {
     assert.equal(isSkippedForDispatch(s), false, `${s} should block dispatch ordering`);
   }
 });
+
+// ─── ADR-030: canonical Status vocabulary + normalization ──────────────────
+
+test('toStatus passes canonical values through unchanged', () => {
+  for (const s of ['pending', 'queued', 'active', 'parked', 'in_progress', 'blocked', 'complete', 'skipped', 'deferred']) {
+    assert.equal(toStatus(s), s, `${s} is canonical and should be returned verbatim`);
+  }
+});
+
+test('toStatus maps known aliases to canonical', () => {
+  assert.equal(toStatus('done'), 'complete');
+  assert.equal(toStatus('closed'), 'complete');
+  assert.equal(toStatus('planned'), 'pending');
+  assert.equal(toStatus('in-progress'), 'in_progress');
+});
+
+test('toStatus trims surrounding whitespace before matching', () => {
+  assert.equal(toStatus('  complete  '), 'complete');
+  assert.equal(toStatus(' done '), 'complete');
+});
+
+test('toStatus quarantines unknown values verbatim (tolerant read, no throw)', () => {
+  assert.equal(toStatus('weird-legacy-value'), 'weird-legacy-value');
+});
+
+test('RAW_CLOSED_STATUSES is the single source: every member is closed', () => {
+  for (const s of RAW_CLOSED_STATUSES) {
+    assert.equal(isClosedStatus(s), true, `${s} is in RAW_CLOSED_STATUSES so must be closed`);
+  }
+});
+
+test('TERMINAL_STATUS_SQL is derived from RAW_CLOSED_STATUSES and renders identically', () => {
+  assert.equal(TERMINAL_STATUS_SQL, "'complete', 'done', 'skipped', 'closed'");
+  assert.equal(TERMINAL_STATUS_SQL, RAW_CLOSED_STATUSES.map((s) => `'${s}'`).join(', '));
+});

package/src/resources/extensions/gsd/tests/stop-auto-race-null-unit.test.ts

@@ -3,7 +3,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { _resolveCurrentUnitStartedAtForTest } from "../auto/phases.ts";
+import { _resolveCurrentUnitStartedAtForTest } from "../auto/phase-helpers.ts";
 
 test("unit started-at resolver tolerates stopAuto clearing currentUnit", () => {
   assert.equal(_resolveCurrentUnitStartedAtForTest(null), undefined);

package/src/resources/extensions/gsd/tests/stop-backtrack.test.ts

@@ -143,8 +143,12 @@ test("executeBacktrack writes trigger and regression markers", () => {
   const tmp = makeTempDir("exec-bt");
   setupGsdDir(tmp);
 
-  // Create target milestone directory
-  mkdirSync(join(tmp, ".gsd", "milestones", "M003"), { recursive: true });
+  // Create target milestone directory with a content file so it is recognised as
+  // a content-bearing legacy milestone by dirIsContentBearingLegacyMilestone
+  // (a metadata-only dir would be ignored by resolveMilestonePath).
+  const m003Dir = join(tmp, ".gsd", "milestones", "M003");
+  mkdirSync(m003Dir, { recursive: true });
+  writeFileSync(join(m003Dir, "M003-CONTEXT.md"), "# M003\n");
 
   const targetMid = executeBacktrack(tmp, "M005", {
     id: "CAP-test123",

package/src/resources/extensions/gsd/tests/stop-notice.test.ts

@@ -0,0 +1,70 @@
+// GSD Extension — Stop Notice module tests
+// Locks the emitter↔detector round-trip: every notice the formatters produce
+// must be recognized by the classifiers the headless host uses for exit codes.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  formatStopNoticePrefix,
+  isBlockedStopReason,
+  stopNoticeDisplayReason,
+  stopNoticeKind,
+  isTerminalNotice,
+  isPauseNotice,
+  isBlockedNoticeMessage,
+  isManualResolutionNotice,
+  PAUSED_NOTICE_PREFIXES,
+  TERMINAL_NOTICE_PREFIXES,
+} from "../stop-notice.js";
+
+describe("stop notice formatting", () => {
+  test("plain stop has no reason suffix", () => {
+    assert.equal(formatStopNoticePrefix(), "Auto-mode stopped");
+    assert.equal(formatStopNoticePrefix(null), "Auto-mode stopped");
+  });
+
+  test("reason is appended after an em-dash", () => {
+    assert.equal(formatStopNoticePrefix("user request"), "Auto-mode stopped — user request");
+  });
+
+  test("Blocked: marker switches the prefix and is stripped from display", () => {
+    assert.equal(formatStopNoticePrefix("Blocked: validation gate"), "Auto-mode blocked — validation gate");
+    assert.equal(stopNoticeKind("Blocked: x"), "blocked");
+    assert.equal(stopNoticeKind("stop"), "stopped");
+    assert.ok(isBlockedStopReason("blocked: lowercase too"));
+    assert.equal(stopNoticeDisplayReason("Blocked:  spaced "), "spaced");
+  });
+});
+
+describe("emitter↔detector round-trip", () => {
+  test("formatted stop notices classify as terminal", () => {
+    for (const reason of [undefined, "user request"]) {
+      const message = formatStopNoticePrefix(reason).toLowerCase();
+      assert.ok(isTerminalNotice(message), `not terminal: ${message}`);
+    }
+  });
+
+  test("pause prefixes classify as pause and as blocked (operator intervention)", () => {
+    for (const prefix of PAUSED_NOTICE_PREFIXES) {
+      assert.ok(isPauseNotice(`${prefix}: provider error`));
+      assert.ok(isBlockedNoticeMessage(`${prefix}: provider error`));
+    }
+  });
+
+  test("idempotent-advance pauses are non-blocking", () => {
+    assert.equal(isBlockedNoticeMessage("auto-mode paused (idempotent advance: unit already active)"), false);
+  });
+
+  test("manual-resolution notices classify as blocked", () => {
+    const message = "merge conflict — resolve manually and re-run /gsd auto";
+    assert.ok(isManualResolutionNotice(message));
+    assert.ok(isBlockedNoticeMessage(message));
+  });
+
+  test("terminal prefixes cover the known stop vocabulary", () => {
+    for (const message of ["auto-mode stopped.", "auto-mode complete", "auto-mode idle", "no active milestone"]) {
+      assert.ok(TERMINAL_NOTICE_PREFIXES.some((prefix) => message.startsWith(prefix)), message);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/stuck-state-via-db.test.ts

@@ -130,6 +130,91 @@ test("getRecentUnitKeysForProjectRoot restores compound keys used by stuck detec
   assert.match(result?.reason ?? "", /3 consecutive times/);
 });
 
+// ── #852: stuck window must be scoped to the current session (trace_id) ───────
+//
+// Without trace_id scoping, two consecutive finalize-retry failures from a
+// PREVIOUS session persist in unit_dispatches and fire detectStuck Rule 1 on
+// the first iteration of every new session — killing auto-mode before any new
+// dispatch runs. The trace_id filter ensures only the current session's
+// dispatches populate the window.
+
+test("#852: getRecentUnitKeysForProjectRoot scoped to trace_id ignores prior-session entries", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M015", title: "T", status: "active" });
+  const worker = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(worker, "M015");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  // PRIOR session: two consecutive finalize-retry failures (trace_id = "old").
+  for (let i = 0; i < 2; i++) {
+    const claim = recordDispatchClaim({
+      traceId: "old-session",
+      workerId: worker,
+      milestoneLeaseToken: lease.token,
+      milestoneId: "M015",
+      unitType: "discuss-milestone",
+      unitId: "M015",
+    });
+    assert.equal(claim.ok, true);
+    if (!claim.ok) return;
+    markFailed(claim.dispatchId, { errorSummary: "finalize-retry" });
+  }
+
+  // NEW session (trace_id = "new") has dispatched nothing yet.
+  // Without the trace_id filter, the window loads the two stale "old-session"
+  // finalize-retry entries → detectStuck Rule 1 fires immediately.
+  const unscopedWindow = getRecentUnitKeysForProjectRoot(base, 20);
+  assert.equal(unscopedWindow.length, 2, "unscoped window sees prior-session entries");
+
+  // With the trace_id filter, the new session's window is empty — no false stuck.
+  const scopedWindow = getRecentUnitKeysForProjectRoot(base, 20, "new-session");
+  assert.equal(scopedWindow.length, 0, "trace_id-scoped window excludes prior-session entries");
+
+  // detectStuck on an empty window returns null (not stuck).
+  assert.equal(detectStuck(scopedWindow), null);
+});
+
+test("#852: getRecentUnitKeysForProjectRoot trace_id filter still includes current-session entries", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M016", title: "T", status: "active" });
+  const worker = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(worker, "M016");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  // Prior session entries.
+  const oldClaim = recordDispatchClaim({
+    traceId: "prior", workerId: worker, milestoneLeaseToken: lease.token,
+    milestoneId: "M016", unitType: "plan-milestone", unitId: "M016",
+  });
+  assert.equal(oldClaim.ok, true);
+  if (oldClaim.ok) markFailed(oldClaim.dispatchId, { errorSummary: "finalize-retry" });
+
+  // Current session entries.
+  for (let i = 0; i < 2; i++) {
+    const claim = recordDispatchClaim({
+      traceId: "current", workerId: worker, milestoneLeaseToken: lease.token,
+      milestoneId: "M016", unitType: "plan-milestone", unitId: "M016",
+    });
+    assert.equal(claim.ok, true);
+    if (!claim.ok) return;
+    markFailed(claim.dispatchId, { errorSummary: "finalize-retry" });
+  }
+
+  // Scoped to "current" → only the 2 current-session entries.
+  const scoped = getRecentUnitKeysForProjectRoot(base, 20, "current");
+  assert.equal(scoped.length, 2, "trace_id filter includes current-session entries");
+
+  // Unscoped → 3 (prior + current).
+  const unscoped = getRecentUnitKeysForProjectRoot(base, 20);
+  assert.equal(unscoped.length, 3, "unscoped window includes all sessions");
+});
+
 test("getRecentUnitKeysForWorker honors the limit parameter", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/sync-lock.test.ts

@@ -6,6 +6,7 @@ import assert from 'node:assert/strict';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
+import { performance } from 'node:perf_hooks';
 import { acquireSyncLock, releaseSyncLock } from '../sync-lock.ts';
 
 function tempDir(): string {
@@ -151,3 +152,25 @@ test('sync-lock: EPERM from live owner PID prevents stale lock stealing', () =>
     cleanupDir(base);
   }
 });
+
+test('sync-lock: contended fresh lock fails fast without honoring long sync timeout', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  const lockPath = path.join(base, '.gsd', 'sync.lock');
+
+  try {
+    fs.writeFileSync(lockPath, JSON.stringify({ pid: 99999, acquired_at: new Date().toISOString() }));
+
+    const startedAt = performance.now();
+    const result = acquireSyncLock(base, 1_000);
+    const elapsedMs = performance.now() - startedAt;
+
+    assert.strictEqual(result.acquired, false, 'fresh lock should not be stolen');
+    assert.ok(
+      elapsedMs < 250,
+      `contended sync lock should fail fast instead of blocking for timeout; elapsed=${elapsedMs.toFixed(1)}ms`,
+    );
+  } finally {
+    cleanupDir(base);
+  }
+});

package/src/resources/extensions/gsd/tests/system-context-message-routing.test.ts

@@ -4,7 +4,35 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
-import { buildContextMessage } from "../bootstrap/system-context.ts";
+import { buildContextMessage, stripVolatileCodebaseMetadata } from "../bootstrap/system-context.ts";
+
+describe("stripVolatileCodebaseMetadata (#847 — KV cache stability)", () => {
+  const map = [
+    "# Codebase Map",
+    "",
+    "Generated: 2026-03-23T14:00:00Z | Files: 3 | Described: 2/3",
+    `<!-- gsd:codebase-meta {"generatedAt":"2026-03-23T14:00:00Z","fingerprint":"abc","fileCount":3,"truncated":false} -->`,
+    "",
+    "### src/",
+    "- `a.ts` — does a",
+    "- `b.ts`",
+  ].join("\n");
+
+  test("removes the Generated timestamp and meta comment lines", () => {
+    const stripped = stripVolatileCodebaseMetadata(map);
+    assert.ok(!stripped.includes("Generated:"));
+    assert.ok(!stripped.includes("gsd:codebase-meta"));
+    assert.ok(stripped.includes("- `a.ts` — does a"));
+    assert.ok(stripped.includes("### src/"));
+  });
+
+  test("is stable across regenerations that only change the timestamp", () => {
+    const later = map
+      .replace("2026-03-23T14:00:00Z | Files", "2026-03-24T09:30:00Z | Files")
+      .replace('"generatedAt":"2026-03-23T14:00:00Z"', '"generatedAt":"2026-03-24T09:30:00Z"');
+    assert.equal(stripVolatileCodebaseMetadata(map), stripVolatileCodebaseMetadata(later));
+  });
+});
 
 describe("buildContextMessage (#5019 — memory routing)", () => {
   const markedMemory = "[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]\nrule one";

package/src/resources/extensions/gsd/tests/teardown-chdir-failure-clears-registry.test.ts

@@ -159,4 +159,21 @@ describe("teardown chdir failure clears registry", () => {
     assert.strictEqual(getAutoWorktreeOriginalBase(), null, "registry null after successful teardown");
     assert.strictEqual(getActiveAutoWorktreeContext(), null, "context null after successful teardown");
   });
+
+  test("teardown survives when current working directory was deleted", () => {
+    repoDir = createTempRepo();
+    seedMilestone(repoDir, "M003");
+
+    const worktreePath = createAutoWorktree(repoDir, "M003");
+    process.chdir(worktreePath);
+    rmSync(worktreePath, { recursive: true, force: true });
+
+    assert.doesNotThrow(
+      () => teardownAutoWorktree(repoDir, "M003"),
+      "teardownAutoWorktree should not call process.cwd() unguarded from a deleted cwd",
+    );
+
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null, "registry null after deleted-cwd teardown");
+    assert.strictEqual(getActiveAutoWorktreeContext(), null, "context null after deleted-cwd teardown");
+  });
 });

package/src/resources/extensions/gsd/tests/terminal-tool-surface-classification.test.ts

@@ -0,0 +1,80 @@
+// Project/App: gsd-pi
+// File Purpose: Contract coverage for terminal tool-surface failure classification (#783).
+//
+// A terminal MCP server status (failed / needs-auth / disabled) must not be
+// classified as transient — retrying the same model cannot repair a dead
+// server and burns retries until the per-unit cost cap pauses auto-mode.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { isTerminalToolSurfaceError, getToolSurfaceReadinessError, TOOL_SURFACE_NOT_READY } from "../tool-surface-readiness.ts";
+import { classifyError, isTransient } from "../error-classifier.ts";
+
+const SERVER = "gsd-workflow";
+
+function readinessFor(status: string): string {
+  return getToolSurfaceReadinessError({
+    unitType: "run-uat",
+    workflowServerName: SERVER,
+    observation: { tools: ["read"], mcpServers: [{ name: SERVER, status }] },
+  })!;
+}
+
+describe("isTerminalToolSurfaceError", () => {
+  test("recognizes every canonical terminal status", () => {
+    for (const status of ["failed", "needs-auth", "disabled"]) {
+      const error = readinessFor(status);
+      assert.ok(error, `expected a readiness error for status=${status}`);
+      assert.equal(
+        isTerminalToolSurfaceError(error),
+        true,
+        `status=${status} should be terminal`,
+      );
+    }
+  });
+
+  test("returns false for genuinely transient (not-yet-connected) variants", () => {
+    assert.equal(isTerminalToolSurfaceError(readinessFor("pending")), false);
+    assert.equal(isTerminalToolSurfaceError(readinessFor("connected")), false);
+    assert.equal(isTerminalToolSurfaceError(readinessFor("connecting")), false);
+  });
+
+  test("returns false for non-readiness and unrelated messages", () => {
+    assert.equal(isTerminalToolSurfaceError(null), false);
+    assert.equal(isTerminalToolSurfaceError(undefined), false);
+    assert.equal(isTerminalToolSurfaceError(""), false);
+    assert.equal(isTerminalToolSurfaceError("some unrelated network error"), false);
+    // A bare "(terminal)" without a real readiness prefix/status must not trip.
+    assert.equal(isTerminalToolSurfaceError("something (terminal) happened"), false);
+  });
+
+  test("the readiness prefix alone (without the terminal marker) is not terminal", () => {
+    const transientMessage = `${TOOL_SURFACE_NOT_READY} for run-uat: MCP server "${SERVER}" is absent from the init surface (not yet connected): gsd_uat_exec`;
+    assert.equal(isTerminalToolSurfaceError(transientMessage), false);
+  });
+});
+
+describe("classifyError terminal readiness contract (#783)", () => {
+  test("every terminal status classifies as non-transient permanent", () => {
+    for (const status of ["failed", "needs-auth", "disabled"]) {
+      const cls = classifyError(`Claude Code error: ${readinessFor(status)}`);
+      assert.equal(isTransient(cls), false, `status=${status} must not be transient`);
+      assert.equal(cls.kind, "permanent", `status=${status} must classify as permanent`);
+    }
+  });
+
+  test("transient not-yet-connected variants still classify as transient network", () => {
+    const cls = classifyError(`Claude Code error: ${readinessFor("pending")}`);
+    assert.equal(isTransient(cls), true);
+    assert.equal(cls.kind, "network");
+  });
+
+  test("terminal branch is matched ahead of the shared transient prefix branch", () => {
+    // The failed-status message shares the TOOL_SURFACE_NOT_READY prefix with
+    // the transient branches. If ordering regressed, this would be `network`.
+    const cls = classifyError(readinessFor("needs-auth"));
+    assert.notEqual(cls.kind, "network");
+    assert.equal(cls.kind, "permanent");
+  });
+});

package/src/resources/extensions/gsd/tests/thinking-level-resolution.test.ts

@@ -19,7 +19,7 @@ function withPreferences<T>(frontmatter: string[], fn: () => T): T {
   const home = mkdtempSync(join(tmpdir(), "gsd-thinking-"));
   try {
     process.env.GSD_HOME = home;
-    writeFileSync(join(home, "preferences.md"), ["---", ...frontmatter, "---", ""].join("\n"));
+    writeFileSync(join(home, "preferences.md"), ["---", "token_profile: burn-max", ...frontmatter, "---", ""].join("\n"));
     return fn();
   } finally {
     if (oldHome === undefined) delete process.env.GSD_HOME;

package/src/resources/extensions/gsd/tests/token-tool-gating.test.ts

@@ -10,6 +10,7 @@ import { DISCUSS_TOOLS_ALLOWLIST } from "../constants.ts";
 import { buildMinimalAutoGsdToolSet, buildMinimalGsdToolSet, buildMinimalGsdWorkflowToolSet, buildRequestScopedGsdToolSet, MINIMAL_AUTO_BASE_TOOL_NAMES, MINIMAL_GSD_TOOL_NAMES, requestHasGsdCustomType, restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch } from "../bootstrap/register-hooks.ts";
 import { filterToolsForProvider } from "../model-router.ts";
 import { applyUnitSkillVisibility } from "../skill-scope.ts";
+import { drainLogs } from "../workflow-logger.ts";
 
 test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surface", () => {
   const result = buildMinimalGsdToolSet([
@@ -17,6 +18,7 @@ test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surf
     "read",
     "browser_open",
     "gsd_plan_milestone",
+    "gsd_plan_slice",
     "gsd_task_complete",
     "gsd_exec",
     "gsd_exec_search",
@@ -103,6 +105,40 @@ test("buildMinimalAutoGsdToolSet keeps unit-specific completion tools without al
   assert.ok(!result.includes("gsd_complete_slice"));
 });
 
+test("buildMinimalAutoGsdToolSet warns when plan-milestone required tools are unresolved", () => {
+  drainLogs();
+  const result = buildMinimalAutoGsdToolSet(
+    [
+      "ask_user_questions",
+      "bash",
+      "read",
+      "gsd_milestone_status",
+      "gsd_plan_milestone",
+    ],
+    "plan-milestone",
+    [
+      "ask_user_questions",
+      "bash",
+      "read",
+      "gsd_milestone_status",
+      "gsd_plan_milestone",
+    ],
+  );
+
+  assert.ok(result.includes("gsd_plan_milestone"));
+  assert.ok(!result.includes("gsd_plan_slice"));
+
+  const logs = drainLogs();
+  assert.ok(
+    logs.some((entry) =>
+      entry.component === "bootstrap" &&
+      entry.message.includes("buildMinimalAutoGsdToolSet(plan-milestone)") &&
+      entry.message.includes("gsd_plan_slice")
+    ),
+    `expected missing gsd_plan_slice bootstrap warning, got ${JSON.stringify(logs)}`,
+  );
+});
+
 test("buildMinimalAutoGsdToolSet scopes run-uat to UAT-specific and read-only tools", () => {
   const active = ["ask_user_questions", "bash", "read", "edit", "write", "gsd_summary_save"];
   const registered = [
@@ -329,13 +365,14 @@ test("buildMinimalAutoGsdToolSet includes closeout tool for complete-slice", ()
     "gsd_complete_slice",
     "memory_query",
     "capture_thought",
+    "gsd_capture_thought",
   ], "complete-slice");
 
   assert.ok(result.includes("gsd_slice_complete"));
   assert.ok(result.includes("gsd_task_reopen"));
   assert.ok(result.includes("gsd_replan_slice"));
   assert.ok(result.includes("subagent"));
-  assert.ok(result.includes("capture_thought"));
+  assert.ok(result.includes("gsd_capture_thought"));
   assert.ok(!result.includes("gsd_task_complete"));
   assert.ok(!result.includes("gsd_complete_slice"));
 });
@@ -351,6 +388,7 @@ test("buildMinimalAutoGsdToolSet preserves workflow MCP-namespaced closeout tool
     "mcp__gsd-workflow__gsd_exec",
     "mcp__gsd-workflow__memory_query",
     "mcp__gsd-workflow__capture_thought",
+    "mcp__gsd-workflow__gsd_capture_thought",
   ], "complete-slice");
 
   assert.ok(result.includes("mcp__gsd-workflow__gsd_task_reopen"));
@@ -359,7 +397,7 @@ test("buildMinimalAutoGsdToolSet preserves workflow MCP-namespaced closeout tool
   assert.ok(!result.includes("mcp__gsd-workflow__gsd_complete_slice"));
   assert.ok(result.includes("mcp__gsd-workflow__gsd_exec"));
   assert.ok(result.includes("mcp__gsd-workflow__memory_query"));
-  assert.ok(result.includes("mcp__gsd-workflow__capture_thought"));
+  assert.ok(result.includes("mcp__gsd-workflow__gsd_capture_thought"));
 });
 
 test("buildMinimalAutoGsdToolSet covers execute-task-simple", () => {
@@ -613,6 +651,46 @@ test("buildMinimalAutoGsdToolSet resolves MCP-scoped gsd_memory_query and gsd_ca
   );
 });
 
+// ── Regression #627: auto-mode cannot run plan-milestone because gsd_plan_slice is missing ──
+// gsd_plan_slice is in AUTO_UNIT_SCOPED_TOOLS["plan-milestone"] (via unit-tool-contracts).
+// buildMinimalAutoGsdToolSet must expose it when unitType is "plan-milestone".
+
+test("buildMinimalAutoGsdToolSet includes gsd_plan_slice for plan-milestone (regression #627)", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "gsd_plan_milestone",
+    "gsd_plan_slice",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "memory_query",
+    "capture_thought",
+  ], "plan-milestone");
+
+  assert.ok(
+    result.includes("gsd_plan_slice"),
+    "gsd_plan_slice must be included in plan-milestone auto-mode tool set",
+  );
+});
+
+test("buildMinimalAutoGsdToolSet resolves MCP-scoped gsd_plan_slice for plan-milestone when subprocess only registers prefixed variant (regression #627)", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "mcp__gsd-workflow__gsd_plan_milestone",
+    "mcp__gsd-workflow__gsd_plan_slice",
+    "mcp__gsd-workflow__gsd_milestone_status",
+    "mcp__gsd-workflow__gsd_checkpoint_db",
+    "mcp__gsd-workflow__memory_query",
+    "mcp__gsd-workflow__capture_thought",
+  ], "plan-milestone");
+
+  assert.ok(
+    result.includes("mcp__gsd-workflow__gsd_plan_slice"),
+    "mcp__gsd-workflow__gsd_plan_slice must be included when only the MCP-scoped variant is available",
+  );
+});
+
 test("applyUnitSkillVisibility sets manifest or clears for wildcard", () => {
   const calls: Array<string[] | undefined> = [];
   applyUnitSkillVisibility({

package/src/resources/extensions/gsd/tests/tool-availability-audit.test.ts

@@ -141,6 +141,41 @@ for (const customType of ["gsd-discuss", "gsd-run"] as const) {
   });
 }
 
+for (const unitType of ["execute-task", "execute-task-simple", "reactive-execute"] as const) {
+  test(`${unitType}: resolves gsd_task_complete via alias gsd_complete_task when only alias is registered`, () => {
+    // Simulates the MCP transport registering gsd_complete_task (alias) instead of gsd_task_complete.
+    // adjust_tool_set strips aliases from providerCompatible, so gsd_complete_task is only present
+    // in registeredToolNames. resolveScopedToolNames must still surface it so the agent can complete tasks.
+    const base: string[] = [...FULL_REGISTERED_TOOLS];
+    const aliasOnlyRegistered = base
+      .filter((name) => name !== "gsd_task_complete")
+      .concat("gsd_complete_task");
+    const aliasStrippedActive = aliasOnlyRegistered.filter((name) => name !== "gsd_complete_task");
+
+    const result = buildMinimalAutoGsdToolSet(aliasStrippedActive, unitType, aliasOnlyRegistered);
+
+    assert.ok(
+      result.includes("gsd_task_complete") || result.includes("gsd_complete_task"),
+      `${unitType} missing gsd_task_complete / gsd_complete_task — agent cannot complete tasks`,
+    );
+  });
+
+  test(`${unitType}: alias does not duplicate canonical when both are in the active set`, () => {
+    // When both canonical and alias are registered/active, only the canonical should be surfaced.
+    const bothPresent: string[] = [...FULL_REGISTERED_TOOLS, "gsd_complete_task"];
+
+    const result = buildMinimalAutoGsdToolSet(bothPresent, unitType, bothPresent);
+
+    const hasCanonical = result.includes("gsd_task_complete");
+    const hasAlias = result.includes("gsd_complete_task");
+    assert.ok(hasCanonical || hasAlias, `${unitType} missing completion tool`);
+    assert.ok(
+      !(hasCanonical && hasAlias),
+      `${unitType} surfaces both gsd_task_complete and gsd_complete_task — alias should not duplicate canonical`,
+    );
+  });
+}
+
 test("discuss-milestone two-stage scoping matches adjust_tool_set request scope", () => {
   const activeTools = simulateDiscussAllowlistFilter(FULL_REGISTERED_TOOLS);
   const dispatchScoped = buildMinimalAutoGsdToolSet(

package/src/resources/extensions/gsd/tests/tool-invocation-error-loop-break.test.ts

@@ -48,6 +48,7 @@ import {
   isDeterministicPolicyError,
   isPendingUserApprovalGateError,
   isToolInvocationError,
+  isToolUnavailableError,
   isQueuedUserMessageSkip,
 } from "../auto-tool-tracking.ts";
 import {
@@ -121,6 +122,13 @@ describe("#2883: isToolInvocationError classification", () => {
     assert.equal(isToolInvocationError("No such tool available: mcp__gsd-workflow__memory_query"), true);
   });
 
+  test("isToolUnavailableError singles out the startup-race error as transient", () => {
+    assert.equal(isToolUnavailableError("No such tool available: mcp__gsd-workflow__gsd_uat_exec"), true);
+    assert.equal(isToolUnavailableError("Validation failed for tool gsd_complete_slice"), false);
+    assert.equal(isToolUnavailableError("Unexpected end of JSON input"), false);
+    assert.equal(isToolUnavailableError(""), false);
+  });
+
   test("detects ESM export-link errors", () => {
     assert.equal(
       isToolInvocationError("The requested module '../paths.js' does not provide an export named 'gsdProjectionRoot'"),