gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/unit-dispatches.test.ts

@@ -13,7 +13,7 @@ import {
   insertSlice,
 } from "../gsd-db.ts";
 import { registerAutoWorker } from "../db/auto-workers.ts";
-import { claimMilestoneLease } from "../db/milestone-leases.ts";
+import { claimMilestoneLease, releaseMilestoneLease } from "../db/milestone-leases.ts";
 import {
   recordDispatchClaim,
   markRunning,
@@ -21,6 +21,7 @@ import {
   markFailed,
   markStuck,
   markCanceled,
+  markLatestActiveForWorkerCanceled,
   getRecentForUnit,
   getLatestForUnit,
 } from "../db/unit-dispatches.ts";
@@ -104,6 +105,55 @@ test("partial unique index rejects double-claim of the same active unit", (t) =>
   }
 });
 
+test("recordDispatchClaim cancels stale active dispatch after lease takeover", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  const { workerId: firstWorkerId, leaseToken: firstLeaseToken } = setup(base);
+
+  const first = recordDispatchClaim({
+    traceId: "t-first",
+    workerId: firstWorkerId,
+    milestoneLeaseToken: firstLeaseToken,
+    milestoneId: "M001",
+    sliceId: "S01",
+    unitType: "plan-slice",
+    unitId: "M001/S01",
+  });
+  assert.equal(first.ok, true);
+  if (!first.ok) return;
+  markRunning(first.dispatchId);
+
+  assert.equal(releaseMilestoneLease(firstWorkerId, "M001", firstLeaseToken), true);
+  const takeoverWorkerId = registerAutoWorker({ projectRootRealpath: base });
+  const takeoverLease = claimMilestoneLease(takeoverWorkerId, "M001");
+  assert.equal(takeoverLease.ok, true);
+  if (!takeoverLease.ok) return;
+
+  const second = recordDispatchClaim({
+    traceId: "t-takeover",
+    workerId: takeoverWorkerId,
+    milestoneLeaseToken: takeoverLease.token,
+    milestoneId: "M001",
+    sliceId: "S01",
+    unitType: "plan-slice",
+    unitId: "M001/S01",
+    attemptN: 2,
+  });
+
+  assert.equal(second.ok, true);
+  if (!second.ok) return;
+
+  const recent = getRecentForUnit("M001/S01", 5);
+  assert.equal(recent.length, 2);
+  assert.equal(recent[0].id, second.dispatchId);
+  assert.equal(recent[0].status, "claimed");
+  assert.equal(recent[0].worker_id, takeoverWorkerId);
+  assert.equal(recent[0].attempt_n, 2);
+  assert.equal(recent[1].id, first.dispatchId);
+  assert.equal(recent[1].status, "canceled");
+  assert.equal(recent[1].exit_reason, "stale-dispatch-lease-takeover");
+});
+
 test("after markCompleted, a fresh claim for the same unit succeeds", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));
@@ -196,6 +246,35 @@ test("markStuck and markCanceled set their respective statuses", (t) => {
   assert.equal(getLatestForUnit("M001/S01/T01")!.status, "canceled");
 });
 
+test("markLatestActiveForWorkerCanceled cancels only the latest active dispatch for a worker", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  const { workerId, leaseToken } = setup(base);
+
+  const first = recordDispatchClaim({
+    traceId: "tc-1", workerId, milestoneLeaseToken: leaseToken,
+    milestoneId: "M001", unitType: "plan-slice", unitId: "M001/S01",
+  });
+  assert.equal(first.ok, true);
+  if (!first.ok) return;
+  markCompleted(first.dispatchId);
+
+  const second = recordDispatchClaim({
+    traceId: "tc-2", workerId, milestoneLeaseToken: leaseToken,
+    milestoneId: "M001", unitType: "run-task", unitId: "M001/S01/T01",
+  });
+  assert.equal(second.ok, true);
+  if (!second.ok) return;
+  markRunning(second.dispatchId);
+
+  assert.equal(markLatestActiveForWorkerCanceled(workerId, "signal-exit"), true);
+  assert.equal(getLatestForUnit("M001/S01")!.status, "completed");
+  const latest = getLatestForUnit("M001/S01/T01")!;
+  assert.equal(latest.status, "canceled");
+  assert.equal(latest.exit_reason, "signal-exit");
+  assert.equal(markLatestActiveForWorkerCanceled(workerId, "signal-exit"), false);
+});
+
 test("terminal transitions do not overwrite an already terminal dispatch", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/unit-runtime.test.ts

@@ -5,9 +5,11 @@ import {
   clearUnitRuntimeRecord,
   formatExecuteTaskRecoveryStatus,
   inspectExecuteTaskDurability,
+  isInFlightRuntimePhase,
   readUnitRuntimeRecord,
   writeUnitRuntimeRecord,
 } from "../unit-runtime.ts";
+import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.ts";
 import { clearPathCache } from '../paths.ts';
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
@@ -22,6 +24,12 @@ writeFileSync(
   "utf-8",
 );
 
+console.log("\n=== in-flight runtime phases ===");
+{
+  assert.equal(isInFlightRuntimePhase("crashed"), true, "crashed records remain recoverable");
+  assert.equal(isInFlightRuntimePhase("finalized"), false, "finalized records are terminal");
+}
+
 console.log("\n=== runtime record write/read/update ===");
 {
   const first = writeUnitRuntimeRecord(base, "execute-task", "M100/S02/T09", 1000, { phase: "dispatched" });
@@ -65,6 +73,35 @@ console.log("\n=== runtime record cleanup ===");
   assert.deepStrictEqual(loaded, null, "record removed");
 }
 
+console.log("\n=== execute-task durability trusts closed DB task status ===");
+{
+  const dbBase = mkdtempSync(join(tmpdir(), "gsd-unit-runtime-db-test-"));
+  mkdirSync(join(dbBase, ".gsd", "milestones", "M300", "slices", "S01", "tasks"), { recursive: true });
+  try {
+    openDatabase(join(dbBase, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M300", title: "DB Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M300", title: "DB Slice", status: "in_progress" });
+    insertTask({ id: "T01", milestoneId: "M300", sliceId: "S01", title: "DB Task", status: "complete" });
+    writeFileSync(
+      join(dbBase, ".gsd", "milestones", "M300", "slices", "S01", "S01-PLAN.md"),
+      "# S01\n\n## Tasks\n\n- [ ] **T01: DB Task** `est:10m`\n",
+      "utf-8",
+    );
+    writeFileSync(join(dbBase, ".gsd", "STATE.md"), "## Next Action\nExecute T01 for S01: DB task\n", "utf-8");
+
+    const status = await inspectExecuteTaskDurability(dbBase, "M300/S01/T01");
+    assert.ok(status !== null, "db-complete: status exists");
+    assert.equal(status!.dbComplete, true, "db-complete: closed DB status is captured");
+    assert.equal(status!.summaryExists, false, "db-complete: summary can still be missing");
+    assert.equal(status!.taskChecked, false, "db-complete: checkbox can still be unchecked");
+    assert.equal(status!.nextActionAdvanced, false, "db-complete: next action can still point at task");
+    assert.equal(formatExecuteTaskRecoveryStatus(status!), "DB task status is closed");
+  } finally {
+    closeDatabase();
+    rmSync(dbBase, { recursive: true, force: true });
+  }
+}
+
 console.log("\n=== hook unit type sanitization (slash in unitType) ===");
 {
   // Hook units have unitType like "hook/code-review" with a slash

package/src/resources/extensions/gsd/tests/unstructured-continue-context-injection.test.ts

@@ -1,99 +1,11 @@
 // GSD-2 — Regression test for #3615: unstructured "continue" must inject task context
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
-
-/**
- * Bug #3615: When a user types "continue" (or any bare text) to resume
- * an in-progress session, buildGuidedExecuteContextInjection() only
- * matched two hardcoded regex patterns (auto-dispatch and guided-resume).
- * The function returned null for any other input, so no task context was
- * injected — causing the agent to rebuild everything from scratch and
- * burn ~86k tokens.
- *
- * This test verifies:
- *   1. Structural: the fallback exists with phase + intent guards
- *   2. Behavioral: RESUME_INTENT_PATTERNS matches expected prompts and
- *      rejects non-resume prompts (control, help, diagnostic, etc.)
- */
 
 import { describe, test } 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 systemContextSource = readFileSync(
-  join(__dirname, "..", "bootstrap", "system-context.ts"),
-  "utf-8",
-);
-
-// ── Structural tests ────────────────────────────────────────────────
-
-describe("#3615 — structural: fallback exists with correct guards", () => {
-  const fnStart = systemContextSource.indexOf("async function buildGuidedExecuteContextInjection(");
-  assert.ok(fnStart >= 0, "should find buildGuidedExecuteContextInjection");
-  const fnEnd = systemContextSource.indexOf("\nasync function ", fnStart + 1);
-  const fnBody = fnEnd >= 0
-    ? systemContextSource.slice(fnStart, fnEnd)
-    : systemContextSource.slice(fnStart);
-
-  test("has a deriveState fallback after the two regex branches", () => {
-    const deriveStateCalls = fnBody.match(/deriveState\(basePath\)/g);
-    assert.ok(
-      deriveStateCalls && deriveStateCalls.length >= 2,
-      `expected >=2 deriveState(basePath) calls, got ${deriveStateCalls?.length ?? 0}`,
-    );
-  });
-
-  test("fallback is phase-gated to executing only", () => {
-    const afterFallback = fnBody.indexOf("// Fallback:");
-    assert.ok(afterFallback >= 0, "should have a fallback comment");
-    const fallbackSection = fnBody.slice(afterFallback);
-    assert.ok(
-      fallbackSection.includes('state.phase === "executing"'),
-      'fallback must be gated on state.phase === "executing"',
-    );
-  });
-
-  test("fallback is intent-gated via RESUME_INTENT_PATTERNS", () => {
-    const afterFallback = fnBody.indexOf("// Fallback:");
-    const fallbackSection = fnBody.slice(afterFallback);
-    assert.ok(
-      fallbackSection.includes("RESUME_INTENT_PATTERNS"),
-      "fallback must check RESUME_INTENT_PATTERNS before deriveState",
-    );
-  });
-
-  test("fallback calls buildTaskExecutionContextInjection with derived state", () => {
-    const afterFallback = fnBody.indexOf("// Fallback:");
-    const fallbackSection = fnBody.slice(afterFallback);
-    assert.ok(
-      fallbackSection.includes("buildTaskExecutionContextInjection") &&
-      fallbackSection.includes("state.activeMilestone.id") &&
-      fallbackSection.includes("state.activeSlice.id") &&
-      fallbackSection.includes("state.activeTask.id"),
-      "fallback must call buildTaskExecutionContextInjection with state-derived IDs",
-    );
-  });
-
-  // Removed: source-grep count of `return null;` occurrences. The behaviour
-  // we care about ("function returns null only when no auto-dispatch /
-  // guided-resume / fallback path matches") is exercised by the behavioural
-  // tests below — counting literal `return null;` tokens encodes statement
-  // shape, not contract. Refs #4851.
-});
-
-// ── Behavioral tests: RESUME_INTENT_PATTERNS ────────────────────────
-
-describe("#3615 — behavioral: RESUME_INTENT_PATTERNS matches resume prompts", () => {
-  // Extract the regex from source so the test stays in sync
-  const patternMatch = systemContextSource.match(/const RESUME_INTENT_PATTERNS\s*=\s*\/(.+)\/;/);
-  assert.ok(patternMatch, "should find RESUME_INTENT_PATTERNS definition");
-  const pattern = new RegExp(patternMatch[1]);
 
-  // Helper: normalize prompt the same way the production code does
-  const normalize = (s: string) => s.trim().toLowerCase().replace(/[.!?,]+$/g, "");
+import { isLowEntropyResumePrompt } from "../bootstrap/system-context.ts";
 
+describe("#3615 — RESUME_INTENT_PATTERNS behavior", () => {
   const shouldMatch = [
     "continue",
     "Continue",
@@ -118,7 +30,7 @@ describe("#3615 — behavioral: RESUME_INTENT_PATTERNS matches resume prompts",
     "do it",
     "let's go",
     "pick up where you left off",
-    "  continue  ",  // whitespace padded
+    "  continue  ",
   ];
 
   const shouldNotMatch = [
@@ -143,19 +55,13 @@ describe("#3615 — behavioral: RESUME_INTENT_PATTERNS matches resume prompts",
 
   for (const prompt of shouldMatch) {
     test(`matches resume prompt: "${prompt}"`, () => {
-      assert.ok(
-        pattern.test(normalize(prompt)),
-        `expected RESUME_INTENT_PATTERNS to match "${prompt}" (normalized: "${normalize(prompt)}")`,
-      );
+      assert.equal(isLowEntropyResumePrompt(prompt), true);
     });
   }
 
   for (const prompt of shouldNotMatch) {
     test(`rejects non-resume prompt: "${prompt}"`, () => {
-      assert.ok(
-        !pattern.test(normalize(prompt)),
-        `expected RESUME_INTENT_PATTERNS to NOT match "${prompt}" (normalized: "${normalize(prompt)}")`,
-      );
+      assert.equal(isLowEntropyResumePrompt(prompt), false);
     });
   }
 });

package/src/resources/extensions/gsd/tests/uok-plan-v2-wiring.test.ts

@@ -1,9 +1,8 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
 
 import {
   closeDatabase,
@@ -19,9 +18,13 @@ import {
   isEmptyPlanV2GraphResult,
   isMissingFinalizedContextResult,
 } from "../uok/plan-v2.ts";
+import {
+  _needsPlanV2GateForTest,
+  _runPlanV2GateForTest,
+} from "../guided-flow.ts";
+import { shouldRunPlanV2Gate } from "../auto/phases.ts";
+import { resolveUokFlags } from "../uok/flags.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const gsdDir = join(__dirname, "..");
 const MILESTONE_ID = "M001";
 const SLICE_ID = "S01";
 const TASK_ID = "T01";
@@ -94,48 +97,52 @@ test.afterEach(() => {
 });
 
 test("guided flow keeps plan-v2 fail-closed handling for non-recoverable failures", () => {
-  const source = readFileSync(join(gsdDir, "guided-flow.ts"), "utf-8");
-  assert.ok(
-    source.includes("needsPlanV2Gate") &&
-    source.includes("ensurePlanV2Graph") &&
-    source.includes("Plan gate failed-closed"),
-    "guided flow should fail-closed when plan-v2 graph compilation fails",
+  const basePath = createBasePath();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+  insertMilestone({ id: MILESTONE_ID, title: "Milestone", status: "active" });
+  insertSlice({
+    id: SLICE_ID,
+    milestoneId: MILESTONE_ID,
+    title: "Slice",
+    status: "pending",
+    sequence: 1,
+  });
+
+  const notifications: string[] = [];
+  const decision = _runPlanV2GateForTest(
+    { ui: { notify: (message: string) => notifications.push(message) } } as any,
+    basePath,
+    buildState("executing"),
   );
+
+  assert.equal(decision, "block");
+  assert.match(notifications[0] ?? "", /Plan gate failed-closed/);
 });
 
 test("guided flow routes recoverable missing finalized context to discuss-milestone", () => {
-  const source = readFileSync(join(gsdDir, "guided-flow.ts"), "utf-8");
-  assert.ok(
-    source.includes('PlanV2GateDecision = "pass" | "recover-missing-context" | "block"') &&
-    source.includes("isMissingFinalizedContextResult(compiled)") &&
-    source.includes('planV2GateDecision === "recover-missing-context"') &&
-    source.includes("buildDiscussMilestonePrompt"),
-    "guided flow should redispatch missing finalized context to discuss-milestone instead of fail-closing",
+  const basePath = createBasePath();
+  seedGraphRows();
+  writeMilestoneFile(basePath, "CONTEXT-DRAFT", "Draft context only.");
+
+  const decision = _runPlanV2GateForTest(
+    { ui: { notify: () => undefined } } as any,
+    basePath,
+    buildState("executing"),
   );
+
+  assert.equal(decision, "recover-missing-context");
 });
 
-test("guided flow checks pending deep setup before plan-v2 gate", () => {
-  const source = readFileSync(join(gsdDir, "guided-flow.ts"), "utf-8");
-  const showSmartEntryIdx = source.indexOf("export async function showSmartEntry");
-  assert.notEqual(showSmartEntryIdx, -1);
-  const deepIdx = source.indexOf("shouldRunDeepProjectSetup(state, prefs, basePath)", showSmartEntryIdx);
-  const planIdx = source.indexOf("runPlanV2Gate(ctx, basePath, state)", showSmartEntryIdx);
-  assert.ok(
-    deepIdx > -1 && planIdx > -1 && deepIdx < planIdx,
-    "foreground deep setup must run before plan-v2 can fail-close guided /gsd",
-  );
-  assert.ok(
-    source.includes("loadEffectiveGSDPreferences(basePath)?.preferences"),
-    "guided plan-v2 gate must load preferences from the target project root",
-  );
+test("guided and auto plan-v2 phase gates agree on execution phases", () => {
+  assert.equal(_needsPlanV2GateForTest(buildState("planning")), false);
+  assert.equal(_needsPlanV2GateForTest(buildState("executing")), true);
+  assert.equal(shouldRunPlanV2Gate("planning"), false);
+  assert.equal(shouldRunPlanV2Gate("executing"), true);
 });
 
 test("auto pre-dispatch uses resolved plan-v2 defaults", () => {
-  const source = readFileSync(join(gsdDir, "auto", "phases.ts"), "utf-8");
-  assert.ok(
-    source.includes("uokFlags.planV2 && shouldRunPlanV2Gate(state.phase)"),
-    "auto-mode should honor resolveUokFlags defaults, not only explicit uok.plan_v2.enabled",
-  );
+  assert.equal(resolveUokFlags(undefined).planV2, true);
+  assert.equal(resolveUokFlags({ uok: { plan_v2: { enabled: false } } } as any).planV2, false);
 });
 
 test("plan-v2 gate fails closed for execution phase when finalized context is missing", () => {

package/src/resources/extensions/gsd/tests/verification-retry-policy.test.ts

@@ -0,0 +1,83 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode verification retry backoff decisions.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  decideVerificationRetry,
+  hashVerificationFailureContext,
+  verificationRetryDelayMs,
+  verificationRetryKey,
+  VERIFICATION_RETRY_MAX_DELAY_MS,
+} from "../auto/verification-retry-policy.ts";
+
+test("verificationRetryDelayMs uses exponential backoff with cap", () => {
+  assert.deepEqual(verificationRetryDelayMs(1, () => 0.5), {
+    delayMs: 2_000,
+    baseDelayMs: 2_000,
+  });
+  assert.deepEqual(verificationRetryDelayMs(2, () => 0.5), {
+    delayMs: 4_000,
+    baseDelayMs: 4_000,
+  });
+  assert.deepEqual(verificationRetryDelayMs(3, () => 0.5), {
+    delayMs: 8_000,
+    baseDelayMs: 8_000,
+  });
+  assert.deepEqual(verificationRetryDelayMs(99, () => 0.5), {
+    delayMs: VERIFICATION_RETRY_MAX_DELAY_MS,
+    baseDelayMs: VERIFICATION_RETRY_MAX_DELAY_MS,
+  });
+});
+
+test("decideVerificationRetry pauses on duplicate failure context", () => {
+  const failureContext = "lint failed\n";
+  const failureHash = hashVerificationFailureContext(failureContext);
+  const decision = decideVerificationRetry({
+    unitType: "execute-task",
+    retryInfo: {
+      unitId: "M001/S01/T01",
+      failureContext,
+      attempt: 2,
+    },
+    previousFailureHash: failureHash,
+    random: () => 0.5,
+  });
+
+  assert.deepEqual(decision, {
+    action: "pause",
+    reason: "duplicate-failure-context",
+    key: verificationRetryKey("execute-task", "M001/S01/T01"),
+    failureHash,
+  });
+});
+
+test("decideVerificationRetry delays changed failure context", () => {
+  const decision = decideVerificationRetry({
+    unitType: "execute-task",
+    retryInfo: {
+      unitId: "M001/S01/T01",
+      failureContext: "test failed differently",
+      attempt: 2,
+    },
+    previousFailureHash: hashVerificationFailureContext("test failed"),
+    random: () => 0.5,
+  });
+
+  assert.equal(decision.action, "delay");
+  assert.equal(decision.key, verificationRetryKey("execute-task", "M001/S01/T01"));
+  assert.equal(decision.delayMs, 4_000);
+  assert.equal(decision.baseDelayMs, 4_000);
+});
+
+test("decideVerificationRetry pauses when retry context is missing", () => {
+  assert.deepEqual(
+    decideVerificationRetry({
+      unitType: "execute-task",
+      retryInfo: null,
+      previousFailureHash: undefined,
+    }),
+    { action: "pause", reason: "missing-retry-context" },
+  );
+});