gsd-pi 2.81.0-dev.3cddbbba2 → 2.81.0-dev.72a81bdf3

package/src/resources/extensions/gsd/state-reconciliation.ts

@@ -1,57 +1,25 @@
 // Project/App: GSD-2
-// File Purpose: ADR-015 State Reconciliation module for pre-dispatch runtime invariants.
+// File Purpose: ADR-017 State Reconciliation Module — public entry point.
+// Re-exports the drift-driven implementation from the state-reconciliation/
+// folder so existing import paths (./state-reconciliation.js) keep working.
 
-import { deriveState, invalidateStateCache, type DeriveStateOptions } from "./state.js";
-import type { GSDState } from "./types.js";
+export {
+  reconcileBeforeDispatch,
+  ReconciliationFailedError,
+  DRIFT_REGISTRY,
+} from "./state-reconciliation/index.js";
 
-export type StateReconciliationResult =
-  | {
-      ok: true;
-      stateSnapshot: GSDState;
-      repaired: readonly string[];
-      blockers: readonly string[];
-    }
-  | {
-      ok: false;
-      reason: string;
-      stateSnapshot?: GSDState;
-      repaired: readonly string[];
-      blockers: readonly string[];
-    };
+export type {
+  DriftContext,
+  DriftHandler,
+  DriftRecord,
+  ReconciliationDeps,
+  ReconciliationFailureDetail,
+  ReconciliationResult,
+} from "./state-reconciliation/index.js";
 
-export interface StateReconciliationDeps {
-  invalidateStateCache: () => void;
-  deriveState: (basePath: string, opts?: DeriveStateOptions) => Promise<GSDState>;
-}
-
-const defaultDeps: StateReconciliationDeps = {
-  invalidateStateCache,
-  deriveState,
-};
-
-export async function reconcileBeforeDispatch(
-  basePath: string,
-  deps: StateReconciliationDeps = defaultDeps,
-  opts?: DeriveStateOptions,
-): Promise<StateReconciliationResult> {
-  deps.invalidateStateCache();
-  const stateSnapshot = await deps.deriveState(basePath, opts);
-  const blockers = stateSnapshot.blockers ?? [];
-
-  if (blockers.length > 0 || stateSnapshot.phase === "blocked") {
-    return {
-      ok: false,
-      reason: blockers[0] ?? `State reconciliation blocked in phase ${stateSnapshot.phase}`,
-      stateSnapshot,
-      repaired: ["derive-state-cache-invalidated"],
-      blockers,
-    };
-  }
-
-  return {
-    ok: true,
-    stateSnapshot,
-    repaired: ["derive-state-cache-invalidated"],
-    blockers,
-  };
-}
+export { reconcileBeforeSpawn } from "./state-reconciliation/spawn-gate.js";
+export type {
+  SpawnGateDeps,
+  SpawnGateResult,
+} from "./state-reconciliation/spawn-gate.js";

package/src/resources/extensions/gsd/tests/artifact-retry-cap.test.ts

@@ -62,7 +62,7 @@ test("#2007 bug 2: recentUnits.push is unconditional — not gated on pendingVer
   );
 });
 
-test("#2007 bug 2: detectStuck is still inside the pendingVerificationRetry guard", () => {
+test("#2007 bug 2: pendingVerificationRetry state is available for dispatch regression coverage", () => {
   const s = new AutoSession();
   s.pendingVerificationRetry = {
     unitId: "M001/S01/T01",

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

@@ -2144,7 +2144,7 @@ test("stuck detection: window resets recovery when deriveState returns a differe
   );
 });
 
-test("stuck detection: does not push to window during verification retry", async () => {
+test("stuck detection: verification retries remain visible to the sliding window", async () => {
   _resetPendingResolve();
   mock.timers.enable({ apis: ["Date", "setTimeout"], now: 20_000 });
 
@@ -2199,8 +2199,9 @@ test("stuck detection: does not push to window during verification retry", async
 
     const loopPromise = autoLoop(ctx, pi, s, deps);
 
-    // Resolve agent_end for 4 iterations (1 initial + 3 retries)
-    for (let i = 1; i <= 4; i++) {
+    // Resolve agent_end for 3 attempts. The 4th iteration should stop before
+    // dispatch because retry dispatches stay visible to stuck detection.
+    for (let i = 1; i <= 3; i++) {
       await waitForMicrotasks(() => pi.calls.length === i, `dispatch ${i}`);
       resolveAgentEnd(makeEvent());
       await drainMicrotasks(100);
@@ -2209,16 +2210,14 @@ test("stuck detection: does not push to window during verification retry", async
 
     await loopPromise;
 
-    // Even though same unit was derived 4 times, verification retries should
-    // not push to the sliding window, so stuck detection should not have fired
     assert.ok(
-      !stopReason.includes("Stuck"),
-      `stuck detection should not fire during verification retries, got: ${stopReason}`,
+      stopReason.includes("Stuck"),
+      `stuck detection should fire during repeated verification retries, got: ${stopReason}`,
     );
     assert.equal(
       verifyCallCount,
-      4,
-      "verification should have been called 4 times (1 initial + 3 retries)",
+      3,
+      "verification should stop before a 4th repeated retry dispatch",
     );
   } finally {
     mock.timers.reset();
@@ -2304,7 +2303,8 @@ test("detectStuck: truncates long error strings", () => {
     { key: "A", error: longError },
   ]);
   assert.ok(result?.stuck);
-  assert.ok(result!.reason.length < 300, "reason should be truncated");
+  assert.ok(result!.reason.includes(longError.slice(0, 200)), "reason should include the truncated error prefix");
+  assert.equal(result!.reason.includes(longError), false, "reason should not include the full long error");
 });
 
 // NOTE: the "stuck-detected" / "stuck-counter-reset" debug-log grep was
@@ -3207,6 +3207,77 @@ test("dispatch Worktree Safety wins before stuck detection for execute-task with
   );
 });
 
+test("runDispatch runs stuck detection while artifact verification retry is pending (#5719)", async (t) => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+  const notifications: string[] = [];
+  ctx.ui.notify = (msg: string) => { notifications.push(msg); };
+
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-5719-retry-stuck-"));
+  t.after(() => rmSync(basePath, { recursive: true, force: true }));
+
+  const s = makeLoopSession({
+    basePath,
+    pendingVerificationRetry: {
+      unitId: "M001/S01/T01",
+      failureContext: "ENOENT: no such file or directory, access '/tmp/missing-plan.md'",
+      attempt: 1,
+    },
+  });
+  const deps = makeMockDeps();
+  const loopState = {
+    recentUnits: [
+      {
+        key: "execute-task/M001/S01/T01",
+        error: "ENOENT: no such file or directory, access '/tmp/missing-plan.md'",
+      },
+      { key: "plan-slice/M001/S02", error: "other failure" },
+      {
+        key: "complete-slice/M001/S01",
+        error: "ENOENT: no such file or directory, access '/tmp/missing-plan.md'",
+      },
+    ],
+    stuckRecoveryAttempts: 0,
+    consecutiveFinalizeTimeouts: 0,
+  };
+
+  const result = await runDispatch(
+    {
+      ctx,
+      pi,
+      s,
+      deps,
+      prefs: undefined,
+      iteration: 1,
+      flowId: "test-flow",
+      nextSeq: () => 1,
+    },
+    {
+      state: {
+        phase: "executing",
+        activeMilestone: { id: "M001", title: "Test", status: "active" },
+        activeSlice: { id: "S01", title: "Slice 1" },
+        activeTask: { id: "T01" },
+        registry: [{ id: "M001", status: "active" }],
+        blockers: [],
+      } as any,
+      mid: "M001",
+      midTitle: "Test",
+    },
+    loopState,
+  );
+
+  assert.equal(result.action, "next", "level-1 stuck recovery should still allow the recovery dispatch");
+  assert.equal(loopState.stuckRecoveryAttempts, 1, "stuck recovery should record the first recovery attempt");
+  assert.ok(deps.callLog.includes("invalidateAllCaches"), "stuck recovery should invalidate caches");
+  assert.ok(
+    notifications.some((n) => n.includes("Missing file referenced twice")),
+    "notification should surface the repeated ENOENT stuck reason",
+  );
+});
+
 test("dispatch Worktree Safety stops unknown unit types with missing Tool Contract", async (t) => {
   _resetPendingResolve();
 

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

@@ -62,8 +62,8 @@ import {
   renderRoadmapCheckboxes,
   renderAllFromDb,
   detectStaleRenders,
-  repairStaleRenders,
 } from "../../markdown-renderer.ts";
+import { repairStaleRenders } from "../../state-reconciliation/drift/stale-render.ts";
 
 // ── State derivation ──────────────────────────────────────────────────────
 import {

package/src/resources/extensions/gsd/tests/markdown-renderer.test.ts

@@ -24,8 +24,8 @@ import {
   renderPlanFromDb,
   renderTaskPlanFromDb,
   detectStaleRenders,
-  repairStaleRenders,
 } from '../markdown-renderer.ts';
+import { repairStaleRenders } from '../state-reconciliation/drift/stale-render.ts';
 import {
   parseRoadmap,
   parsePlan,

package/src/resources/extensions/gsd/tests/progressive-planning.test.ts

@@ -14,9 +14,9 @@ import {
   insertMilestone,
   insertSlice,
   setSliceSketchFlag,
-  autoHealSketchFlags,
   getSlice,
 } from "../gsd-db.ts";
+import { autoHealSketchFlags } from "../state-reconciliation/drift/sketch-flag.ts";
 import { deriveStateFromDb } from "../state.ts";
 import { resolveDispatch } from "../auto-dispatch.ts";
 import type { DispatchContext } from "../auto-dispatch.ts";

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

@@ -42,16 +42,19 @@ test("State Reconciliation invalidates cache and returns reconciled state", asyn
   assert.equal(result.ok && result.stateSnapshot, state);
 });
 
-test("State Reconciliation blocks when derived state carries blockers", async () => {
+test("State Reconciliation surfaces terminal blockers in result (ADR-017)", async () => {
+  // Under ADR-017, blockers are terminal but do not throw — they ride along
+  // in the result so the orchestrator adapter can map them to ok=false.
   const result = await reconcileBeforeDispatch("/project", {
     invalidateStateCache() {},
     async deriveState() {
       return makeState({ phase: "blocked", blockers: ["slice lock missing"] });
     },
+    registry: [],
   });
 
-  assert.equal(result.ok, false);
-  assert.equal(!result.ok && result.reason, "slice lock missing");
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.blockers, ["slice lock missing"]);
 });
 
 test("Tool Contract compiles known Unit prompt and tool policy", () => {

package/src/resources/extensions/gsd/tests/session-switch-abort-misclassification.test.ts

@@ -188,6 +188,30 @@ test("empty-content aborted during session-switch is silently ignored", () => {
   assert.equal(cancelledWith, null);
 });
 
+test("completed assistant content with aborted stopReason during session-switch is ignored", () => {
+  // newSession() can abort the just-finished provider stream while the last
+  // assistant message still carries the completed unit summary. That is a
+  // session-transition artifact, not a cancellation for the next unit.
+  let cancelledWith: unknown = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    {
+      stopReason: "aborted",
+      content: [{
+        type: "text",
+        text: "Implemented T01 and verified the slice task is complete.",
+      }],
+    },
+    resolveCancelled,
+  );
+
+  assert.equal(cancelledWith, null);
+});
+
 test("non-abort errors during session-switch are not propagated through this helper", () => {
   // Real provider errors (rate-limit, network, unsupported-model) are handled
   // by the post-switch retry pipeline — not by the in-flight switch handler.