gsd-pi 2.58.0-dev.d63175c → 2.58.0-dev.e002a57

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

@@ -0,0 +1,106 @@
+/**
+ * stop-auto-race-null-unit.test.ts — Regression test for #2939.
+ *
+ * When the user stops auto-mode while a unit is executing, stopAuto()
+ * calls s.reset() which sets s.currentUnit = null. The resumed
+ * runUnitPhase() then hits s.currentUnit.startedAt on the closeout
+ * line and throws a TypeError.
+ *
+ * The fix adds null guards (matching the existing pattern at lines 136
+ * and 344) so that closeout and subsequent accesses are skipped when
+ * s.currentUnit has been nulled by a concurrent stopAuto().
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertTrue, report } = createTestContext();
+
+const phasesPath = join(import.meta.dirname, "..", "auto", "phases.ts");
+const phasesSrc = readFileSync(phasesPath, "utf-8");
+
+console.log("\n=== #2939: stopAuto race — null guard on s.currentUnit in closeout ===");
+
+// ── Test 1: closeoutUnit call is guarded by if (s.currentUnit) ──────────
+// The closeout block starting around the "Immediate unit closeout" comment
+// must be wrapped in an `if (s.currentUnit)` guard, matching the pattern
+// already used at lines 136 and 344.
+
+const closeoutComment = "Immediate unit closeout";
+const closeoutIdx = phasesSrc.indexOf(closeoutComment);
+assertTrue(
+  closeoutIdx > 0,
+  "phases.ts contains the 'Immediate unit closeout' comment block",
+);
+
+// Extract the region from the closeout comment to the next section comment
+const closeoutRegion = phasesSrc.slice(closeoutIdx, closeoutIdx + 500);
+assertTrue(
+  closeoutRegion.includes("if (s.currentUnit)"),
+  "closeoutUnit call is guarded by `if (s.currentUnit)` check (#2939)",
+);
+
+// ── Test 2: zero-tool-call guard uses s.currentUnit?.startedAt ──────────
+// The zero-tool-call section accesses s.currentUnit!.startedAt (non-null
+// assertion) which will throw if currentUnit is null.
+
+const zeroToolComment = "Zero tool-call guard";
+const zeroToolIdx = phasesSrc.indexOf(zeroToolComment);
+assertTrue(
+  zeroToolIdx > 0,
+  "phases.ts contains the 'Zero tool-call guard' comment block",
+);
+
+const zeroToolRegion = phasesSrc.slice(zeroToolIdx, zeroToolIdx + 600);
+
+// The non-null assertion `s.currentUnit!.startedAt` must be replaced with
+// optional chaining `s.currentUnit?.startedAt`
+assertTrue(
+  !zeroToolRegion.includes("s.currentUnit!.startedAt"),
+  "zero-tool-call guard no longer uses non-null assertion on s.currentUnit (#2939)",
+);
+
+// ── Test 3: return value uses optional chaining for startedAt ───────────
+// The final return at the end of runUnitPhase uses s.currentUnit.startedAt
+// which will throw if currentUnit was nulled. It must use optional chaining.
+
+// Find the last return statement in runUnitPhase that references startedAt.
+// There are two: one inside the zero-tool-call block and one at the end.
+// Both must use s.currentUnit?.startedAt
+
+// Count unguarded s.currentUnit.startedAt (without optional chaining)
+// after the "Immediate unit closeout" comment. All of them should use
+// optional chaining or be inside a guard.
+const afterCloseout = phasesSrc.slice(closeoutIdx);
+
+// Count s.currentUnit!.startedAt (non-null assertion — always unsafe)
+const nonNullPattern = /s\.currentUnit!\.startedAt/g;
+const nonNullAfterCloseout = [...afterCloseout.matchAll(nonNullPattern)];
+assertTrue(
+  nonNullAfterCloseout.length === 0,
+  `no non-null assertions s.currentUnit!.startedAt after closeout comment (found ${nonNullAfterCloseout.length}, expected 0) (#2939)`,
+);
+
+// Count bare s.currentUnit.startedAt that are NOT inside an if (s.currentUnit) guard.
+// The closeout block itself uses s.currentUnit.startedAt inside a guard — that's fine.
+// But any usage outside a guard block (e.g. in a return statement) must use optional chaining.
+// We check that all return statements use optional chaining.
+const returnWithBareAccess = /return\s*\{[^}]*s\.currentUnit\.startedAt/g;
+const bareReturnCount = [...afterCloseout.matchAll(returnWithBareAccess)].length;
+assertTrue(
+  bareReturnCount === 0,
+  `no return statements use bare s.currentUnit.startedAt (found ${bareReturnCount}, expected 0) (#2939)`,
+);
+
+// ── Test 4: the return at end of runUnitPhase uses optional chaining ────
+// The final `return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } }`
+// must use optional chaining.
+
+const finalReturnPattern = /unitStartedAt:\s*s\.currentUnit\?\.startedAt/;
+assertTrue(
+  finalReturnPattern.test(afterCloseout),
+  "final return uses s.currentUnit?.startedAt with optional chaining (#2939)",
+);
+
+report();

package/src/resources/extensions/gsd/tests/stuck-detection-coverage.test.ts

@@ -0,0 +1,174 @@
+// GSD State Machine Regression Tests — Stuck Detection Coverage (#3161)
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { detectStuck } from "../auto/detect-stuck.ts";
+
+// ─── Baseline: window too small ──────────────────────────────────────────────
+
+test("returns null for empty window", () => {
+  assert.equal(detectStuck([]), null);
+});
+
+test("returns null for single entry", () => {
+  assert.equal(detectStuck([{ key: "A" }]), null);
+});
+
+test("returns null for two different entries without errors", () => {
+  assert.equal(detectStuck([{ key: "A" }, { key: "B" }]), null);
+});
+
+// ─── Rule 1: Same error repeated consecutively ───────────────────────────────
+
+test("Rule 1: same error twice consecutively triggers stuck", () => {
+  const result = detectStuck([
+    { key: "A", error: "ENOENT: no such file" },
+    { key: "A", error: "ENOENT: no such file" },
+  ]);
+  assert.notEqual(result, null);
+  assert.equal(result!.stuck, true);
+  assert.ok(result!.reason.includes("Same error"), `reason was: ${result!.reason}`);
+});
+
+test("Rule 1: different errors do not trigger stuck", () => {
+  // Only 2 entries with different errors — Rule 2 needs 3 entries, so null.
+  const result = detectStuck([
+    { key: "A", error: "err1" },
+    { key: "A", error: "err2" },
+  ]);
+  assert.equal(result, null);
+});
+
+test("Rule 1: only last two entries matter for error check", () => {
+  // First two share an error, but the last two have distinct errors — no trigger.
+  const result = detectStuck([
+    { key: "A", error: "same-error" },
+    { key: "A", error: "same-error" },
+    { key: "B", error: "different-error-1" },
+    { key: "C", error: "different-error-2" },
+  ]);
+  assert.equal(result, null);
+});
+
+// ─── Rule 2: Same unit key 3+ consecutive times ───────────────────────────────
+
+test("Rule 2: same unit key 3 consecutive times triggers stuck", () => {
+  const result = detectStuck([
+    { key: "A" },
+    { key: "A" },
+    { key: "A" },
+  ]);
+  assert.notEqual(result, null);
+  assert.equal(result!.stuck, true);
+  assert.ok(
+    result!.reason.includes("3 consecutive times"),
+    `reason was: ${result!.reason}`,
+  );
+});
+
+test("Rule 2: same key twice is not enough", () => {
+  assert.equal(detectStuck([{ key: "A" }, { key: "A" }]), null);
+});
+
+test("Rule 2: interrupted sequence does not trigger", () => {
+  // A, B, A — last three are not all the same key.
+  assert.equal(
+    detectStuck([{ key: "A" }, { key: "B" }, { key: "A" }]),
+    null,
+  );
+});
+
+// ─── Rule 3: Oscillation A→B→A→B ─────────────────────────────────────────────
+
+test("Rule 3: A-B-A-B oscillation triggers stuck", () => {
+  const result = detectStuck([
+    { key: "A" },
+    { key: "B" },
+    { key: "A" },
+    { key: "B" },
+  ]);
+  assert.notEqual(result, null);
+  assert.equal(result!.stuck, true);
+  assert.ok(
+    result!.reason.includes("Oscillation"),
+    `reason was: ${result!.reason}`,
+  );
+});
+
+test("Rule 3: A-B-A-C does not trigger oscillation", () => {
+  assert.equal(
+    detectStuck([{ key: "A" }, { key: "B" }, { key: "A" }, { key: "C" }]),
+    null,
+  );
+});
+
+test("Rule 3: A-A-A-A triggers Rule 2 not Rule 3", () => {
+  // Rule 2 fires first (last 3 are all the same key).
+  const result = detectStuck([
+    { key: "A" },
+    { key: "A" },
+    { key: "A" },
+    { key: "A" },
+  ]);
+  assert.notEqual(result, null);
+  assert.equal(result!.stuck, true);
+  assert.ok(
+    result!.reason.includes("3 consecutive times"),
+    `expected Rule 2 reason but got: ${result!.reason}`,
+  );
+  assert.ok(
+    !result!.reason.includes("Oscillation"),
+    `unexpectedly matched Rule 3: ${result!.reason}`,
+  );
+});
+
+// ─── Gap documentation: 3-unit cycle evades detection ────────────────────────
+
+test("Three-unit cycle A-B-C-A-B-C does NOT trigger stuck (documents gap L13)", () => {
+  // None of the three rules fires for a 3-unit repeating cycle.
+  // This test intentionally documents the coverage gap where such cycles
+  // slip through undetected (#3161).
+  const result = detectStuck([
+    { key: "A" },
+    { key: "B" },
+    { key: "C" },
+    { key: "A" },
+    { key: "B" },
+    { key: "C" },
+  ]);
+  assert.equal(result, null);
+});
+
+// ─── Window boundary: earlier patterns do not contaminate recent check ─────────
+
+test("window bounded: detection uses last N entries correctly", () => {
+  // The first three entries would trigger Rule 2, but the last entries are
+  // healthy — only the tail matters.
+  const result = detectStuck([
+    { key: "X" },
+    { key: "X" },
+    { key: "X" }, // would be stuck if this were the end
+    { key: "A" },
+    { key: "B" }, // last two: different keys, no error
+  ]);
+  assert.equal(result, null);
+});
+
+// ─── Rule priority: Rule 1 before Rule 2 ─────────────────────────────────────
+
+test("Rule 1 takes priority over Rule 2 when both match", () => {
+  // Last 3 entries share the same key (Rule 2 candidate) AND last 2 share
+  // the same error (Rule 1 candidate). Rule 1 is evaluated first.
+  const result = detectStuck([
+    { key: "A", error: "boom" },
+    { key: "A", error: "boom" },
+    { key: "A", error: "boom" },
+  ]);
+  assert.notEqual(result, null);
+  assert.equal(result!.stuck, true);
+  assert.ok(
+    result!.reason.includes("Same error"),
+    `expected Rule 1 reason but got: ${result!.reason}`,
+  );
+});

package/src/resources/extensions/gsd/tests/summary-render-parity.test.ts

@@ -0,0 +1,221 @@
+/**
+ * summary-render-parity.test.ts — Regression test for #2720
+ *
+ * Asserts that the SUMMARY.md produced at task-completion time
+ * (renderSummaryMarkdown in complete-task.ts) is structurally identical
+ * to the SUMMARY.md produced at projection-regeneration time
+ * (renderSummaryContent in workflow-projections.ts).
+ *
+ * Both render paths receive equivalent data (CompleteTaskParams vs TaskRow)
+ * and must produce the same output. If they diverge, projection regeneration
+ * silently replaces richer content with a stripped-down version.
+ */
+
+import { createTestContext } from './test-helpers.ts';
+import { renderSummaryContent } from '../workflow-projections.ts';
+import type { TaskRow } from '../gsd-db.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Fixtures — same logical data in both shapes
+// ═══════════════════════════════════════════════════════════════════════════
+
+const SLICE_ID = "S01";
+const MILESTONE_ID = "M001";
+
+const taskRow: TaskRow = {
+  milestone_id: MILESTONE_ID,
+  slice_id: SLICE_ID,
+  id: "T01",
+  title: "Implement widget parser",
+  status: "complete",
+  one_liner: "Implement widget parser",
+  narrative: "Added a recursive descent parser for widget DSL.",
+  verification_result: "All 42 unit tests pass; linter clean.",
+  duration: "2h",
+  completed_at: "2025-01-15T10:30:00.000Z",
+  blocker_discovered: false,
+  deviations: "Switched from PEG to hand-rolled parser for perf.",
+  known_issues: "No known issues.",
+  key_files: ["src/parser.ts", "src/lexer.ts"],
+  key_decisions: ["Hand-rolled parser over PEG for 3x throughput"],
+  full_summary_md: "",
+  description: "",
+  estimate: "",
+  files: [],
+  verify: "",
+  inputs: [],
+  expected_output: [],
+  observability_impact: "",
+  full_plan_md: "",
+  sequence: 1,
+};
+
+const verificationEvidence = [
+  { command: "npm test", exitCode: 0, verdict: "42/42 passed ✅", durationMs: 3200 },
+  { command: "npm run lint", exitCode: 0, verdict: "No warnings ✅", durationMs: 1100 },
+];
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+// Test 1: renderSummaryContent includes Verification section
+{
+  const output = renderSummaryContent(taskRow, SLICE_ID, MILESTONE_ID);
+  assertTrue(
+    output.includes("## Verification"),
+    "renderSummaryContent must include a ## Verification section",
+  );
+}
+
+// Test 2: renderSummaryContent includes Verification Evidence table
+{
+  const output = renderSummaryContent(taskRow, SLICE_ID, MILESTONE_ID, verificationEvidence);
+  assertTrue(
+    output.includes("## Verification Evidence"),
+    "renderSummaryContent must include a ## Verification Evidence section",
+  );
+  assertTrue(
+    output.includes("npm test"),
+    "Verification Evidence table must include the command",
+  );
+  assertTrue(
+    output.includes("| Exit Code |") || output.includes("exit_code") || output.includes("Exit Code"),
+    "Verification Evidence table must include exit code column",
+  );
+}
+
+// Test 3: renderSummaryContent includes Files Created/Modified section
+{
+  const output = renderSummaryContent(taskRow, SLICE_ID, MILESTONE_ID);
+  assertTrue(
+    output.includes("## Files Created/Modified"),
+    "renderSummaryContent must include a ## Files Created/Modified section",
+  );
+  assertTrue(
+    output.includes("`src/parser.ts`"),
+    "Files section must list key_files as inline code",
+  );
+}
+
+// Test 4: one_liner renders as bold (not blockquote) for consistency
+{
+  const output = renderSummaryContent(taskRow, SLICE_ID, MILESTONE_ID);
+  assertTrue(
+    output.includes(`**${taskRow.one_liner}**`),
+    "one_liner must render as bold text (not blockquote)",
+  );
+}
+
+// Test 5: frontmatter key_files uses YAML list format (not JSON array)
+{
+  const output = renderSummaryContent(taskRow, SLICE_ID, MILESTONE_ID);
+  assertTrue(
+    output.includes("key_files:\n  - src/parser.ts\n  - src/lexer.ts"),
+    "key_files frontmatter must use YAML list format, not JSON array",
+  );
+}
+
+// Test 6: frontmatter key_decisions uses YAML list format (not JSON array)
+{
+  const output = renderSummaryContent(taskRow, SLICE_ID, MILESTONE_ID);
+  assertTrue(
+    output.includes("key_decisions:\n  - Hand-rolled parser over PEG for 3x throughput"),
+    "key_decisions frontmatter must use YAML list format, not JSON array",
+  );
+}
+
+// Test 7: Deviations section always present (with "None." fallback)
+{
+  const noDeviations = { ...taskRow, deviations: "" };
+  const output = renderSummaryContent(noDeviations, SLICE_ID, MILESTONE_ID);
+  assertTrue(
+    output.includes("## Deviations"),
+    "Deviations section must always be present even when empty",
+  );
+  assertTrue(
+    output.includes("None."),
+    "Deviations section must show 'None.' when no deviations",
+  );
+}
+
+// Test 8: Known Issues section always present (with "None." fallback)
+{
+  const noKnownIssues = { ...taskRow, known_issues: "" };
+  const output = renderSummaryContent(noKnownIssues, SLICE_ID, MILESTONE_ID);
+  assertTrue(
+    output.includes("## Known Issues"),
+    "Known Issues section must always be present even when empty",
+  );
+}
+
+// Test 9: verification_result frontmatter not double-quoted
+{
+  const output = renderSummaryContent(taskRow, SLICE_ID, MILESTONE_ID);
+  // Should be: verification_result: passed (not "passed")
+  assertTrue(
+    !output.includes('verification_result: "'),
+    "verification_result frontmatter value must not be double-quoted",
+  );
+}
+
+// Test 10: duration frontmatter not double-quoted
+{
+  const output = renderSummaryContent(taskRow, SLICE_ID, MILESTONE_ID);
+  assertTrue(
+    !output.includes('duration: "'),
+    "duration frontmatter value must not be double-quoted",
+  );
+}
+
+// Test 11: empty key_files renders YAML placeholder, not empty array
+{
+  const noFiles = { ...taskRow, key_files: [] };
+  const output = renderSummaryContent(noFiles, SLICE_ID, MILESTONE_ID);
+  assertTrue(
+    output.includes("key_files:\n  - (none)"),
+    "empty key_files must render as YAML list with (none) placeholder",
+  );
+}
+
+// Test 12: frontmatter does not contain extra projection-only fields
+{
+  const output = renderSummaryContent(taskRow, SLICE_ID, MILESTONE_ID);
+  assertTrue(
+    !output.includes("provides:"),
+    "frontmatter must not contain provides field",
+  );
+  assertTrue(
+    !output.includes("requires:"),
+    "frontmatter must not contain requires field",
+  );
+  assertTrue(
+    !output.includes("affects:"),
+    "frontmatter must not contain affects field",
+  );
+  assertTrue(
+    !output.includes("patterns_established:"),
+    "frontmatter must not contain patterns_established field",
+  );
+  assertTrue(
+    !output.includes("drill_down_paths:"),
+    "frontmatter must not contain drill_down_paths field",
+  );
+  assertTrue(
+    !output.includes("observability_surfaces:"),
+    "frontmatter must not contain observability_surfaces field",
+  );
+}
+
+// Test 13: no verification evidence renders empty table row
+{
+  const output = renderSummaryContent(taskRow, SLICE_ID, MILESTONE_ID, []);
+  assertTrue(
+    output.includes("No verification commands discovered"),
+    "Empty evidence array must render placeholder row",
+  );
+}
+
+report();

package/src/resources/extensions/gsd/tests/terminated-transient.test.ts

@@ -82,3 +82,47 @@ test("#2572: 'SyntaxError' with JSON context (truncated stream) is transient", (
   assert.equal(isTransient(result), true, "'SyntaxError...JSON' should be transient");
   assert.equal(result.kind, "stream", "JSON parse errors are stream kind");
 });
+
+// --- Catch-all: all V8 JSON.parse variants matched by "in JSON at position" ---
+
+test("V8 JSON.parse: 'No number after minus sign in JSON' is transient (#2882)", () => {
+  const result = classifyError("No number after minus sign in JSON at position 42");
+  assert.equal(isTransient(result), true);
+  assert.equal(result.kind, "stream");
+});
+
+test("V8 JSON.parse: 'Expected property value after colon' is transient", () => {
+  const result = classifyError("Expected ',' or '}' after property value in JSON at position 108");
+  assert.equal(isTransient(result), true);
+  assert.equal(result.kind, "stream");
+});
+
+test("V8 JSON.parse: 'Bad control character in string literal' is transient", () => {
+  const result = classifyError("Bad control character in string literal in JSON at position 5");
+  assert.equal(isTransient(result), true);
+  assert.equal(result.kind, "stream");
+});
+
+test("V8 JSON.parse: 'Bad escaped character' is transient", () => {
+  const result = classifyError("Bad escaped character in JSON at position 17");
+  assert.equal(isTransient(result), true);
+  assert.equal(result.kind, "stream");
+});
+
+test("V8 JSON.parse: 'Unexpected number' is transient", () => {
+  const result = classifyError("Unexpected number in JSON at position 0");
+  assert.equal(isTransient(result), true);
+  assert.equal(result.kind, "stream");
+});
+
+test("V8 JSON.parse: 'Unexpected string' is transient", () => {
+  const result = classifyError("Unexpected string in JSON at position 12");
+  assert.equal(isTransient(result), true);
+  assert.equal(result.kind, "stream");
+});
+
+test("V8 JSON.parse with line/column suffix is transient", () => {
+  const result = classifyError("Unexpected token x in JSON at position 99 (line 3 column 14)");
+  assert.equal(isTransient(result), true);
+  assert.equal(result.kind, "stream");
+});

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

@@ -24,6 +24,7 @@ function makeMockPi() {
 const RENAME_MAP: Array<{ canonical: string; alias: string }> = [
   { canonical: "gsd_decision_save", alias: "gsd_save_decision" },
   { canonical: "gsd_requirement_update", alias: "gsd_update_requirement" },
+  { canonical: "gsd_requirement_save", alias: "gsd_save_requirement" },
   { canonical: "gsd_summary_save", alias: "gsd_save_summary" },
   { canonical: "gsd_milestone_generate_id", alias: "gsd_generate_milestone_id" },
   { canonical: "gsd_task_complete", alias: "gsd_complete_task" },
@@ -44,7 +45,7 @@ console.log('\n── Tool naming: registration count ──');
 const pi = makeMockPi();
 registerDbTools(pi);
 
-assert.deepStrictEqual(pi.tools.length, 27, 'Should register exactly 27 tools (13 canonical + 13 aliases + 1 gate tool)');
+assert.deepStrictEqual(pi.tools.length, 29, 'Should register exactly 29 tools (14 canonical + 14 aliases + 1 gate tool)');
 
 // ─── Both names exist for each pair ──────────────────────────────────────────
 

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

@@ -212,6 +212,14 @@ test("resolution: buildQuickTaskPrompt includes capture text and ID", () => {
   assert.ok(prompt.includes("add retry logic to OAuth"), "should include capture text");
   assert.ok(prompt.includes("Quick Task"), "should have Quick Task header");
   assert.ok(prompt.includes("Do NOT modify"), "should warn about plan files");
+  assert.ok(
+    prompt.includes("Verify the issue still exists"),
+    "should instruct agent to verify issue still exists (#2872)",
+  );
+  assert.ok(
+    prompt.includes("Already resolved"),
+    "should instruct agent to report already resolved if fixed (#2872)",
+  );
 });
 
 // ─── markCaptureExecuted ─────────────────────────────────────────────────────