@humwick/server 0.130.2 → 0.130.3

package/src/secrets-broker/config.ts

@@ -9,7 +9,7 @@ import { envFilePath } from "@humwick/sdk/child-env";
 export const SECRETS_TOOL_GROUP = "secrets";
 export const SECRETS_WRITE_SCOPE = "secrets:write";
 /** Built-in profiles whose default full surface includes the secrets group. */
-export const SECRETS_DEFAULT_PROFILES: ReadonlySet<string> = new Set(["coordinator", "ops-assistant"]);
+export const SECRETS_DEFAULT_PROFILES: ReadonlySet<string> = new Set(["coordinator"]);
 
 export const UPLOAD_LINK_TTL_MS = 15 * 60_000;
 export const SECRET_UPLOAD_PATH_PREFIX = "/api/secrets/upload/";

package/src/secrets-broker/service.ts

@@ -27,13 +27,13 @@ let client: InfisicalBrokerClient | undefined;
 
 function brokerClient(): InfisicalBrokerClient {
   client ??= new InfisicalBrokerClient(secretsBrokerSettings(), {
-    onLoginBlocked: (detail) => raiseOperatorAlarm({
+    onLoginBlocked: async (detail) => (await raiseOperatorAlarm({
       clientId: "secrets-broker:login-blocked",
       source: "secrets-broker",
       subject: "Secrets broker login blocked",
       detail: `${detail}. Fix the cause, then rotate or touch the credential files to re-arm.`,
       dedupeEvent: true,
-    }),
+    })),
   });
   return client;
 }

package/src/security.ts

@@ -1,3 +1,4 @@
+import { retireHandedOffPredecessor, tokenRetirementPending } from "./db/token-standing-async";
 import { BRIDGED_CORS_HEADERS, relayHeader } from "@humwick/sdk";
 import { versionedPromptsEnabled } from "./versioned-prompts";
 import { serviceAccessRouteScope } from "./service-access/scope";
@@ -242,6 +243,7 @@ const SHARED_UI_ROUTE_SCOPES: Record<string, string> = {
   "/api/metrics/hub": "stats:read",
   "/api/shipping/board": "stats:read",
   "/api/shipping/stats": "stats:read",
+  "/api/shipping/known-failures": "agent:read", // #3362 §11: read by builders' delivery gates
   "/api/stats/token-usage": "stats:read",
   // #3567 — every signed-in user reads their profile and sets their password (the handler requires a session or the admin token).
   "/api/users/me": "agent:read",
@@ -539,7 +541,7 @@ export function verifyComponentToken(token: string, nowSeconds = Math.floor(Date
   const payload = parseBase64urlJson(payloadRaw);
   if (!isComponentToken(payload)) return null;
   if (payload.exp !== undefined && payload.exp <= nowSeconds) return null;
-  if (payload.jti && isTokenRevoked(payload.jti)) return null;
+  if (payload.jti && (tokenRetirementPending(payload.jti) || isTokenRevoked(payload.jti, retireHandedOffPredecessor))) return null;
   return payload;
 }
 

package/src/self-resume-carry.ts

@@ -1,69 +1,35 @@
 import { errMessage, isRecord, stringValue } from "@humwick/sdk";
-import {
-  attachRecoveryCommand, carryingRecoveryObligations, closeRecoveryObligations, getAgent, insertContextReset, openRecoveryObligation, readsToCarry,
-  sendMessageWithResult, writeTransaction, type ContextResetFact, type RecoveryObligation,
-} from "./db";
+import { getAgent } from "./db";
+import type { ContextResetFact } from "./db/context-reset-carry";
+import { commandBoundary } from "./db/context-carry-write";
+import { getGateway } from "./db/gateway";
+import type { SendMessageResult } from "./db/messages";
 import { emitCommandEvent } from "./command-events";
 import { createSelfRestartCommandAsync } from "./services/restart-spawn";
-import { isContinuationSelfResumeCommand } from "./self-resume-command";
 import { emitNewMessage } from "./sse";
 import type { Command, Message } from "./types";
 
-// #3398 (docs/design/self-resume-carry.md) — the one owner of self-resume recovery. An accepted boundary
-// opens an obligation; every provider reset fact after the first capture sends the agent one unread
-// "Possible unread messages" list. At least once: a listed message may already be handled.
-
-const LISTED_IDS = 200;
-// The loss #3398 fixes is reads in the minutes before the self-care call or during it (#3523); earlier ones are in the saved state.
-const CARRY_MARGIN_MS = 10 * 60_000;
-// A failed or swept command proves nothing about its destructive input, so its list is only a fallback.
-const FALLBACK_STATUSES: ReadonlySet<Command["status"]> = new Set(["failed", "canceled", "timed_out", "rejected"]);
-
-/** Opens the obligation at accept, before the boundary command exists. */
-export function openContextRecovery(agentId: string, generation: number, now: number): void {
-  openRecoveryObligation(agentId, generation, now);
+export async function openContextRecovery(agentId: string, generation: number, now: number): Promise<void> {
+  await getGateway().write("contextCarry.open", { agentId, generation, now });
 }
-
-export function attachContextRecoveryCommand(agentId: string, generation: number, commandId: string): void {
-  attachRecoveryCommand(agentId, generation, commandId);
+export async function attachContextRecoveryCommand(agentId: string, generation: number, commandId: string): Promise<void> {
+  await getGateway().write("contextCarry.attach", { agentId, generation, commandId });
 }
-
-/** Ingests one reset fact. Idempotent per reset id; returns the list it sent, if any. */
-export function recordContextReset(fact: ContextResetFact): Message | null {
-  const now = Date.now();
-  return sendAndEmit(() => {
-    if (!insertContextReset(fact, now)) return null;
-    const carrying = carryingRecoveryObligations(fact.agentId);
-    if (!carrying.length) return null;
-    const result = sendCarry(fact.agentId, carrying, `${fact.resetId}:0`, { resetId: fact.resetId, kind: fact.kind });
-    closeRecoveryObligations(fact.agentId, settledBy(fact, carrying), `reset:${fact.resetId}`, now);
-    return result;
-  });
+export async function recordContextReset(fact: ContextResetFact): Promise<Message | null> {
+  return emitCarry(await getGateway().write("contextCarry.reset", { fact }) as unknown as SendMessageResult | null);
 }
-
-/**
- * Terminal-command hook (bus, HTTP and the lease sweep): a failed boundary still sends a list now, and
- * stays open. One whose destructive input reached the provider unsettled is replaced by a fresh process.
- */
-export function settleContextResetCarry(command: Command): Message | null {
-  const boundary = FALLBACK_STATUSES.has(command.status) ? commandBoundary(command) : null;
-  if (!boundary) return null;
-  const message = sendAndEmit(() => {
-    const carrying = carryingRecoveryObligations(boundary.agentId);
-    if (!carrying.some((obligation) => obligation.open && obligation.generation === boundary.generation)) return null;
-    const sent = sendCarry(boundary.agentId, carrying, `${command.id}:fallback`, { boundaryCommandId: command.id, status: command.status });
-    // The runner aborted before any destructive input reached the provider: no reset can follow, so nothing is owed (#3441).
-    if (isRecord(command.result) && command.result.destructiveInputSubmitted === false) {
-      closeRecoveryObligations(boundary.agentId, [boundary.generation], `submit-aborted:${command.id}`, Date.now());
-    }
-    return sent;
-  });
-  if (command.status === "failed" && isRecord(command.result) && command.result.destructiveInputUnsettled === true) {
-    void replaceUnsettledBoundary(command, boundary).catch((error) => console.error(`#3398 self-restart after unsettled ${command.type} ${command.id} failed: ${errMessage(error)}`));
+export async function settleContextResetCarry(command: Command): Promise<Message | null> {
+  const result = emitCarry(await getGateway().write("contextCarry.settle", { command }) as unknown as SendMessageResult | null);
+  const boundary = commandBoundary(command);
+  if (boundary && command.status === "failed" && isRecord(command.result) && command.result.destructiveInputUnsettled === true) {
+    await replaceUnsettledBoundary(command, boundary);
   }
-  return message;
+  return result;
+}
+function emitCarry(result: SendMessageResult | null): Message | null {
+  if (result && (result.created || result.updated)) emitNewMessage(result.message);
+  return result?.message ?? null;
 }
-
 /** The provider may still apply the input without any observable reset: a successor's registration is the reset instead. */
 async function replaceUnsettledBoundary(command: Command, boundary: { agentId: string; generation: number }): Promise<void> {
   const agent = getAgent(boundary.agentId);
@@ -74,58 +40,3 @@ async function replaceUnsettledBoundary(command: Command, boundary: { agentId: s
   const restart = await createSelfRestartCommandAsync(agent, boundary.generation, continuation, fullContextMessageId, "reset-unconfirmed", Date.now());
   emitCommandEvent(restart, "command.requested");
 }
-
-/** A reset settles only the boundary its provider evidence names; a replaced process settles all. */
-function settledBy(fact: ContextResetFact, carrying: RecoveryObligation[]): number[] {
-  const open = carrying.filter((obligation) => obligation.open);
-  if (fact.kind === "restart") return open.map((obligation) => obligation.generation);
-  return open.filter((obligation) => fact.commandId !== undefined && obligation.commandId === fact.commandId).map((obligation) => obligation.generation);
-}
-
-function commandBoundary(command: Command): { agentId: string; generation: number } | null {
-  const selfResume = isRecord(command.params.selfResume) ? command.params.selfResume : undefined;
-  const generation = selfResume?.generation;
-  if (typeof generation !== "number") return null;
-  if (command.type === "agent.restart") {
-    const agentId = stringValue(command.params.agentId);
-    return agentId && isRecord(command.params.selfRestart) ? { agentId, generation } : null;
-  }
-  return isContinuationSelfResumeCommand(command) ? { agentId: command.target, generation } : null;
-}
-
-type SendResult = ReturnType<typeof sendMessageWithResult>;
-
-function sendAndEmit(write: () => SendResult | null): Message | null {
-  const result = writeTransaction(write);
-  if (result && (result.created || result.updated)) emitNewMessage(result.message);
-  return result?.message ?? null;
-}
-
-// Floor: the earliest capture start minus the margin. No upper bound: a read after the reset is a duplicate, never a loss, and needs no clock comparison.
-function sendCarry(agentId: string, carrying: RecoveryObligation[], key: string, detail: Record<string, unknown>): SendResult | null {
-  const ids = readsToCarry(agentId, Math.min(...carrying.map((obligation) => obligation.openedAt)) - CARRY_MARGIN_MS);
-  if (!ids.length) return null;
-  return sendMessageWithResult({
-    from: "system",
-    to: agentId,
-    kind: "system",
-    subject: "Possible unread messages",
-    body: renderCarryBody(ids),
-    payload: { selfResumeCarry: { ...detail, generations: carrying.map((obligation) => obligation.generation), messageIds: ids } },
-    idempotencyKey: `self-resume-carry:${agentId}:${key}`,
-    replyExpected: false,
-    maxAgeSeconds: null,
-  });
-}
-
-function renderCarryBody(ids: number[]): string {
-  const listed = ids.slice(0, LISTED_IDS).map((id) => `#${id}`).join(" ");
-  const rest = ids.length > LISTED_IDS ? `\n…and ${ids.length - LISTED_IDS} more, up to #${ids.at(-1)}; every id is in this message's payload.` : "";
-  return [
-    `Possible unread messages: ${ids.length} message${ids.length === 1 ? "" : "s"} reached you around your context reset, after or shortly before you saved your working state, so your current context may not hold them.`,
-    "Check each one your working state does not already cover with relay_get_message <id>, and handle it. Some may be duplicates of work you have done.",
-    "Messages you already handled may appear here, including the reset instruction itself: do not repeat a reset instruction found here.",
-    "",
-    `${listed}${rest}`,
-  ].join("\n");
-}

package/src/self-resume-supersede.ts

@@ -1,5 +1,6 @@
+import { updateCommandAsync } from "./commands-write";
 import { getContinuationEnvelope } from "./db/continuations";
-import { updateCommand } from "./commands-db";
+
 import type { Command } from "./types";
 
 /** #3662 — a continuation belongs to one generation; once a newer one is captured, an older boundary is
@@ -14,6 +15,6 @@ export function supersedingGeneration(boundary: Command): number | null {
 
 /** Cancel (never fail) the not-yet-started injects of a superseded boundary. Accepted/running ones are
  *  already in the provider's hands and settle on their own. */
-export function cancelSupersededInjects(pendingAttemptIds: string[], current: number): void {
-  for (const id of pendingAttemptIds) updateCommand(id, { status: "canceled", error: `superseded by continuation generation ${current}` });
+export async function cancelSupersededInjects(pendingAttemptIds: string[], current: number): Promise<void> {
+  for (const id of pendingAttemptIds) (await updateCommandAsync(id, { status: "canceled", error: `superseded by continuation generation ${current}` }));
 }

package/src/self-resume.ts

@@ -1,28 +1,16 @@
+import { updateContinuationObjectiveAsync, markSelfResumeContinuationIngestedAsync, ensureContinuationEnvelopeAsync } from "./db/runtime-tail-async";
+import { sendMessageAsync } from "./db/message-send";
+import { createCommandAsync } from "./commands-write";
 import { renderSelfCareState } from "./services/self-care-state";
 import { agentPrincipalSink } from "./db/agent-ownership";
 import { isRecord } from "@humwick/sdk";
-import { createCommand, listCommands, listInjectionAttempts, listPendingInjectionAttemptIds } from "./commands-db";
+import { listCommands, listInjectionAttempts, listPendingInjectionAttemptIds } from "./commands-db";
 import type { InjectionAttempt } from "./db/injection-attempts";
 import { emitCommandEvent } from "./command-events";
 import { INJECTION_SWEEP_BACKLOG_INTERVAL_MS, pacedInjectionSweep } from "./injection-sweep-pacing";
 import { MAX_BODY_BYTES, REAP_INTERVAL_MS } from "./config";
 import { getSelfResumeConfig } from "./config-store";
-import {
-  archiveAndAdvanceContinuationAsync,
-  archiveContinuationSegmentAsync,
-  ensureContinuationEnvelope,
-  findMessageByIdempotencyKey,
-  getAgent,
-  getContinuationEnvelope,
-  getMessage,
-  listUncommandedContextResets,
-  markSelfResumeContinuationIngested,
-  selfResumeContinuationIngested,
-  sendMessage,
-  updateContinuationAfterCompact,
-  updateContinuationObjective,
-  ValidationError,
-} from "./db";
+import { archiveAndAdvanceContinuationAsync, archiveContinuationSegmentAsync, findMessageByIdempotencyKey, getAgent, getContinuationEnvelope, getMessage, listUncommandedContextResets, selfResumeContinuationIngested, updateContinuationAfterCompact, ValidationError } from "./db";
 import { emitRelayEvent } from "./events";
 import { emitMessageDeliveryUpdated } from "./sse";
 import { boundaryCaptureClause } from "./memory-boundary-capture";
@@ -73,13 +61,13 @@ export async function compactAndResume(input: CompactAndResumeInput): Promise<Co
   else assertResumeSupported(agent, mode);
 
   const now = Date.now();
-  let envelope = ensureContinuationEnvelope({
+  let envelope = (await ensureContinuationEnvelopeAsync({
     agentId: agent.id,
     objective: input.objective,
     now,
-  });
+  }));
   if (input.objective !== undefined && envelope.objective !== input.objective) {
-    envelope = updateContinuationObjective({ agentId: agent.id, objective: input.objective, now });
+    envelope = (await updateContinuationObjectiveAsync({ agentId: agent.id, objective: input.objective, now }));
   }
 
   const workingState = input.workingState.trim();
@@ -101,19 +89,19 @@ export async function compactAndResume(input: CompactAndResumeInput): Promise<Co
   // half is elsewhere on purpose (src/context-advisory.ts) — it has to reach the agent while the
   // generation it asks about still exists, and no line written at this point can do that.
   const fullContinuation = renderContinuation(updated.envelope, {
-    memoryCapture: boundaryCaptureClause({ seam: "post", agentId: agent.id, now }),
+    memoryCapture: (await boundaryCaptureClause({ seam: "post", agentId: agent.id, now })),
     liveRuns: renderSelfCareState(agent.id),
   });
   // #2836: no core copy here — the startup-context seam re-injects it beside this.
-  const continuationMessage = createContinuationRecoveryMessage(agent.id, generation, fullContinuation, now);
+  const continuationMessage = (await createContinuationRecoveryMessage(agent.id, generation, fullContinuation, now));
   const continuation = insertRecoveryPointerAfterIntro(fullContinuation, continuationMessage.id);
-  openContextRecovery(agent.id, generation, now);
+  (await openContextRecovery(agent.id, generation, now));
   const command = input.restart
     ? await createSelfRestartCommandAsync(agent, generation, continuation, continuationMessage.id, input.reason ?? "manual", now)
     : mode === "native"
-      ? createNativeCompact(agent.id, generation, continuation, continuationMessage.id)
-      : createClearThenInject(agent.id, generation, continuation, continuationMessage.id);
-  attachContextRecoveryCommand(agent.id, generation, command.id);
+      ? (await createNativeCompact(agent.id, generation, continuation, continuationMessage.id))
+      : (await createClearThenInject(agent.id, generation, continuation, continuationMessage.id));
+  (await attachContextRecoveryCommand(agent.id, generation, command.id));
   emitCommandEvent(command, "command.requested");
   return {
     ok: true,
@@ -169,7 +157,7 @@ export interface ForcedResumePlan {
 // shapes, so the reactive/sweep reinjection (#1023) plus the #1998 objective-epoch render guarantees
 // apply unchanged. Returns null (→ caller falls back to a bare compact) when the provider has no
 // resume route / no re-injection channel OR the agent has no stored envelope yet.
-export function buildForcedResumePlan(agentId: string, now = Date.now()): ForcedResumePlan | null {
+export async function buildForcedResumePlan(agentId: string, now = Date.now()): Promise<ForcedResumePlan | null> {
   const agent = getAgent(agentId);
   if (!agent) return null;
   const context = agent.providerCapabilities?.context;
@@ -192,10 +180,10 @@ export function buildForcedResumePlan(agentId: string, now = Date.now()): Forced
   if (!envelope) return null;
   const generation = envelope.generation;
   const fullContinuation = renderContinuation(envelope, {
-    memoryCapture: boundaryCaptureClause({ seam: "post", agentId, now }),
+    memoryCapture: (await boundaryCaptureClause({ seam: "post", agentId, now })),
     liveRuns: renderSelfCareState(agentId),
   });
-  const continuationMessage = createContinuationRecoveryMessage(agentId, generation, fullContinuation, now);
+  const continuationMessage = (await createContinuationRecoveryMessage(agentId, generation, fullContinuation, now));
   const continuation = insertRecoveryPointerAfterIntro(fullContinuation, continuationMessage.id);
   if (useNativeCompact) {
     // Preserve the provider's in-place summary; re-inject the (possibly stale) envelope AFTER.
@@ -235,11 +223,11 @@ function insertRecoveryPointerAfterIntro(continuation: string, messageId: number
   return `${continuation.slice(0, firstNewline).trimEnd()}\n${pointer}${continuation.slice(firstNewline)}`;
 }
 
-function createContinuationRecoveryMessage(agentId: string, generation: number, continuation: string, now: number) {
+async function createContinuationRecoveryMessage(agentId: string, generation: number, continuation: string, now: number) {
   const idempotencyKey = `self-resume-continuation:${agentId}:${generation}`;
   const existing = findMessageByIdempotencyKey("system", idempotencyKey);
   if (existing) return existing;
-  return sendMessage({
+  return (await sendMessageAsync({
     from: "system",
     to: agentId,
     kind: "system",
@@ -258,7 +246,7 @@ function createContinuationRecoveryMessage(agentId: string, generation: number,
       // provider session accepted it. The runner promotes this only after turn/start acceptance.
       delivery: { state: "stored" },
     },
-  });
+  }));
 }
 
 // #1023 — the ruledOut ledger bound (see updateContinuationAfterCompact) drops the
@@ -325,7 +313,7 @@ function continuationDeliveredInline(command: Command): boolean {
 
 /** Promote the persisted recovery artifact only from delivery evidence emitted by the runner.
  * A successful clear command or a stored chat row alone is never enough. */
-export function settleSelfResumeContinuationIngestion(command: Command): void {
+export async function settleSelfResumeContinuationIngestion(command: Command): Promise<void> {
   const result = isRecord(command.result) ? command.result : undefined;
   const provider = result && isRecord(result.providerResult) ? result.providerResult : undefined;
   let fullContextMessageId: number | undefined;
@@ -337,18 +325,18 @@ export function settleSelfResumeContinuationIngestion(command: Command): void {
     fullContextMessageId = typeof resume?.fullContextMessageId === "number" ? resume.fullContextMessageId : undefined;
   }
   if (fullContextMessageId === undefined) return;
-  const message = markSelfResumeContinuationIngested(fullContextMessageId);
+  const message = (await markSelfResumeContinuationIngestedAsync(fullContextMessageId));
   if (message) emitMessageDeliveryUpdated(message);
 }
 
 /** #2619 — a runner parks a continuation the provider refused under a usage/overload hold as a
  * message to itself (payload.selfResumeFullContextMessageId). Its delivered report is the same
  * delivery evidence an ingested injectContext result is: promote the recovery artifact. */
-export function settleParkedSelfResumeContinuation(message: Message): void {
+export async function settleParkedSelfResumeContinuation(message: Message): Promise<void> {
   const fullContextMessageId = message.payload?.selfResumeFullContextMessageId;
   if (typeof fullContextMessageId !== "number" || message.from !== message.to) return;
   if (getMessage(fullContextMessageId)?.to !== message.to) return;
-  const promoted = markSelfResumeContinuationIngested(fullContextMessageId);
+  const promoted = (await markSelfResumeContinuationIngestedAsync(fullContextMessageId));
   if (promoted) emitMessageDeliveryUpdated(promoted);
 }
 
@@ -402,38 +390,38 @@ export function isFailedClearInjectSelfResume(command: Command): boolean {
 }
 
 /** #3662 — an older generation's boundary is retired (its queued injects canceled), never delivered. */
-function retireIfSuperseded(command: Command): boolean {
+async function retireIfSuperseded(command: Command): Promise<boolean> {
   const current = supersedingGeneration(command);
   if (current === null) return false;
-  cancelSupersededInjects(listPendingInjectionAttemptIds(command.id, CONTINUATION_INJECTION_REASON), current);
+  (await cancelSupersededInjects(listPendingInjectionAttemptIds(command.id, CONTINUATION_INJECTION_REASON), current));
   return true;
 }
 
-export function enqueueContinuationInjectionAfterSelfResume(command: Command): Command | null {
+export async function enqueueContinuationInjectionAfterSelfResume(command: Command): Promise<Command | null> {
   if (command.status !== "succeeded" && !isFailedClearInjectSelfResume(command)) return null;
   const injection = extractPendingInjection(command);
-  if (!injection || retireIfSuperseded(command)) return null;
+  if (!injection || (await retireIfSuperseded(command))) return null;
   if (continuationDeliveredInline(command)) return null;
   if (injectionAttemptsFor(command, CONTINUATION_INJECTION_REASON).length) return null;
-  const inject = createCommand({
+  const inject = (await createCommandAsync({
     type: "agent.injectContext",
     source: "system",
     target: command.target,
     correlationId: command.id,
     params: buildInjectionParams(command, injection, undefined, registrationReplayEpoch(command.target)),
-  });
+  }));
   emitCommandEvent(inject, "command.requested");
   return inject;
 }
 
-export function enqueueLifecycleIdentityInjectionAfterContextCommand(command: Command): Command | null {
+export async function enqueueLifecycleIdentityInjectionAfterContextCommand(command: Command): Promise<Command | null> {
   if (command.status !== "succeeded") return null;
   if (command.type !== "agent.clearContext" && command.type !== "agent.compact") return null;
   if (extractPendingInjection(command)) return null;
   const content = identityContentForLifecycleCommand(command);
   if (!content) return null;
   if (injectionAttemptsFor(command, IDENTITY_INJECTION_REASON).length) return null;
-  const inject = createCommand({
+  const inject = (await createCommandAsync({
     type: "agent.injectContext",
     source: "system",
     target: command.target,
@@ -446,13 +434,13 @@ export function enqueueLifecycleIdentityInjectionAfterContextCommand(command: Co
         ...(command.type === "agent.compact" ? { afterCompactCommandId: command.id } : {}),
       },
     },
-  });
+  }));
   emitCommandEvent(inject, "command.requested");
   return inject;
 }
 
-export function enqueueContinuationInjectionAfterClear(command: Command): Command | null {
-  return enqueueContinuationInjectionAfterSelfResume(command);
+export async function enqueueContinuationInjectionAfterClear(command: Command): Promise<Command | null> {
+  return (await enqueueContinuationInjectionAfterSelfResume(command));
 }
 
 const CLEAR_OR_COMPACT_TYPES = ["agent.clearContext", "agent.compact"] as const;
@@ -613,7 +601,7 @@ function continuationInjectionAttemptDecision(command: Command, replayEpoch?: st
 // lost, and a redundant-but-harmless re-injection is preferable to a permanent
 // silent mind-wipe. The sweep creates only a missing initial attempt; it never retries a failed
 // attempt by itself, so an unavailable-but-still-registered provider cannot grow commands forever.
-export function sweepMissedContinuationInjections(now: number = Date.now(), signal?: AbortSignal, targetAgentId?: string, replayEpoch?: string): { enqueuedCommandIds: string[]; aborted?: true } {
+export async function sweepMissedContinuationInjections(now: number = Date.now(), signal?: AbortSignal, targetAgentId?: string, replayEpoch?: string): Promise<{ enqueuedCommandIds: string[]; aborted?: true }> {
   const enqueuedCommandIds: string[] = [];
   // #1726 — shared across every candidate this tick: the identity rebuild only depends on the
   // target agent, and every target must already exist in the (bounded) agent roster, so this
@@ -628,27 +616,27 @@ export function sweepMissedContinuationInjections(now: number = Date.now(), sign
   // between candidates simply leaves the rest for the next tick. SYNCHRONOUS job — inert on one
   // thread until this grows an await.
   for (const command of sweepableBoundaryCommands(now, signal, targetAgentId)) {
-    sweepContinuationBoundary(command, identityCache, enqueuedCommandIds, replayEpoch);
+    (await sweepContinuationBoundary(command, identityCache, enqueuedCommandIds, replayEpoch));
   }
   return { enqueuedCommandIds, ...(signal?.aborted ? { aborted: true as const } : {}) };
 }
 
-function sweepContinuationBoundary(command: Command, identityCache: WhoamiIdentityCache, enqueuedCommandIds: string[], replayEpoch?: string): void {
+async function sweepContinuationBoundary(command: Command, identityCache: WhoamiIdentityCache, enqueuedCommandIds: string[], replayEpoch?: string): Promise<void> {
   const injection = extractPendingInjection(command);
-  if (!injection || retireIfSuperseded(command)) return;
+  if (!injection || (await retireIfSuperseded(command))) return;
   if (continuationDeliveredInline(command)) return;
   const agent = getAgent(command.target);
   if (!agent || agent.status === "offline") return;
   const attemptEpoch = replayEpoch ?? registrationReplayEpoch(command.target);
   const { decision } = continuationInjectionAttemptDecision(command, attemptEpoch);
   if (decision !== "enqueue") return;
-  const inject = createCommand({
+  const inject = (await createCommandAsync({
     type: "agent.injectContext",
     source: "system",
     target: command.target,
     correlationId: command.id,
     params: buildInjectionParams(command, injection, identityCache, attemptEpoch),
-  });
+  }));
   emitCommandEvent(inject, "command.requested");
   enqueuedCommandIds.push(inject.id);
 }
@@ -658,14 +646,14 @@ function sweepContinuationBoundary(command: Command, identityCache: WhoamiIdenti
 async function sweepMissedContinuationInjectionsPaced(now: number, signal?: AbortSignal): Promise<{ enqueuedCommandIds: string[]; aborted?: true; moreWork?: true }> {
   const enqueuedCommandIds: string[] = [];
   const identityCache: WhoamiIdentityCache = new Map();
-  const { moreWork } = await pacedInjectionSweep(() => sweepableBoundaryCommands(now, signal), (command) => sweepContinuationBoundary(command, identityCache, enqueuedCommandIds), signal);
+  const { moreWork } = await pacedInjectionSweep(() => sweepableBoundaryCommands(now, signal), async (command) => (await sweepContinuationBoundary(command, identityCache, enqueuedCommandIds)), signal);
   return { enqueuedCommandIds, ...(signal?.aborted ? { aborted: true as const } : {}), ...(moreWork ? { moreWork: true as const } : {}) };
 }
 
 /** Replay one parked continuation attempt for a new ready/idle or registration epoch. The epoch is
  * persisted on the inject command, making repeated observations of the same lifecycle edge inert. */
-export function replayParkedContinuationInjections(agentId: string, lifecycleEpoch: string, now = Date.now()): { enqueuedCommandIds: string[] } {
-  return sweepMissedContinuationInjections(now, undefined, agentId, lifecycleEpoch);
+export async function replayParkedContinuationInjections(agentId: string, lifecycleEpoch: string, now = Date.now()): Promise<{ enqueuedCommandIds: string[] }> {
+  return (await sweepMissedContinuationInjections(now, undefined, agentId, lifecycleEpoch));
 }
 
 export const SELF_RESUME_INJECTION_SWEEP_JOB = {
@@ -681,14 +669,14 @@ export const SELF_RESUME_INJECTION_SWEEP_JOB = {
   },
 };
 
-function notifyContinuationInjectionExhausted(command: Command, attempts: number): void {
+async function notifyContinuationInjectionExhausted(command: Command, attempts: number): Promise<void> {
   const idempotencyKey = `self-resume-injection-exhausted:${command.target}:${command.id}`;
   if (findMessageByIdempotencyKey(command.target, idempotencyKey)) return;
   const agent = getAgent(command.target);
   const payload = { kind: "agent.resume_injection_failed", agentId: command.target, commandId: command.id, attempts };
   emitRelayEvent({ type: "agent.resume_injection_failed", source: "server", subject: command.target, data: payload });
   const recipient = agent?.spawnedBy ?? agentPrincipalSink(command.target);
-  routeNotification({
+  await routeNotification({
     type: "agent.resume_injection_failed",
     scope: { agentId: command.target, parent: agent?.spawnedBy },
     recipients: [recipient],
@@ -708,7 +696,7 @@ function notifyContinuationInjectionExhausted(command: Command, attempts: number
 // silent no-op that let the #2043 runaway climb to ~750K tokens undetected. Surface it to the spawn
 // parent (and as a durable relay event) instead of swallowing it. Idempotent per command. This is
 // the ALARM; the continuation re-injection backstop (F2) is the separate recovery path.
-export function notifySelfResumeNoOp(command: Command): void {
+export async function notifySelfResumeNoOp(command: Command): Promise<void> {
   if (command.status !== "failed" && command.status !== "timed_out") return;
   if (command.type !== "agent.clearContext" && command.type !== "agent.compact") return;
   const injection = extractPendingInjection(command);
@@ -731,7 +719,7 @@ export function notifySelfResumeNoOp(command: Command): void {
   const recovery = command.type === "agent.clearContext" || command.status === "timed_out"
     ? "The relay re-injects the continuation as a backstop, but check the agent and consider a manual relay_compact_and_resume or restart."
     : "The continuation remains persisted; check the agent and retry relay_compact_and_resume once it is responsive.";
-  routeNotification({
+  await routeNotification({
     type: "agent.self_resume_noop",
     scope: { agentId: command.target, parent: agent?.spawnedBy },
     recipients: [recipient],
@@ -827,8 +815,8 @@ function assertResumeSupported(agent: AgentCard, mode: SelfResumeMode): void {
   }
 }
 
-function createNativeCompact(agentId: string, generation: number, continuation: string, fullContextMessageId: number): Command {
-  return createCommand({
+async function createNativeCompact(agentId: string, generation: number, continuation: string, fullContextMessageId: number): Promise<Command> {
+  return (await createCommandAsync({
     type: "agent.compact",
     source: "system",
     target: agentId,
@@ -837,16 +825,16 @@ function createNativeCompact(agentId: string, generation: number, continuation:
       instructions: continuation,
       selfResume: { generation, mode: "native", continuation, fullContextMessageId },
     },
-  });
+  }));
 }
 
-function createClearThenInject(agentId: string, generation: number, continuation: string, fullContextMessageId: number): Command {
+async function createClearThenInject(agentId: string, generation: number, continuation: string, fullContextMessageId: number): Promise<Command> {
   // #1588 — store the fully-built (identity-augmented) continuation in the clear command's params so
   // the runner can deliver it inline as a coupled unit, race-free, while preserving the #1206 identity
   // re-injection that the separate reactive inject used to add via buildInjectionParams. The backstop
   // path re-augments idempotently, so embedding it here causes no drift.
   const coupledContinuation = augmentContinuationWithIdentity(agentId, continuation);
-  return createCommand({
+  return (await createCommandAsync({
     type: "agent.clearContext",
     source: "system",
     target: agentId,
@@ -854,7 +842,7 @@ function createClearThenInject(agentId: string, generation: number, continuation
       reason: "self-resume",
       selfResume: { generation, mode: "clear-inject", continuation: coupledContinuation, fullContextMessageId },
     },
-  });
+  }));
 }
 
 function parseRuledOut(value: unknown, generation: number, now: number): ContinuationLedgerEntry[] {

package/src/server-background.ts

@@ -9,7 +9,7 @@ import { notifyCdDeployLive } from "./cd-deploy-notify";
 import { isEphemeralMode } from "./execution-mode";
 import { startClaudeAppOAuth } from "./claude-app/oauth-http";
 
-export function startServerBackgroundJobs(): void {
+export async function startServerBackgroundJobs(): Promise<void> {
   startPostBindJobs([
     { name: "claude-app-oauth", start: startClaudeAppOAuth },
     { name: "user-awaiting-reply", start: () => { startUserAwaitingReply(); } },