gsd-pi 2.63.0 → 2.64.0-dev.1a85e85

package/src/resources/extensions/gsd/tests/slice-parallel-conflict.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Tests for slice-level parallel conflict detection.
+ * Verifies hasFileConflict() correctly identifies when two slices
+ * touch too many of the same files to safely run in parallel.
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { hasFileConflict } from "../slice-parallel-conflict.js";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-slice-conflict-test-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function writeSlicePlan(base: string, mid: string, sid: string, content: string): void {
+  const dir = join(base, ".gsd", "milestones", mid, sid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "PLAN.md"), content, "utf-8");
+}
+
+describe("hasFileConflict", () => {
+  let base: string;
+
+  beforeEach(() => {
+    base = makeTmpBase();
+  });
+
+  afterEach(() => {
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  it("two slices with >5 overlapping file paths → blocked (true)", () => {
+    const planA = `# Plan S01
+## Tasks
+- T01: Update src/auth/login.ts
+- T02: Update src/auth/register.ts
+- T03: Update src/auth/session.ts
+- T04: Update src/auth/middleware.ts
+- T05: Update src/auth/types.ts
+- T06: Update src/auth/utils.ts
+`;
+    const planB = `# Plan S02
+## Tasks
+- T01: Refactor src/auth/login.ts
+- T02: Refactor src/auth/register.ts
+- T03: Refactor src/auth/session.ts
+- T04: Refactor src/auth/middleware.ts
+- T05: Refactor src/auth/types.ts
+- T06: Refactor src/auth/utils.ts
+`;
+    writeSlicePlan(base, "M001", "S01", planA);
+    writeSlicePlan(base, "M001", "S02", planB);
+    assert.equal(hasFileConflict(base, "M001", "S01", "S02"), true);
+  });
+
+  it("two slices with 0 overlapping paths → allowed (false)", () => {
+    const planA = `# Plan S01
+## Tasks
+- T01: Create src/api/routes.ts
+- T02: Create src/api/handlers.ts
+`;
+    const planB = `# Plan S02
+## Tasks
+- T01: Create src/ui/components.ts
+- T02: Create src/ui/styles.ts
+`;
+    writeSlicePlan(base, "M001", "S01", planA);
+    writeSlicePlan(base, "M001", "S02", planB);
+    assert.equal(hasFileConflict(base, "M001", "S01", "S02"), false);
+  });
+
+  it("missing PLAN.md → conservative block (true)", () => {
+    // Only create one slice's plan
+    writeSlicePlan(base, "M001", "S01", "# Plan\n- T01: src/foo.ts");
+    // S02 has no plan at all
+    assert.equal(hasFileConflict(base, "M001", "S01", "S02"), true);
+  });
+
+  it("one slice empty plan → allowed (false)", () => {
+    writeSlicePlan(base, "M001", "S01", "# Plan S01\n## Tasks\n- T01: Create src/foo.ts");
+    writeSlicePlan(base, "M001", "S02", "# Plan S02\n## Tasks\n(no tasks yet)");
+    assert.equal(hasFileConflict(base, "M001", "S01", "S02"), false);
+  });
+});

package/src/resources/extensions/gsd/tests/slice-parallel-eligibility.test.ts

@@ -0,0 +1,95 @@
+/**
+ * Tests for slice-level parallel eligibility.
+ * Verifies getEligibleSlices() correctly determines which slices
+ * can run in parallel based on dependency satisfaction.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import { getEligibleSlices } from "../slice-parallel-eligibility.js";
+
+describe("getEligibleSlices", () => {
+  it("diamond DAG: S01 done, S02 depends:[S01], S03 depends:[S01] → both eligible", () => {
+    const slices = [
+      { id: "S01", done: true, depends: [] },
+      { id: "S02", done: false, depends: ["S01"] },
+      { id: "S03", done: false, depends: ["S01"] },
+    ];
+    const completed = new Set(["S01"]);
+    const result = getEligibleSlices(slices, completed);
+    const ids = result.map(s => s.id);
+    assert.deepStrictEqual(ids.sort(), ["S02", "S03"]);
+  });
+
+  it("linear chain: S01→S02→S03, only S01 done → only S02 eligible", () => {
+    const slices = [
+      { id: "S01", done: true, depends: [] },
+      { id: "S02", done: false, depends: ["S01"] },
+      { id: "S03", done: false, depends: ["S02"] },
+    ];
+    const completed = new Set(["S01"]);
+    const result = getEligibleSlices(slices, completed);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].id, "S02");
+  });
+
+  it("no deps declared: S01 done, S02 no deps, S03 no deps → only S02 eligible (positional fallback)", () => {
+    const slices = [
+      { id: "S01", done: true, depends: [] },
+      { id: "S02", done: false, depends: [] },
+      { id: "S03", done: false, depends: [] },
+    ];
+    const completed = new Set(["S01"]);
+    const result = getEligibleSlices(slices, completed);
+    // Positional fallback: when no deps declared, only the first non-done slice
+    // after all positionally-earlier slices are done is eligible
+    assert.equal(result.length, 1);
+    assert.equal(result[0].id, "S02");
+  });
+
+  it("all done: empty result", () => {
+    const slices = [
+      { id: "S01", done: true, depends: [] },
+      { id: "S02", done: true, depends: ["S01"] },
+      { id: "S03", done: true, depends: ["S02"] },
+    ];
+    const completed = new Set(["S01", "S02", "S03"]);
+    const result = getEligibleSlices(slices, completed);
+    assert.equal(result.length, 0);
+  });
+
+  it("empty input: empty result", () => {
+    const result = getEligibleSlices([], new Set());
+    assert.equal(result.length, 0);
+  });
+
+  it("mixed deps and no-deps: only dep-satisfied slices with explicit deps are eligible alongside positional", () => {
+    const slices = [
+      { id: "S01", done: true, depends: [] },
+      { id: "S02", done: false, depends: ["S01"] },  // explicit dep satisfied
+      { id: "S03", done: false, depends: [] },         // no deps, positional fallback
+      { id: "S04", done: false, depends: ["S01"] },  // explicit dep satisfied
+    ];
+    const completed = new Set(["S01"]);
+    const result = getEligibleSlices(slices, completed);
+    const ids = result.map(s => s.id);
+    // S02 and S04 have explicit deps satisfied; S03 has no deps but
+    // positionally S02 (before it) is not done, so S03 is blocked by positional rule
+    assert.ok(ids.includes("S02"), "S02 should be eligible (dep on S01 satisfied)");
+    assert.ok(ids.includes("S04"), "S04 should be eligible (dep on S01 satisfied)");
+  });
+
+  it("unsatisfied dependency blocks slice", () => {
+    const slices = [
+      { id: "S01", done: false, depends: [] },
+      { id: "S02", done: false, depends: ["S01"] },
+    ];
+    const completed = new Set<string>();
+    const result = getEligibleSlices(slices, completed);
+    // S01 has no deps and is first → eligible by positional
+    // S02 depends on S01 which is not completed → blocked
+    assert.equal(result.length, 1);
+    assert.equal(result[0].id, "S01");
+  });
+});

package/src/resources/extensions/gsd/tests/slice-parallel-orchestrator.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Structural tests for slice-level parallel orchestrator.
+ * Verifies the orchestrator module exists and has the correct shape,
+ * env var usage, and preference gating.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const gsdDir = join(__dirname, "..");
+
+describe("slice-parallel-orchestrator structural tests", () => {
+  it("orchestrator uses GSD_SLICE_LOCK env var", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    assert.ok(
+      source.includes("GSD_SLICE_LOCK"),
+      "Orchestrator must use GSD_SLICE_LOCK env var to isolate slice workers",
+    );
+  });
+
+  it("orchestrator sets GSD_PARALLEL_WORKER=1 to prevent nesting", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    assert.ok(
+      source.includes("GSD_PARALLEL_WORKER"),
+      "Orchestrator must set GSD_PARALLEL_WORKER to prevent nested parallel",
+    );
+  });
+
+  it("maxWorkers default is 2", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    // Check that default max workers is 2 (in opts.maxWorkers ?? 2 or similar)
+    assert.ok(
+      source.includes("maxWorkers") && source.includes("2"),
+      "Default maxWorkers should be 2",
+    );
+  });
+
+  it("orchestrator imports GSD_MILESTONE_LOCK for milestone isolation", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    assert.ok(
+      source.includes("GSD_MILESTONE_LOCK"),
+      "Orchestrator must also pass GSD_MILESTONE_LOCK for milestone context",
+    );
+  });
+});
+
+describe("slice_parallel preference gating", () => {
+  it("preferences-types.ts includes slice_parallel in interface", () => {
+    const source = readFileSync(join(gsdDir, "preferences-types.ts"), "utf-8");
+    assert.ok(
+      source.includes("slice_parallel"),
+      "GSDPreferences should have slice_parallel field",
+    );
+  });
+
+  it("slice_parallel is in KNOWN_PREFERENCE_KEYS", () => {
+    const source = readFileSync(join(gsdDir, "preferences-types.ts"), "utf-8");
+    assert.ok(
+      source.includes('"slice_parallel"'),
+      'KNOWN_PREFERENCE_KEYS should include "slice_parallel"',
+    );
+  });
+
+  it("state.ts checks GSD_SLICE_LOCK for slice isolation", () => {
+    const source = readFileSync(join(gsdDir, "state.ts"), "utf-8");
+    assert.ok(
+      source.includes("GSD_SLICE_LOCK"),
+      "State derivation should check GSD_SLICE_LOCK for slice-level parallel isolation",
+    );
+  });
+
+  it("auto.ts imports slice parallel orchestrator when enabled", () => {
+    const source = readFileSync(join(gsdDir, "auto.ts"), "utf-8");
+    assert.ok(
+      source.includes("slice_parallel") || source.includes("slice-parallel"),
+      "auto.ts should reference slice_parallel for dispatch gating",
+    );
+  });
+});

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

@@ -123,6 +123,48 @@ test("Rule 3: A-A-A-A triggers Rule 2 not Rule 3", () => {
   );
 });
 
+// ─── Rule 4: ENOENT same path twice in window (#3575) ───────────────────────
+
+test("Rule 4: same ENOENT path in two entries triggers stuck", () => {
+  const result = detectStuck([
+    { key: "A", error: "ENOENT: no such file or directory, access '/home/user/.gsd/agent/skills/debug-like-expert/SKILL.md'" },
+    { key: "B" },
+    { key: "A", error: "ENOENT: no such file or directory, access '/home/user/.gsd/agent/skills/debug-like-expert/SKILL.md'" },
+  ]);
+  assert.notEqual(result, null);
+  assert.equal(result!.stuck, true);
+  assert.ok(result!.reason.includes("Missing file"), `reason was: ${result!.reason}`);
+  assert.ok(result!.reason.includes("ENOENT"), `reason was: ${result!.reason}`);
+});
+
+test("Rule 4: different ENOENT paths do not trigger stuck", () => {
+  const result = detectStuck([
+    { key: "A", error: "ENOENT: no such file or directory, access '/path/a'" },
+    { key: "B", error: "ENOENT: no such file or directory, access '/path/b'" },
+  ]);
+  assert.equal(result, null);
+});
+
+test("Rule 4: single ENOENT does not trigger stuck", () => {
+  const result = detectStuck([
+    { key: "A", error: "ENOENT: no such file or directory, access '/path/a'" },
+    { key: "B" },
+  ]);
+  assert.equal(result, null);
+});
+
+test("Rule 4: ENOENT paths non-consecutive still triggers", () => {
+  const result = detectStuck([
+    { key: "A", error: "ENOENT: no such file or directory, access '/missing/skill'" },
+    { key: "B" },
+    { key: "C" },
+    { key: "D", error: "ENOENT: no such file or directory, access '/missing/skill'" },
+  ]);
+  assert.notEqual(result, null);
+  assert.equal(result!.stuck, true);
+  assert.ok(result!.reason.includes("/missing/skill"), `reason was: ${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)", () => {

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

@@ -0,0 +1,103 @@
+/**
+ * Regression tests for #2883: gsd_complete_slice tool invocation fails with
+ * JSON truncation, causing stuck retry loop.
+ *
+ * When a GSD tool is invoked with malformed/truncated JSON arguments, the tool
+ * execution fails (isError: true). But postUnitPreVerification only checks if
+ * the expected artifact exists on disk — it does not know the tool itself failed.
+ * When the artifact is missing (because the tool never ran), it sets up
+ * pendingVerificationRetry, re-dispatching the same unit with the same truncated
+ * input, creating a stuck loop.
+ *
+ * The fix adds a `lastToolInvocationError` field to AutoSession. When a GSD tool
+ * execution ends with isError, the error is recorded. postUnitPreVerification
+ * checks this field before retrying — if a tool invocation error occurred, it
+ * pauses auto-mode instead of retrying.
+ */
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { AutoSession } from "../auto/session.ts";
+
+// ─── AutoSession.lastToolInvocationError field ───────────────────────────
+
+describe("#2883: tool invocation error tracking on AutoSession", () => {
+  test("lastToolInvocationError defaults to null", () => {
+    const s = new AutoSession();
+    assert.equal(s.lastToolInvocationError, null);
+  });
+
+  test("lastToolInvocationError is cleared on reset()", () => {
+    const s = new AutoSession();
+    s.lastToolInvocationError = "Validation failed for tool gsd_complete_slice";
+    assert.ok(s.lastToolInvocationError);
+    s.reset();
+    assert.equal(s.lastToolInvocationError, null);
+  });
+
+  test("lastToolInvocationError can store truncated JSON error", () => {
+    const s = new AutoSession();
+    const errorMsg = "Expected ',' or '}' in JSON at position 4096";
+    s.lastToolInvocationError = errorMsg;
+    assert.equal(s.lastToolInvocationError, errorMsg);
+  });
+});
+
+// ─── isToolInvocationError classifier ────────────────────────────────────
+
+import { isToolInvocationError } from "../auto-tool-tracking.ts";
+
+describe("#2883: isToolInvocationError classification", () => {
+  test("detects JSON validation failure pattern", () => {
+    assert.equal(
+      isToolInvocationError("Validation failed for tool gsd_complete_slice: Expected ',' or '}' in JSON"),
+      true,
+    );
+  });
+
+  test("detects truncated JSON parse error", () => {
+    assert.equal(
+      isToolInvocationError("Expected ',' or '}' in JSON at position 4096"),
+      true,
+    );
+  });
+
+  test("detects Unexpected end of JSON input", () => {
+    assert.equal(
+      isToolInvocationError("Unexpected end of JSON input"),
+      true,
+    );
+  });
+
+  test("detects Unexpected token in JSON", () => {
+    assert.equal(
+      isToolInvocationError("Unexpected token < in JSON at position 0"),
+      true,
+    );
+  });
+
+  test("detects 'Validation failed for tool' prefix", () => {
+    assert.equal(
+      isToolInvocationError("Validation failed for tool gsd_slice_complete"),
+      true,
+    );
+  });
+
+  test("returns false for normal tool errors (business logic)", () => {
+    assert.equal(
+      isToolInvocationError("Slice S01 is already complete"),
+      false,
+    );
+  });
+
+  test("returns false for empty string", () => {
+    assert.equal(isToolInvocationError(""), false);
+  });
+
+  test("returns false for generic error", () => {
+    assert.equal(isToolInvocationError("Something went wrong"), false);
+  });
+
+  test("returns false for network errors (handled elsewhere)", () => {
+    assert.equal(isToolInvocationError("ECONNRESET"), false);
+  });
+});