@humwick/server 0.130.2 → 0.130.3

package/src/services/review-ref-reconcile.ts

@@ -1,3 +1,4 @@
+import { cancelPendingCommandAsync, recordReviewRefCleanupDispatchAsync, markReviewRefPublishedAsync, markReviewRefFailedAsync, markReviewRefClosedAsync, markReviewRefAnnouncedAsync, deleteReviewRefCleanupAsync } from "../db/runtime-tail-async";
 // #1452 round-4 — the durable, OFF-critical-path engine that settles the review-ref (refs/review/*)
 // lifecycle and cleans up leaked refs. It reads the review_ref_cleanups ledger (one row per EXACT
 // server-derived ref) — NOT a per-workspace marker — so it fixes every round-4 finding at once:
@@ -23,18 +24,8 @@
 // was never enabled, since rows are only written when a publish is dispatched.
 
 import { getWorkspace } from "../db";
-import {
-  deleteReviewRefCleanup,
-  getReviewRefFenceToken,
-  listReviewRefCleanups,
-  markReviewRefAnnounced,
-  markReviewRefClosed,
-  markReviewRefFailed,
-  markReviewRefPublished,
-  recordReviewRefCleanupDispatch,
-  type ReviewRefCleanup,
-} from "../db/review-ref-cleanups";
-import { cancelPendingCommand, getCommand } from "../commands-db";
+import { getReviewRefFenceToken, listReviewRefCleanups, type ReviewRefCleanup } from "../db/review-ref-cleanups";
+import { getCommand } from "../commands-db";
 import { emitCommand } from "../maintenance/events";
 import { emitRelayEvent } from "../events";
 import { buildReviewRefUnpublishCommandFromFields } from "../workspace-actions";
@@ -81,16 +72,16 @@ interface ReconcileDeps {
    *  pending publish can still be externally spoofed to succeeded{pushed:true}. Requiring the token here
    *  refuses that phantom before it can announce a ref that was never pushed. Returns null when absent. */
   getFenceToken: (id: string) => string | null;
-  markPublished: typeof markReviewRefPublished;
-  markFailed: typeof markReviewRefFailed;
-  markAnnounced: typeof markReviewRefAnnounced;
-  markClosed: typeof markReviewRefClosed;
-  recordDispatch: typeof recordReviewRefCleanupDispatch;
-  deleteCleanup: typeof deleteReviewRefCleanup;
+  markPublished: typeof markReviewRefPublishedAsync;
+  markFailed: typeof markReviewRefFailedAsync;
+  markAnnounced: typeof markReviewRefAnnouncedAsync;
+  markClosed: typeof markReviewRefClosedAsync;
+  recordDispatch: typeof recordReviewRefCleanupDispatchAsync;
+  deleteCleanup: typeof deleteReviewRefCleanupAsync;
   buildUnpublish: typeof buildReviewRefUnpublishCommandFromFields;
   /** #1452 round-10 HIGH #1 — atomically cancel the publish command IFF still pending; true means it
    *  was never dispatched (proven no push can occur), so a closed round can retire it without racing. */
-  cancelPublish: (id: string) => boolean;
+  cancelPublish: (id: string) => boolean | Promise<boolean>;
   emit: (command: Command) => void;
   /** Durable publish-settled announcement: emitted for a published-but-unannounced row, then marked
    *  announced only on success — so a crash/outbox failure re-emits next pass (round-6 H-atomicity). */
@@ -164,21 +155,21 @@ const realDeps: ReconcileDeps = {
   },
   getCommand,
   getFenceToken: getReviewRefFenceToken,
-  markPublished: markReviewRefPublished,
-  markFailed: markReviewRefFailed,
-  markAnnounced: markReviewRefAnnounced,
-  markClosed: markReviewRefClosed,
-  recordDispatch: recordReviewRefCleanupDispatch,
-  deleteCleanup: deleteReviewRefCleanup,
+  markPublished: markReviewRefPublishedAsync,
+  markFailed: markReviewRefFailedAsync,
+  markAnnounced: markReviewRefAnnouncedAsync,
+  markClosed: markReviewRefClosedAsync,
+  recordDispatch: recordReviewRefCleanupDispatchAsync,
+  deleteCleanup: deleteReviewRefCleanupAsync,
   buildUnpublish: buildReviewRefUnpublishCommandFromFields,
-  cancelPublish: (id) => cancelPendingCommand(id, "workspace.publish-review", "review publish canceled: round closed before dispatch"),
+  cancelPublish: async (id) => (await cancelPendingCommandAsync(id, "workspace.publish-review", "review publish canceled: round closed before dispatch")),
   emit: emitCommand,
   emitPublished: emitPublishedEvent,
   now: () => Date.now(),
 };
 
 /** One reconcile pass over the durable ledger. Pure over its (injectable) deps for testing. */
-export function reconcileReviewRefs(deps: ReconcileDeps = realDeps, signal?: AbortSignal): ReviewRefReconcileResult {
+export async function reconcileReviewRefs(deps: ReconcileDeps = realDeps, signal?: AbortSignal): Promise<ReviewRefReconcileResult> {
   const rows = deps.listCleanups();
   const published: string[] = [];
   const failed: string[] = [];
@@ -208,7 +199,7 @@ export function reconcileReviewRefs(deps: ReconcileDeps = realDeps, signal?: Abo
       const roundClosed = !ws
         || TERMINAL_WORKSPACE_STATUSES.has(ws.status as any)
         || Boolean(ws.branch && row.branch && ws.branch !== row.branch);
-      if (roundClosed) { deps.markClosed(row.id, now); closed = true; }
+      if (roundClosed) { await deps.markClosed(row.id, now); closed = true; }
     }
 
     // 1) Settle the publish outcome (H2). A ref is only real once its push command TERMINALLY
@@ -229,8 +220,8 @@ export function reconcileReviewRefs(deps: ReconcileDeps = realDeps, signal?: Abo
         // push can occur) → retire with nothing on origin. If it was already claimed (accepted/running),
         // the host may push, so WAIT for its terminal settlement — cleanup then runs safely AFTER it.
         if (!closed) { inFlight.push(label()); continue; }
-        if (!deps.cancelPublish(row.id)) { inFlight.push(label()); continue; } // already claimed → wait
-        deps.markFailed(row.id, now, false); // canceled before dispatch → nothing on origin, drop the ref
+        if (!await deps.cancelPublish(row.id)) { inFlight.push(label()); continue; } // already claimed → wait
+        await deps.markFailed(row.id, now, false); // canceled before dispatch → nothing on origin, drop the ref
         confirmedRef = undefined;
         publishState = "failed";
         failed.push(label());
@@ -242,7 +233,7 @@ export function reconcileReviewRefs(deps: ReconcileDeps = realDeps, signal?: Abo
         // never-claimed pending publish spoofed to succeeded has none, so it never advances to published.
         const ref = confirmedPublishRef(cmd, row.requestedSha, row.ref, deps.getFenceToken(row.id));
         if (ref) {
-          deps.markPublished(row.id, ref, now); // sets announced=0 → announced below (H-atomicity)
+          await deps.markPublished(row.id, ref, now); // sets announced=0 → announced below (H-atomicity)
           confirmedRef = ref;
           publishState = "published";
           announced = false;
@@ -253,7 +244,7 @@ export function reconcileReviewRefs(deps: ReconcileDeps = realDeps, signal?: Abo
           // timed-out/canceled, a missing/pruned result, or a malformed success) may have pushed before
           // its result was lost ⇒ RETAIN the pinned ref as a tombstone and unpublish before deletion.
           const notPushed = definitivelyNotPushed(cmd);
-          deps.markFailed(row.id, now, !notPushed);
+          await deps.markFailed(row.id, now, !notPushed);
           if (notPushed) confirmedRef = undefined;
           publishState = "failed";
           failed.push(label());
@@ -267,7 +258,7 @@ export function reconcileReviewRefs(deps: ReconcileDeps = realDeps, signal?: Abo
     if (publishState === "published" && !announced && confirmedRef) {
       try {
         deps.emitPublished({ workspaceId: row.workspaceId, ref: confirmedRef, ...(row.requestedSha ? { sha: row.requestedSha } : {}), ...(row.branch ? { branch: row.branch } : {}) });
-        deps.markAnnounced(row.id, now);
+        await deps.markAnnounced(row.id, now);
         announced = true;
       } catch { /* emit failed → leave announced=0 so the next pass re-emits (at-least-once) */ }
     }
@@ -285,7 +276,7 @@ export function reconcileReviewRefs(deps: ReconcileDeps = realDeps, signal?: Abo
 
     // A closed round with NOTHING on origin — a DEFINITIVELY-not-pushed outcome, or a legacy row that
     // never pinned a ref — has nothing to delete. Retire it directly, no host round-trip, no leak.
-    if (!confirmedRef) { deps.deleteCleanup(row.id); cleared.push(label()); continue; }
+    if (!confirmedRef) { await deps.deleteCleanup(row.id); cleared.push(label()); continue; }
 
     // 3) Drive deletion (H4/M7) of the EXACT host-confirmed ref. CONFIRM a prior attempt first — a
     //    succeeded delete clears the row regardless of the backoff window; the backoff gates only a
@@ -294,20 +285,20 @@ export function reconcileReviewRefs(deps: ReconcileDeps = realDeps, signal?: Abo
       const cmd = deps.getCommand(row.cleanupCommandId);
       if (cmd && !COMMAND_TERMINAL.has(cmd.status)) { inFlight.push(confirmedRef); continue; }
       if (cmd && cmd.status === "succeeded" && !cmd.error) {
-        deps.deleteCleanup(row.id); // origin confirmed the ref is gone (deleted or already absent)
+        await deps.deleteCleanup(row.id); // origin confirmed the ref is gone (deleted or already absent)
         cleared.push(confirmedRef);
         continue;
       }
       // failed / timed_out / missing → re-dispatch below, subject to backoff.
     }
     if (row.nextAttemptAt != null && row.nextAttemptAt > now) { waiting.push(confirmedRef); continue; }
-    const built = deps.buildUnpublish(
+    const built = await deps.buildUnpublish(
       { workspaceId: row.workspaceId, repoRoot: row.repoRoot, worktreePath: row.worktreePath, branch: row.branch, orchestratorId: row.orchestratorId, ref: confirmedRef },
       "review-ref-reconciler",
     );
     if (!built.ok) continue; // no owning host reachable yet — retry next tick (no backoff burned)
     deps.emit(built.command);
-    deps.recordDispatch(row.id, built.command.id, now + cleanupBackoffMs(row.cleanupAttempts), now);
+    await deps.recordDispatch(row.id, built.command.id, now + cleanupBackoffMs(row.cleanupAttempts), now);
     dispatched.push(confirmedRef);
   }
 
@@ -326,7 +317,7 @@ export const REVIEW_REF_RECONCILE_JOB = {
   intervalMs: WORKSPACE_ORPHAN_REAPER_INTERVAL_MS,
   runOnStart: false,
   deadlineMs: 60 * 1000,
-  handler: (context: { signal?: AbortSignal }) => reconcileReviewRefs(undefined, context.signal) as unknown as Record<string, unknown>,
+  handler: async (context: { signal?: AbortSignal }) => (await reconcileReviewRefs(undefined, context.signal)) as unknown as Record<string, unknown>,
 };
 
 // Test seam: backoff parameters so tests assert scheduling without duplicating literals.

package/src/services/runtime-dependency-alert.ts

@@ -0,0 +1,27 @@
+import { createHash } from "node:crypto";
+import { isRecord } from "@humwick/sdk";
+import { createActivityEventByClientIdAsync } from "../db/activity-async";
+import { notifyWorkspaceHumanEscalation } from "../workspace-human-escalation";
+import { stewardFallbackTarget } from "../config";
+import { notifyTarget } from "../maintenance/events";
+
+/** Heartbeats already persist provider failures for Fleet; page once per broken checkout (#3791). */
+export async function reportRuntimeDependencyFailure(hostId: string, hostname: string, body: unknown): Promise<void> {
+  if (!isRecord(body) || !Array.isArray(body.providerStatus)) return;
+  const failure = body.providerStatus.find((status) => isRecord(status) && status.available === false
+    && typeof status.reason === "string" && status.reason.startsWith("Runtime dependencies unavailable in "));
+  if (!failure) return;
+  const reason = failure.reason as string;
+  const checkout = reason.split(": ")[0]!;
+  const key = `runtime-dependencies:${hostId}:${createHash("sha256").update(checkout).digest("hex")}`;
+  const subject = `Runtime dependencies broken on ${hostname}`;
+  const message = `${hostname}: ${reason}. Providers are unavailable until this checkout is repaired.`;
+  const event = await createActivityEventByClientIdAsync({ clientId: key, kind: "state", title: subject, body: message,
+    meta: hostId, icon: "ti-alert-triangle", view: "orchestrators", metadata: { hostId, reason } });
+  if (!event.created) return;
+  const payload = { hostId, reason, kind: "runtime-dependencies.failed" };
+  const human = await notifyWorkspaceHumanEscalation({ subject, body: message, priority: "urgent", source: "runtime-dependencies", payload, idempotencyKey: key });
+  const target = stewardFallbackTarget();
+  const routed = target ? await notifyTarget("maintenance.degraded", {}, target, subject, message, payload, key) : null;
+  console.warn(`[relay] ${subject}: ${reason}${human.accepted || routed ? "" : " — no notification target configured"}`);
+}

package/src/services/scheduler-command.ts

@@ -1,9 +1,11 @@
+import { updateCommandAsync } from "../commands-write";
 import { writeChildEnv } from "@humwick/sdk/env";
 import { basename } from "node:path";
 import { SCHEDULER_RETRY_MS } from "../config";
 import { errMessage, stringValue } from "@humwick/sdk";
 import { hasScope } from "@humwick/sdk/types";
-import { findLatestCommandByCorrelation, getCommand, updateCommand } from "../commands-db";
+import { getCommand } from "../commands-db";
+import { findLatestCommandByCorrelationAsync } from "../commands-write";
 import { RELAY_RUN_DEADLINE_GRACE_MS } from "../relay-run-lease";
 import { storeTextArtifact } from "../artifact-text";
 import { gateRunIdentity, recordAgentGateRun } from "../gate-run-capture";
@@ -119,7 +121,7 @@ export async function dispatchScheduledCommand(timer: ScheduledTimer, ctx = pers
   // Freeze the agent generation that owns this command. Managed restarts reuse the
   // durable agent id, so agentId alone would let predecessor teardown kill a successor's command.
   const executionOwnerSpawnRequestId = spawnRequestIds?.length === 1 ? spawnRequestIds[0] : undefined;
-  const command = findLatestCommandByCorrelation("scheduler.command", timer.correlationId) ?? await dispatchCommandAsync({
+  const command = await findLatestCommandByCorrelationAsync("scheduler.command", timer.correlationId) ?? await dispatchCommandAsync({
     type: "scheduler.command",
     source: timer.createdBy,
     target: `orchestrator-${timer.command.orchestratorId}`,
@@ -186,7 +188,7 @@ export async function fireScheduledCommandTimeout(timer: ScheduledTimer, now: nu
     return { status: "deferred" };
   }
   const neverStarted = !!command && (command.status === "pending" || command.status === "accepted") && commandResult(command).phase !== "running";
-  if (command) updateCommand(command.id, { status: "timed_out", error: "background command timed out" });
+  if (command) (await updateCommandAsync(command.id, { status: "timed_out", error: "background command timed out" }));
   const result = command ? commandResult(command) : {};
   const admittedAt = numberValue(result.admittedAt) ?? timer.command.admittedAt;
   const durationMs = admittedAt === undefined ? 0 : Math.max(0, now - admittedAt);
@@ -202,7 +204,7 @@ export async function fireScheduledCommandTimeout(timer: ScheduledTimer, now: nu
     stdoutTail: stringValue(result.stdoutTail) ?? timer.command.stdoutTail ?? "",
     stderrTail: stringValue(result.stderrTail) ?? timer.command.stderrTail ?? (neverStarted ? queuedTimeoutReason(timer.command.orchestratorId) : "background command timed out"),
   };
-  return fireScheduledCommandWake(timer, {
+  return (await fireScheduledCommandWake(timer, {
     status: "timed_out",
     finishedAt: timer.command.finishedAt ?? now,
     durationMs,
@@ -213,7 +215,7 @@ export async function fireScheduledCommandTimeout(timer: ScheduledTimer, now: nu
     exitCode: null,
     stdoutTail: timeoutResult.stdoutTail,
     stderrTail: timeoutResult.stderrTail,
-  }, timeoutResult, now, inlineWakeSuppressed(timer.command, now));
+  }, timeoutResult, now, inlineWakeSuppressed(timer.command, now)));
 }
 
 /** #2776 — admission report: the fallback timer now guards the RUN (end + grace), not the queue ceiling. */
@@ -243,7 +245,7 @@ export async function settleScheduledCommandTimer(command: Command, now = Date.n
       : "failed";
   const stdout = clipTail(stringValue(result.stdoutTail) ?? stringValue(result.stdout) ?? "");
   const stderr = clipTail(stringValue(result.stderrTail) ?? stringValue(result.stderr) ?? command.error ?? "");
-  return fireScheduledCommandWake(timer, {
+  return (await fireScheduledCommandWake(timer, {
     status,
     finishedAt: timer.command.finishedAt ?? now,
     startedAt: numberValue(result.startedAt),
@@ -262,7 +264,7 @@ export async function settleScheduledCommandTimer(command: Command, now = Date.n
     // Strictly stronger than truncation: the command was KILLED for flooding, it did not finish.
     outputLimitExceeded: result.outputLimitExceeded === true,
     logArtifactId: stringValue(result.logArtifactId),
-  }, result, now, inlineWakeSuppressed(timer.command, now));
+  }, result, now, inlineWakeSuppressed(timer.command, now)));
 }
 
 /**
@@ -358,7 +360,7 @@ async function fireScheduledCommandWake(
   try {
     const runNumber = timerForSend.runCount + 1;
     const payloadResult = commandPayload(timerForSend.command!, rawResult, logArtifactId);
-    const send = sendMessageService({
+    const send = (await sendMessageService({
       from: timerForSend.deliveryFrom,
       to: timerForSend.target,
       kind: timerForSend.messageKind as SendMessageInput["kind"] | undefined,
@@ -387,7 +389,7 @@ async function fireScheduledCommandWake(
       },
       // One stable key per command completion (not per run count): overlapping settlements dedupe.
       idempotencyKey: `${timerForSend.idempotencyKey ?? `scheduler:${timerForSend.id}`}:completion`,
-    }, persistedCommandAuthContext(timerForSend));
+    }, persistedCommandAuthContext(timerForSend)));
     await completeTimerRunAsync(timerForSend, send.message.id, now);
     return { status: "fired", messageId: send.message.id };
   } catch (error) {

package/src/services/scheduler.ts

@@ -1,3 +1,4 @@
+import { framed } from "../hub-metrics";
 import { createScheduledTimer } from "./scheduler-create";
 import { planScheduledTimerCreate, cleanOptionalString, canAdministerTimers, type ScheduleTimerInput } from "./scheduler-plan";
 export { type ScheduleTimerInput } from "./scheduler-plan";
@@ -84,9 +85,8 @@ export function startRelayScheduler(): void {
   if (isEphemeralMode()) return;
   if (schedulerTimer) return;
   void timePostBindPhase("runDueScheduledTimers", runDueScheduledTimers).catch((error) => console.warn(`relay scheduler tick failed: ${errMessage(error)}`));
-  schedulerTimer = setInterval(() => {
-    void timePostBindPhase("runDueScheduledTimers", runDueScheduledTimers).catch((error) => console.warn(`relay scheduler tick failed: ${errMessage(error)}`));
-  }, SCHEDULER_TICK_MS);
+  schedulerTimer = setInterval(framed("timer scheduled-timers", () =>
+    timePostBindPhase("runDueScheduledTimers", runDueScheduledTimers).catch((error) => console.warn(`relay scheduler tick failed: ${errMessage(error)}`))), SCHEDULER_TICK_MS);
   // #1408 K7 Phase-2: additively light up the kernel-served timers supervisor iff the reversible
   // switch is on (default OFF ⇒ pure no-op). Legacy above stays authoritative; the kernel path is
   // not yet a functional replacement for message/command dispatch (see kernel-timers.ts).
@@ -292,7 +292,7 @@ async function fireClaimedTimer(
       await disableTimerAsync(timer.id, "timer expired before delivery");
       return { status: "disabled" };
     }
-    return fireScheduledCommandTimeout(timer, now);
+    return (await fireScheduledCommandTimeout(timer, now));
   }
 
   try {
@@ -323,7 +323,7 @@ async function fireClaimedTimer(
       await disableTimerAsync(timer.id, "timer expired before delivery");
       return { status: "disabled" };
     }
-    const result = sendMessageService(sendInput, persistedAuthContext(timer));
+    const result = (await sendMessageService(sendInput, persistedAuthContext(timer)));
     await completeTimerRunAsync(timer, result.message.id, now);
     return { status: "fired", messageId: result.message.id };
   } catch (error) {

package/src/services/self-effort-grant.ts

@@ -1,3 +1,5 @@
+import { grantSelfEffortAsync } from "../db/agent-control-async";
+export { SELF_EFFORT_GRANT_COMMAND } from "../db/agent-control-write";
 import { randomUUID } from "node:crypto";
 import { stringValue } from "@humwick/sdk";
 import { createCommandInternal, updateCommandInternal } from "../commands-db";
@@ -14,7 +16,7 @@ import type { Command } from "../types";
 
 // #2966 — the operator turns selfEffort on or off for a running agent. The permission row is the
 // state; the settled command written beside it is the audit record.
-export const SELF_EFFORT_GRANT_COMMAND = "agent.grantSelfEffort";
+
 
 interface SelfEffortGrantInput extends SelfEffortSpawnInput {
   agentId: string;
@@ -27,7 +29,7 @@ interface SelfEffortGrantInput extends SelfEffortSpawnInput {
 export async function grantSelfEffort(input: SelfEffortGrantInput, ctx: AuthContext): Promise<{ selfEffort: SelfEffortPolicy | null; command: Command }> {
   const agent = getAgent(input.agentId);
   if (!agent) throw new AgentActionTargetError(`agent ${input.agentId} not found`);
-  authorizeShutdown(ctx, { agentId: agent.id, requestedVia: input.requestedVia });
+  (await authorizeShutdown(ctx, { agentId: agent.id, requestedVia: input.requestedVia }));
   const spawnRequestId = stringValue(agent.meta?.spawnRequestId);
   if (typeof input.selfEffort !== "boolean") throw new ValidationError("selfEffort must be true or false");
   const model = agent.providerCapabilities?.model;
@@ -64,29 +66,7 @@ export async function grantSelfEffort(input: SelfEffortGrantInput, ctx: AuthCont
   revalidateAgentInstance(agent);
   // Nothing executes a grant: it is written settled with the permission in one transaction. The
   // identity is resolved inside it, so a stale writer cannot restore a deleted policy's row.
-  const command = writeTransaction(() => {
-    const now = Date.now();
-    const identity = selfEffortIdentity(agent);
-    setSelfEffortCeilingInternal(identity, !grant ? null : "band" in grant ? SELF_EFFORT_BAND : grant.ceiling, requestedBy, now);
-    createCommandInternal({ id: commandId, input: {
-      type: SELF_EFFORT_GRANT_COMMAND,
-      source: "system",
-      target: agent.id,
-      ...(spawnRequestId ? { correlationId: spawnRequestId } : {}),
-      params: {
-        agentId: agent.id,
-        ...(spawnRequestId ? { spawnRequestId } : {}),
-        permission: identity,
-        selfEffort,
-        previousSelfEffort: previous,
-        requestedBy,
-        ...(input.requestedByUser ? { requestedByUser: input.requestedByUser } : {}),
-        requestedVia: input.requestedVia,
-        requestedAt: now,
-      },
-    } }, now);
-    return updateCommandInternal(commandId, { status: "succeeded", result: { selfEffort } }, {}, now).command!;
-  });
+  const command = await grantSelfEffortAsync({ agent, grant, requestedBy, commandId, spawnRequestId, input, selfEffort, previous });
   emitCommandEvent(command, "command.succeeded");
   emitActivityEvent(event);
   return { selfEffort, command };

package/src/services/send-message.ts

@@ -1,7 +1,9 @@
+import { promoteLineageCapturedResponseAsync } from "../db/runtime-tail-async";
+import { sendMessageWithResultAsync } from "../db/message-send";
 import { refusedResponseReport } from "./response-report-admission";
 import { suppressResultsOnlyAck, isResultsOnlyAckCandidate } from "../db/message-send-suppression";
 import { getGateway } from "../db/gateway";
-import { getMessageAsync, channelObligationAnsweredByAsync } from "../db";
+import { getMessageAsync, channelObligationAnsweredByAsync, ValidationError, getAgent, getMessage, isChannelAgentId, listAgents, sendMessagesBatchWithResultAsync, channelObligationAnsweredBy, agentPrincipalUserId, isMultiUserWorld, type SendMessageResult as DbSendMessageResult } from "../db";
 import { agentPrincipalSink } from "../db/agent-ownership";
 // Transport convergence (epic #342, slice #346) — the message-send service.
 //
@@ -27,21 +29,6 @@ import { agentPrincipalSink } from "../db/agent-ownership";
 // OUT OF SCOPE (transport-edge, excluded from the parity facet): automatic memory injection
 // (needs request-derived context) and per-transport audit (HTTP domain row vs MCP tool-call row).
 import { LEGACY_HUMAN_AGENT_ID, USER_NAMESPACE_PREFIX, userSinkId, canonicalHumanAgentId, heldForSender, isHumanAgentId, isMechanicalMessageKind, isRecord, isReservedAgentId, isTurnFinalSession } from "@humwick/sdk";
-import {
-  ValidationError,
-  getAgent,
-  getMessage,
-  isChannelAgentId,
-  listAgents,
-  promoteLineageCapturedResponse,
-  sendMessagesBatchWithResultAsync,
-  sendMessageWithResult,
-  sendMessageWithResultAsync,
-  channelObligationAnsweredBy,
-  agentPrincipalUserId,
-  isMultiUserWorld,
-  type SendMessageResult as DbSendMessageResult,
-} from "../db";
 import { recentFinalResponseCaptureIds } from "../db/lineage-startup-captures";
 import { yieldToEventLoop } from "../event-loop-yield";
 import { markAgentWorkFinal } from "./work-finality";
@@ -367,18 +354,12 @@ function agentSendAllowed(input: SendMessageInput, ctx: AuthContext, sender: Mes
   return inSameMessagingRun(sender, getAgent(input.to));
 }
 
-export function sendMessageService(
+export async function sendMessageService(
   input: SendMessageInput,
   ctx: AuthContext,
   opts: SendMessageOptions = {},
-): SendMessageResult {
-  const { receipt, suppressedParent } = prepareSendMessage(input, ctx, opts);
-  if (suppressedParent) return { message: suppressedParent, created: false, receipt };
-  const result = sendMessageWithResult(input, { allowUnregisteredSender: opts.allowUnregisteredSender });
-  const sent = { message: result.message, created: result.created, receipt: finalizeReceipt(result.message, receipt) };
-  if (opts.deferLiveEffects) return { ...sent, publish: () => emitSendResults([result]) };
-  emitSendResults([result]);
-  return sent;
+): Promise<SendMessageResult> {
+  return sendMessageServiceAsync(input, ctx, opts);
 }
 
 /** Async persistence and message-history reads; live target authorization and emits stay on main.
@@ -391,8 +372,10 @@ export async function sendMessageServiceAsync(
   const { receipt, suppressedParent } = await prepareSendMessageAsync(input, ctx, opts);
   if (suppressedParent) return { message: suppressedParent, created: false, receipt };
   const result = await sendMessageWithResultAsync(input, { allowUnregisteredSender: opts.allowUnregisteredSender });
-  emitSendResults([result]);
-  return { message: result.message, created: result.created, receipt: finalizeReceipt(result.message, receipt) };
+  const sent = { message: result.message, created: result.created, receipt: finalizeReceipt(result.message, receipt) };
+  if (opts.deferLiveEffects) return { ...sent, publish: async () => (await emitSendResults([result])) };
+  (await emitSendResults([result]));
+  return sent;
 }
 
 export async function sendMessagesBatchService(
@@ -426,7 +409,7 @@ export async function sendMessagesBatchService(
       receipt: finalizeReceipt(result.message, prepared[outputIndex]!.receipt),
     };
   }
-  emitSendResults(stored);
+  (await emitSendResults(stored));
   return results;
 }
 
@@ -504,11 +487,11 @@ export async function sweepDeferredLineageReportsOnStartup(now: number = Date.no
     // A tagged capture was already flushed before boot (or by an earlier sweep). Skipping it avoids
     // re-arming the held ring, minting a second finality window, and re-emitting `message.finalized`.
     if (isRecord(capture.payload?.finality)) continue;
-    const promoted = promoteLineageCapturedResponse(capture);
+    const promoted = (await promoteLineageCapturedResponseAsync(capture));
     if (promoted?.created) emitted.push(promoted.message);
     // The ordinary 10-minute cutoff protects live coalescing. Recovery is already bounded by the
     // 24-hour query, and persistence proves this capture's source turn completed before boot.
-    const recovered = markAgentWorkFinal(capture.from, "edge-fallback", { includeStaleCompletedFinals: true });
+    const recovered = (await markAgentWorkFinal(capture.from, "edge-fallback", { includeStaleCompletedFinals: true }));
     recoveredCount += recovered.forwarded.filter((entry) => entry.created).length;
   }
   if (emitted.length > 0) emitNewMessages(emitted);
@@ -517,7 +500,7 @@ export async function sweepDeferredLineageReportsOnStartup(now: number = Date.no
   return { promoted: emitted.length + recoveredCount, scanned, ...(signal?.aborted ? { aborted: true as const } : {}) };
 }
 
-function emitSendResults(results: DbSendMessageResult[]): void {
+export async function emitSendResults(results: DbSendMessageResult[]): Promise<void> {
   const liveMessages: Message[] = [];
   for (const result of results) {
     if (result.created) {
@@ -538,13 +521,13 @@ function emitSendResults(results: DbSendMessageResult[]): void {
           emitMessageDeliveryUpdated(result.message);
         }
       }
-      const promoted = promoteLineageCapturedResponse(result.message);
+      const promoted = (await promoteLineageCapturedResponseAsync(result.message));
       if (promoted?.created) liveMessages.push(promoted.message);
     } else if (result.updated) {
       // Session-step upsert (#parity): the row changed in place (same DB id). Re-emit so the
       // dashboard's id-keyed merge replaces the existing step live — no duplicate row.
       liveMessages.push(result.message);
-      const promoted = promoteLineageCapturedResponse(result.message);
+      const promoted = (await promoteLineageCapturedResponseAsync(result.message));
       if (promoted?.created) liveMessages.push(promoted.message);
     }
   }

package/src/services/shutdown-agent.ts

@@ -1,3 +1,5 @@
+import { createAgentControlAsync } from "../db/agent-control-async";
+import type { SafeCandidate } from "./idle-agent-digest";
 import { spawnTreeContains } from "../db/spawn-tree";
 import { spawnDelegationState } from "../db/spawn-delegation-state";
 // Transport convergence (epic #342, slice #347) — the agent-shutdown service.
@@ -37,7 +39,6 @@ import { spawnDelegationState } from "../db/spawn-delegation-state";
 // system auth" — the steward-reaper's forceful escalation does; its graceful first attempt does not.
 import {
   ValidationError,
-  inWriteTransaction,
   createActivityEventAsync,
   getAgent,
   getOrchestrator,
@@ -46,7 +47,7 @@ import {
   mergeAgentMetaAsync,
 } from "../db";
 import { randomUUID } from "node:crypto";
-import { createCommandInternal, findSpawnCommandByRequestId, getCommand } from "../commands-db";
+import { findSpawnCommandByRequestId, getCommand } from "../commands-db";
 import { SPAWN_CANCELABLE_STATUSES } from "../spawn-intent";
 import { isRestartSensitiveCommand } from "../db/restart-sensitive";
 import { cancelCommandIfStatusAsync } from "../commands-write";
@@ -112,6 +113,7 @@ interface ShutdownAgentInput {
   /** #3428 — automatic disposal only: re-checked on the fresh card at command admission, after
    * every await; a returned reason refuses the shutdown. */
   admit?: (agent: AgentCard) => string | undefined;
+  idleCandidate?: SafeCandidate;
 }
 
 interface ShutdownAgentResult {
@@ -173,7 +175,7 @@ export interface ShutdownAuthorization {
 
 /** The #221 parent→child gate — the single home for shutdown authorization across all
  * three transports. Throws `ShutdownAuthError` on denial; full-reach callers bypass ownership. */
-export function authorizeShutdown(ctx: AuthContext, input: ShutdownAgentInput, action = "shutdown"): ShutdownAuthorization {
+export async function authorizeShutdown(ctx: AuthContext, input: ShutdownAgentInput, action = "shutdown"): Promise<ShutdownAuthorization> {
   const callerId = ctx.callerAgentId;
   // A scoped agent caller may target only its OWN live spawned children — or (#2618) live members
   // of a team it currently coordinates, e.g. after claiming a dead coordinator's team. Two PRECISE
@@ -211,7 +213,7 @@ export function authorizeShutdown(ctx: AuthContext, input: ShutdownAgentInput, a
       }
     }
     // #3567 — the one lifecycle-control check (principal, role, coordinator authority).
-    const denied = authorizeAgentControl(ctx, target, action);
+    const denied = (await authorizeAgentControl(ctx, target, action));
     if (denied) {
       throw new ShutdownAuthError(denied.reason === "coordinator" && !input.agentId
         ? `no spawned child of yours matches spawnRequestId ${input.spawnRequestId}` : denied.message);
@@ -315,7 +317,7 @@ async function reapInFlightSpawnCommand(
     return { command: canceled ?? command, orchestratorId: (canceled ?? command).target, agent: null };
   }
   emitCommandEvent(canceled, "command.canceled");
-  notifyAgentSpawnFailed({
+  await notifyAgentSpawnFailed({
     parent: stringValue(canceled.params.spawnedBy) ?? ctx.callerAgentId ?? ctx.actor.id,
     spawnRequestId: input.spawnRequestId,
     provider: stringValue(canceled.params.provider),
@@ -334,11 +336,11 @@ async function reapInFlightSpawnCommand(
  * shutting-down (uniform across transports — MCP previously skipped this), and writes the
  * audit row. The single fat-service entry point the three thin transports call. */
 export function shutdownAgent(input: ShutdownAgentInput, ctx: AuthContext): Promise<ShutdownAgentResult> {
-  return withRelayEventDrain(() => shutdownAgentBody(input, ctx));
+  return withRelayEventDrain(async () => (await shutdownAgentBody(input, ctx)));
 }
 
 async function shutdownAgentBody(input: ShutdownAgentInput, ctx: AuthContext): Promise<ShutdownAgentResult> {
-  const authz = authorizeShutdown(ctx, input);
+  const authz = (await authorizeShutdown(ctx, input));
   if (authz.spawnCommand) return reapInFlightSpawnCommand(authz.spawnCommand, input, ctx);
 
   const agent = input.agentId ? getAgent(input.agentId) : null;
@@ -414,19 +416,20 @@ async function shutdownAgentBody(input: ShutdownAgentInput, ctx: AuthContext): P
   const priorCommand = input.commandId ? getCommand(commandId) : null;
   if (priorCommand) return { command: priorCommand, orchestratorId: orchestrator.id, agent: currentAgent };
   const admit = input.admit;
-  // #3428 — automatic disposal re-decides on the fresh card in the same write transaction as the insert.
-  const command = admit && currentAgent ? inWriteTransaction(() => {
-    const refused = admit(getAgent(currentAgent.id) ?? currentAgent);
+  if (admit && currentAgent) {
+    const refused = admit(currentAgent);
     if (refused) throw new AutomaticShutdownRefused(`automatic shutdown of ${currentAgent.id} refused at admission: ${refused}`);
-    return createCommandInternal({ input: commandInput, id: commandId });
-  }) : createCommandInternal({ input: commandInput, id: commandId });
+  }
+  const admitted = await createAgentControlAsync({ agent: currentAgent, commandId, commandInput, idleCandidate: input.idleCandidate });
+  if (!admitted.command) throw new AutomaticShutdownRefused(`automatic shutdown of ${currentAgent?.id} refused at admission: ${admitted.refused}`);
+  const command = admitted.command;
   emitCommandEvent(command, "command.requested");
-  if (targetAgentId) reapAgentBrowserSessions(targetAgentId); // #3489 — a requested stop takes its browser with it
+  if (targetAgentId) (await reapAgentBrowserSessions(targetAgentId)); // #3489 — a requested stop takes its browser with it
   // #1084 — an explicit shutdown is a platform-owned teardown signal: close the target's work
   // window now rather than let a held final group die silently with the process. `edge-fallback`
   // is the closest fit in the closed source enum — there is no cleaner workspace-ready/task-done
   // signal backing an arbitrary teardown (which may target an agent with neither).
-  if (targetAgentId) markAgentWorkFinal(targetAgentId, "edge-fallback");
+  if (targetAgentId) (await markAgentWorkFinal(targetAgentId, "edge-fallback"));
 
   // Lifecycle indicator — uniform across transports. The MCP path previously skipped
   // this, so an MCP-initiated shutdown left the agent with no "shutting down" signal in