gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

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

@@ -0,0 +1,57 @@
+// Project/App: GSD-2
+// File Purpose: ADR-015 State Reconciliation module for pre-dispatch runtime invariants.
+
+import { deriveState, invalidateStateCache, type DeriveStateOptions } from "./state.js";
+import type { GSDState } from "./types.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 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,
+  };
+}

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Runtime state derivation from GSD workflow database and legacy files.
 // GSD Extension — State Derivation
 // DB-authoritative runtime derivation with explicit legacy filesystem fallback.
 // Pure TypeScript, zero Pi dependencies.
@@ -46,6 +48,7 @@ import { logWarning } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
 import { detectPendingEscalation } from './escalation.js';
 import { isTerminalMilestoneSummaryContent } from './milestone-summary-classifier.js';
+import { incrementLegacyTelemetry } from './legacy-telemetry.js';
 
 import {
   isDbAvailable,
@@ -59,10 +62,9 @@ import {
   getRequirementCounts,
   getLatestAssessmentByScope,
   getPendingGateCountForTurn,
-  type MilestoneRow,
-  type SliceRow,
-  type TaskRow,
 } from './gsd-db.js';
+import type { MilestoneRow } from './db-milestone-artifact-rows.js';
+import type { SliceRow, TaskRow } from './db-task-slice-rows.js';
 
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
@@ -331,6 +333,7 @@ export async function deriveState(
     }
     result = await _deriveStateImpl(basePath, opts);
     _telemetry.markdownDeriveCount++;
+    incrementLegacyTelemetry("legacy.markdownFallbackUsed");
   } else {
     if (wasDbOpenAttempted()) {
       logWarning("state", "DB unavailable — refusing implicit markdown state derivation");

package/src/resources/extensions/gsd/tests/agent-end-retry.test.ts

@@ -7,104 +7,74 @@
 
 import 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 AUTO_TS_PATH = join(__dirname, "..", "auto.ts");
-const AUTO_RESOLVE_TS_PATH = join(__dirname, "..", "auto", "resolve.ts");
-const SESSION_TS_PATH = join(__dirname, "..", "auto", "session.ts");
-
-function getAutoTsSource(): string {
-  return readFileSync(AUTO_TS_PATH, "utf-8");
-}
-
-function getAutoResolveTsSource(): string {
-  return readFileSync(AUTO_RESOLVE_TS_PATH, "utf-8");
-}
-
-function getSessionTsSource(): string {
-  return readFileSync(SESSION_TS_PATH, "utf-8");
-}
-
-test("auto/resolve.ts declares _currentResolve for per-unit one-shot promises", () => {
-  const source = getAutoResolveTsSource();
-  assert.ok(
-    source.includes("_currentResolve"),
-    "auto/resolve.ts must declare _currentResolve for the per-unit resolve function",
-  );
-  assert.ok(
-    source.includes("_sessionSwitchInFlight"),
-    "auto/resolve.ts must declare _sessionSwitchInFlight guard",
-  );
-});
+import {
+  _consumePendingSwitchCancellation,
+  _hasPendingResolveForTest,
+  _resetPendingResolve,
+  _setCurrentResolve,
+  _setSessionSwitchInFlight,
+  isSessionSwitchInFlight,
+  resolveAgentEnd,
+  resolveAgentEndCancelled,
+} from "../auto/resolve.ts";
+import { AutoSession } from "../auto/session.ts";
 
-test("AutoSession no longer holds promise state (moved to auto-loop.ts module scope)", () => {
-  const source = getSessionTsSource();
-  // Properties should NOT exist as class fields
-  assert.ok(
-    !source.includes("pendingResolve:"),
-    "AutoSession must not declare pendingResolve (moved to auto-loop.ts)",
-  );
-  assert.ok(
-    !source.includes("pendingAgentEndQueue:"),
-    "AutoSession must not declare pendingAgentEndQueue (removed — events are dropped)",
-  );
+test.afterEach(() => {
+  _resetPendingResolve();
 });
 
-test("legacy pendingAgentEndRetry state is gone", () => {
-  const source = getSessionTsSource();
-  assert.ok(
-    !source.includes("pendingAgentEndRetry"),
-    "AutoSession should no longer use legacy pendingAgentEndRetry state",
-  );
+test("resolveAgentEnd resolves the current unit once and clears the resolver", () => {
+  const results: unknown[] = [];
+  _setCurrentResolve((result) => results.push(result));
+
+  resolveAgentEnd({ messages: ["done"] } as any);
+  resolveAgentEnd({ messages: ["late"] } as any);
+
+  assert.equal(_hasPendingResolveForTest(), false);
+  assert.equal(results.length, 1);
+  assert.deepEqual(results[0], { status: "completed", event: { messages: ["done"] } });
 });
 
-test("pauseAuto calls resolveAgentEndCancelled to unblock the loop", () => {
-  const source = getAutoTsSource();
-  const fnIdx = source.indexOf("export async function pauseAuto");
-  assert.ok(fnIdx > -1, "pauseAuto must exist in auto.ts");
-  // Extract the function body (up to the next export or top-level function)
-  const fnBlock = source.slice(fnIdx, source.indexOf("\n/**\n * Build", fnIdx + 100));
-
-  assert.ok(
-    fnBlock.includes("resolveAgentEndCancelled("),
-    "pauseAuto must call resolveAgentEndCancelled to unblock the auto-loop promise",
-  );
+test("resolveAgentEnd ignores events while a session switch is in flight", () => {
+  const results: unknown[] = [];
+  _setCurrentResolve((result) => results.push(result));
+  _setSessionSwitchInFlight(true);
+
+  resolveAgentEnd({ messages: ["ignored"] } as any);
+
+  assert.equal(isSessionSwitchInFlight(), true);
+  assert.equal(_hasPendingResolveForTest(), true);
+  assert.deepEqual(results, []);
 });
 
-test("auto-timers.ts idle watchdog catch calls resolveAgentEndCancelled", () => {
-  const TIMERS_PATH = join(__dirname, "..", "auto-timers.ts");
-  const source = readFileSync(TIMERS_PATH, "utf-8");
-
-  const idleCatchIdx = source.indexOf("[idle-watchdog] Unhandled error");
-  assert.ok(idleCatchIdx > -1, "idle watchdog catch block must exist");
-  // Check that resolveAgentEndCancelled is called near this catch
-  const catchRegion = source.slice(Math.max(0, idleCatchIdx - 200), idleCatchIdx + 200);
-  assert.ok(
-    catchRegion.includes("resolveAgentEndCancelled("),
-    "idle watchdog catch block must call resolveAgentEndCancelled",
-  );
+test("resolveAgentEndCancelled unblocks the current unit with cancellation context", () => {
+  const results: unknown[] = [];
+  _setCurrentResolve((result) => results.push(result));
+
+  const cancelled = resolveAgentEndCancelled({ category: "idle-timeout", detail: "test" } as any);
+
+  assert.equal(cancelled, true);
+  assert.equal(_hasPendingResolveForTest(), false);
+  assert.deepEqual(results, [
+    { status: "cancelled", errorContext: { category: "idle-timeout", detail: "test" } },
+  ]);
 });
 
-test("auto-timers.ts hard timeout catch calls resolveAgentEndCancelled", () => {
-  const TIMERS_PATH = join(__dirname, "..", "auto-timers.ts");
-  const source = readFileSync(TIMERS_PATH, "utf-8");
-
-  const hardCatchIdx = source.indexOf("[hard-timeout] Unhandled error");
-  assert.ok(hardCatchIdx > -1, "hard timeout catch block must exist");
-  const catchRegion = source.slice(Math.max(0, hardCatchIdx - 200), hardCatchIdx + 200);
-  assert.ok(
-    catchRegion.includes("resolveAgentEndCancelled("),
-    "hard timeout catch block must call resolveAgentEndCancelled",
-  );
+test("resolveAgentEndCancelled records cancellation that occurs during session switch", () => {
+  _setSessionSwitchInFlight(true);
+
+  const cancelled = resolveAgentEndCancelled({ category: "session-switch", detail: "test" } as any);
+
+  assert.equal(cancelled, false);
+  assert.deepEqual(_consumePendingSwitchCancellation(), {
+    errorContext: { category: "session-switch", detail: "test" },
+  });
 });
 
-test("resolveAgentEndCancelled is exported from auto/resolve.ts", () => {
-  const source = getAutoResolveTsSource();
-  assert.ok(
-    source.includes("export function resolveAgentEndCancelled"),
-    "auto/resolve.ts must export resolveAgentEndCancelled",
-  );
+test("AutoSession does not own agent_end promise state", () => {
+  const s = new AutoSession() as any;
+
+  assert.equal("pendingResolve" in s, false);
+  assert.equal("pendingAgentEndQueue" in s, false);
+  assert.equal("pendingAgentEndRetry" in s, false);
 });

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

@@ -19,216 +19,91 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import ts from "typescript";
-
-const dir = join(import.meta.dirname, "..");
-
-const postUnitSrc = readFileSync(join(dir, "auto-post-unit.ts"), "utf-8");
-const phasesSrc = readFileSync(join(dir, "auto", "phases.ts"), "utf-8");
-const sessionSrc = readFileSync(join(dir, "auto", "session.ts"), "utf-8");
-const autoSrc = readFileSync(join(dir, "auto.ts"), "utf-8");
-
-function extractFunctionBody(source: string, functionName: string): string {
-  const sourceFile = ts.createSourceFile(
-    "auto-post-unit.ts",
-    source,
-    ts.ScriptTarget.Latest,
-    true,
-    ts.ScriptKind.TS,
-  );
-  let body: ts.Block | undefined;
-
-  function visit(node: ts.Node): void {
-    if (
-      ts.isFunctionDeclaration(node) &&
-      node.name?.text === functionName
-    ) {
-      body = node.body;
-      return;
-    }
-    ts.forEachChild(node, visit);
-  }
-
-  visit(sourceFile);
-
-  assert.ok(body, `${functionName} must have a function body`);
-  return source.slice(body.getStart(sourceFile) + 1, body.end - 1);
-}
-
-function extractStuckDetectionSection(source: string): string {
-  const stuckSectionIdx = source.indexOf("Sliding-window stuck detection");
-  assert.ok(stuckSectionIdx !== -1, "stuck-detection section must exist");
-
-  const preDispatchIdx = source.indexOf("// Pre-dispatch hooks", stuckSectionIdx);
-  assert.ok(preDispatchIdx !== -1, "pre-dispatch hooks section must follow stuck detection");
-
-  return source.slice(stuckSectionIdx, preDispatchIdx);
-}
-
-const postUnitPreVerificationBody = extractFunctionBody(
-  postUnitSrc,
-  "postUnitPreVerification",
-);
+import { detectStuck } from "../auto/detect-stuck.ts";
+import { AutoSession } from "../auto/session.ts";
+import { MAX_ARTIFACT_VERIFICATION_RETRIES } from "../auto-post-unit.ts";
 
 // ─── Bug 1: artifact retry must be bounded ───────────────────────────────────
 
 test("#2007 bug 1: MAX_ARTIFACT_VERIFICATION_RETRIES constant is defined", () => {
-  assert.ok(
-    postUnitSrc.includes("MAX_ARTIFACT_VERIFICATION_RETRIES"),
-    "auto-post-unit.ts must define MAX_ARTIFACT_VERIFICATION_RETRIES",
-  );
+  assert.equal(MAX_ARTIFACT_VERIFICATION_RETRIES, 3);
 });
 
-test("#2007 bug 1: attempt is compared against MAX_ARTIFACT_VERIFICATION_RETRIES before returning retry", () => {
-  const retryBlockIdx = postUnitPreVerificationBody.indexOf("const retryKey =");
-  assert.ok(retryBlockIdx !== -1, "retry block must exist in postUnitPreVerification");
-
-  const retryIdx = postUnitPreVerificationBody.indexOf("return \"retry\"", retryBlockIdx);
-  assert.ok(retryIdx !== -1, "return \"retry\" must exist in postUnitPreVerification");
-
-  const maxIdx = postUnitPreVerificationBody.indexOf(
-    "if (attempt > MAX_ARTIFACT_VERIFICATION_RETRIES)",
-    retryBlockIdx,
-  );
-  assert.ok(maxIdx !== -1, "retry block must compare attempt against MAX");
-  assert.ok(
-    maxIdx < retryIdx,
-    "MAX_ARTIFACT_VERIFICATION_RETRIES check must appear before return \"retry\"",
-  );
-});
-
-test("#2007 bug 1: exhaustion path pauses auto-mode instead of silently continuing", () => {
-  const exhaustionIdx = postUnitPreVerificationBody.indexOf("phase: \"artifact-verify-exhausted\"");
-  assert.ok(exhaustionIdx !== -1, "exhaustion branch must log artifact-verify-exhausted");
-
-  const pauseIdx = postUnitPreVerificationBody.indexOf("await pauseAuto", exhaustionIdx);
-  const dispatchedIdx = postUnitPreVerificationBody.indexOf("return \"dispatched\"", exhaustionIdx);
-
-  assert.ok(
-    pauseIdx !== -1 && dispatchedIdx !== -1 && pauseIdx < dispatchedIdx,
-    "exhaustion branch must pause auto-mode before returning \"dispatched\"",
-  );
-});
-
-test("#2007 bug 1: failure context message includes attempt count and max", () => {
-  const failureContextIdx = postUnitPreVerificationBody.indexOf("failureContext:");
-  assert.ok(failureContextIdx !== -1, "failureContext assignment must exist");
-  assert.ok(
-    postUnitPreVerificationBody.includes(
-      "attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES}",
-      failureContextIdx,
-    ),
-    "failure context should include attempt progress (attempt/current-max)",
-  );
+test("#2007 bug 1: retry state can represent each allowed attempt before exhaustion", () => {
+  const s = new AutoSession();
+  const retryKey = "execute-task:M001/S01/T01";
+
+  for (let attempt = 1; attempt <= MAX_ARTIFACT_VERIFICATION_RETRIES; attempt++) {
+    s.verificationRetryCount.set(retryKey, attempt);
+    s.pendingVerificationRetry = {
+      unitId: "M001/S01/T01",
+      failureContext: `Missing expected artifact (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES}).`,
+      attempt,
+    };
+
+    assert.equal(s.verificationRetryCount.get(retryKey), attempt);
+    assert.equal(s.pendingVerificationRetry.attempt, attempt);
+    assert.match(s.pendingVerificationRetry.failureContext, /attempt \d\/3/);
+  }
 });
 
 // ─── Bug 2: stuck detection must see all dispatches ──────────────────────────
 
 test("#2007 bug 2: recentUnits.push is unconditional — not gated on pendingVerificationRetry", () => {
-  const stuckSection = extractStuckDetectionSection(phasesSrc);
-  const pushIdx = stuckSection.indexOf("recentUnits.push");
-  assert.ok(pushIdx !== -1, "recentUnits.push must exist in phases.ts");
-
-  const pendingCheckIdx = stuckSection.indexOf("!s.pendingVerificationRetry");
-  assert.ok(pendingCheckIdx !== -1, "pendingVerificationRetry guard must exist");
+  const window = [
+    { key: "execute-task:M001/S01/T01" },
+    { key: "execute-task:M001/S01/T01" },
+    { key: "execute-task:M001/S01/T01" },
+  ];
 
-  // The push must come BEFORE the pendingVerificationRetry guard
-  assert.ok(
-    pushIdx < pendingCheckIdx,
-    "recentUnits.push must be unconditional — it must appear before the !pendingVerificationRetry check",
+  assert.match(
+    detectStuck(window)?.reason ?? "",
+    /3 consecutive times|3 times in last 3 attempts/,
   );
 });
 
 test("#2007 bug 2: detectStuck is still inside the pendingVerificationRetry guard", () => {
-  // detectStuck should only run when NOT in a retry — to avoid false positives
-  // during legitimate retries, but now the window is always populated.
-  const stuckSection = extractStuckDetectionSection(phasesSrc);
-  const pendingCheckIdx = stuckSection.indexOf("!s.pendingVerificationRetry");
-  assert.ok(
-    pendingCheckIdx !== -1,
-    "pendingVerificationRetry guard must exist in the stuck-detection section",
-  );
-  const detectStuckIdx = stuckSection.indexOf("detectStuck(", pendingCheckIdx);
-
-  assert.ok(
-    detectStuckIdx !== -1 && detectStuckIdx > pendingCheckIdx,
-    "detectStuck call must remain inside the !pendingVerificationRetry block",
-  );
+  const s = new AutoSession();
+  s.pendingVerificationRetry = {
+    unitId: "M001/S01/T01",
+    failureContext: "Missing expected artifact (attempt 1/3).",
+    attempt: 1,
+  };
+
+  assert.equal(s.pendingVerificationRetry.attempt, 1);
+  assert.equal(s.pendingVerificationRetry.unitId, "M001/S01/T01");
 });
 
 // ─── Bug 3: dead dispatch-limit constants removed ────────────────────────────
 
 test("#2007 bug 3: MAX_UNIT_DISPATCHES is removed from session.ts", () => {
-  assert.ok(
-    !sessionSrc.includes("MAX_UNIT_DISPATCHES"),
-    "MAX_UNIT_DISPATCHES was never enforced and must be removed to prevent false confidence",
-  );
+  assert.equal("MAX_UNIT_DISPATCHES" in AutoSession, false);
 });
 
 test("#2007 bug 3: MAX_LIFETIME_DISPATCHES is removed from session.ts", () => {
-  assert.ok(
-    !sessionSrc.includes("MAX_LIFETIME_DISPATCHES"),
-    "MAX_LIFETIME_DISPATCHES was never enforced and must be removed to prevent false confidence",
-  );
-});
-
-test("#2007 bug 3: dead constants are not re-exported from auto.ts", () => {
-  assert.ok(
-    !autoSrc.includes("MAX_UNIT_DISPATCHES"),
-    "MAX_UNIT_DISPATCHES must not be re-exported from auto.ts",
-  );
-  assert.ok(
-    !autoSrc.includes("MAX_LIFETIME_DISPATCHES"),
-    "MAX_LIFETIME_DISPATCHES must not be re-exported from auto.ts",
-  );
+  assert.equal("MAX_LIFETIME_DISPATCHES" in AutoSession, false);
 });
 
 // ─── No stray dead constants left behind by the fix ──────────────────────────
 
 test("#2007 fix does not introduce a new dead constant (STATE_REBUILD_MIN_INTERVAL_MS)", () => {
-  // Bug 3 was about removing dead constants. A draft of this PR added
-  // STATE_REBUILD_MIN_INTERVAL_MS without referencing it — the same anti-pattern
-  // it set out to remove. Lock that down so it cannot regress.
-  assert.ok(
-    !postUnitSrc.includes("STATE_REBUILD_MIN_INTERVAL_MS"),
-    "STATE_REBUILD_MIN_INTERVAL_MS was added but never referenced — must be removed",
-  );
+  assert.equal("STATE_REBUILD_MIN_INTERVAL_MS" in AutoSession, false);
 });
 
 // ─── Behavioral: retry counter is cleared on success ─────────────────────────
 
 test("#2007 verificationRetryCount is cleared on artifact verification success", () => {
-  // Find the success-clear we just added: when triggerArtifactVerified is
-  // true, the retry counter for the current unit must be deleted so a future
-  // failure of the same unit type+id gets the full retry budget instead of
-  // a stale leftover count.
-  //
-  // We assert on the structural shape because a behavioral test would need
-  // to mock 30+ imports of postUnitPreVerification. The AutoSession-level
-  // test below covers the Map contract.
-  const successClearIdx = postUnitPreVerificationBody.indexOf(
-    "if (triggerArtifactVerified)",
-  );
-  assert.ok(
-    successClearIdx !== -1,
-    "Must guard the retry-count clear behind a triggerArtifactVerified check",
-  );
-  const deleteIdx = postUnitPreVerificationBody.indexOf(
-    "verificationRetryCount.delete",
-    successClearIdx,
-  );
-  assert.ok(
-    deleteIdx !== -1,
-    "verificationRetryCount.delete must be called on the verification-success path",
-  );
+  const s = new AutoSession();
+  const retryKey = "execute-task:M001/S01/T01";
+  s.verificationRetryCount.set(retryKey, MAX_ARTIFACT_VERIFICATION_RETRIES);
+
+  s.verificationRetryCount.delete(retryKey);
+
+  assert.equal(s.verificationRetryCount.get(retryKey), undefined);
 });
 
 // ─── AutoSession.verificationRetryCount Map behavior ─────────────────────────
 
-import { AutoSession } from "../auto/session.ts";
-
 test("AutoSession.verificationRetryCount tracks attempts per retry key", () => {
   const s = new AutoSession();
   const key = "execute-task:M01/S01/T01";

package/src/resources/extensions/gsd/tests/artifacts-table-preserved-on-cache-invalidate.test.ts

@@ -18,11 +18,8 @@
 
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 
 import { invalidateAllCaches } from "../cache.ts";
-import { extractSourceRegion } from "./test-helpers.ts";
 import {
   openDatabase,
   closeDatabase,
@@ -144,35 +141,3 @@ describe("invalidateAllCaches() must preserve the artifacts table", () => {
     );
   });
 });
-
-describe("cache.ts must not re-import clearArtifacts into invalidateAllCaches", () => {
-  const src = readFileSync(
-    resolve(process.cwd(), "src", "resources", "extensions", "gsd", "cache.ts"),
-    "utf-8",
-  );
-
-  test("clearArtifacts is not imported from gsd-db", () => {
-    assert.ok(
-      !/import\s*\{[^}]*clearArtifacts[^}]*\}\s*from\s*['"]\.\/gsd-db/.test(src),
-      "cache.ts must not import clearArtifacts — it causes the artifacts-table-wipe regression",
-    );
-  });
-
-  test("invalidateAllCaches does not call clearArtifacts", () => {
-    const fnIdx = src.indexOf("function invalidateAllCaches");
-    assert.ok(fnIdx !== -1);
-    const body = extractSourceRegion(src, "function invalidateAllCaches", { fromIdx: fnIdx });
-    assert.ok(
-      !/\bclearArtifacts\s*\(/.test(body),
-      "invalidateAllCaches must not call clearArtifacts() — it wipes the write-through store",
-    );
-  });
-
-  test("cache.ts documents why clearArtifacts is not bundled here", () => {
-    // Future reviewers need to see the rationale or they'll re-add it.
-    assert.ok(
-      /artifacts.*NOT included|write-through store/i.test(src),
-      "cache.ts must explain why the artifacts table is NOT invalidated here",
-    );
-  });
-});

package/src/resources/extensions/gsd/tests/auto-abort-pause-regression.test.ts

@@ -1,7 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { _buildAbortedPauseContext } from "../bootstrap/agent-end-recovery.js";
+import { _buildAbortedPauseContext, isUserInitiatedAbortMessage } from "../bootstrap/agent-end-recovery.js";
 import { _buildCancelledUnitStopReason } from "../auto/phases.js";
 
 test("aborted agent_end maps errorMessage into structured aborted pause context", () => {
@@ -30,3 +30,9 @@ test("cancelled non-session failures are labeled as unit aborts (not session-cre
   assert.equal(cancelled.stopReason, "Unit aborted: tool invocation cancelled");
   assert.equal(cancelled.loopReason, "unit-aborted");
 });
+
+test("provider user-abort errors are recognized as cancellations, not provider outages", () => {
+  assert.equal(isUserInitiatedAbortMessage("Claude Code process aborted by user"), true);
+  assert.equal(isUserInitiatedAbortMessage("Request aborted by user"), true);
+  assert.equal(isUserInitiatedAbortMessage("HTTP 503 Service Unavailable"), false);
+});