gsd-pi 2.80.0-dev.e146beb20 → 2.80.0-dev.e51d2c88c

package/src/resources/extensions/gsd/tests/auto-loop.test.ts

@@ -10,6 +10,8 @@ import {
   _resetPendingResolve,
   _hasPendingResolveForTest,
   _setActiveSession,
+  _setSessionSwitchInFlight,
+  _consumePendingSwitchCancellation,
   isSessionSwitchInFlight,
 } from "../auto/resolve.js";
 import { runUnit } from "../auto/run-unit.js";
@@ -206,6 +208,28 @@ test("runUnit returns cancelled when session creation fails", async () => {
   assert.equal(pi.calls.length, 0);
 });
 
+test("runUnit clears queued switch cancellation when session creation fails", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+  const s = makeMockSession({
+    newSessionThrows: "connection refused",
+    onNewSessionStart: () => {
+      resolveAgentEndCancelled({
+        message: "Claude Code process aborted by user",
+        category: "aborted",
+        isTransient: false,
+      });
+    },
+  });
+
+  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt");
+
+  assert.equal(result.status, "cancelled");
+  assert.equal(_consumePendingSwitchCancellation(), null);
+});
+
 test("runUnit returns cancelled when session creation times out", async () => {
   _resetPendingResolve();
 
@@ -221,6 +245,34 @@ test("runUnit returns cancelled when session creation times out", async () => {
   assert.equal(pi.calls.length, 0);
 });
 
+test("runUnit consumes a cancellation queued during session switch before dispatch", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+  let cancellationQueued = false;
+  const s = makeMockSession({
+    newSessionDelayMs: 10,
+    onNewSessionStart: () => {
+      setTimeout(() => {
+        cancellationQueued = !resolveAgentEndCancelled({
+          message: "Claude Code process aborted by user",
+          category: "aborted",
+          isTransient: false,
+        });
+      }, 0);
+    },
+  });
+
+  const result = await runUnit(ctx, pi, s, "plan-slice", "M009/S01", "prompt");
+
+  assert.equal(cancellationQueued, true);
+  assert.equal(result.status, "cancelled");
+  assert.equal(result.errorContext?.category, "aborted");
+  assert.equal(result.errorContext?.message, "Claude Code process aborted by user");
+  assert.equal(pi.calls.length, 0, "queued switch cancellation must prevent prompt dispatch");
+});
+
 test("runUnit keeps the session-switch guard across a late newSession settlement", async () => {
   _resetPendingResolve();
   mock.timers.enable();
@@ -2089,6 +2141,25 @@ test("resolveAgentEndCancelled without args produces no errorContext field", asy
   assert.equal(resolved.errorContext, undefined, "errorContext must not be present when no args passed");
 });
 
+test("resolveAgentEndCancelled queues cancellation that arrives during session switch", () => {
+  _resetPendingResolve();
+
+  _setSessionSwitchInFlight(true);
+  const resolved = resolveAgentEndCancelled({
+    message: "Claude Code process aborted by user",
+    category: "aborted",
+    isTransient: false,
+  });
+
+  assert.equal(resolved, false);
+  const pending = _consumePendingSwitchCancellation();
+  assert.ok(pending?.errorContext, "queued cancellation should preserve errorContext");
+  assert.equal(pending.errorContext.category, "aborted");
+  assert.equal(pending.errorContext.message, "Claude Code process aborted by user");
+  assert.equal(_consumePendingSwitchCancellation(), null);
+  _resetPendingResolve();
+});
+
 // ─── #1571: artifact verification retry ──────────────────────────────────────
 
 test("autoLoop re-iterates when postUnitPreVerification returns retry (#1571)", async () => {

package/src/resources/extensions/gsd/tests/auto-phases-lifecycle.test.ts

@@ -1,17 +1,20 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
 import { runFinalize } from "../auto/phases.ts";
 import { AutoSession } from "../auto/session.ts";
+import { readUnitRuntimeRecord, writeUnitRuntimeRecord } from "../unit-runtime.ts";
 
-test("runFinalize clears currentUnit after successful finalize", async () => {
-  const s = new AutoSession();
-  s.basePath = "/tmp/gsd-finalize-current-unit";
-  s.currentUnit = {
-    type: "execute-task",
-    id: "M001/S01/T01",
-    startedAt: Date.now(),
-  };
+async function runSuccessfulFinalize(s: AutoSession) {
+  const unit = s.currentUnit;
+  assert.ok(unit, "test setup must provide currentUnit");
+
+  writeUnitRuntimeRecord(s.basePath, unit.type, unit.id, unit.startedAt, {
+    phase: "dispatched",
+  });
 
   const deps = {
     clearUnitTimeout() {},
@@ -26,7 +29,7 @@ test("runFinalize clears currentUnit after successful finalize", async () => {
     postUnitPostVerification: async () => "continue",
   };
 
-  const result = await runFinalize(
+  return runFinalize(
     {
       ctx: { ui: { notify() {} } },
       pi: {},
@@ -38,8 +41,8 @@ test("runFinalize clears currentUnit after successful finalize", async () => {
       nextSeq: () => 1,
     } as any,
     {
-      unitType: "execute-task",
-      unitId: "M001/S01/T01",
+      unitType: unit.type,
+      unitId: unit.id,
       prompt: "",
       finalPrompt: "",
       pauseAfterUatDispatch: false,
@@ -55,7 +58,47 @@ test("runFinalize clears currentUnit after successful finalize", async () => {
       consecutiveFinalizeTimeouts: 0,
     },
   );
+}
+
+test("runFinalize clears currentUnit after successful finalize", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-finalize-current-unit-"));
+  const s = new AutoSession();
+  s.basePath = base;
+  s.currentUnit = {
+    type: "execute-task",
+    id: "M001/S01/T01",
+    startedAt: Date.now(),
+  };
+
+  try {
+    const result = await runSuccessfulFinalize(s);
+
+    assert.equal(result.action, "next");
+    assert.equal(s.currentUnit, null);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("runFinalize marks unit runtime finalized after successful finalize", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-finalize-runtime-"));
+  const s = new AutoSession();
+  const startedAt = Date.now();
+  s.basePath = base;
+  s.currentUnit = {
+    type: "complete-milestone",
+    id: "M001",
+    startedAt,
+  };
+
+  try {
+    const result = await runSuccessfulFinalize(s);
+    const runtime = readUnitRuntimeRecord(base, "complete-milestone", "M001");
 
-  assert.equal(result.action, "next");
-  assert.equal(s.currentUnit, null);
+    assert.equal(result.action, "next");
+    assert.equal(runtime?.phase, "finalized");
+    assert.equal(runtime?.lastProgressKind, "finalize-success");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
 });

package/src/resources/extensions/gsd/tests/auto-recovery.test.ts

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, buildLoopRemediationSteps, writeBlockerPlaceholder } from "../auto-recovery.ts";
+import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, buildLoopRemediationSteps, writeBlockerPlaceholder, refreshRecoveryDbForArtifact } from "../auto-recovery.ts";
 import { resolveMilestoneFile } from "../paths.ts";
 import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow, insertTask, getMilestoneCommitAttributionShas } from "../gsd-db.ts";
 import { clearParseCache } from "../files.ts";
@@ -175,6 +175,19 @@ test("resolveExpectedArtifactPath returns correct path for all slice-level types
   }
 });
 
+test("refreshRecoveryDbForArtifact treats missing execute-task DB rows as fatal mismatches", () => {
+  makeTmpProject();
+
+  const result = refreshRecoveryDbForArtifact("execute-task", "M001/S01/T01");
+
+  assert.deepEqual(result, {
+    ok: false,
+    fatal: true,
+    reason: "execute-task-artifact-db-missing",
+    message: "Stuck recovery found execute-task M001/S01/T01 artifacts, but no matching DB task row exists after refresh.",
+  });
+});
+
 // ─── diagnoseExpectedArtifact ─────────────────────────────────────────────
 
 test("diagnoseExpectedArtifact returns description for known types", () => {

package/src/resources/extensions/gsd/tests/compaction-snapshot.test.ts

@@ -29,7 +29,8 @@ test('buildSnapshot: renders memories, exec history, and active context', () =>
     memories: [
       { id: 'MEM001', category: 'gotcha', content: 'FTS5 needs Porter tokenizer', confidence: 0.9,
         source_unit_type: null, source_unit_id: null, created_at: '', updated_at: '',
-        superseded_by: null, hit_count: 0, scope: 'project', seq: 1, tags: [], structured_fields: null },
+        superseded_by: null, hit_count: 0, scope: 'project', seq: 1, tags: [], structured_fields: null,
+        last_hit_at: null },
     ],
     execHistory: [
       {
@@ -65,6 +66,7 @@ test('buildSnapshot: enforces the byte cap with a truncation marker', () => {
     seq: i,
     tags: [] as string[],
     structured_fields: null,
+    last_hit_at: null,
   }));
   const snap = buildSnapshot(
     { generatedAt: new Date(), memories: longMemories, execHistory: [] },
@@ -121,3 +123,14 @@ test('executeResume: reports friendly empty state when no snapshot exists', () =
     cleanup(base);
   }
 });
+
+test('executeResume: returns disabled error when context_mode.enabled=false', () => {
+  const base = freshBase();
+  try {
+    const result = executeResume({}, { baseDir: base, preferences: { context_mode: { enabled: false } } });
+    assert.equal(result.isError, true);
+    assert.equal((result.details as { error?: string }).error, 'context_mode_disabled');
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/context-budget.test.ts

@@ -4,7 +4,7 @@
  * No I/O, no extension context, no global state.
  */
 
-import { describe, it } from "node:test";
+import { describe, it, beforeEach } from "node:test";
 import assert from "node:assert/strict";
 
 import {
@@ -16,8 +16,17 @@ import {
   computeBudgets,
   truncateAtSectionBoundary,
   resolveExecutorContextWindow,
+  _resetEmpiricalCacheForTest,
 } from "../context-budget.js";
 
+// Reset the per-provider empirical chars-per-token cache before each test.
+// The hardcoded char-ratio assertions below assume the static fallback path
+// (3.5 / 4.0 chars/token) is used. Without this guard, a prior test that
+// warms tiktoken would populate the cache and silently break these tests.
+beforeEach(() => {
+  _resetEmpiricalCacheForTest();
+});
+
 import type { TokenProvider } from "../token-counter.js";
 
 // ─── Test helpers ─────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/dispatch-rule-coverage.test.ts

@@ -0,0 +1,313 @@
+// gsd-2 / dispatch rule coverage canary test
+//
+// Iterates DISPATCH_RULES in order against representative GSDState stubs and
+// asserts that the first matching rule has the expected name and unitType
+// (mirroring auto-dispatch's first-match-wins semantics). The goal is a
+// canary: if a future PR adds a new rule in the wrong position and steals
+// a match from an existing one, this test fails.
+
+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 { DISPATCH_RULES } from "../auto-dispatch.ts";
+import type { DispatchContext, DispatchAction } from "../auto-dispatch.ts";
+import type { GSDState } from "../types.ts";
+
+// ─── State helpers ────────────────────────────────────────────────────────
+
+function makeState(overrides: Partial<GSDState> = {}): GSDState {
+  return {
+    activeMilestone: { id: "M001", title: "Test Milestone" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "pre-planning",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+    ...overrides,
+  };
+}
+
+function makeCtx(basePath: string, state: GSDState, mid = "M001"): DispatchContext {
+  return {
+    basePath,
+    mid,
+    midTitle: "Test Milestone",
+    state,
+    prefs: undefined,
+  };
+}
+
+// ─── Disk scaffold helpers ────────────────────────────────────────────────
+
+function writeMilestoneFile(basePath: string, mid: string, suffix: string, content = "stub\n"): void {
+  const dir = join(basePath, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-${suffix}.md`), content);
+}
+
+function writeSliceFile(
+  basePath: string,
+  mid: string,
+  sid: string,
+  suffix: string,
+  content = "stub\n",
+): void {
+  const dir = join(basePath, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${sid}-${suffix}.md`), content);
+}
+
+function writeTaskPlan(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}\n\n## Steps\n- [ ] Step\n`);
+}
+
+// ─── Rule evaluation ──────────────────────────────────────────────────────
+
+interface MatchEntry {
+  ruleName: string;
+  result: DispatchAction;
+}
+
+// First-match-wins semantics: walks DISPATCH_RULES in order and stops at the
+// first non-null result. This mirrors the production resolver and is the
+// canary against rule reordering or shadowing.
+async function findFirstMatch(ctx: DispatchContext): Promise<MatchEntry | null> {
+  for (const rule of DISPATCH_RULES) {
+    const result = await rule.match(ctx);
+    if (result) return { ruleName: rule.name, result };
+  }
+  return null;
+}
+
+function assertMatch(
+  match: MatchEntry | null,
+  expected: { ruleName: string; action: DispatchAction["action"]; unitType?: string },
+  scenario: string,
+): void {
+  assert.ok(match, `${scenario}: no rule matched`);
+  assert.equal(match.ruleName, expected.ruleName, `${scenario}: matched rule mismatch`);
+  assert.equal(match.result.action, expected.action, `${scenario}: action mismatch`);
+  if (expected.action === "dispatch" && expected.unitType) {
+    assert.ok(
+      match.result.action === "dispatch" && match.result.unitType === expected.unitType,
+      `${scenario}: unitType mismatch (got ${
+        match.result.action === "dispatch" ? match.result.unitType : match.result.action
+      })`,
+    );
+  }
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────
+
+test("dispatch-rule-coverage: escalating-task → stop (info)", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-esc-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const ctx = makeCtx(
+    tmp,
+    makeState({
+      phase: "escalating-task",
+      activeSlice: { id: "S01", title: "Slice" },
+      nextAction: "Resolve escalation X",
+    }),
+  );
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    { ruleName: "escalating-task → pause-for-escalation", action: "stop" },
+    "escalating-task",
+  );
+});
+
+test("dispatch-rule-coverage: pre-planning, no CONTEXT → discuss-milestone", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-disc-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  // Bare milestone dir, no CONTEXT/RESEARCH/ROADMAP files.
+  mkdirSync(join(tmp, ".gsd", "milestones", "M001"), { recursive: true });
+
+  const ctx = makeCtx(tmp, makeState({ phase: "pre-planning" }));
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    {
+      ruleName: "pre-planning (no context) → discuss-milestone",
+      action: "dispatch",
+      unitType: "discuss-milestone",
+    },
+    "pre-planning no context",
+  );
+});
+
+test("dispatch-rule-coverage: pre-planning, has CONTEXT, no RESEARCH → research-milestone", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-res-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  writeMilestoneFile(tmp, "M001", "CONTEXT", "# Context\n");
+
+  const ctx = makeCtx(tmp, makeState({ phase: "pre-planning" }));
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    {
+      ruleName: "pre-planning (no research) → research-milestone",
+      action: "dispatch",
+      unitType: "research-milestone",
+    },
+    "pre-planning no research",
+  );
+});
+
+test("dispatch-rule-coverage: pre-planning, has CONTEXT + RESEARCH → plan-milestone", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-plan-m-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  writeMilestoneFile(tmp, "M001", "CONTEXT", "# Context\n");
+  writeMilestoneFile(tmp, "M001", "RESEARCH", "# Research\n");
+
+  const ctx = makeCtx(tmp, makeState({ phase: "pre-planning" }));
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    {
+      ruleName: "pre-planning (has research) → plan-milestone",
+      action: "dispatch",
+      unitType: "plan-milestone",
+    },
+    "pre-planning has research",
+  );
+});
+
+test("dispatch-rule-coverage: planning with active slice and skip_research → plan-slice", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-plan-s-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  writeMilestoneFile(tmp, "M001", "CONTEXT", "# Context\n");
+  writeMilestoneFile(tmp, "M001", "ROADMAP", "# Roadmap\n");
+
+  const state = makeState({
+    phase: "planning",
+    activeSlice: { id: "S01", title: "First Slice" },
+  });
+  const ctx: DispatchContext = {
+    basePath: tmp,
+    mid: "M001",
+    midTitle: "Test Milestone",
+    state,
+    // Skip slice research so the parallel/single research rules fall through.
+    prefs: { phases: { skip_slice_research: true } } as DispatchContext["prefs"],
+  };
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    {
+      ruleName: "planning → plan-slice",
+      action: "dispatch",
+      unitType: "plan-slice",
+    },
+    "planning → plan-slice",
+  );
+});
+
+test("dispatch-rule-coverage: executing with task plan present → execute-task", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-exec-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  writeMilestoneFile(tmp, "M001", "CONTEXT", "# Context\n");
+  writeSliceFile(tmp, "M001", "S01", "PLAN", "# Plan\n");
+  writeTaskPlan(tmp, "M001", "S01", "T01");
+
+  const state = makeState({
+    phase: "executing",
+    activeSlice: { id: "S01", title: "First Slice" },
+    activeTask: { id: "T01", title: "First Task" },
+  });
+  // Disable reactive dispatch so the parallel batching rule falls through.
+  const ctx: DispatchContext = {
+    basePath: tmp,
+    mid: "M001",
+    midTitle: "Test Milestone",
+    state,
+    prefs: { reactive_execution: { enabled: false } } as DispatchContext["prefs"],
+  };
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    {
+      ruleName: "executing → execute-task",
+      action: "dispatch",
+      unitType: "execute-task",
+    },
+    "executing → execute-task",
+  );
+});
+
+test("dispatch-rule-coverage: summarizing → complete-slice", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-sum-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  // Rule "execution-entry phase (no context)" fires for summarizing if CONTEXT
+  // is missing — write it so the summarizing rule wins.
+  writeMilestoneFile(tmp, "M001", "CONTEXT", "# Context\n");
+
+  const ctx = makeCtx(
+    tmp,
+    makeState({
+      phase: "summarizing",
+      activeSlice: { id: "S01", title: "First Slice" },
+    }),
+  );
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    {
+      ruleName: "summarizing → complete-slice",
+      action: "dispatch",
+      unitType: "complete-slice",
+    },
+    "summarizing → complete-slice",
+  );
+});
+
+test("dispatch-rule-coverage: complete phase → stop", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-done-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const ctx = makeCtx(
+    tmp,
+    makeState({
+      phase: "complete",
+      activeMilestone: null,
+      lastCompletedMilestone: { id: "M001", title: "Test Milestone" },
+    }),
+  );
+  const match = await findFirstMatch(ctx);
+  assertMatch(
+    match,
+    { ruleName: "complete → stop", action: "stop" },
+    "complete → stop",
+  );
+});
+
+// ─── Ordering canary: every scenario above resolves to exactly one rule ────
+
+test("dispatch-rule-coverage: rule registry has the expected size", () => {
+  // Sanity check that complements the per-state assertions: if someone adds a
+  // new rule, this number changes — prompting them to add a state stub above.
+  // Exact count is a brittle but useful canary; update when adding rules
+  // intentionally.
+  assert.equal(
+    DISPATCH_RULES.length,
+    29,
+    `DISPATCH_RULES length changed (got ${DISPATCH_RULES.length}). ` +
+      "If you added a rule, add a state stub to dispatch-rule-coverage.test.ts " +
+      "and update this expected count.",
+  );
+});

package/src/resources/extensions/gsd/tests/exec-history.test.ts

@@ -108,6 +108,21 @@ test('executeExecSearch: returns helpful empty-state message when no matches', (
   }
 });
 
+test('executeExecSearch: returns disabled error when context_mode.enabled=false', () => {
+  const base = freshBase();
+  try {
+    writeRun(base, 'should-not-surface', { stdout: 'hidden\n' });
+    const result = executeExecSearch(
+      { query: 'hidden' },
+      { baseDir: base, preferences: { context_mode: { enabled: false } } },
+    );
+    assert.equal(result.isError, true);
+    assert.equal((result.details as { error?: string }).error, 'context_mode_disabled');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('executeExecSearch: includes stdout_path and preview in details', () => {
   const base = freshBase();
   try {