talon-agent 3.33.4 → 3.34.0

package/src/core/background/cron-spec.ts

@@ -0,0 +1,273 @@
+/**
+ * The schedule half of a cron job — cadence, lifecycle bounds, run cap,
+ * catch-up policy, and the query overrides — parsed and validated once for
+ * both `create_cron_job` and `edit_cron_job`.
+ *
+ * The two actions read the same body fields but with different absence
+ * semantics: on create an absent field takes its default, on edit an absent
+ * field is left alone and a blank one (`null` / `""`) clears the stored
+ * value. `parseCronSpec` folds both into one pass: pass `existing` to parse
+ * as an edit. Cross-field rules (end after start, provider needs model,
+ * overrides only on query jobs) are checked against the *effective* job —
+ * the merge of what's stored and what's changing — so a partial edit is
+ * judged on the job it produces, not the fields it touches.
+ */
+
+import {
+  validateCronExpression,
+  type CatchupPolicy,
+  type CronJob,
+  type CronJobType,
+} from "../../storage/cron-store.js";
+
+/** The scheduler ticks once a minute, so sub-minute intervals are meaningless. */
+const MIN_INTERVAL_SECONDS = 60;
+const MAX_CONTENT_LENGTH = 10_000;
+const CATCHUP_POLICIES = new Set<CatchupPolicy>(["skip", "once", "all"]);
+
+/** The job fields the spec covers; everything else is identity or telemetry. */
+type CronSpec = Pick<CronJob, "name" | "type" | "content" | "catchup"> &
+  Partial<
+    Pick<
+      CronJob,
+      | "enabled"
+      | "timezone"
+      | "schedule"
+      | "everyMs"
+      | "startAt"
+      | "endAt"
+      | "maxRuns"
+      | "model"
+      | "provider"
+      | "instructions"
+    >
+  >;
+
+/**
+ * The fields an edit touches, in body order. A key present with value
+ * `undefined` clears that field (`updateCronJob` has Object.assign
+ * semantics), so key *presence* is the signal — not truthiness.
+ */
+type CronSpecUpdates = Partial<CronSpec>;
+
+export type ParsedCronSpec =
+  | {
+      ok: true;
+      /** What to write: the full spec on create, the touched fields on edit. */
+      updates: CronSpecUpdates;
+      /** The job as it will be after the write — what the cross-field rules saw. */
+      effective: CronSpec;
+    }
+  | { ok: false; error: string };
+
+/** True for a body field that was actually supplied (not absent/blank). */
+function provided(v: unknown): boolean {
+  return v !== undefined && v !== null && v !== "";
+}
+
+/**
+ * Parse an instant given as an ISO-8601 string or epoch-ms number into epoch
+ * ms. Returns undefined when the field is absent or unparseable — callers
+ * distinguish the two via `provided()`.
+ */
+function parseInstant(v: unknown): number | undefined {
+  if (!provided(v)) return undefined;
+  if (typeof v === "number") return Number.isFinite(v) ? v : undefined;
+  const s = String(v).trim();
+  if (/^\d+$/.test(s)) return Number(s);
+  const d = Date.parse(s);
+  return Number.isFinite(d) ? d : undefined;
+}
+
+/** What one parse pass works on; each section parser fills `updates`. */
+type Parse = {
+  body: Record<string, unknown>;
+  existing: CronJob | undefined;
+  editing: boolean;
+  /** On create a blank is absent; on edit it is a request to clear. */
+  touched: (key: string) => boolean;
+  updates: CronSpecUpdates;
+};
+
+/** A section parser returns an error message, or null when its fields are fine. */
+type Section = (p: Parse) => string | null;
+
+/**
+ * The job the write produces. On create `updates` is the whole spec (name,
+ * type, content and catchup are always filled in), so the cast only papers
+ * over what the parse order already guarantees.
+ */
+const merge = (p: Parse) => ({ ...p.existing, ...p.updates }) as CronSpec;
+
+const parsePayload: Section = ({ body, editing, touched, updates }) => {
+  if (editing) {
+    if (touched("name")) updates.name = String(body.name);
+    if (touched("content")) updates.content = String(body.content);
+    if (touched("enabled")) updates.enabled = Boolean(body.enabled);
+    if (touched("type")) updates.type = String(body.type) as CronJobType;
+  } else {
+    updates.name = String(body.name ?? "Unnamed job");
+    updates.type = (body.type as CronJobType) ?? "message";
+    updates.content = String(body.content ?? "");
+    if (!updates.content) return "Missing content";
+    if (updates.content.length > MAX_CONTENT_LENGTH)
+      return "Content too long (max 10,000 chars)";
+  }
+  if (touched("timezone"))
+    updates.timezone = body.timezone ? String(body.timezone) : undefined;
+  return null;
+};
+
+/**
+ * Exactly one of `schedule` (cron expression) or `every_seconds` (fixed
+ * interval). On edit, setting one switches mode and clears the other.
+ */
+const parseCadence: Section = ({
+  body,
+  existing,
+  editing,
+  touched,
+  updates,
+}) => {
+  const schedule = provided(body.schedule) ? String(body.schedule) : undefined;
+  const hasEvery = provided(body.every_seconds);
+  if (!editing && !schedule && !hasEvery)
+    return "Provide either 'schedule' (a cron expression) or 'every_seconds' (a fixed interval).";
+  if (schedule && hasEvery)
+    return "Provide only one of 'schedule' or 'every_seconds', not both.";
+  if (schedule) {
+    const timezone = touched("timezone")
+      ? updates.timezone
+      : existing?.timezone;
+    const validation = validateCronExpression(schedule, timezone);
+    if (!validation.valid)
+      return `Invalid cron expression: ${validation.error}`;
+    updates.schedule = schedule;
+    if (editing) updates.everyMs = undefined;
+  }
+  if (hasEvery) {
+    const everySeconds = Number(body.every_seconds);
+    if (!Number.isFinite(everySeconds) || everySeconds < MIN_INTERVAL_SECONDS)
+      return `'every_seconds' must be a number >= ${MIN_INTERVAL_SECONDS}${
+        editing ? "" : " (the scheduler ticks once a minute)"
+      }.`;
+    updates.everyMs = Math.round(everySeconds * 1000);
+    if (editing) updates.schedule = undefined;
+  }
+  return null;
+};
+
+/** Lifecycle bounds; on edit pass null/"" to clear one. */
+const parseBounds: Section = (p) => {
+  const { body, editing, touched, updates } = p;
+  const hint = editing ? "" : " (use an ISO-8601 timestamp or epoch ms)";
+  if (touched("start_at")) {
+    const startAt = parseInstant(body.start_at);
+    if (provided(body.start_at) && startAt === undefined)
+      return `Could not parse 'start_at'${hint}.`;
+    updates.startAt = startAt;
+  }
+  if (touched("end_at")) {
+    const endAt = parseInstant(body.end_at);
+    if (provided(body.end_at) && endAt === undefined)
+      return `Could not parse 'end_at'${hint}.`;
+    updates.endAt = endAt;
+  }
+  const { startAt, endAt } = merge(p);
+  if (startAt !== undefined && endAt !== undefined && endAt <= startAt)
+    return "'end_at' must be after 'start_at'.";
+  if (updates.endAt !== undefined && updates.endAt <= Date.now())
+    return "'end_at' is in the past — the job would never run.";
+  return null;
+};
+
+/** Run cap. `once: true` is sugar for max_runs = 1 (one-shot). */
+const parseRunCap: Section = ({ body, touched, updates }) => {
+  if (body.once === true) {
+    updates.maxRuns = 1;
+    return null;
+  }
+  if (!touched("max_runs")) return null;
+  if (!provided(body.max_runs)) {
+    updates.maxRuns = undefined;
+    return null;
+  }
+  const m = Number(body.max_runs);
+  if (!Number.isInteger(m) || m < 1)
+    return "'max_runs' must be a positive integer.";
+  updates.maxRuns = m;
+  return null;
+};
+
+/**
+ * Missed-run catch-up policy. New jobs default to "once": a run that came
+ * due while Talon was down (or while the scheduler was wedged) replays a
+ * single time at startup instead of being lost silently — a live audit
+ * found one-shot reminders that missed their date under the old "skip"
+ * default and quietly rolled over a full year. Explicit "skip" remains
+ * available for jobs where a late run is worthless.
+ */
+const parseCatchup: Section = ({ body, editing, touched, updates }) => {
+  if (!touched("catchup")) {
+    if (!editing) updates.catchup = "once";
+    return null;
+  }
+  const catchup = String(body.catchup) as CatchupPolicy;
+  if (!CATCHUP_POLICIES.has(catchup))
+    return "'catchup' must be one of: skip, once, all.";
+  updates.catchup = catchup;
+  return null;
+};
+
+/**
+ * Model / provider / instructions only make sense for "query" jobs (a
+ * "message" job just sends text — no model runs), and a provider override
+ * needs a model to pick on it.
+ */
+const parseOverrides: Section = (p) => {
+  const { body, touched, updates } = p;
+  for (const key of ["model", "provider", "instructions"] as const) {
+    if (touched(key))
+      updates[key] = provided(body[key]) ? String(body[key]) : undefined;
+  }
+  const { type, model, provider, instructions } = merge(p);
+  if (type !== "query" && (model || provider || instructions))
+    return "Model/provider/instructions only apply to 'query' jobs.";
+  if (provider && !model)
+    return "A 'provider' override also requires a 'model'.";
+  return null;
+};
+
+const SECTIONS: Section[] = [
+  parsePayload,
+  parseCadence,
+  parseBounds,
+  parseRunCap,
+  parseCatchup,
+  parseOverrides,
+];
+
+/**
+ * Validate a create/edit body's schedule fields and normalise them into job
+ * fields. Without `existing` this is a create: cadence is required, blanks
+ * are absent, defaults fill in. With `existing` it is an edit of that job:
+ * only supplied fields are emitted, blanks clear.
+ */
+export function parseCronSpec(
+  body: Record<string, unknown>,
+  existing?: CronJob,
+): ParsedCronSpec {
+  const editing = existing !== undefined;
+  const p: Parse = {
+    body,
+    existing,
+    editing,
+    touched: (key) => (editing ? body[key] !== undefined : provided(body[key])),
+    updates: {},
+  };
+  for (const section of SECTIONS) {
+    const error = section(p);
+    if (error) return { ok: false, error };
+  }
+  return { ok: true, updates: p.updates, effective: merge(p) };
+}

package/src/core/background/heartbeat/agent.ts

@@ -12,7 +12,8 @@ import { toYMD } from "../../../util/time.js";
 import { getDefaultModel } from "../../models/catalog.js";
 import { loadSystemTemplate } from "../../prompt/templates.js";
 import { formatGoal, getOpenGoals } from "../../../storage/goal-store.js";
-import { taskTable } from "../../tasks/index.js";
+import { taskTable, type TaskHandle } from "../../tasks/index.js";
+import type { Backend } from "../../agent-runtime/capabilities.js";
 import type { OneShotAgentParams } from "../../types.js";
 import { resolveBackgroundEffort } from "../effort.js";
 import { hb } from "./state.js";
@@ -102,29 +103,25 @@ function renderGoalsBlock(): { text: string; count: number } {
   return { text, count };
 }
 
-export async function runHeartbeatAgent(
-  lastRunTimestamp: number,
-  runCount: number,
-): Promise<string> {
-  const config = hb.config;
-  if (!config) {
-    throw new Error("Heartbeat agent not initialized");
-  }
+/** Everything the seeded heartbeat.md template interpolates. */
+type HeartbeatPromptInputs = {
+  lastRunIso: string;
+  runCount: number;
+  workspace: string;
+  logsDir: string;
+  memoryFile: string;
+  instructionsFile: string;
+  dailyMemoryFile: string;
+};
 
-  const lastRunIso =
-    lastRunTimestamp > 0 ? new Date(lastRunTimestamp).toISOString() : "never";
-
-  const logsDir = dirs.logs;
-  const memoryFile = pathFiles.memory;
-  const workspace = config.workspace ?? dirs.workspace;
-  const instructionsFile = resolve(workspace, "heartbeat-instructions.md");
-  const dailyMemoryFile = resolve(dirs.dailyMemory, `${toYMD(new Date())}.md`);
-
-  // Load prompt template from the prompts directory (seeded to ~/.talon/prompts/)
+/**
+ * Load the user's heartbeat.md (seeded to ~/.talon/prompts/) and fill its
+ * placeholders. Seeded copies are never rewritten once the user owns them,
+ * so two older vintages get their missing sections appended instead.
+ */
+function renderHeartbeatPrompt(inputs: HeartbeatPromptInputs): string {
   const promptPath = resolve(dirs.prompts, "heartbeat.md");
-
   const goalsBlock = renderGoalsBlock();
-
   let prompt: string;
   let hadGoalsVar: boolean;
   let hadStateVar: boolean;
@@ -133,14 +130,14 @@ export async function runHeartbeatAgent(
     hadGoalsVar = raw.includes("{{goals}}");
     hadStateVar = raw.includes("{{stateFile}}");
     prompt = raw
-      .replace(/\{\{workspace\}\}/g, workspace)
-      .replace(/\{\{logsDir\}\}/g, logsDir)
-      .replace(/\{\{lastRunIso\}\}/g, lastRunIso)
-      .replace(/\{\{memoryFile\}\}/g, memoryFile)
+      .replace(/\{\{workspace\}\}/g, inputs.workspace)
+      .replace(/\{\{logsDir\}\}/g, inputs.logsDir)
+      .replace(/\{\{lastRunIso\}\}/g, inputs.lastRunIso)
+      .replace(/\{\{memoryFile\}\}/g, inputs.memoryFile)
       .replace(/\{\{stateFile\}\}/g, pathFiles.state)
-      .replace(/\{\{instructionsFile\}\}/g, instructionsFile)
-      .replace(/\{\{dailyMemoryFile\}\}/g, dailyMemoryFile)
-      .replace(/\{\{runCount\}\}/g, String(runCount))
+      .replace(/\{\{instructionsFile\}\}/g, inputs.instructionsFile)
+      .replace(/\{\{dailyMemoryFile\}\}/g, inputs.dailyMemoryFile)
+      .replace(/\{\{runCount\}\}/g, String(inputs.runCount))
       .replace(/\{\{intervalMinutes\}\}/g, String(hb.intervalMinutesRef))
       .replace(/\{\{goals\}\}/g, goalsBlock.text);
   } catch {
@@ -161,8 +158,6 @@ export async function runHeartbeatAgent(
   // Same vintage problem for the memory/state split: a seeded heartbeat.md
   // from before it still instructs the agent to write memory.md, which is
   // how status snapshots accreted in the durable store in the first place.
-  // Append the ownership rules so the split holds regardless of template
-  // vintage — the seeded copy is never rewritten once the user owns it.
   if (!hadStateVar) {
     logWarn(
       "heartbeat",
@@ -172,33 +167,20 @@ export async function runHeartbeatAgent(
     prompt += `\n\n${loadSystemTemplate("heartbeat-agent", {
       mode: "state-fallback",
       stateFile: pathFiles.state,
-      memoryFile,
+      memoryFile: inputs.memoryFile,
     }).trim()}`;
   }
+  return prompt;
+}
 
-  const model = config.heartbeatModel ?? config.model ?? getDefaultModel();
-
-  const backend = config.getBackend?.() ?? null;
-  const background = backend?.background;
-  if (!background) {
-    throw new Error(
-      "Heartbeat requires a backend that implements the background capability",
-    );
-  }
-
-  // Effort is resolved against the heartbeat backend's catalog, not just
-  // copied from config — a level the model doesn't offer is dropped with a
-  // reason rather than handed to the SDK.
-  const effort = await resolveBackgroundEffort({
-    requested: config.heartbeatEffort,
-    model,
-    backend,
-  });
-  if (effort.dropped) {
-    logWarn("heartbeat", effort.dropped);
-  }
-
-  // Set up heartbeat log file
+/** Create this run's log file and write its header; returns the path. */
+async function openHeartbeatLog(
+  runCount: number,
+  lastRunIso: string,
+  model: string,
+  effort: { effort?: string; dropped?: string },
+  prompt: string,
+): Promise<string> {
   const heartbeatLogFile = await createHeartbeatLogFile();
   await appendHeartbeatLog(
     heartbeatLogFile,
@@ -219,32 +201,23 @@ export async function runHeartbeatAgent(
     heartbeatLogFile,
     `**Prompt:**\n\`\`\`\n${prompt}\n\`\`\`\n\n---\n`,
   );
+  return heartbeatLogFile;
+}
 
-  // AbortController is the canonical way to signal a cancellation to a backend.
-  // .abort() should tear down any spawned subprocess (Claude SDK) or stop
-  // streaming (Kilo/OpenCode). We defend against backends that ignore it — see
-  // heartbeatAbortGraceMs below.
-  const abortController = new AbortController();
-
-  const task = taskTable.begin({
-    kind: "heartbeat",
-    label: `#${runCount}`,
-    abort: () => abortController.abort(),
-  });
-  task.bind({ model });
-
-  const oneShotParams: OneShotAgentParams = {
-    prompt,
-    systemPrompt: buildHeartbeatSystemPrompt(),
-    workspace,
-    model,
-    ...(effort.effort ? { reasoningEffort: effort.effort } : {}),
-    contextLabel: "heartbeat",
-    abortController,
-    appendLog: (text) => appendHeartbeatLog(heartbeatLogFile, text),
-  };
-
-  // Timeout that requests eviction (graceful first, force-kill on grace exit).
+/**
+ * Run the one-shot agent under the heartbeat's soft timeout. On timeout the
+ * abort signal goes out, the backend gets a bounded grace window to clean
+ * up, and a backend that ignores it is asked to evict its orphans; either
+ * way the error propagates so the caller releases the lock.
+ */
+async function runOneShotWithTimeout(
+  background: NonNullable<Backend["background"]>,
+  params: OneShotAgentParams,
+  abortController: AbortController,
+  task: TaskHandle,
+  runCount: number,
+  heartbeatLogFile: string,
+): Promise<Awaited<ReturnType<typeof background.runOneShotAgent>>> {
   let timeoutFired = false;
   let timeoutHandle: ReturnType<typeof setTimeout> | null = null;
   const timeoutPromise = new Promise<never>((_, reject) => {
@@ -262,7 +235,7 @@ export async function runHeartbeatAgent(
   });
 
   const agentPromise = (async () => {
-    const usage = await background.runOneShotAgent(oneShotParams);
+    const usage = await background.runOneShotAgent(params);
     await appendHeartbeatLog(
       heartbeatLogFile,
       `\n---\n**Heartbeat #${runCount} completed at ${new Date().toISOString()}**\n`,
@@ -270,9 +243,8 @@ export async function runHeartbeatAgent(
     return usage;
   })();
 
-  let usage: Awaited<typeof agentPromise>;
   try {
-    usage = await Promise.race([agentPromise, timeoutPromise]);
+    return await Promise.race([agentPromise, timeoutPromise]);
   } catch (err) {
     // Snapshot timeout state and clear the timer immediately, BEFORE any awaits
     // in the error-handling path. Otherwise the timer can fire during the async
@@ -289,28 +261,7 @@ export async function runHeartbeatAgent(
       `\n---\n**Heartbeat #${runCount} FAILED at ${new Date().toISOString()}:** ${err}\n`,
     );
     if (wasTimeout) {
-      // Give the backend a bounded grace window to clean up after the abort
-      // signal — but never wait indefinitely. If the backend ignores the abort,
-      // release the lock anyway and ask it to evict any orphan subprocesses.
-      const settled = await raceWithTimeout(
-        agentPromise.catch(() => "settled"),
-        heartbeatAbortGraceMs(),
-      );
-      if (settled === "timed_out") {
-        logWarn(
-          "heartbeat",
-          `Heartbeat #${runCount} backend ignored abort after ${heartbeatAbortGraceMs()}ms — releasing lock and evicting orphan subprocesses`,
-        );
-        // Fire-and-forget — we don't block the next heartbeat on subprocess
-        // cleanup. Backends that don't spawn per-run subprocesses leave
-        // evictOrphanSubprocesses unimplemented; that's fine.
-        const evict = background.evictOrphanSubprocesses;
-        if (evict) {
-          evict("heartbeat").catch((sweepErr: unknown) => {
-            logError("heartbeat", "Orphan subprocess sweep failed", sweepErr);
-          });
-        }
-      }
+      await evictAfterIgnoredAbort(background, agentPromise, runCount);
     } else {
       // Non-timeout failure path — agentPromise has already settled.
       await agentPromise.catch(() => {});
@@ -321,7 +272,119 @@ export async function runHeartbeatAgent(
     // resolution of Promise.race() needs this too.
     if (timeoutHandle) clearTimeout(timeoutHandle);
   }
+}
 
+/**
+ * Give the backend a bounded grace window to clean up after the abort
+ * signal — but never wait indefinitely. If the backend ignores the abort,
+ * release the lock anyway and ask it to evict any orphan subprocesses.
+ */
+async function evictAfterIgnoredAbort(
+  background: NonNullable<Backend["background"]>,
+  agentPromise: Promise<unknown>,
+  runCount: number,
+): Promise<void> {
+  const settled = await raceWithTimeout(
+    agentPromise.catch(() => "settled"),
+    heartbeatAbortGraceMs(),
+  );
+  if (settled !== "timed_out") return;
+  logWarn(
+    "heartbeat",
+    `Heartbeat #${runCount} backend ignored abort after ${heartbeatAbortGraceMs()}ms — releasing lock and evicting orphan subprocesses`,
+  );
+  // Fire-and-forget — we don't block the next heartbeat on subprocess
+  // cleanup. Backends that don't spawn per-run subprocesses leave
+  // evictOrphanSubprocesses unimplemented; that's fine.
+  const evict = background.evictOrphanSubprocesses;
+  if (evict) {
+    evict("heartbeat").catch((sweepErr: unknown) => {
+      logError("heartbeat", "Orphan subprocess sweep failed", sweepErr);
+    });
+  }
+}
+
+export async function runHeartbeatAgent(
+  lastRunTimestamp: number,
+  runCount: number,
+): Promise<string> {
+  const config = hb.config;
+  if (!config) {
+    throw new Error("Heartbeat agent not initialized");
+  }
+
+  const lastRunIso =
+    lastRunTimestamp > 0 ? new Date(lastRunTimestamp).toISOString() : "never";
+  const workspace = config.workspace ?? dirs.workspace;
+  const memoryFile = pathFiles.memory;
+  const prompt = renderHeartbeatPrompt({
+    lastRunIso,
+    runCount,
+    workspace,
+    logsDir: dirs.logs,
+    memoryFile,
+    instructionsFile: resolve(workspace, "heartbeat-instructions.md"),
+    dailyMemoryFile: resolve(dirs.dailyMemory, `${toYMD(new Date())}.md`),
+  });
+
+  const model = config.heartbeatModel ?? config.model ?? getDefaultModel();
+  const backend = config.getBackend?.() ?? null;
+  const background = backend?.background;
+  if (!background) {
+    throw new Error(
+      "Heartbeat requires a backend that implements the background capability",
+    );
+  }
+
+  // Effort is resolved against the heartbeat backend's catalog, not just
+  // copied from config — a level the model doesn't offer is dropped with a
+  // reason rather than handed to the SDK.
+  const effort = await resolveBackgroundEffort({
+    requested: config.heartbeatEffort,
+    model,
+    backend,
+  });
+  if (effort.dropped) {
+    logWarn("heartbeat", effort.dropped);
+  }
+
+  const heartbeatLogFile = await openHeartbeatLog(
+    runCount,
+    lastRunIso,
+    model,
+    effort,
+    prompt,
+  );
+
+  // AbortController is the canonical way to signal a cancellation to a backend.
+  // .abort() should tear down any spawned subprocess (Claude SDK) or stop
+  // streaming (Kilo/OpenCode). We defend against backends that ignore it — see
+  // heartbeatAbortGraceMs.
+  const abortController = new AbortController();
+  const task = taskTable.begin({
+    kind: "heartbeat",
+    label: `#${runCount}`,
+    abort: () => abortController.abort(),
+  });
+  task.bind({ model });
+
+  const usage = await runOneShotWithTimeout(
+    background,
+    {
+      prompt,
+      systemPrompt: buildHeartbeatSystemPrompt(),
+      workspace,
+      model,
+      ...(effort.effort ? { reasoningEffort: effort.effort } : {}),
+      contextLabel: "heartbeat",
+      abortController,
+      appendLog: (text) => appendHeartbeatLog(heartbeatLogFile, text),
+    },
+    abortController,
+    task,
+    runCount,
+    heartbeatLogFile,
+  );
   task.succeed(usage ?? undefined);
   return heartbeatLogFile;
 }

package/src/core/engine/backend-controller/pool.ts

@@ -14,6 +14,7 @@ import { log, logWarn } from "../../../util/log.js";
 import { roleHolder } from "./holders.js";
 import {
   pool,
+  initInFlight,
   bindings,
   listeners,
   ctx,
@@ -285,6 +286,7 @@ export async function cleanupBackendPool(): Promise<void> {
 /** Test-only state reset. */
 export function resetBackendPoolForTest(): void {
   pool.clear();
+  initInFlight.clear();
   bindings.clear();
   ctx.initCtx = null;
   ctx.poolConfig = null;