gsd-pi 2.26.0 → 2.27.0

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

@@ -103,6 +103,7 @@ async function main(): Promise<void> {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
       writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_CONTENT);
       writeFile(base, 'milestones/M001/slices/S01/tasks/.gitkeep', '');
+      writeFile(base, 'milestones/M001/slices/S01/tasks/T01-PLAN.md', '# T01 Plan');
       writeFile(base, 'REQUIREMENTS.md', REQUIREMENTS_CONTENT);
 
       // Derive state from files only (no DB)
@@ -166,6 +167,7 @@ async function main(): Promise<void> {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
       writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_CONTENT);
       writeFile(base, 'milestones/M001/slices/S01/tasks/.gitkeep', '');
+      writeFile(base, 'milestones/M001/slices/S01/tasks/T01-PLAN.md', '# T01 Plan');
 
       // No DB open — isDbAvailable() is false
       assertTrue(!isDbAvailable(), 'fallback: DB is not available');
@@ -189,6 +191,7 @@ async function main(): Promise<void> {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
       writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_CONTENT);
       writeFile(base, 'milestones/M001/slices/S01/tasks/.gitkeep', '');
+      writeFile(base, 'milestones/M001/slices/S01/tasks/T01-PLAN.md', '# T01 Plan');
 
       // Open DB but insert nothing — empty artifacts table
       openDatabase(':memory:');
@@ -219,6 +222,7 @@ async function main(): Promise<void> {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
       writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_CONTENT);
       writeFile(base, 'milestones/M001/slices/S01/tasks/.gitkeep', '');
+      writeFile(base, 'milestones/M001/slices/S01/tasks/T01-PLAN.md', '# T01 Plan');
       writeFile(base, 'REQUIREMENTS.md', REQUIREMENTS_CONTENT);
 
       // Open DB but only insert the roadmap — plan and requirements missing from DB
@@ -348,6 +352,7 @@ async function main(): Promise<void> {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
       writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_CONTENT);
       writeFile(base, 'milestones/M001/slices/S01/tasks/.gitkeep', '');
+      writeFile(base, 'milestones/M001/slices/S01/tasks/T01-PLAN.md', '# T01 Plan');
 
       openDatabase(':memory:');
       insertArtifactRow('milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT, {

package/src/resources/extensions/gsd/tests/derive-state-deps.test.ts

@@ -45,6 +45,7 @@ function writeContext(base: string, mid: string, frontmatter: string): void {
 function writeSlicePlan(base: string, mid: string, sid: string, content: string): void {
   const dir = join(base, '.gsd', 'milestones', mid, 'slices', sid);
   mkdirSync(join(dir, 'tasks'), { recursive: true });
+  writeFileSync(join(dir, "tasks", "T01-PLAN.md"), "# T01 Plan\n");
   writeFileSync(join(dir, `${sid}-PLAN.md`), content);
 }
 

package/src/resources/extensions/gsd/tests/derive-state-draft.test.ts

@@ -45,6 +45,7 @@ function writeRoadmap(base: string, mid: string, content: string): void {
 function writePlan(base: string, mid: string, sid: string, content: string): void {
   const dir = join(base, '.gsd', 'milestones', mid, 'slices', sid);
   mkdirSync(join(dir, 'tasks'), { recursive: true });
+  writeFileSync(join(dir, "tasks", "T01-PLAN.md"), "# T01 Plan\n");
   writeFileSync(join(dir, `${sid}-PLAN.md`), content);
 }
 

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

@@ -22,8 +22,17 @@ function writeRoadmap(base: string, mid: string, content: string): void {
 
 function writePlan(base: string, mid: string, sid: string, content: string): void {
   const dir = join(base, '.gsd', 'milestones', mid, 'slices', sid);
-  mkdirSync(join(dir, 'tasks'), { recursive: true });
+  const tasksDir = join(dir, 'tasks');
+  mkdirSync(tasksDir, { recursive: true });
   writeFileSync(join(dir, `${sid}-PLAN.md`), content);
+  // Create stub task plan files for any tasks in the plan content (#909)
+  // so deriveState doesn't fall back to planning phase.
+  const taskMatches = content.matchAll(/\*\*(T\d+):/g);
+  for (const m of taskMatches) {
+    const tid = m[1];
+    const planPath = join(tasksDir, `${tid}-PLAN.md`);
+    writeFileSync(planPath, `# ${tid} Plan\n\nTask plan stub for testing.\n`);
+  }
 }
 
 function writeContinue(base: string, mid: string, sid: string, content: string): void {

package/src/resources/extensions/gsd/tests/dispatch-missing-task-plans.test.ts

@@ -0,0 +1,132 @@
+/**
+ * Regression test for issue #909.
+ *
+ * When S##-PLAN.md exists (causing deriveState → phase:'executing') but the
+ * individual task plan files (tasks/T01-PLAN.md, etc.) are absent, the dispatch
+ * table must recover by re-running plan-slice — NOT hard-stop.
+ *
+ * Prior behaviour: action:"stop" → infinite loop on restart.
+ * Fixed behaviour: action:"dispatch" unitType:"plan-slice".
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { resolveDispatch } from "../auto-dispatch.ts";
+import type { DispatchContext } from "../auto-dispatch.ts";
+import type { GSDState } from "../types.ts";
+
+function makeState(overrides: Partial<GSDState> = {}): GSDState {
+  return {
+    activeMilestone: { id: "M002", title: "Test Milestone" },
+    activeSlice: { id: "S03", title: "Third Slice" },
+    activeTask: { id: "T01", title: "First Task" },
+    phase: "executing",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+    ...overrides,
+  };
+}
+
+function makeContext(basePath: string, stateOverrides?: Partial<GSDState>): DispatchContext {
+  return {
+    basePath,
+    mid: "M002",
+    midTitle: "Test Milestone",
+    state: makeState(stateOverrides),
+    prefs: undefined,
+  };
+}
+
+// ─── Scaffold helpers ──────────────────────────────────────────────────────
+
+function scaffoldSlicePlan(basePath: string, mid: string, sid: string): void {
+  const dir = join(basePath, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${sid}-PLAN.md`), [
+    `# ${sid}: Third Slice`,
+    "",
+    "## Tasks",
+    "- [ ] **T01: Do something** `est:1h`",
+    "- [ ] **T02: Do another thing** `est:30m`",
+    "",
+  ].join("\n"));
+}
+
+function scaffoldTaskPlan(basePath: string, mid: string, sid: string, tid: string): void {
+  const dir = join(basePath, ".gsd", "milestones", mid, "slices", sid, "tasks");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${tid}-PLAN.md`), [
+    `# ${tid}: Do something`,
+    "",
+    "## Steps",
+    "- [ ] Step 1",
+    "",
+  ].join("\n"));
+}
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+test("dispatch: missing task plan triggers plan-slice (not stop) — issue #909", async () => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-909-"));
+  try {
+    // Slice plan exists with tasks, but tasks/ directory is empty
+    scaffoldSlicePlan(tmp, "M002", "S03");
+
+    const ctx = makeContext(tmp);
+    const result = await resolveDispatch(ctx);
+
+    assert.equal(result.action, "dispatch", "should dispatch, not stop");
+    assert.ok(result.action === "dispatch" && result.unitType === "plan-slice",
+      `unitType should be plan-slice, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+    assert.ok(result.action === "dispatch" && result.unitId === "M002/S03",
+      `unitId should be M002/S03, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("dispatch: present task plan proceeds to execute-task normally", async () => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-909-ok-"));
+  try {
+    scaffoldSlicePlan(tmp, "M002", "S03");
+    scaffoldTaskPlan(tmp, "M002", "S03", "T01");
+
+    const ctx = makeContext(tmp);
+    const result = await resolveDispatch(ctx);
+
+    assert.equal(result.action, "dispatch");
+    assert.ok(result.action === "dispatch" && result.unitType === "execute-task",
+      `unitType should be execute-task, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+    assert.ok(result.action === "dispatch" && result.unitId === "M002/S03/T01",
+      `unitId should be M002/S03/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("dispatch: plan-slice recovery loop — second call after plan-slice still recovers cleanly", async () => {
+  // Simulate: plan-slice ran but T01-PLAN.md is still missing (e.g. agent crashed mid-write).
+  // Dispatch should still re-dispatch plan-slice, not hard-stop.
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-909-loop-"));
+  try {
+    scaffoldSlicePlan(tmp, "M002", "S03");
+
+    const ctx = makeContext(tmp);
+    const r1 = await resolveDispatch(ctx);
+    assert.equal(r1.action, "dispatch");
+    assert.ok(r1.action === "dispatch" && r1.unitType === "plan-slice");
+
+    // Still no task plan written — dispatch again
+    const r2 = await resolveDispatch(ctx);
+    assert.equal(r2.action, "dispatch");
+    assert.ok(r2.action === "dispatch" && r2.unitType === "plan-slice",
+      "should keep dispatching plan-slice until task plans appear");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/doctor-proactive.test.ts

@@ -193,6 +193,20 @@ async function main(): Promise<void> {
       assertEq(result.issues.length, 0, "no issues on clean state");
     }
 
+    console.log("\n=== health gate: missing STATE.md does NOT block dispatch (#889) ===");
+    {
+      const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-proactive-")));
+      cleanups.push(dir);
+      // Create milestones dir but no STATE.md — mimics fresh worktree
+      mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+      writeFileSync(join(dir, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# Roadmap\n");
+
+      const result = await preDispatchHealthGate(dir);
+      assertTrue(result.proceed, "gate must NOT block when STATE.md is missing (deadlock #889)");
+      assertEq(result.issues.length, 0, "missing STATE.md is not a blocking issue");
+      assertTrue(result.fixesApplied.some((f: string) => f.includes("STATE.md")), "reports STATE.md status as info");
+    }
+
     console.log("\n=== health gate: stale crash lock auto-cleared ===");
     {
       const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-proactive-")));

package/src/resources/extensions/gsd/tests/integration-mixed-milestones.test.ts

@@ -42,6 +42,7 @@ function writeRoadmap(base: string, mid: string, content: string): void {
 function writePlan(base: string, mid: string, sid: string, content: string): void {
   const dir = join(base, '.gsd', 'milestones', mid, 'slices', sid);
   mkdirSync(join(dir, 'tasks'), { recursive: true });
+  writeFileSync(join(dir, "tasks", "T01-PLAN.md"), "# T01 Plan\n");
   writeFileSync(join(dir, `${sid}-PLAN.md`), content);
 }
 

package/src/resources/extensions/gsd/tests/milestone-transition-worktree.test.ts

@@ -134,7 +134,7 @@ test("auto.ts milestone transition block contains worktree lifecycle", () => {
     "auto.ts should contain the worktree lifecycle comment marker",
   );
   assert.ok(
-    autoSrc.includes("mergeMilestoneToMain") && autoSrc.includes("mid !== currentMilestoneId"),
+    autoSrc.includes("mergeMilestoneToMain") && autoSrc.includes("mid !== s.currentMilestoneId"),
     "auto.ts should call mergeMilestoneToMain during milestone transition",
   );
   assert.ok(

package/src/resources/extensions/gsd/tests/native-has-changes-cache.test.ts

@@ -0,0 +1,61 @@
+/**
+ * Unit tests for the nativeHasChanges() fallback cache (10s TTL).
+ *
+ * Verifies:
+ *   1. Cached result is returned within the TTL window
+ *   2. Cache invalidates after TTL expires
+ *   3. Cache invalidates when basePath changes
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { nativeHasChanges, _resetHasChangesCache } from '../native-git-bridge.ts';
+
+// We can't easily mock gitExec or Date.now inside the module, so we test
+// the observable caching behaviour by calling the real function against
+// the current repo (which is a valid git checkout).
+
+const REPO_ROOT = process.cwd();
+
+test('nativeHasChanges: returns a boolean for the current repo', () => {
+  _resetHasChangesCache();
+  const result = nativeHasChanges(REPO_ROOT);
+  assert.strictEqual(typeof result, 'boolean', 'should return a boolean');
+});
+
+test('nativeHasChanges: second call within TTL returns same result (cache hit)', () => {
+  _resetHasChangesCache();
+  const first = nativeHasChanges(REPO_ROOT);
+  const second = nativeHasChanges(REPO_ROOT);
+  assert.strictEqual(first, second, 'cached result should match first call');
+});
+
+test('nativeHasChanges: different basePath invalidates cache', () => {
+  _resetHasChangesCache();
+
+  // Prime cache with REPO_ROOT
+  const first = nativeHasChanges(REPO_ROOT);
+
+  // Call with a different path — should NOT return the stale cached value
+  // (it will compute fresh). We just verify it doesn't throw and returns boolean.
+  const other = nativeHasChanges('/tmp');
+  assert.strictEqual(typeof other, 'boolean', 'should return boolean for different path');
+
+  // After switching path, calling with REPO_ROOT again should recompute
+  const third = nativeHasChanges(REPO_ROOT);
+  assert.strictEqual(typeof third, 'boolean', 'should return boolean after path switch');
+});
+
+test('nativeHasChanges: cache expires after TTL', () => {
+  _resetHasChangesCache();
+
+  // Prime the cache
+  nativeHasChanges(REPO_ROOT);
+
+  // Manually expire the cache by resetting it (simulates TTL expiry)
+  _resetHasChangesCache();
+
+  // This call should recompute (not use stale data)
+  const result = nativeHasChanges(REPO_ROOT);
+  assert.strictEqual(typeof result, 'boolean', 'should recompute after cache reset');
+});

package/src/resources/extensions/gsd/tests/network-error-fallback.test.ts

@@ -6,7 +6,7 @@ import assert from "node:assert/strict";
 // just test that `resolveModelWithFallbacksForUnit` returns the correct format since
 // the fallback rotation logic itself was verified manually.
 
-import { getNextFallbackModel } from "../preferences.ts";
+import { getNextFallbackModel, isTransientNetworkError } from "../preferences.ts";
 
 test("getNextFallbackModel selects next fallback if current is a fallback", () => {
     const modelConfig = { primary: "model-a", fallbacks: ["model-b", "model-c"] };
@@ -52,3 +52,53 @@ test("getNextFallbackModel returns primary if current model is undefined", () =>
 
     assert.equal(nextModelId, "model-a", "should default to primary if current is undefined");
 });
+
+// ── isTransientNetworkError tests ────────────────────────────────────────────
+
+test("isTransientNetworkError detects ECONNRESET", () => {
+    assert.ok(isTransientNetworkError("fetch failed: ECONNRESET"));
+});
+
+test("isTransientNetworkError detects ETIMEDOUT", () => {
+    assert.ok(isTransientNetworkError("ETIMEDOUT: request timed out"));
+});
+
+test("isTransientNetworkError detects generic network error", () => {
+    assert.ok(isTransientNetworkError("network error"));
+});
+
+test("isTransientNetworkError detects socket hang up", () => {
+    assert.ok(isTransientNetworkError("socket hang up"));
+});
+
+test("isTransientNetworkError detects fetch failed", () => {
+    assert.ok(isTransientNetworkError("fetch failed"));
+});
+
+test("isTransientNetworkError detects connection reset", () => {
+    assert.ok(isTransientNetworkError("connection was reset by peer"));
+});
+
+test("isTransientNetworkError detects DNS errors", () => {
+    assert.ok(isTransientNetworkError("dns resolution failed"));
+});
+
+test("isTransientNetworkError rejects auth errors", () => {
+    assert.ok(!isTransientNetworkError("unauthorized: invalid API key"));
+});
+
+test("isTransientNetworkError rejects quota errors", () => {
+    assert.ok(!isTransientNetworkError("quota exceeded"));
+});
+
+test("isTransientNetworkError rejects billing errors", () => {
+    assert.ok(!isTransientNetworkError("billing issue: network payment required"));
+});
+
+test("isTransientNetworkError rejects empty string", () => {
+    assert.ok(!isTransientNetworkError(""));
+});
+
+test("isTransientNetworkError rejects non-network errors", () => {
+    assert.ok(!isTransientNetworkError("model not found"));
+});