@humwick/server 0.130.2 → 0.130.4

package/runner/src/provider-setup.ts

@@ -4,13 +4,14 @@ import { selectProviderConfigEnv } from "@humwick/sdk/child-env";
 import type { ProviderAdapter, ProviderStatusEvent } from "./adapter";
 import { logger } from "./logger";
 import { hostSourcesFor } from "./host-asset-plan";
+import { resolveLaunchCommand } from "./provider-command";
 
 /** All real adapters share the managed-spawn login check, including replacements (#3751). */
 export function withProviderSetup(adapter: ProviderAdapter): ProviderAdapter {
   const spawn = adapter.spawn.bind(adapter);
   adapter.spawn = async (config) => {
     const env = selectProviderConfigEnv(config.providerConfig.env, hostSourcesFor(config).settings);
-    const auth = await checkProviderAuth(config.provider, undefined, env, config.providerConfig.command);
+    const auth = await checkProviderAuth(config.provider, undefined, env, resolveLaunchCommand(config.providerConfig.command), config.env);
     if (!auth.ok) throw new Error(auth.reason);
     return spawn(config);
   };
@@ -21,7 +22,7 @@ export function providerStartupFailure(error: unknown): ProviderStatusEvent {
   const message = `Provider startup failed: ${errMessage(error)}`;
   return { status: "error", reason: "provider-turn", providerState: {
     state: "blocked", terminal: true, reason: "providerSetupRequired", label: "Provider setup required", message,
-    recommendedAction: "Complete the provider login and first-run setup on this host, then restart the runner.",
+    recommendedAction: "Resolve the provider startup failure shown above, then restart the runner.",
   } };
 }
 

package/runner/src/runner-core.ts

@@ -11,7 +11,7 @@ import { PromptCommands, promptOrigin } from "./agent-runner/commands/prompt";
 import type { NativeSelfResumeHandoff } from "./native-self-resume";
 import { LifecyclePhase } from "./agent-runner/lifecycle-phase";
 import { startRunnerMcpProxy, runnerWebToolLog, runnerWebSearch, runnerMcpHiddenTools } from "./runner-mcp-proxy";
-import { HttpLiveness } from "./agent-runner/http-liveness";
+import { LivenessExchange } from "./agent-runner/liveness-exchange";
 import { TaskClaims } from "./agent-runner/task-claims";
 import { TurnReport } from "./agent-runner/turn-report";
 import { SessionMirror } from "./agent-runner/session-mirror";
@@ -22,7 +22,7 @@ import { hostname } from "node:os";
 import { resolveEnvLayers, selectProviderConfigEnv } from "@humwick/sdk/child-env";
 import { createHash } from "node:crypto";
 import { join } from "node:path";
-import { type ContextState, type Message, type ProviderState, HELD_FOR_PAYLOAD_KEY, PROVIDER_SUBMIT_UNCONFIRMED, PROXY_AUTH_HOLD_KIND, errMessage, frameSuppressedFromTurn, stringValue } from "@humwick/sdk";
+import { type ContextState, type Message, type ProviderState, HELD_FOR_PAYLOAD_KEY, PROVIDER_SUBMIT_UNCONFIRMED, PROXY_AUTH_HOLD_KIND, errMessage, frameSuppressedFromTurn, relayBusUrl, stringValue } from "@humwick/sdk";
 import { exitRunner } from "./runner-exit";
 import { isResumeWake, ProviderHoldEpisodes } from "./provider-hold";
 import { contextStateFromProbeMetrics, quotaStateFromProbeMetrics } from "@humwick/sdk/context-probe";
@@ -88,7 +88,6 @@ import {
   providerMonitorUnavailableMessage,
   providerStateFromActiveWork,
   registerWithinDeadline,
-  relayBusUrl,
   runnerAgentStatus,
   runnerBusErrorAction,
   runnerMessageMatches,
@@ -218,7 +217,7 @@ export class AgentRunner {
   private terminalProviderExit?: Record<string, unknown>;
   private nativeSelfResume = new NativeSelfResumeTracker();
   private readonly registration: Registration;
-  private readonly httpLiveness: HttpLiveness;
+  private readonly liveness: LivenessExchange;
   private readonly taskClaims: TaskClaims;
   private delivering = false;
   private drainTimer?: Timer;
@@ -367,7 +366,7 @@ export class AgentRunner {
       disposeEmptyTurns: () => this.emptyTurns.dispose(), resetEmptyTurns: () => this.emptyTurns.reset(), resetLateClearRecovery: () => { this.lateClearRecovery.reset(); this.continuationFence.reset(); },
       clearLifecycleAction: () => this.lifecycle.setLifecycleAction(undefined), setOffline: () => this.claims.setTerminalStatus("offline"), publishStatus: () => this.publishStatus(),
       stopDrainTimer: () => { if (this.drainTimer) clearTimeout(this.drainTimer); this.drainTimer = undefined; }, stopSubmitRecoveryPoll: () => this.stopSubmitRecoveryPoll(),
-      stopTaskClaims: () => this.taskClaims.stop(), stopHttpLiveness: () => this.httpLiveness.stop(), stopCredentials: () => this.credentials.stop(),
+      stopTaskClaims: () => this.taskClaims.stop(), stopLiveness: () => this.liveness.stop(), stopCredentials: () => this.credentials.stop(),
       disarmBusyLivenessReconcile: () => this.disarmBusyLivenessReconcile(), disarmBusyReconciler: () => this.busyReconciler.disarm(),
       disposeProviderInput: () => this.providerInput.dispose(), disposeParkPosts: () => this.parkPosts.dispose(),
       stopReasoningTail: () => this.sessionMirror.stopReasoningTail(), clearNativeSessionCapture: () => this.sessionMirror.clearNativeSessionCapture(), stopObligationCache: () => this.obligationCache.stop(),
@@ -433,11 +432,11 @@ export class AgentRunner {
     void this.proxy?.refreshTools().catch(() => {});
       },
       resumeLivenessAndPublishRotation: (status, jti) => {
-        this.httpLiveness.resetAuthFailure();
+        this.liveness.resetAuthFailure();
         // An earlier auth failure may have stopped the liveness loop; restart it so the
-        // agent reports live again on the fresh token. startHttpLiveness clears any
+        // agent reports live again on the fresh token. startLiveness clears any
         // existing timer first, so this is safe on the normal (proactive) renew path too.
-        this.startHttpLiveness();
+        this.startLiveness();
         this.pendingTimelineEvent = { status, id: jti, timestamp: Date.now() };
         this.bus.reconnectTransport(status === "runtime-token-reminted" ? "runtime token re-minted" : "runtime token renewed");
         this.publishStatus();
@@ -469,14 +468,14 @@ export class AgentRunner {
       // #2514 — the per-provider config env carries a dedicated-home provider's (claude-b's) own
       // credential, which the quota harvest needs to key its reports under the B subscription.
       providerConfigEnv: () => this.options.providerConfig.env,
-      http: () => this.http,
     });
-    this.httpLiveness = new HttpLiveness({
-      http: this.http, agentId: this.agentId, instanceId: options.instanceId, logIntervalMs: HTTP_LIVENESS_LOG_INTERVAL_MS,
+    this.liveness = new LivenessExchange({
+      http: this.http, bus: () => this.bus, agentId: this.agentId, instanceId: options.instanceId, logIntervalMs: HTTP_LIVENESS_LOG_INTERVAL_MS,
       isStopped: () => this.lifecycle.stopped, isTerminalStatusLatched: () => this.lifecycle.terminalStatusLatched,
       currentStatus: () => this.claims.currentStatus(),
-      publishQuota: () => this.providerQuotaHarvest.publish(),
-      bootstrapUnreadMessages: () => this.bootstrapUnreadMessages(), triggerEffort: () => this.effort.trigger(),
+      sampleQuota: () => this.providerQuotaHarvest.sample(),
+      acceptQuota: (report, result) => this.providerQuotaHarvest.accept(report, result),
+      enqueueMessage: (message) => this.enqueueMessage(message), triggerEffort: () => this.effort.trigger(),
       recoverRuntimeTokenAfterAuthFailure: (source) => this.credentials.recoverRuntimeTokenAfterAuthFailure(source),
       logRunnerDiagnostic: (message) => this.logRunnerDiagnostic(message),
     });
@@ -741,7 +740,7 @@ export class AgentRunner {
     }, (status) => this.setProviderStatus(status));
     await this.bootstrapUnreadMessages();
     this.taskClaims.start();
-    this.startHttpLiveness();
+    this.startLiveness();
     this.testRunDedupSweep.start();
     this.credentials.scheduleRuntimeTokenRenewal();
     this.scheduleDrain();
@@ -2861,7 +2860,7 @@ export class AgentRunner {
     if (published && this.pendingTimelineEvent === timelineEvent) this.pendingTimelineEvent = undefined;
   }
 
-  private startHttpLiveness(): void { this.httpLiveness.start(); }
+  private startLiveness(): void { this.liveness.start(); }
 
   private logRunnerDiagnostic(message: string): void { this.context.logRunnerDiagnostic(message); }
   private sessionLog(message: string): void { this.context.sessionLog(message); }

package/runner/src/runner-helpers.ts

@@ -133,14 +133,6 @@ export function csvTags(raw: string | undefined): string[] {
   return (raw || "").split(",").map((tag) => tag.trim()).filter(Boolean);
 }
 
-export function relayBusUrl(relayUrl: string): string {
-  const url = new URL(relayUrl);
-  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-  url.pathname = `${url.pathname.replace(/\/+$/, "")}/bus`;
-  url.search = "";
-  return url.toString();
-}
-
 export function runnerAgentStatus(status: "idle" | "busy" | "offline" | "error"): "idle" | "busy" | "offline" {
   return status === "error" ? "offline" : status;
 }

package/runner/src/session-scratch.ts

@@ -194,9 +194,13 @@ export function reapSessionScratch(target: SessionScratchTarget): void {
 // scratch dir reap to avoid leaking one file per spawn.
 export function reapSessionLauncher(target: SessionLauncherTarget): string[] {
   const removed: string[] = [];
-  for (const path of dedupePaths([
+  const launchers = dedupePaths([
     target.launcherScript,
     target.tmuxSession ? launcherScriptPathForSession(target.tmuxSession, target.launcherDir) : undefined,
+  ]);
+  for (const path of dedupePaths([
+    ...launchers,
+    ...launchers.flatMap(path => [`${path}.exit-code`, `${path}.exit-code.stderr`]),
     target.tmuxSession ? launcherGatePathForSession(target.tmuxSession, target.launcherDir) : undefined,
   ])) {
     try {
@@ -286,7 +290,7 @@ export async function sweepStaleLaunchersAsync(opts: LauncherSweepOptions): Prom
     try {
       const current = await stat(scriptPath);
       if (!current.isFile() || opts.now - current.mtimeMs < minAge) continue;
-      const agentId = await launcherAgentId(scriptPath);
+      const agentId = await launcherAgentId(scriptPath.replace(/\.exit-code(?:\.stderr)?$/, ""));
       if (agentId && opts.keepAgentIds.has(agentId)) continue;
       await rm(scriptPath, { force: true });
       removed.push(scriptPath);

package/runner/test-support/provisioning-context.ts

@@ -1,3 +1,5 @@
+import { readFileSync } from "node:fs";
+import { getManifest } from "@humwick/providers";
 import type { SpawnProvider } from "@humwick/sdk";
 import type { RunnerSpawnConfig, SpawnArgs } from "../src/adapter";
 import { codexLaunchContext } from "../src/adapters/codex";
@@ -16,8 +18,8 @@ export function systemPromptAppendFromSpawnArgs(
   spawnArgs: Pick<SpawnArgs, "args">,
   runnerConfig: RunnerSpawnConfig,
 ): string {
-  return provider === "claude"
-    ? flagValue(spawnArgs.args, "--append-system-prompt") ?? ""
+  return getManifest(provider)?.shim?.kind === "claude-relay"
+    ? readFileSync(flagValue(spawnArgs.args, "--append-system-prompt-file")!, "utf8")
     : codexLaunchContext({ meta: { config: runnerConfig } }) ?? "";
 }
 

package/runner/test-support/runner-harness.ts

@@ -91,7 +91,8 @@ export class RunnerHttp {
     });
     for (const method of ["listPromptTemplates", "listReplyObligations", "listAgents", "pollMessages"] as const) this.when(method, async () => []);
     this.when("getProviderQuotaConfig", async () => ({}));
-    for (const method of ["setStatus", "setReady", "heartbeat", "markRead"] as const) this.when(method, async () => {});
+    this.when("heartbeat", async () => ({ ok: true, messages: [] }));
+    for (const method of ["setStatus", "setReady", "markRead"] as const) this.when(method, async () => {});
     this.when("recordMessageDeliveryAttempt", async () => ({}) as Awaited<ReturnType<HumwickHttpClient["recordMessageDeliveryAttempt"]>>);
     this.when("claimMessageResult", async () => ({ ok: true, claimExpiresAt: Date.now() + 60_000 }));
     this.when("updateTaskStatus", async () => ({}) as Awaited<ReturnType<HumwickHttpClient["updateTaskStatus"]>>);

package/scripts/steward-policy-cleanup.ts

@@ -44,7 +44,7 @@ const USAGE = [
   "  --db <path>  target DB (default: $DB_PATH, else <stateDir>/agent-relay.db)",
 ].join("\n");
 
-function main(): void {
+async function main(): Promise<void> {
   const args = parseCleanupArgs(process.argv.slice(2));
   if (args.help) {
     console.log(USAGE);
@@ -58,7 +58,7 @@ function main(): void {
   console.log(`[steward-policy-cleanup] db=${dbPath} mode=${dryRun ? "DRY RUN" : "APPLY"}`);
   console.log(`[steward-policy-cleanup] scanned ${plan.scanned} steward polic${plan.scanned === 1 ? "y" : "ies"}`);
 
-  const result = applyStewardPolicyCleanup(plan, { dryRun });
+  const result = (await applyStewardPolicyCleanup(plan, { dryRun }));
   for (const line of result.log) console.log(`  ${line}`);
   if (result.log.length === 0) console.log("  (nothing to change — already canonical)");
 

package/src/agent-authz.ts

@@ -189,9 +189,9 @@ export function sessionControlsOwnAgentsOnly(ctx: AuthContext): boolean {
  * operator on agents they are principal of, viewer never. Agent: coordinator authority and, with
  * several users, the target's principal (or an admin principal). Full-reach callers: always.
  * Single-user installs keep today's behavior: only the agent coordinator rule applies. */
-export function authorizeAgentControl(ctx: AuthContext, target: Pick<AgentCard, "id" | "spawnedBy" | "teamId">, action = "control"): AgentControlDenial | null {
+export async function authorizeAgentControl(ctx: AuthContext, target: Pick<AgentCard, "id" | "spawnedBy" | "teamId">, action = "control"): Promise<AgentControlDenial | null> {
   const denied = agentControlDecision(ctx, target);
-  if (denied) recordAuthorityDenial(ctx, target.id, action, denied.reason);
+  if (denied) (await recordAuthorityDenial(ctx, target.id, action, denied.reason));
   return denied;
 }
 

package/src/agent-drive-arbiter.ts

@@ -1,3 +1,4 @@
+import { releaseDriveLeaseAsync } from "./db/runtime-tail-async";
 // Concurrency arbitration — "two humans driving one agent safely" (#388 users wave 5, #394).
 //
 // THE single decision home for "may this user drive this agent right now?". It composes three
@@ -18,13 +19,7 @@ import { canonicalHumanAgentId, userSinkId } from "@humwick/sdk";
 import { isMultiUserWorldAsync } from "./db/agent-ownership-async.ts";
 import { resolveViewer } from "./agent-authz.ts";
 import { getUser } from "./db/users.ts";
-import {
-  acquireDriveLease,
-  getDriveLease,
-  releaseDriveLease,
-  takeOverDriveLease,
-  type DriveLeaseRecord,
-} from "./db/drive-leases.ts";
+import { acquireDriveLease, getDriveLease, takeOverDriveLease, type DriveLeaseRecord } from "./db/drive-leases.ts";
 
 /** Who holds (or held) the wheel, resolved for human-readable "X is driving" messaging. */
 interface DriveHolder {
@@ -100,7 +95,7 @@ export async function releaseDrive(userId: string, agentId: string, opts: { forc
   if (!(await isMultiUserWorldAsync())) return { released: false };
   const current = getDriveLease(agentId);
   const isAdmin = resolveViewer(userId)?.role === "admin";
-  const released = releaseDriveLease(opts.force && isAdmin ? { agentId } : { agentId, userId });
+  const released = (await releaseDriveLeaseAsync(opts.force && isAdmin ? { agentId } : { agentId, userId }));
   return released && current ? { released, previousHolder: driveHolder(current.holderUserId) } : { released };
 }
 

package/src/agent-exit-cleanup-async.ts

@@ -51,11 +51,11 @@ export async function settleAgentExitCleanupAsync(command: Command): Promise<boo
       const settled = await getGateway().write("commands.settleAgentCleanupSlice", { command: { ...command,
         result: { owners: [{ ...owner, workspaceIds: ids.slice(at, at + 8) }] } } }) as unknown as AgentCleanupSettlement;
       for (const workspace of settled.changed) emitWorkspaceChange(workspace);
-      for (const alert of settled.alerts) alertCleanup(command, alert.agentId, alert.detail, owner);
+      for (const alert of settled.alerts) await alertCleanup(command, alert.agentId, alert.detail, owner);
       await Bun.sleep(5);
     }
     if (typeof owner.agentId === "string" && typeof owner.error === "string") {
-      alertCleanup(command, owner.agentId, owner.error, owner);
+      await alertCleanup(command, owner.agentId, owner.error, owner);
       await Bun.sleep(5);
     }
   }

package/src/agent-exit-cleanup.ts

@@ -1,10 +1,14 @@
+import { deleteWorkspaceAsync } from "./db/lifecycle-tail-async";
+import { getGateway } from "./db/gateway";
+import type { AgentCleanupSettlement } from "./db/agent-exit-cleanup";
+import { createCommandAsync } from "./commands-write";
 import { subscribeRelayEvents } from "./events";
 import { createHash } from "node:crypto";
 import { isHumanAgentId, isRecord } from "@humwick/sdk";
-import { createCommand } from "./commands-db";
-import { hasActiveAgentCleanup, settleAgentCleanupWorkspaces } from "./db/agent-exit-cleanup";
+
+import { hasActiveAgentCleanup } from "./db/agent-exit-cleanup";
 import { emitCommandEvent } from "./command-events";
-import { deleteWorkspace, emitWorkspaceChange, getAgent, listOrchestrators, listWorkspaces, getWorkspace } from "./db";
+import { emitWorkspaceChange, getAgent, listOrchestrators, listWorkspaces, getWorkspace } from "./db";
 import { workspaceOwnerOrchestrator } from "./workspace-host";
 import { raiseOperatorAlarm } from "./operator-alarm";
 import { routeNotification } from "./notification-router";
@@ -14,17 +18,17 @@ import { exitCleanupCondition } from "./agent-exit-alarm";
 import { reapAgentBrowserSessions } from "./services/browser-session";
 
 // #3489 — HTTP, bus self-exit, host reports and reapers share the persisted status event.
-subscribeRelayEvents((event) => {
-  if (event.type === "agent.status" && event.data.status === "offline" && event.subject) reapAgentBrowserSessions(event.subject);
+subscribeRelayEvents(async (event) => {
+  if (event.type === "agent.status" && event.data.status === "offline" && event.subject) (await reapAgentBrowserSessions(event.subject));
 });
 
-export function requestAgentExitCleanup(agentId?: string): number {
+export async function requestAgentExitCleanup(agentId?: string): Promise<number> {
   if (agentId === "system" || isHumanAgentId(agentId)) return 0;
   const agent = agentId ? getAgent(agentId) : null;
   if (agent && agent.status !== "offline") return 0;
-  if (agentId) reapAgentBrowserSessions(agentId); // #3489 — a browser never outlives its agent
+  if (agentId) (await reapAgentBrowserSessions(agentId)); // #3489 — a browser never outlives its agent
   if (agentId) for (const ws of listWorkspaces({ ownerAgentId: agentId })) {
-    if (ws.mode === "shared") deleteWorkspace(ws.id);
+    if (ws.mode === "shared") (await deleteWorkspaceAsync(ws.id));
   }
   const hosts = listOrchestrators().filter((host) => host.status === "online");
   const owned = agentId ? listWorkspaces({ ownerAgentId: agentId }) : [];
@@ -34,8 +38,8 @@ export function requestAgentExitCleanup(agentId?: string): number {
   for (const host of hosts) {
     if (agentId && hostIds.size && !hostIds.has(host.id)) continue;
     if (hasActiveAgentCleanup(host.agentId, agentId)) continue;
-    const command = createCommand({ type: "agent.cleanup", source: "system", target: host.agentId, ttlMs: 10 * 60_000,
-      params: { ...(agentId ? { agentId } : { sweep: true }), requestedBy: "agent-exit-cleanup" } });
+    const command = (await createCommandAsync({ type: "agent.cleanup", source: "system", target: host.agentId, ttlMs: 10 * 60_000,
+      params: { ...(agentId ? { agentId } : { sweep: true }), requestedBy: "agent-exit-cleanup" } }));
     emitCommandEvent(command, "command.requested");
     dispatched++;
   }
@@ -53,25 +57,25 @@ export async function settleAgentExitCleanup(command: Command): Promise<boolean>
     const error = command.error ?? "No cleanup inventory owner found; cleanup retained";
     await settleWorkspaceCleanupCommand({ ...command, status: "failed", error,
       result: { ...result, workspaceId: typeof command.params.workspaceId === "string" ? command.params.workspaceId : command.correlationId } });
-    if (command.status === "succeeded") alertCleanup(command, undefined, error);
+    if (command.status === "succeeded") await alertCleanup(command, undefined, error);
   }
-  const settled = settleAgentCleanupWorkspaces(command);
+  const settled = await getGateway().write("commands.settleAgentCleanupSlice", { command }) as unknown as AgentCleanupSettlement;
   for (const workspace of settled.changed) emitWorkspaceChange(workspace);
-  for (const alert of settled.alerts) alertCleanup(command, alert.agentId, alert.detail);
+  for (const alert of settled.alerts) await alertCleanup(command, alert.agentId, alert.detail);
   for (const owner of owners) {
     if (typeof owner.agentId !== "string") continue;
-    if (typeof owner.error === "string") alertCleanup(command, owner.agentId, owner.error, owner);
+    if (typeof owner.error === "string") await alertCleanup(command, owner.agentId, owner.error, owner);
   }
   if (command.status !== "succeeded" && !owners.some((owner) => typeof owner.error === "string")) {
     console.warn(`[agent-exit-cleanup] host ${command.target} agent ${command.params.agentId ?? "host sweep"}: ${command.error ?? "host cleanup failed"}`);
   }
   if (Array.isArray(result?.unattributed) && result.unattributed.length) {
-    alertCleanup(command, undefined, `Host artifacts retained because ownership is unavailable: ${result.unattributed.join(", ")}`, { artifactPaths: result.unattributed });
+    await alertCleanup(command, undefined, `Host artifacts retained because ownership is unavailable: ${result.unattributed.join(", ")}`, { artifactPaths: result.unattributed });
   }
   return true;
 }
 
-export function alertCleanup(command: Command, agentId: string | undefined, detail: string, artifacts?: Record<string, unknown>): void {
+export async function alertCleanup(command: Command, agentId: string | undefined, detail: string, artifacts?: Record<string, unknown>): Promise<void> {
   const owner = artifacts ?? (Array.isArray(command.result?.owners) ? command.result.owners.filter(isRecord)
     .find((owner) => owner.agentId === agentId) : undefined);
   if (owner?.inventoryFailed === true) return;
@@ -91,9 +95,9 @@ export function alertCleanup(command: Command, agentId: string | undefined, deta
   const host = listOrchestrators().find((host) => host.agentId === command.target);
   const body = `Agent ${agent?.label ?? agent?.name ?? "unknown"} (${identity ?? "unknown"}) on host ${host ? `${host.hostname} (${host.id})` : command.target}\nPaths: ${paths.join(", ")}\n${detail}`;
   const digest = createHash("sha256").update(`${command.target}:${identity}:${exitCleanupCondition(detail)}:${JSON.stringify(paths)}`).digest("hex").slice(0, 24);
-  if (!raiseOperatorAlarm({ clientId: `exit-cleanup:${digest}`, source: "agent-exit-cleanup", subject: "Agent exit cleanup retained files", detail: body, dedupeEvent: true,
-    metadata: { agentId, commandId: command.id, orchestrator: command.target, paths } })) return;
+  if (!(await raiseOperatorAlarm({ clientId: `exit-cleanup:${digest}`, source: "agent-exit-cleanup", subject: "Agent exit cleanup retained files", detail: body, dedupeEvent: true,
+    metadata: { agentId, commandId: command.id, orchestrator: command.target, paths } }))) return;
   const parent = agent?.spawnedBy;
-  if (parent) routeNotification({ type: "agent.cleanup_failed", scope: { agentId, parent }, recipients: [parent], forceDelivery: true,
+  if (parent) await routeNotification({ type: "agent.cleanup_failed", scope: { agentId, parent }, recipients: [parent], forceDelivery: true,
     message: { subject: "Agent exit cleanup retained files", body, replyExpected: false, idempotencyKey: `exit-cleanup:${digest}`, payload: { kind: "agent.cleanup_failed", agentId, commandId: command.id } } });
 }