@humwick/server 0.130.1 → 0.130.3

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 } } });
 }

package/src/agent-lifecycle-events.ts

@@ -1,9 +1,10 @@
-import { clearAgentNotice, hasAgentExitNotice, recordAgentNoticeOnce, recordAgentReadyNoticeOnce } from "./db/terminal-events";
+import { clearAgentNoticeAsync, recordCrashReportAsync, recordTerminalEventAsync } from "./db/lifecycle-tail-async";
+import { hasAgentExitNotice } from "./db/terminal-events";
 import { requestAgentExitCleanup } from "./agent-exit-cleanup";
 import { emitRelayEvent } from "./events";
-import { routeNotification } from "./notification-router";
+import { routeAgentNotice, routeNotification } from "./notification-router";
 import { LIFECYCLE_STATE_WORKING, childSignalKey, stampLifecycleSignal, taskSignalKey } from "./lifecycle-signal-registry";
-import { currentCoordinatorOf, deliverableTaskIdsBySpawnRequestId, getAgent, markAgentReadyNotified, recordCrashReport, recordTerminalEvent, workflowRunIdOf } from "./db";
+import { currentCoordinatorOf, deliverableTaskIdsBySpawnRequestId, getAgent, markAgentReadyNotifiedAsync, workflowRunIdOf } from "./db";
 import { crashReportFor } from "./agent-death-diagnosis";
 import { renderTemplate } from "./prompt-resolver";
 import { markAgentWorkFinal } from "./services/work-finality";
@@ -57,6 +58,19 @@ function diagnosisSuffix(diagnosis?: AgentDeathDiagnosis): string {
 // it guards is same-moment, so a relay restart between the two is not a concern.
 type SpawnTerminal = "agent.ready" | "agent.spawn_failed";
 const spawnTerminalBySpawnRequest = new Map<string, SpawnTerminal>();
+const pendingSpawnNotices = new Map<string, Promise<void>>();
+function spawnQueueKey(agentId: string): string {
+  const child = getAgent(agentId);
+  return (child && spawnRequestIdOf(child)) || agentId;
+}
+// #1870 — terminal guards advance only after commit; serialize one generation across writer awaits.
+function serializeSpawnNotice(key: string, work: () => Promise<void>): Promise<void> {
+  const prior = pendingSpawnNotices.get(key);
+  const result = prior ? prior.catch(() => {}).then(work) : work();
+  pendingSpawnNotices.set(key, result);
+  void result.finally(() => { if (pendingSpawnNotices.get(key) === result) pendingSpawnNotices.delete(key); }).catch(() => {});
+  return result;
+}
 
 // #1513 — spawns we've already told the spawner are queued-for-host-memory, keyed by spawnRequestId
 // (falling back to the parent id when a request has no id). The orchestrator re-reports the whole
@@ -76,13 +90,6 @@ function recordSpawnTerminal(spawnRequestId: string | undefined, outcome: SpawnT
   spawnTerminalBySpawnRequest.set(spawnRequestId, outcome);
 }
 
-function tryRecordSpawnFailed(spawnRequestId: string | undefined): boolean {
-  if (spawnRequestId === undefined) return true;
-  if (spawnTerminalBySpawnRequest.has(spawnRequestId)) return false;
-  spawnTerminalBySpawnRequest.set(spawnRequestId, "agent.spawn_failed");
-  return true;
-}
-
 /** A child counts as "had become ready" once its durable readiness stamp exists. */
 function everReady(child: AgentCard): boolean {
   return typeof child.meta?.readyNotifiedAt === "number";
@@ -128,50 +135,49 @@ function stampChildLifecycleSignal(parent: string, child: AgentCard): void {
  * `spawned_by` parent a one-shot notice so it can stop block-polling. No-op for non-spawned agents
  * and for a child whose ready was already announced (reconnect / heartbeat re-registration).
  */
-export function notifyAgentReady(childId: string): void {
+export async function notifyAgentReady(childId: string): Promise<void> {
+  return serializeSpawnNotice(spawnQueueKey(childId), () => notifyAgentReadyBody(childId));
+}
+
+async function notifyAgentReadyBody(childId: string): Promise<void> {
   const child = getAgent(childId);
   const parent = child?.spawnedBy;
   // A workflow step agent with no spawner (a run a dashboard user started) still records its ready edge on its run (#3160).
   if (!child || (!parent && !workflowRunIdOf(child))) return;
   if (isSpawnIntentCanceled(child.meta?.spawnRequestId)) return;
   // Idempotent — only stamped on first ready; classifies a later offline edge as exited.
-  markAgentReadyNotified(childId);
+  await markAgentReadyNotifiedAsync(childId);
   // #2899 — a self-compact flips ready again; the generation slot keeps the push one-shot.
-  recordAgentReadyNoticeOnce(child, () => announceReady(child, parent));
+  await announceReady(child, parent);
 }
 
-function announceReady(child: AgentCard, spawner: string | undefined): void {
+async function announceReady(child: AgentCard, spawner: string | undefined): Promise<void> {
   const childId = child.id;
   const spawnRequestId = spawnRequestIdOf(child);
   // #648 — if a spawn_failed was already emitted for this request, this ready RETRACTS it: the agent
   // actually came up, so the earlier failure was a false negative. Emit a corrective recovery instead
   // of a plain ready notice so a coordinator that acted on the failure can reconcile.
   const recovered = spawnTerminalOf(spawnRequestId) === "agent.spawn_failed";
-  recordSpawnTerminal(spawnRequestId, "agent.ready");
 
   const workflowRunId = workflowRunIdOf(child);
-  emitRelayEvent({
-    type: "agent.ready",
-    source: "server",
-    subject: childId,
-    data: { agentId: childId, parent: spawner, provider: providerOf(child), label: child.label, spawnRequestId, ...(workflowRunId ? { workflowRunId } : {}) },
-  });
-  if (!spawner) return;
-  const parent = noticeRecipient(child, spawner);
-
-  if (recovered) {
-    emitRelayEvent({
-      type: "agent.spawn_recovered",
-      source: "server",
-      subject: childId,
-      data: { agentId: childId, parent: spawner, provider: providerOf(child), label: child.label, spawnRequestId, supersedes: "agent.spawn_failed" },
-    });
+  const readyEvent = () => {
+    emitRelayEvent({ type: "agent.ready", source: "server", subject: childId,
+      data: { agentId: childId, parent: spawner, provider: providerOf(child), label: child.label, spawnRequestId, ...(workflowRunId ? { workflowRunId } : {}) } });
+    if (recovered && spawner) emitRelayEvent({ type: "agent.spawn_recovered", source: "server", subject: childId,
+      data: { agentId: childId, parent: spawner, provider: providerOf(child), label: child.label, spawnRequestId, supersedes: "agent.spawn_failed" } });
+  };
+  const slot = { child, kind: "agent.ready" };
+  if (!spawner) {
+    const created = await routeAgentNotice(slot);
+    recordSpawnTerminal(spawnRequestId, "agent.ready");
+    if (created) readyEvent();
+    return;
   }
-
+  const parent = noticeRecipient(child, spawner);
   if (recovered) {
     // A correction must always reach a parent that got the (false) failure — gate only on the global
     // switch, NOT the agentReady sub-toggle, so the retraction lands even if ready pushes are off.
-    routeNotification({
+    const created = await routeAgentNotice(slot, {
       type: "agent.spawn_recovered",
       scope: { agentId: childId, parent },
       recipients: [parent],
@@ -186,9 +192,11 @@ function announceReady(child: AgentCard, spawner: string | undefined): void {
         replyExpected: false,
       },
     });
+    recordSpawnTerminal(spawnRequestId, "agent.ready");
+    if (created) readyEvent();
     return;
   }
-  routeNotification({
+  const created = await routeAgentNotice(slot, {
     type: "agent.ready",
     scope: { agentId: childId, parent },
     recipients: [parent],
@@ -199,7 +207,8 @@ function announceReady(child: AgentCard, spawner: string | undefined): void {
       replyExpected: false,
     },
   });
-  stampChildLifecycleSignal(parent, child);
+  recordSpawnTerminal(spawnRequestId, "agent.ready");
+  if (created) { readyEvent(); stampChildLifecycleSignal(parent, child); }
 }
 
 /**
@@ -209,16 +218,20 @@ function announceReady(child: AgentCard, spawner: string | undefined): void {
  * No-op for non-spawned agents.
  * `reason` is the offline cause (e.g. "heartbeat lost", "shutdown").
  */
-export function notifyAgentOffline(childId: string, reason: string, diagnosis?: AgentDeathDiagnosis): void {
-  requestAgentExitCleanup(childId);
+export async function notifyAgentOffline(childId: string, reason: string, diagnosis?: AgentDeathDiagnosis): Promise<void> {
+  return serializeSpawnNotice(spawnQueueKey(childId), () => notifyAgentOfflineBody(childId, reason, diagnosis));
+}
+
+async function notifyAgentOfflineBody(childId: string, reason: string, diagnosis?: AgentDeathDiagnosis): Promise<void> {
+  (await requestAgentExitCleanup(childId));
   const child = getAgent(childId);
   const parent = child?.spawnedBy;
   if (!child) return;
   if (!parent) {
     // A workflow step agent with no spawner records its exit on its run (#3160); nobody else is told.
     if (workflowRunIdOf(child) && everReady(child)) {
-      clearAgentNotice(child, "agent.ready");
-      notifyAgentExit(child, reason, diagnosis);
+      await clearAgentNoticeAsync(child, "agent.ready");
+      await notifyAgentExit(child, reason, diagnosis);
     }
     return;
   }
@@ -228,38 +241,32 @@ export function notifyAgentOffline(childId: string, reason: string, diagnosis?:
   // later signal (relay_workspace_ready, task→done) is coming from a process that no longer exists.
   // Idempotent (flushWorkFinalReports no-ops once the ring is empty), so a redundant call from a
   // second offline classification of the same agent is harmless.
-  markAgentWorkFinal(childId, "edge-fallback");
+  (await markAgentWorkFinal(childId, "edge-fallback"));
   // Classify from the durable readiness stamp; re-arm this generation's ready push for a return.
   const wasReady = everReady(child);
-  clearAgentNotice(child, "agent.ready");
+  await clearAgentNoticeAsync(child, "agent.ready");
   // #636 — persist the post-mortem keyed by agentId so the WHY survives the reaper, regardless of
   // whether the parent push is enabled. Recorded once per terminal-event emission.
-  if (diagnosis) recordCrashReport(crashReportFor(child, reason, diagnosis));
+  if (diagnosis) await recordCrashReportAsync(crashReportFor(child, reason, diagnosis));
   if (hasAgentExitNotice(child)) return;
 
   // #645 — persist a terminal marker for ANY offline terminus (clean exit or spawn-fail) keyed by
   // agentId so it outlives the reaper. The #634 watchdog reads this to skip a benign shutdown; it
   // must fire ONLY on a genuine silent death that emitted no terminal event at all.
-  recordTerminalEvent({ agentId: childId, reason, kind: wasReady ? "agent.exited" : "agent.spawn_failed", epoch: child.epoch, createdAt: Date.now() });
+  await recordTerminalEventAsync({ agentId: childId, reason, kind: wasReady ? "agent.exited" : "agent.spawn_failed", epoch: child.epoch, createdAt: Date.now() });
 
   if (wasReady) {
-    notifyAgentExit(child, reason, diagnosis);
+    await notifyAgentExit(child, reason, diagnosis);
     return;
   }
 
-  recordAgentNoticeOnce(child, () => {
+
     const recipient = noticeRecipient(child, parent);
     // #648 — record the terminal outcome so a (defensive) later ready for the same request is detected
     // as a recovery and corrected, keeping the one-terminal-per-spawn invariant across both fail paths.
     const spawnRequestId = spawnRequestIdOf(child);
-    if (!tryRecordSpawnFailed(spawnRequestId)) return;
-    emitRelayEvent({
-      type: "agent.spawn_failed",
-      source: "server",
-      subject: childId,
-      data: { agentId: childId, parent, reason, provider: providerOf(child), spawnRequestId, neverReady: true, ...(diagnosis ? { diagnosis } : {}) },
-    });
-    routeNotification({
+    if (spawnTerminalOf(spawnRequestId)) return;
+    const created = await routeAgentNotice({ child, kind: "agent.spawn_failed" }, {
       type: "agent.spawn_failed",
       scope: { agentId: childId, parent: recipient },
       recipients: [recipient],
@@ -274,7 +281,15 @@ export function notifyAgentOffline(childId: string, reason: string, diagnosis?:
         replyExpected: false,
       },
     });
-  }, "agent.spawn_failed");
+    recordSpawnTerminal(spawnRequestId, "agent.spawn_failed");
+    if (created) {
+    emitRelayEvent({
+      type: "agent.spawn_failed",
+      source: "server",
+      subject: childId,
+      data: { agentId: childId, parent, reason, provider: providerOf(child), spawnRequestId, neverReady: true, ...(diagnosis ? { diagnosis } : {}) },
+    });
+    }
 }
 
 /**
@@ -286,21 +301,19 @@ export function notifyAgentOffline(childId: string, reason: string, diagnosis?:
  * the subsequent agent.ready / agent.spawn_failed — no separate "admitted" event needed. Non-terminal:
  * it deliberately does NOT touch the one-terminal-per-spawn guard.
  */
-export function notifyAgentSpawnQueued(input: { parent: string; spawnRequestId?: string; provider?: string; reason: string }): void {
+export async function notifyAgentSpawnQueued(input: { parent: string; spawnRequestId?: string; provider?: string; reason: string }): Promise<void> {
+  return serializeSpawnNotice(input.spawnRequestId ?? `parent:${input.parent}`, () => notifyAgentSpawnQueuedBody(input));
+}
+
+async function notifyAgentSpawnQueuedBody(input: { parent: string; spawnRequestId?: string; provider?: string; reason: string }): Promise<void> {
   const dedupeKey = input.spawnRequestId ?? `parent:${input.parent}`;
   if (spawnQueuedNotified.has(dedupeKey)) return;
   // A queued spawn whose terminal outcome already landed (a fast admit→ready, or a fail) must not now
   // emit a stale "queued" notice out of order. Ready/failed is authoritative; suppress a late queue.
   if (spawnTerminalOf(input.spawnRequestId)) return;
-  spawnQueuedNotified.add(dedupeKey);
-  emitRelayEvent({
-    type: "agent.spawn_queued",
-    source: "server",
-    subject: input.spawnRequestId ?? input.parent,
-    data: { parent: input.parent, spawnRequestId: input.spawnRequestId, provider: input.provider, reason: input.reason },
-  });
+
   const recipient = spawnerRecipient(input.parent, input.spawnRequestId);
-  routeNotification({
+  await routeNotification({
     type: "agent.spawn_queued",
     scope: { parent: recipient },
     recipients: [recipient],
@@ -314,6 +327,13 @@ export function notifyAgentSpawnQueued(input: { parent: string; spawnRequestId?:
       replyExpected: false,
     },
   });
+  spawnQueuedNotified.add(dedupeKey);
+  emitRelayEvent({
+    type: "agent.spawn_queued",
+    source: "server",
+    subject: input.spawnRequestId ?? input.parent,
+    data: { parent: input.parent, spawnRequestId: input.spawnRequestId, provider: input.provider, reason: input.reason },
+  });
 }
 
 /**
@@ -321,18 +341,17 @@ export function notifyAgentSpawnQueued(input: { parent: string; spawnRequestId?:
  * (provider unavailable, bad cwd, launch error) before any child agent registered. Routes directly
  * to the spawning parent threaded on the command, since there is no child agent record to resolve.
  */
-export function notifyAgentSpawnFailed(input: { parent: string; spawnRequestId?: string; provider?: string; reason: string }): void {
+export async function notifyAgentSpawnFailed(input: { parent: string; spawnRequestId?: string; provider?: string; reason: string }): Promise<void> {
+  return serializeSpawnNotice(input.spawnRequestId ?? `parent:${input.parent}`, () => notifyAgentSpawnFailedBody(input));
+}
+
+async function notifyAgentSpawnFailedBody(input: { parent: string; spawnRequestId?: string; provider?: string; reason: string }): Promise<void> {
   // #648/#864 — if the spawn already reached any terminal outcome, a later command-failure report
   // for the same request is stale or duplicate. Ready is authoritative; failed is already reported.
-  if (!tryRecordSpawnFailed(input.spawnRequestId)) return;
-  emitRelayEvent({
-    type: "agent.spawn_failed",
-    source: "server",
-    subject: input.spawnRequestId ?? input.parent,
-    data: { parent: input.parent, spawnRequestId: input.spawnRequestId, provider: input.provider, reason: input.reason },
-  });
+  if (spawnTerminalOf(input.spawnRequestId)) return;
+
   const recipient = spawnerRecipient(input.parent, input.spawnRequestId);
-  routeNotification({
+  await routeNotification({
     type: "agent.spawn_failed",
     scope: { parent: recipient },
     recipients: [recipient],
@@ -346,6 +365,13 @@ export function notifyAgentSpawnFailed(input: { parent: string; spawnRequestId?:
       replyExpected: false,
     },
   });
+  recordSpawnTerminal(input.spawnRequestId, "agent.spawn_failed");
+  emitRelayEvent({
+    type: "agent.spawn_failed",
+    source: "server",
+    subject: input.spawnRequestId ?? input.parent,
+    data: { parent: input.parent, spawnRequestId: input.spawnRequestId, provider: input.provider, reason: input.reason },
+  });
 }
 
 /**
@@ -353,7 +379,7 @@ export function notifyAgentSpawnFailed(input: { parent: string; spawnRequestId?:
  * deliberately non-terminal: the runner can still register after the watchdog fires, so callers
  * must not retry or infer that a new spawn is safe.
  */
-export function notifyAgentSpawnUnconfirmed(input: { parent: string; spawnRequestId: string; provider?: string; reason: string; phase: "dispatch_unacknowledged" | "registration_unconfirmed" }): void {
+export async function notifyAgentSpawnUnconfirmed(input: { parent: string; spawnRequestId: string; provider?: string; reason: string; phase: "dispatch_unacknowledged" | "registration_unconfirmed" }): Promise<void> {
   emitRelayEvent({
     type: "agent.spawn_unconfirmed",
     source: "server",
@@ -361,7 +387,7 @@ export function notifyAgentSpawnUnconfirmed(input: { parent: string; spawnReques
     data: input,
   });
   const recipient = spawnerRecipient(input.parent, input.spawnRequestId);
-  routeNotification({
+  await routeNotification({
     type: "agent.spawn_unconfirmed",
     scope: { parent: recipient },
     recipients: [recipient],
@@ -392,24 +418,18 @@ export function notifyAgentRegistered(agent: AgentCard): void {
 }
 
 /** Emit one parent exit notice per generation, including automatic reaps before the offline report. */
-export function notifyAgentExit(child: AgentCard, reason: string, diagnosis?: AgentDeathDiagnosis, context: { workspaceId?: string; workspaceStatus?: string } = {}): void {
+export async function notifyAgentExit(child: AgentCard, reason: string, diagnosis?: AgentDeathDiagnosis, context: { workspaceId?: string; workspaceStatus?: string } = {}): Promise<void> {
   const parent = child.spawnedBy;
   const workflowRunId = workflowRunIdOf(child);
-  recordAgentNoticeOnce(child, () => {
-    emitRelayEvent({
-      type: "agent.exited",
-      source: "server",
-      subject: child.id,
-      data: { ...context, agentId: child.id, parent, reason, provider: providerOf(child), spawnRequestId: spawnRequestIdOf(child), ...(workflowRunId ? { workflowRunId } : {}), ...(diagnosis ? { diagnosis } : {}) },
-    });
+
     // The parent already got a shutdown command receipt for requesting this exit, so the
     // exit itself is expected — including a non-zero code from a force-reap kill. Keep the
     // terminal event for timeline consumers; only skip the parent wake-up. An exit nobody
     // requested (no shutdown command from the parent) still wakes: crashes and spawn failures
     // keep their notice.
-    if (parent && parentRequestedShutdown(child.id, spawnRequestIdOf(child) ?? "", parent, Date.now() - 5 * 60_000)) return;
+    const suppressed = parent && parentRequestedShutdown(child.id, spawnRequestIdOf(child) ?? "", parent, Date.now() - 5 * 60_000);
     const recipient = parent ? noticeRecipient(child, parent) : undefined;
-    routeNotification({
+    const created = await routeAgentNotice({ child, kind: "agent.exited" }, suppressed ? undefined : {
       type: "agent.exited",
       scope: { agentId: child.id, parent: recipient },
       recipients: [recipient],
@@ -424,5 +444,12 @@ export function notifyAgentExit(child: AgentCard, reason: string, diagnosis?: Ag
         replyExpected: false,
       },
     });
-  });
+    if (created) {
+    emitRelayEvent({
+      type: "agent.exited",
+      source: "server",
+      subject: child.id,
+      data: { ...context, agentId: child.id, parent, reason, provider: providerOf(child), spawnRequestId: spawnRequestIdOf(child), ...(workflowRunId ? { workflowRunId } : {}), ...(diagnosis ? { diagnosis } : {}) },
+    });
+    }
 }

package/src/agent-ref.ts

@@ -160,8 +160,9 @@ export function resolveAgentRef(ref: string, agents: AgentCard[], opts: ResolveO
   return { status: "not_found", offlineMatches: matches };
 }
 
-export function targetMatchesAgent(target: string, agentId: string, agent?: AgentCard | null): boolean {
-  if (!agent) return false;
+export function targetMatchesAgent(target: string | null | undefined, agentId: string, agent?: AgentCard | null): boolean {
+  // Untargeted task events have no agent recipient, on live streams or replay (#3801).
+  if (!agent || typeof target !== "string" || !target) return false;
   if (target.startsWith("coordinator:")) return resolveTeamCoordinatorAgentId(target.slice(12)) === agentId;
   return targetMatchesAgentIdentity(target, {
     id: agentId,

package/src/agent-status-events.ts

@@ -1,18 +1,41 @@
-// The ONE agent.status emitter (#3606): every seam lands here, so "unchanged card → no event" holds on all.
-// A card equal to the last one emitted, ignoring lastSeen and statusSeq, is dropped before persistence:
-// liveness ticks only moved those two (39% of prod agent.status events), the dashboard reads heartbeat
-// age from its 5–15 s roster poll, and no consumer orders by statusSeq.
+// The ONE agent.status emitter (#3606): every seam lands here. A card unchanged but for lastSeen and
+// statusSeq is dropped (the dashboard reads heartbeat age from its roster poll; nothing orders by
+// statusSeq). #3614 — a change only in liveness telemetry (timestamps, ages, gauges the next tick
+// supersedes) goes out live-only, with no outbox row; replay keeps every real state change.
 
 import { getAgentRuntimeAsync } from "./db";
 import { projectAgentStatusData } from "./agent-card-projection";
-import { emitRelayEvent } from "./events";
+import { emitEphemeralRelayEvent, emitRelayEvent } from "./events";
 import { emitNotificationCreated, notificationForAgentStatus } from "./dashboard-notifications";
 
-const lastEmitted = new Map<string, number | bigint>();
+type Fingerprint = number | bigint;
 
-function cardFingerprint(data: Record<string, unknown>): number | bigint {
-  const { lastSeen: _lastSeen, statusSeq: _statusSeq, ...card } = data;
-  return Bun.hash(JSON.stringify(card));
+const UNEMITTED_KEYS = [["lastSeen"], ["statusSeq"]] as const;
+const LIVENESS_KEYS = [
+  ...UNEMITTED_KEYS,
+  ["context", "lastUpdatedAt"], ["context", "tokensUsed"], ["context", "utilization"],
+  ["meta", "unreportedTokenUsage"], ["meta", "lastProviderEventAt"],
+  ["meta", "transport", "lastServerFrameAt"], ["meta", "transport", "lastHeartbeatAckAt"],
+  ["meta", "liveness", "transportLiveAt"], ["meta", "liveness", "lastProgressAt"],
+  ["meta", "busyHealth", "activeWorkAgeMs"], ["meta", "busyHealth", "staleForMs"], ["meta", "busyHealth", "lastProgressAt"],
+  ["meta", "busyHealth", "transportLiveAt"], ["meta", "busyHealth", "transportStaleForMs"],
+] as const;
+
+const lastEmitted = new Map<string, { card: Fingerprint; durable: Fingerprint }>();
+
+/** Hash of the card without `paths`; copies only the objects on a stripped path. */
+function fingerprint(data: Record<string, unknown>, paths: ReadonlyArray<readonly string[]>): Fingerprint {
+  const root = { ...data };
+  for (const path of paths) {
+    let parent: Record<string, unknown> = root;
+    for (const key of path.slice(0, -1)) {
+      const child = parent[key];
+      if (!child || typeof child !== "object" || Array.isArray(child)) { parent = {}; break; }
+      parent = parent[key] = { ...child as Record<string, unknown> };
+    }
+    delete parent[path[path.length - 1]!];
+  }
+  return Bun.hash(JSON.stringify(root));
 }
 
 export async function emitAgentStatus(agentId: string): Promise<void> {
@@ -20,15 +43,21 @@ export async function emitAgentStatus(agentId: string): Promise<void> {
   // Enrich with the branch-state badge fields (#236) and the resolved issueRepo (#533) so
   // the dashboard's live agent updates carry the same projection as GET /api/agents (#560).
   const data = await projectAgentStatusData(agentId, agent) as unknown as Record<string, unknown>;
-  const fingerprint = cardFingerprint(data);
-  if (lastEmitted.get(agentId) === fingerprint) return;
-  lastEmitted.set(agentId, fingerprint);
+  const next = { card: fingerprint(data, UNEMITTED_KEYS), durable: fingerprint(data, LIVENESS_KEYS) };
+  const previous = lastEmitted.get(agentId);
+  if (previous?.card === next.card) return;
+  lastEmitted.set(agentId, next);
+  const event = { type: "agent.status", source: "server", subject: agentId, data };
+  if (previous?.durable === next.durable) {
+    emitEphemeralRelayEvent(event);
+    return;
+  }
   try {
     // Awaited: a bus registration must not install its socket before its own status event is durable.
-    await emitRelayEvent({ type: "agent.status", source: "server", subject: agentId, data });
+    await emitRelayEvent(event);
   } catch (error) {
     // Never let an append that did not happen suppress the next identical card.
-    if (lastEmitted.get(agentId) === fingerprint) lastEmitted.delete(agentId);
+    if (lastEmitted.get(agentId) === next) lastEmitted.delete(agentId);
     throw error;
   }
   const notification = agent ? notificationForAgentStatus(agent) : undefined;