@coreplane/switchboard 1.260.1 → 1.260.3

package/bin/switchboard.js

@@ -1,25 +1,29 @@
 #!/usr/bin/env node
-// The `switchboard` bin: this file hands the process to dist/cli.js, the bundle
-// the build writes (build.mts; docs/reference/specs/packaging.md item 1). A
-// committed entry rather than the bundle itself, because npm links a bin only
-// when its target exists at install time, and the gitignored dist/ does not
-// until the build runs: with dist/cli.js as the bin, `npx <the package>` inside
-// the checkout — where npx prefers the workspace over the registry — found no
-// link and died with `sh: switchboard: command not found`. The published package
-// always carries the bundle, so there this is one extra module load; a checkout
-// that has not built the package is told what to run.
+// The published `switchboard` bin hands the process to the bundle beside it.
+// In a repository checkout npm resolves the package name to this workspace too,
+// but an ignored dist/ may be older than source. The checkout therefore never
+// trusts dist: operators run the root source script, while a tarball runs only
+// the bundle that its build packed.
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
 const bundle = new URL("../dist/cli.js", import.meta.url);
+const checkoutRoot = new URL("../../../", import.meta.url);
+const runsFromCheckout =
+  existsSync(new URL("project.json", checkoutRoot)) && existsSync(new URL("src/cli.ts", checkoutRoot));
 
-if (!existsSync(bundle)) {
+if (runsFromCheckout) {
   console.error(
-    `switchboard: ${fileURLToPath(bundle)} is missing — the package is not built. Inside the checkout, npx runs this workspace, not the published package: run \`npm run build -w packages/switchboard\` first, or use the checkout's CLI, \`npm run cli -- <group> <verb> …\`.`,
+    "switchboard: npx resolved the package name to this checkout; its ignored dist/ is not authoritative. Run `npm run --silent cli -- <group> <verb> …` from the checkout root instead.",
   );
   process.exit(1);
 }
 
+if (!existsSync(bundle)) {
+  console.error(`switchboard: ${fileURLToPath(bundle)} is missing — the published package is incomplete.`);
+  process.exit(1);
+}
+
 // From here the bundle is the script: its entry claim (src/invokedAsScript.ts)
 // and its usage spelling (`programName`, src/cli.ts) read argv[1].
 process.argv[1] = fileURLToPath(bundle);

package/dist/assets/deploy/cloudflare-memory/backgroundTasks.ts

@@ -0,0 +1,49 @@
+type WaitUntilContext = Pick<DurableObjectState, "waitUntil">;
+
+const TASKS = Symbol.for("switchboard.memory-worker.pending-background-tasks");
+const REGISTRATIONS = Symbol.for("switchboard.memory-worker.background-task-registrations");
+type PendingTasks = Map<Promise<unknown>, string>;
+type Registrations = string[];
+
+type DiagnosticRoot = typeof globalThis & {
+  [TASKS]?: PendingTasks;
+  [REGISTRATIONS]?: Registrations;
+};
+
+const root = (): DiagnosticRoot => globalThis as DiagnosticRoot;
+const pendingTasks = (): PendingTasks => (root()[TASKS] ??= new Map());
+
+export function beginBackgroundTaskDiagnostics(): void {
+  root()[REGISTRATIONS] = [];
+}
+
+export function endBackgroundTaskDiagnostics(): void {
+  delete root()[REGISTRATIONS];
+}
+
+export function backgroundTaskDiagnostics(): {
+  registeredBackgroundTasks: string[];
+  pendingPromises: string[];
+} {
+  return {
+    registeredBackgroundTasks: [...(root()[REGISTRATIONS] ?? [])],
+    pendingPromises: [...pendingTasks().values()],
+  };
+}
+
+/** Keep deliberately detached Worker work in the runtime's request lifetime.
+ * The process-wide label set is also the test seam: a case cannot finish while
+ * work it started is still able to contend with the next case. */
+export function holdBackgroundTask(context: WaitUntilContext, label: string, task: Promise<unknown>): void {
+  const pending = pendingTasks();
+  root()[REGISTRATIONS]?.push(label);
+  const held = task.finally(() => pending.delete(held));
+  pending.set(held, label);
+  context.waitUntil(held);
+}
+
+export function assertNoPendingBackgroundTasks(): void {
+  const labels = [...pendingTasks().values()];
+  if (labels.length === 0) return;
+  throw new Error(`test ended with ${labels.length} pending background task(s): ${labels.join(", ")}`);
+}

package/dist/assets/deploy/cloudflare-memory/testDiagnostics.ts

@@ -0,0 +1,227 @@
+import { afterEach, beforeEach, type TestContext } from "vitest";
+import {
+  assertNoPendingBackgroundTasks,
+  backgroundTaskDiagnostics,
+  beginBackgroundTaskDiagnostics,
+  endBackgroundTaskDiagnostics,
+} from "./backgroundTasks.ts";
+import { MEMORY_DIAGNOSTICS_ANNOTATION, type MemoryTestAnnotation } from "./testDiagnosticsProtocol.ts";
+
+type TimerKind = "timeout" | "interval";
+type TimerHandler = (...args: unknown[]) => unknown;
+type TimerSetter = (
+  handler: TimerHandler,
+  delay?: number,
+  ...args: unknown[]
+) => ReturnType<typeof globalThis.setTimeout>;
+interface PendingTimer {
+  id: ReturnType<typeof setTimeout>;
+  kind: TimerKind;
+  label: string;
+  owner: string;
+}
+interface RunningTest {
+  name: string;
+  trackTimers: boolean;
+  timers: Map<ReturnType<typeof setTimeout>, PendingTimer>;
+}
+interface TimerOriginals {
+  setTimeout: typeof globalThis.setTimeout;
+  clearTimeout: typeof globalThis.clearTimeout;
+  setInterval: typeof globalThis.setInterval;
+  clearInterval: typeof globalThis.clearInterval;
+}
+
+const RUNNING = Symbol.for("switchboard.memory-worker.running-test");
+const TIMER_ORIGINALS = Symbol.for("switchboard.memory-worker.timer-originals");
+const REJECTION_TRAP = Symbol.for("switchboard.memory-worker.rejection-trap");
+
+type DiagnosticGlobal = typeof globalThis & {
+  [RUNNING]?: RunningTest;
+  [TIMER_ORIGINALS]?: TimerOriginals;
+  [REJECTION_TRAP]?: boolean;
+  __vitest_worker__?: { ctx?: { poolId?: number; workerId?: number } };
+  process?: {
+    env?: Record<string, string | undefined>;
+    prependListener?: (event: "unhandledRejection", listener: (reason: unknown) => void) => void;
+  };
+};
+
+const diagnosticGlobal = (): DiagnosticGlobal => globalThis as DiagnosticGlobal;
+
+function reasonText(reason: unknown): string {
+  return reason instanceof Error ? reason.message : String(reason);
+}
+
+function runningTestName(): string {
+  return diagnosticGlobal()[RUNNING]?.name ?? "<no test>";
+}
+
+function unhandledRejection(reason: unknown): never {
+  throw new Error(`unhandled rejection while "${runningTestName()}" was running: ${reasonText(reason)}`);
+}
+
+function installUnhandledRejectionTrap(): void {
+  const root = diagnosticGlobal();
+  if (root[REJECTION_TRAP]) return;
+  root[REJECTION_TRAP] = true;
+
+  if (typeof root.addEventListener === "function") {
+    root.addEventListener("unhandledrejection", (event) => {
+      const rejection = event as PromiseRejectionEvent;
+      rejection.preventDefault();
+      unhandledRejection(rejection.reason);
+    });
+    return;
+  }
+
+  root.process?.prependListener?.("unhandledRejection", unhandledRejection);
+}
+
+function timerLabel(kind: TimerKind, handler: TimerHandler, delay?: number): string {
+  const callback = typeof handler === "function" && handler.name ? handler.name : "anonymous";
+  return `${kind} ${callback} (${delay ?? 0}ms)`;
+}
+
+function strayTimerError(timer: PendingTimer): Error {
+  return new Error(`stray ${timer.label} from "${timer.owner}" fired while "${runningTestName()}" was running`);
+}
+
+function installTimerTrap(): void {
+  const root = diagnosticGlobal();
+  if (root[TIMER_ORIGINALS]) return;
+
+  const originals: TimerOriginals = {
+    setTimeout: root.setTimeout.bind(root),
+    clearTimeout: root.clearTimeout.bind(root),
+    setInterval: root.setInterval.bind(root),
+    clearInterval: root.clearInterval.bind(root),
+  };
+  root[TIMER_ORIGINALS] = originals;
+
+  root.setTimeout = ((handler: TimerHandler, delay?: number, ...args: unknown[]) => {
+    const running = root[RUNNING];
+    if (!running?.trackTimers || typeof handler !== "function") {
+      return (originals.setTimeout as unknown as TimerSetter)(handler, delay, ...args);
+    }
+
+    const pending: PendingTimer = {
+      id: undefined as unknown as ReturnType<typeof setTimeout>,
+      kind: "timeout",
+      label: timerLabel("timeout", handler, delay),
+      owner: running.name,
+    };
+    const id = (originals.setTimeout as unknown as TimerSetter)(
+      (...callbackArgs: unknown[]) => {
+        running.timers.delete(id);
+        if (root[RUNNING]?.name !== pending.owner) throw strayTimerError(pending);
+        handler(...callbackArgs);
+      },
+      delay,
+      ...args,
+    );
+    pending.id = id;
+    running.timers.set(id, pending);
+    return id;
+  }) as typeof globalThis.setTimeout;
+
+  root.setInterval = ((handler: TimerHandler, delay?: number, ...args: unknown[]) => {
+    const running = root[RUNNING];
+    if (!running?.trackTimers || typeof handler !== "function") {
+      return (originals.setInterval as unknown as TimerSetter)(handler, delay, ...args);
+    }
+
+    const pending: PendingTimer = {
+      id: undefined as unknown as ReturnType<typeof setTimeout>,
+      kind: "interval",
+      label: timerLabel("interval", handler, delay),
+      owner: running.name,
+    };
+    const id = (originals.setInterval as unknown as TimerSetter)(
+      (...callbackArgs: unknown[]) => {
+        if (root[RUNNING]?.name !== pending.owner) throw strayTimerError(pending);
+        handler(...callbackArgs);
+      },
+      delay,
+      ...args,
+    );
+    pending.id = id;
+    running.timers.set(id, pending);
+    return id;
+  }) as typeof globalThis.setInterval;
+
+  root.clearTimeout = ((id?: ReturnType<typeof setTimeout>) => {
+    root[RUNNING]?.timers.delete(id as ReturnType<typeof setTimeout>);
+    return originals.clearTimeout(id);
+  }) as typeof globalThis.clearTimeout;
+  root.clearInterval = ((id?: ReturnType<typeof setInterval>) => {
+    root[RUNNING]?.timers.delete(id as ReturnType<typeof setTimeout>);
+    return originals.clearInterval(id);
+  }) as typeof globalThis.clearInterval;
+}
+
+function poolWorker(): string {
+  const root = diagnosticGlobal();
+  const poolId = root.__vitest_worker__?.ctx?.poolId ?? root.process?.env?.VITEST_POOL_ID;
+  const workerId = root.__vitest_worker__?.ctx?.workerId ?? root.process?.env?.VITEST_WORKER_ID;
+  return `pool ${poolId ?? "unknown"} / worker ${workerId ?? "unknown"}`;
+}
+
+function pendingTimerLabels(running: RunningTest): string[] {
+  running.trackTimers = false;
+  return [...running.timers.values()].map((timer) => timer.label);
+}
+
+function clearPendingTimers(running: RunningTest): void {
+  const originals = diagnosticGlobal()[TIMER_ORIGINALS];
+  if (!originals) return;
+  for (const timer of running.timers.values()) {
+    if (timer.kind === "interval") originals.clearInterval(timer.id);
+    else originals.clearTimeout(timer.id);
+  }
+  running.timers.clear();
+}
+
+function testName(context: TestContext): string {
+  return context.task.fullTestName || context.task.name;
+}
+
+export function installMemoryTestDiagnostics(): void {
+  installUnhandledRejectionTrap();
+  installTimerTrap();
+
+  beforeEach((context) => {
+    diagnosticGlobal()[RUNNING] = { name: testName(context), trackTimers: true, timers: new Map() };
+    beginBackgroundTaskDiagnostics();
+  });
+
+  afterEach((context) => {
+    const root = diagnosticGlobal();
+    const running = root[RUNNING] ?? { name: testName(context), trackTimers: false, timers: new Map() };
+    const background = backgroundTaskDiagnostics();
+    const timers = pendingTimerLabels(running);
+    const annotation: MemoryTestAnnotation = {
+      poolWorker: poolWorker(),
+      ...background,
+      pendingTimers: timers,
+    };
+
+    const problems: Error[] = [];
+    try {
+      assertNoPendingBackgroundTasks();
+    } catch (error) {
+      problems.push(error instanceof Error ? error : new Error(String(error)));
+    }
+    if (timers.length > 0) {
+      problems.push(new Error(`test ended with ${timers.length} pending timer(s): ${timers.join(", ")}`));
+    }
+
+    (context.task.meta as Record<string, unknown>)[MEMORY_DIAGNOSTICS_ANNOTATION] = annotation;
+    clearPendingTimers(running);
+    endBackgroundTaskDiagnostics();
+    delete root[RUNNING];
+
+    if (problems.length === 1) throw problems[0];
+    if (problems.length > 1) throw new AggregateError(problems, "test ended with pending asynchronous work");
+  });
+}

package/dist/assets/deploy/cloudflare-memory/testDiagnosticsProtocol.ts

@@ -0,0 +1,22 @@
+export const MEMORY_DIAGNOSTICS_ANNOTATION = "memory-worker-diagnostics";
+
+export interface MemoryTestAnnotation {
+  poolWorker: string;
+  registeredBackgroundTasks: string[];
+  pendingPromises: string[];
+  pendingTimers: string[];
+}
+
+export interface MemoryTestDiagnostic extends MemoryTestAnnotation {
+  test: string;
+  file: string;
+  state: "passed" | "failed" | "skipped" | "pending";
+  durationMs: number;
+  startedAt: number;
+}
+
+export interface MemoryTestDiagnosticsArtifact {
+  reason: "passed" | "failed" | "interrupted";
+  unhandledErrors: string[];
+  tests: MemoryTestDiagnostic[];
+}

package/dist/assets/deploy/cloudflare-memory/testDiagnosticsReporter.ts

@@ -0,0 +1,88 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import type { Reporter, TestRunEndReason } from "vitest/reporters";
+import {
+  MEMORY_DIAGNOSTICS_ANNOTATION,
+  type MemoryTestAnnotation,
+  type MemoryTestDiagnostic,
+  type MemoryTestDiagnosticsArtifact,
+} from "./testDiagnosticsProtocol.ts";
+
+type TestCase = Parameters<NonNullable<Reporter["onTestCaseResult"]>>[0];
+
+export interface MemoryDiagnosticsReporterOptions {
+  outputFile?: string;
+  writeLog?: (line: string) => void;
+}
+
+function annotationFor(testCase: TestCase): MemoryTestAnnotation {
+  const annotation = (testCase.meta() as Record<string, unknown>)[MEMORY_DIAGNOSTICS_ANNOTATION];
+  if (
+    typeof annotation === "object" &&
+    annotation !== null &&
+    "poolWorker" in annotation &&
+    typeof annotation.poolWorker === "string"
+  ) {
+    return annotation as MemoryTestAnnotation;
+  }
+  return {
+    poolWorker: "unknown",
+    registeredBackgroundTasks: [],
+    pendingPromises: [],
+    pendingTimers: [],
+  };
+}
+
+function errorMessage(error: { message?: string } | unknown): string {
+  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string"
+    ? error.message
+    : String(error);
+}
+
+export class MemoryDiagnosticsReporter implements Reporter {
+  readonly #outputFile: string;
+  readonly #writeLog: (line: string) => void;
+  readonly #tests: MemoryTestDiagnostic[] = [];
+
+  constructor(options: MemoryDiagnosticsReporterOptions = {}) {
+    this.#outputFile =
+      options.outputFile ??
+      process.env.MEMORY_TEST_DIAGNOSTICS_PATH ??
+      path.join(process.cwd(), "artifacts", "memory-test-diagnostics.json");
+    this.#writeLog = options.writeLog ?? ((line) => process.stdout.write(`${line}\n`));
+  }
+
+  onTestCaseResult(testCase: TestCase): void {
+    const diagnostic = testCase.diagnostic();
+    const result = testCase.result();
+    this.#tests.push({
+      test: testCase.fullName,
+      file: testCase.module.moduleId,
+      state: result.state,
+      durationMs: diagnostic?.duration ?? 0,
+      startedAt: diagnostic?.startTime ?? 0,
+      ...annotationFor(testCase),
+    });
+  }
+
+  async onTestRunEnd(
+    _testModules: Parameters<NonNullable<Reporter["onTestRunEnd"]>>[0],
+    unhandledErrors: Parameters<NonNullable<Reporter["onTestRunEnd"]>>[1],
+    reason: TestRunEndReason,
+  ): Promise<void> {
+    const artifact: MemoryTestDiagnosticsArtifact = {
+      reason,
+      unhandledErrors: unhandledErrors.map(errorMessage),
+      tests: this.#tests,
+    };
+    await mkdir(path.dirname(this.#outputFile), { recursive: true });
+    await writeFile(this.#outputFile, `${JSON.stringify(artifact, null, 2)}\n`, "utf8");
+
+    const slowest = [...this.#tests].sort((a, b) => b.durationMs - a.durationMs).slice(0, 5);
+    const summary =
+      slowest.length === 0
+        ? "no completed tests"
+        : slowest.map((test) => `${Math.round(test.durationMs)}ms ${test.test}`).join("; ");
+    this.#writeLog(`[memory diagnostics] slowest ${slowest.length}: ${summary}`);
+  }
+}

package/dist/assets/deploy/cloudflare-memory/tsconfig.json

@@ -7,11 +7,23 @@
     "module": "esnext",
     "moduleResolution": "bundler",
     "lib": ["esnext"],
-    "types": ["@cloudflare/workers-types/experimental", "@cloudflare/vitest-pool-workers/types"],
+    "types": ["@cloudflare/workers-types/experimental", "@cloudflare/vitest-pool-workers/types", "node"],
     "strict": true,
     "noEmit": true,
     "skipLibCheck": true,
     "allowImportingTsExtensions": true
   },
-  "include": ["worker.ts", "worker.test.ts", "friction.test.ts", "schedules.test.ts", "test-env.d.ts"]
+  "include": [
+    "worker.ts",
+    "worker.test.ts",
+    "schedules.test.ts",
+    "backgroundTasks.ts",
+    "backgroundTasks.test.ts",
+    "testDiagnostics.ts",
+    "testDiagnosticsProtocol.ts",
+    "testDiagnosticsReporter.ts",
+    "testSetup.ts",
+    "vitest.config.ts",
+    "test-env.d.ts"
+  ]
 }

package/dist/assets/deploy/cloudflare-memory/worker.ts

@@ -78,6 +78,7 @@ import {
   selectReclaim,
 } from "../../src/core/runLedger/decisions.ts";
 import { intakeReceiptRetentionMs, minutesToMs, PLANE } from "../../src/core/budgets.ts";
+import { holdBackgroundTask } from "./backgroundTasks.ts";
 import {
   causeOfClose,
   causeOfReclaim,
@@ -2058,7 +2059,7 @@ export class RunHistoryDO extends DurableObject<Env> {
   /** The admission ask (`POST /plane/admit`, record 0064 "The queue"): one
    *  transaction decides and writes — `admitted` reserves the thread,
    *  `queued` stores the request under the minted id. */
-  planeAdmit(
+  async planeAdmit(
     post: {
       runId: string;
       requester: string;
@@ -2070,7 +2071,7 @@ export class RunHistoryDO extends DurableObject<Env> {
       reaskMs?: number;
     },
     now: number,
-  ): PlaneAskAnswer {
+  ): Promise<PlaneAskAnswer> {
     let answer!: PlaneAskAnswer;
     this.ctx.storage.transactionSync(() => {
       if (post.reaskMs !== undefined)
@@ -2089,7 +2090,7 @@ export class RunHistoryDO extends DurableObject<Env> {
       this.applyPlaneWrites(decision.writes);
       answer = planeAskAnswerOf(decision, post.runId);
     });
-    if (answer.kind === "queued") void this.ensurePlaneReaskAlarm(now);
+    if (answer.kind === "queued") await this.settlePlaneReaskAlarmAfterCommit(now);
     console.log(
       `[plane/admit] ${post.threadKey} → ${answer.kind}${answer.kind === "queued" ? ` position ${answer.position}` : ""} (run ${post.runId})`,
     );
@@ -2152,7 +2153,10 @@ export class RunHistoryDO extends DurableObject<Env> {
 
   /** A refusal-by-name the bot met at attach or exec (`POST /plane/observe`,
    *  record 0064): an admitted run re-enters the queue at its old position. */
-  planeObserve(post: { runId: string; resident: string; refusal: string }, now: number): { reentered: boolean } {
+  async planeObserve(
+    post: { runId: string; resident: string; refusal: string },
+    now: number,
+  ): Promise<{ reentered: boolean }> {
     let reentered = false;
     this.ctx.storage.transactionSync(() => {
       const decision = decide(this.planeState(), {
@@ -2165,7 +2169,7 @@ export class RunHistoryDO extends DurableObject<Env> {
       this.applyPlaneWrites(decision.writes);
       reentered = decision.writes.length > 0;
     });
-    if (reentered) void this.ensurePlaneReaskAlarm(now);
+    if (reentered) await this.settlePlaneReaskAlarmAfterCommit(now);
     console.log(
       `[plane/observe] run ${post.runId} on ${post.resident}: ${post.refusal.slice(0, 60)} — ${reentered ? "re-entered" : "no-op"}`,
     );
@@ -2194,6 +2198,18 @@ export class RunHistoryDO extends DurableObject<Env> {
     if (set === null || set > due) await this.ctx.storage.setAlarm(due);
   }
 
+  /** Settle alarm I/O without contradicting the plane transaction that already
+   *  committed. A scheduling failure may delay a re-ask until another wake,
+   *  but returning an error would make the caller proceed or retry while the
+   *  durable queued row remains eligible for admission. */
+  private async settlePlaneReaskAlarmAfterCommit(now: number): Promise<void> {
+    try {
+      await this.ensurePlaneReaskAlarm(now);
+    } catch (err) {
+      console.error("[plane/alarm] re-ask scheduling failed after the plane state committed", err);
+    }
+  }
+
   /** The earliest instant the plane must wake at (record 0064): the
    *  earliest hosting deadline, lease end or re-ask across its rows. A due
    *  already past re-offers at the re-ask cadence, never in a hot loop, and
@@ -2372,21 +2388,24 @@ export class RunHistoryDO extends DurableObject<Env> {
 
   /** The transport's push (record 0064, "Where it lives"): committed effects
    *  are pushed to the bot Worker over the service binding, which forwards to
-   *  the container. Fire and forget — a push that fails is not retried by a
-   *  timer; the effect rides the next heartbeat or reclaim-sweep answer. */
+   *  the container. The response does not wait for this best-effort push, but
+   *  the actor does: waitUntil keeps its I/O inside this request's lifetime so
+   *  it cannot contend with an unrelated request after the caller moves on. */
   private pushPlaneEffects(effects: PlaneEffect[]): void {
     if (effects.length === 0) return;
     const bot = this.env.BOT;
     if (!bot) return;
-    void bot
-      .fetch("https://bot/plane/effects", {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          authorization: `Bearer ${this.env.MEMORY_TOKEN ?? ""}`,
-        },
-        body: JSON.stringify({ effects }),
-      })
+    const delivery = Promise.resolve()
+      .then(() =>
+        bot.fetch("https://bot/plane/effects", {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${this.env.MEMORY_TOKEN ?? ""}`,
+          },
+          body: JSON.stringify({ effects }),
+        }),
+      )
       .then((r) => {
         if (!r.ok)
           console.warn(
@@ -2398,6 +2417,7 @@ export class RunHistoryDO extends DurableObject<Env> {
           `[plane/push] ${effects.length} effect(s) not delivered: ${err instanceof Error ? err.message : String(err)} — they ride the next heartbeat`,
         );
       });
+    holdBackgroundTask(this.ctx, `plane effect push (${effects.map((effect) => effect.id).join(", ")})`, delivery);
   }
 
   /** The unacknowledged effects, oldest first, at most `PLANE_EFFECTS_PER_ANSWER`

package/dist/assets/deploy/cloudflare-resident/worker.ts

@@ -5027,11 +5027,32 @@ export class ResidentDO extends Sandbox<Env> {
    *  deploy's alone. Answers `restarted` when a stop was issued, else why
    *  not. */
   private async reconcileImage(where: "attach" | "refresh" | "deploy", force = false): Promise<ImageReconcileResult> {
-    if (!(await this.isRuntimeActive().catch(() => false))) {
-      // Inactivity proves only that the old process is gone, not that its
-      // replacement started successfully. Keep the marker: the next refresh's
-      // hydration starts the deployed image and reports only after it reaches
-      // `warm` (issue 2101).
+    const active = await this.isRuntimeActive().catch((err) => {
+      console.log(`image-reconcile (${where}): activity probe failed — preserving the pending report: ${errMsg(err)}`);
+      return null;
+    });
+    // A failed probe proves neither state. Preserve the marker and its drain
+    // hold until a later reconcile confirms inactivity or hydrates a fresh
+    // active container. An attach with that marker must fail closed even after
+    // the drain backstop reopens: admitting it could wake a pre-deploy image.
+    if (active === null) {
+      if (
+        where === "attach" &&
+        (await this.ctx.storage.get<{ resource: string }>(IMAGE_REPORT_PENDING_KEY)) !== undefined
+      ) {
+        console.log(
+          "image-stale (attach): activity could not be verified while a new-image report is pending — the attach is refused",
+        );
+        return "stale";
+      }
+      return "deferred";
+    }
+    if (!active) {
+      // An inactive container's next start is on the deployed image by
+      // construction. Report on every reconcile: the deploy may have marked
+      // it pending after an earlier idle cycle, and the drain itself refuses
+      // the attach that would otherwise wake it and provide another reporter.
+      await this.reportPendingImageCurrent(where);
       return "inactive";
     }
     const last = THREAD_USERS[THREAD_USERS.length - 1];
@@ -5091,12 +5112,13 @@ export class ResidentDO extends Sandbox<Env> {
   /** The report a held drain waits for (issue 1931): when the deploy's
    *  reconcile could not verify this resident's fresh container on the new
    *  image, a marker stays in storage and the registry holds the drain. The
-   *  fact the report stands on is the replacement's own completed hydration:
-   *  the fresh container has restored its snapshot and reached `warm`. A stop
-   *  or inactive runtime does not report; each keeps the marker for that next
-   *  start (issue 2101). The marker is deleted only after a successful report:
-   *  a transient failure keeps it for the next reconcile, and the drain's
-   *  `until` is the backstop for a report that never lands. */
+   *  fact the report stands on is either an inactive runtime, whose next start
+   *  uses the deployed image by construction, or the active replacement's own
+   *  completed hydration: the fresh container has restored its snapshot and
+   *  reached `warm`. A stop alone does not report (issue 2101). The marker is
+   *  deleted only after a successful report: a transient failure keeps it for
+   *  the next reconcile, and the drain's `until` is the backstop for a report
+   *  that never lands. */
   private async reportPendingImageCurrent(where: string): Promise<boolean> {
     const pending = await this.ctx.storage.get<{ resource: string }>(IMAGE_REPORT_PENDING_KEY);
     if (pending === undefined) return true;
@@ -5125,9 +5147,9 @@ export class ResidentDO extends Sandbox<Env> {
    *  an active, quiet container is always cycled, but that stop is not a report.
    *  The marker survives until the replacement hydrates and reaches `warm` on
    *  the deploy's image (issue 2101: the old probe raced that restore and lost).
-   *  `verified` true is the fact the reopen may stand on; a cycle or inactive
-   *  result leaves a hold on the drain, cleared by this resident's later
-   *  `reportPendingImageCurrent`, never by a timer.
+   *  `verified` true is the fact the reopen may stand on: inactivity reports
+   *  at once, while an active container's cycle leaves a hold until its fresh
+   *  hydration calls `reportPendingImageCurrent`, never until a timer.
    *
    *  The hold lands BEFORE the marker: the marker is what lets any concurrent
    *  attach/refresh reconcile report, and a report that reaches the registry
@@ -5139,10 +5161,9 @@ export class ResidentDO extends Sandbox<Env> {
     await this.ctx.storage.put(IMAGE_REPORT_PENDING_KEY, { resource });
     const result = await this.reconcileImage("deploy", true);
     if (result === "deferred") return { result, verified: false };
-    // Neither inactivity nor a successful stop is verification: only the
-    // replacement's completed hydration clears the marker. A concurrent fresh
-    // start may have done so while this reconcile yielded, hence the storage
-    // read rather than an unconditional false.
+    // Inactivity reports synchronously; a successful stop does not. A
+    // concurrent fresh start may also have hydrated while this reconcile
+    // yielded, hence the storage read rather than a verdict from `result`.
     const verified = (await this.ctx.storage.get(IMAGE_REPORT_PENDING_KEY)) === undefined;
     return { result, verified };
   }