@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

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

@@ -0,0 +1,94 @@
+/**
+ * status-per-repo.test.ts — `/gsd status` per-repository git-health block (#818).
+ *
+ * Covers the parent-workspace addition to formatTextStatus:
+ *   - parent mode with child repos → "Repositories:" section listing each
+ *   - dirty vs clean markers
+ *   - single-repo (project-mode) project → no Repositories section
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { formatTextStatus } from "../commands/handlers/core.ts";
+import type { GSDState } from "../types.ts";
+
+function gitInit(cwd: string): void {
+  execFileSync("git", ["init"], { cwd, stdio: "ignore" });
+}
+
+function makeBaseState(): GSDState {
+  return {
+    activeMilestone: null,
+    activeSlice: null,
+    activeTask: null,
+    phase: "planning",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "None",
+    registry: [],
+  };
+}
+
+function writeParentPrefs(base: string, repos: Record<string, { path: string; role?: string }>): void {
+  const repoLines = Object.entries(repos)
+    .map(([id, cfg]) => `    ${id}:\n      path: ${cfg.path}${cfg.role ? `\n      role: ${cfg.role}` : ""}`)
+    .join("\n");
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    `---\nversion: 1\nworkspace:\n  mode: parent\n  repositories:\n${repoLines}\n---\n`,
+    "utf-8",
+  );
+}
+
+test("formatTextStatus shows a Repositories section for a clean parent workspace", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-status-repo-clean-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    mkdirSync(join(base, "frontend"), { recursive: true });
+    gitInit(join(base, "frontend"));
+    writeParentPrefs(base, { frontend: { path: "frontend", role: "web UI" } });
+
+    const out = formatTextStatus(makeBaseState(), base);
+    assert.match(out, /Repositories:/);
+    assert.match(out, /✓ frontend — web UI \(clean\)/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("formatTextStatus marks a dirty child repo with ✗", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-status-repo-dirty-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    mkdirSync(join(base, "backend"), { recursive: true });
+    gitInit(join(base, "backend"));
+    writeParentPrefs(base, { backend: { path: "backend" } });
+    // Make the backend repo dirty.
+    writeFileSync(join(base, "backend", "README.md"), "# dirty\n", "utf-8");
+
+    const out = formatTextStatus(makeBaseState(), base);
+    assert.match(out, /✗ backend \(uncommitted changes\)/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("formatTextStatus omits the Repositories section for single-repo projects", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-status-repo-single-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    // No workspace config → project mode (default).
+    const out = formatTextStatus(makeBaseState(), base);
+    assert.doesNotMatch(out, /Repositories:/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

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/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/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/token-tool-gating.test.ts

@@ -552,6 +552,41 @@ test("discuss-milestone dispatch keeps required headless milestone tools after t
   assert.ok(!activeTools.includes("gsd_complete_milestone"));
 });
 
+test("#1157: validate-milestone dispatch surface removes generic write and bash tools", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "ask_user_questions",
+    "bash",
+    "bg_shell",
+    "edit",
+    "find",
+    "glob",
+    "grep",
+    "ls",
+    "read",
+    "subagent",
+    "write",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_validate_milestone",
+    "gsd_reassess_roadmap",
+  ], "validate-milestone");
+
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("find"));
+  assert.ok(result.includes("subagent"));
+  assert.ok(result.includes("gsd_validate_milestone"));
+  assert.ok(result.includes("gsd_milestone_status"));
+  assert.ok(result.includes("gsd_exec"));
+  assert.ok(result.includes("gsd_reassess_roadmap"));
+  assert.ok(!result.includes("bash"));
+  assert.ok(!result.includes("bg_shell"));
+  assert.ok(!result.includes("write"));
+  assert.ok(!result.includes("edit"));
+  assert.ok(!result.includes("ask_user_questions"));
+});
+
 test("scopeGsdWorkflowToolsForDispatch applies and restores per-unit skill visibility", () => {
   const calls: Array<{ kind: "tools" | "skills"; value: string[] | undefined }> = [];
   let activeTools = [