@humwick/server 0.130.1 → 0.130.3

package/src/routes/agents.ts

@@ -1,8 +1,8 @@
 // Auto-split from routes.ts (#299). Domain: agents.
 import { messageViewerForRequest, visibleMessages } from "./message-viewer";
 import { attachPrincipal, attachPrincipals } from "../agent-principal";
-import { VALID_AGENT_STATUSES, agentSessionStatus, auditEvent, canViewAgentRoute, error, json, normalizeAgentSessionGuard, parseBody, parseId, parseQueryInt, visibleAgentIdsForRequest, type Handler } from "./_shared";
-import { ValidationError, deleteAgentAsync, getAgent, getAgentAsync, getAgentIdentityAsync, getAgentQuotaSnapshotsAsync, getAgentTimelineAsync, getCrashReport, recordHeartbeat, listAgentChatHistoryAsync, listAgents, listAgentsAsync, listArtifactsForEntityAsync, listContextSnapshotsAsync, listPendingReplyObligationsAsync, markReadyAsync, searchAgentsAsync, setLabelAsync, setStatusAsync, setTagsAsync, validateAgentSession } from "../db";
+import { agentSessionStatus, auditEvent, authorizeRoute, canViewAgentRoute, error, json, normalizeAgentSessionGuard, parseBody, parseId, parseQueryInt, visibleAgentIdsForRequest, type Handler } from "./_shared";
+import { ValidationError, deleteAgentAsync, getAgent, getAgentAsync, getAgentIdentityAsync, getAgentQuotaSnapshotsAsync, getAgentTimelineAsync, getCrashReport, listAgentChatHistoryAsync, listAgents, listAgentsAsync, listArtifactsForEntityAsync, listContextSnapshotsAsync, listPendingReplyObligationsAsync, searchAgentsAsync, setLabelAsync, setTagsAsync, validateAgentSession } from "../db";
 import { attachBranchState, attachBranchStates } from "../agent-branch-state";
 import { redactAgentCardLaunchShape } from "../agent-launch-shape-redaction";
 import { attachChannelBinding, attachChannelBindings } from "../agent-channel-binding";
@@ -10,47 +10,16 @@ import { attachCommandActivities, attachCommandActivity } from "../agent-command
 import { attachIssueRepo, attachIssueRepos } from "../agent-issue-repo";
 import { cleanStringArray } from "../validation";
 import { emitAgentRemoved, emitAgentStatus } from "../sse";
-import { announceSpawnedAgentReady } from "../services/register-agent";
-import { flushQueuedDirectMessages } from "../services/managed-running";
-import { acquireTeamOnReady } from "../services/team";
 import { artifactReadScopeForRequest } from "../services/artifact-access";
-import { isAgentUnavailable } from "../db/agent-predicates";
 import { getCompactionWatch } from "../compaction-watch";
 import { isRecord } from "@humwick/sdk";
 import { getComponentAuth, hasComponentScope } from "../security";
-import { type AgentCard, type AgentSessionGuard } from "../types";
+import { type AgentCard } from "../types";
 import { attachToolchain } from "../project-toolchain";
 import { listEffortChangesAsync } from "../commands-write";
 import { markAgentWorkFinal } from "../services/work-finality";
-
-type AgentActivityState = {
-  key: "available" | "busy" | "not-ready" | "offline";
-  title: string;
-  icon: string;
-};
-
-function agentActivityState(agent?: Pick<AgentCard, "ready" | "status"> | null): AgentActivityState | null {
-  if (!agent) return null;
-  if (agent.status === "offline") return { key: "offline", title: "Agent offline", icon: "ti-plug-off" };
-  if (!agent.ready) return { key: "not-ready", title: "Agent not ready", icon: "ti-loader" };
-  if (agent.status === "busy") return { key: "busy", title: "Agent busy", icon: "ti-activity" };
-  return { key: "available", title: "Agent available", icon: "ti-circle-check" };
-}
-
-async function auditAgentStateTransition(agentId: string, before: AgentCard | null | undefined, after: AgentCard | null | undefined): Promise<void> {
-  const previous = agentActivityState(before);
-  const next = agentActivityState(after);
-  if (!next || previous?.key === next.key) return;
-  await auditEvent({
-    clientId: "server-agent-" + agentId + "-state-" + next.key + "-" + Date.now(),
-    kind: "state",
-    title: next.title,
-    meta: agentId,
-    icon: next.icon,
-    view: "agents",
-    agentId,
-  });
-}
+import { authorizeProviderQuotaWrite } from "./provider-quotas";
+import { applyAgentHeartbeat, applyAgentReady, applyAgentStatus, cleanAgentStatus, cleanHeartbeatReport, noteUnchangedLifecycle } from "../services/agent-heartbeat";
 
 // #1797 round 2 (F1b) — the agent roster carried `meta.policyName` + `meta.spawnRequestId` in the
 // clear to any `agent:read` holder. Those two strings are the ADDRESSING for every managed-agent
@@ -248,56 +217,6 @@ export const getTaskArtifactsRoute: Handler = async (req, params) => {
   return json(await listArtifactsForEntityAsync("task", id, artifactReadScopeForRequest(req)));
 };
 
-type AgentStatusValue = (typeof VALID_AGENT_STATUSES)[number];
-
-function cleanAgentStatus(value: unknown): AgentStatusValue {
-  if (!VALID_AGENT_STATUSES.includes(value as AgentStatusValue)) throw new ValidationError(`status must be one of: ${VALID_AGENT_STATUSES.join(", ")}`);
-  return value as AgentStatusValue;
-}
-
-// #3606 — a reported status/readiness equal to the live card is a liveness tick, not a transition: no
-// row write, no agent.status event. Presence still advances through the coalescing heartbeat buffer,
-// except for a terminal row, which a beat would resurrect.
-function noteUnchangedLifecycle(agentId: string, current: AgentCard, guard: AgentSessionGuard | undefined): void {
-  if (current.status !== "offline" && current.status !== "stale") recordHeartbeat(agentId, { guard });
-}
-
-async function applyAgentStatus(agentId: string, status: AgentStatusValue, guard: AgentSessionGuard | undefined, before: AgentCard | null): Promise<boolean> {
-  // #1895 (S3.2 L10, review finding 3) — routed through the async gateway facade.
-  if (!(await setStatusAsync(agentId, status, guard))) return false;
-  await auditAgentStateTransition(agentId, before, getAgent(agentId));
-  await emitAgentStatus(agentId);
-  return true;
-}
-
-async function applyAgentReady(agentId: string, ready: boolean, guard: AgentSessionGuard | undefined, before: AgentCard | null): Promise<boolean> {
-  // #1895 (S3.2 L10, review finding 3) — routed through the async gateway facade.
-  if (!(await markReadyAsync(agentId, ready, guard))) return false;
-  await auditAgentStateTransition(agentId, before, getAgent(agentId));
-  // #308 — a spawned child flipping false→true ready is "genuinely ready" (past onboarding):
-  // wake its parent so it can stop block-polling and stamp the durable readiness. #2432 —
-  // announceSpawnedAgentReady is the shared seam; it no-ops for non-spawned agents and dedups
-  // repeat readies (e.g. a later bus status frame or PATCH for an already-announced child).
-  // #1927 review round 2 (HIGH 1) — the audit above now awaits the async gateway, widening the
-  // window for a concurrent same-instance PATCH to flip ready back to false before we get here.
-  // Re-read the LIVE card (and re-check the session guard) right before firing these effects
-  // instead of trusting the pre-audit snapshot, so a superseded transition never fires a false
-  // durable agent.ready.
-  if (ready && !before?.ready) {
-    const live = getAgent(agentId);
-    const stillCurrentInstance = validateAgentSession(agentId, guard).ok;
-    if (live?.ready === true && stillCurrentInstance) {
-      announceSpawnedAgentReady(agentId, "agent-ready");
-      acquireTeamOnReady(agentId); // #3107 — before the flush, so seat mail reaches a new holder
-      // #416 — also flush queued direct messages: a not-ready agent that becomes ready
-      // may have queued messages waiting (e.g. starting up, clearing context).
-      flushQueuedDirectMessages(agentId);
-    }
-  }
-  await emitAgentStatus(agentId);
-  return true;
-}
-
 export const patchAgentStatus: Handler = async (req, params) => {
   const parsed = await parseBody<{ status: string }>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
@@ -309,7 +228,7 @@ export const patchAgentStatus: Handler = async (req, params) => {
     const session = validateAgentSession(params.id!, guard);
     if (!session.ok) return error(session.error!, agentSessionStatus(session.error));
     const before = getAgent(params.id!);
-    if (before?.status === status) noteUnchangedLifecycle(params.id!, before, guard);
+    if (before?.status === status) await noteUnchangedLifecycle(params.id!, before, guard);
     else if (!(await applyAgentStatus(params.id!, status, guard, before))) return error("agent not found", 404);
   } catch (e) {
     if (e instanceof ValidationError) return error(e.message, 400);
@@ -322,40 +241,19 @@ export const postHeartbeat: Handler = async (req, params) => {
   const parsed = await parseBody<unknown>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
   try {
-    // #3606 — the runner's liveness tick reports status and readiness on this one call (it used to
-    // be status PATCH + ready PATCH + heartbeat). Only a value that differs from the live card takes
-    // the transition path; the rest is a coalesced beat.
-    const body = isRecord(parsed.body) ? parsed.body : {};
-    const status = body.status === undefined ? undefined : cleanAgentStatus(body.status);
-    if (body.ready !== undefined && typeof body.ready !== "boolean") return error("ready must be a boolean");
-    const ready = body.ready as boolean | undefined;
-    const guard = normalizeAgentSessionGuard(req, parsed.body);
-    const session = validateAgentSession(params.id!, guard);
-    if (!session.ok) return error(session.error!, agentSessionStatus(session.error));
-    // #416 — capture unavailability before heartbeat to detect the transition.
-    const beforeHeartbeat = getAgent(params.id!);
-    if (beforeHeartbeat?.kind === "channel" && !beforeHeartbeat.ready) {
-      return error("channel agent not ready; re-register required", 409);
-    }
-    const wasUnavailable = beforeHeartbeat ? isAgentUnavailable(beforeHeartbeat) : false;
-    let current = beforeHeartbeat;
-    if (status !== undefined && status !== current?.status) {
-      if (!(await applyAgentStatus(params.id!, status, guard, current))) return error("agent not found", 404);
-      current = getAgent(params.id!);
-    }
-    if (ready !== undefined && ready !== current?.ready) {
-      if (!(await applyAgentReady(params.id!, ready, guard, current))) return error("agent not found", 404);
-    }
-    // A reported terminal status must not be undone by the beat's offline/stale resurrection.
-    if (status !== "offline" && status !== "stale") {
-      // #1468 — route the API heartbeat through the same coalescing buffer as the bus path.
-      if (!recordHeartbeat(params.id!, { guard })) return error("agent not found", 404);
+    // #3606 — the runner's liveness tick reports status and readiness on this one call; the bus
+    // `agent.heartbeat` frame (#3618) is the same exchange through the same service.
+    const report = cleanHeartbeatReport(params.id!, parsed.body);
+    if (report.unread) {
+      const denied = await authorizeRoute(req, { scope: "message:read", resource: { agentId: params.id!, target: params.id! } });
+      if (denied) return denied;
     }
-    if (wasUnavailable) {
-      const after = getAgent(params.id!);
-      if (after && !isAgentUnavailable(after)) flushQueuedDirectMessages(params.id!);
+    if (report.providerQuota) {
+      const denied = (await authorizeRoute(req, { scope: "quota:write", resource: { agentId: params.id! } })) ?? await authorizeProviderQuotaWrite(req, report.providerQuota);
+      if (denied) return denied;
     }
-    return json({ ok: true });
+    const outcome = await applyAgentHeartbeat(params.id!, report, normalizeAgentSessionGuard(req, parsed.body), messageViewerForRequest(req));
+    return outcome.ok ? json(outcome.result) : error(outcome.error, outcome.status);
   } catch (e) {
     if (e instanceof ValidationError) return error(e.message, 400);
     throw e;
@@ -429,7 +327,7 @@ export const patchAgentReady: Handler = async (req, params) => {
     const session = validateAgentSession(params.id!, guard);
     if (!session.ok) return error(session.error!, agentSessionStatus(session.error));
     const before = getAgent(params.id!);
-    if (before?.ready === body.ready) noteUnchangedLifecycle(params.id!, before, guard);
+    if (before?.ready === body.ready) await noteUnchangedLifecycle(params.id!, before, guard);
     else if (!(await applyAgentReady(params.id!, body.ready, guard, before))) return error("agent not found", 404);
   } catch (e) {
     if (e instanceof ValidationError) return error(e.message, 400);
@@ -439,7 +337,7 @@ export const patchAgentReady: Handler = async (req, params) => {
 };
 
 export const deleteAgentById: Handler = async (_req, params) => {
-  markAgentWorkFinal(params.id!, "edge-fallback");
+  (await markAgentWorkFinal(params.id!, "edge-fallback"));
   // #1895 (S3.2 L10, review finding 3) — routed through the async gateway facade.
   const result = await deleteAgentAsync(params.id!);
   if (!result.ok) {

package/src/routes/auth.ts

@@ -6,7 +6,7 @@ import { authorityDenied, recordUserManagement } from "../authority-audit";
 import { isRecord, type User } from "@humwick/sdk";
 import { error, json, parseBody, type Handler } from "./_shared";
 import { getAuthProvider, listAuthProviders, mintUserSession, type MintedSession } from "../auth";
-import { getAuthIdentity, getUser } from "../db";
+import { getAuthIdentity, getUser, InviteUnavailableError, ValidationError } from "../db";
 import { revokeTokenAsync } from "../token-db-write.ts";
 import { refreshUserSession } from "../auth/session-refresh";
 import { revokeUserSession } from "../auth/session";
@@ -14,7 +14,6 @@ import { readSessionCookie, sessionOriginAllowed, withSessionCookie } from "../a
 import { getComponentAuth } from "../security";
 import { acceptInvite, userInvitesEnabled } from "../services/user-onboarding";
 import { invitesDisabled } from "./users";
-import { InviteUnavailableError, ValidationError } from "../db";
 
 /** Public projection of a user for login/refresh responses — never leaks internal-only columns. */
 function userView(user: User): Record<string, unknown> {
@@ -60,7 +59,7 @@ export const getAuthProvidersRoute: Handler = () =>
  * session. Every failure returns the same generic 401 (no provider/user/credential enumeration).
  */
 export const postAuthLoginRoute: Handler = async (req) => {
-  if (!sessionOriginAllowed(req, false)) return authorityDenied(req, "origin not allowed", 403);
+  if (!sessionOriginAllowed(req, false)) return (await authorityDenied(req, "origin not allowed", 403));
   const parsed = await parseBody<unknown>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
   if (!isRecord(parsed.body)) return error("login body required", 400);
@@ -68,33 +67,33 @@ export const postAuthLoginRoute: Handler = async (req) => {
   if (typeof providerId !== "string" || !providerId) return error("provider required", 400);
 
   const provider = getAuthProvider(providerId);
-  if (!provider) return authorityDenied(req, "invalid credentials", 401);
+  if (!provider) return (await authorityDenied(req, "invalid credentials", 401));
 
   const result = await provider.verify(parsed.body);
-  if (!result) return authorityDenied(req, "invalid credentials", 401);
+  if (!result) return (await authorityDenied(req, "invalid credentials", 401));
 
   const identity = getAuthIdentity(provider.id, result.providerSubject);
-  if (!identity) return authorityDenied(req, "invalid credentials", 401);
+  if (!identity) return (await authorityDenied(req, "invalid credentials", 401));
 
   const user = getUser(identity.userId);
-  if (!user || user.status !== "active") return authorityDenied(req, "invalid credentials", 401);
+  if (!user || user.status !== "active") return (await authorityDenied(req, "invalid credentials", 401));
 
-  return sessionResponse(req, user, mintUserSession(user));
+  return sessionResponse(req, user, (await mintUserSession(user)));
 };
 
 /** POST /api/auth/refresh — cookie only, same-origin, with a short concurrent-request grace. */
 export const postAuthRefreshRoute: Handler = async (req) => {
-  if (!sessionOriginAllowed(req)) return authorityDenied(req, "origin not allowed", 403);
+  if (!sessionOriginAllowed(req)) return (await authorityDenied(req, "origin not allowed", 403));
   const refreshToken = readSessionCookie(req);
   const result = refreshToken ? await refreshUserSession(refreshToken) : null;
   // A stale response must never delete the cookie just rotated by another tab (#3567).
-  if (!result) return authorityDenied(req, "invalid refresh token", 401);
+  if (!result) return (await authorityDenied(req, "invalid refresh token", 401));
   return sessionResponse(req, result.user, result.session);
 };
 
 /** POST /api/auth/logout — bearer authenticates the session; the refresh-only cookie is cleared. */
 export const postAuthLogoutRoute: Handler = async (req) => {
-  if (!sessionOriginAllowed(req, false)) return authorityDenied(req, "origin not allowed", 403);
+  if (!sessionOriginAllowed(req, false)) return (await authorityDenied(req, "origin not allowed", 403));
   const component = getComponentAuth(req);
   if (component?.jti && !(await revokeUserSession(component))) await revokeTokenAsync(component.jti, "admin");
   return withSessionCookie(req, new Response(null, { status: 204 }));
@@ -105,7 +104,7 @@ export const postAuthLogoutRoute: Handler = async (req) => {
  * the single-use code is the credential. Creates the user and returns their first session.
  */
 export const postAcceptInviteRoute: Handler = async (req) => {
-  if (!sessionOriginAllowed(req, false)) return authorityDenied(req, "origin not allowed", 403);
+  if (!sessionOriginAllowed(req, false)) return (await authorityDenied(req, "origin not allowed", 403));
   if (!userInvitesEnabled()) return invitesDisabled();
   const parsed = await parseBody<unknown>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
@@ -113,10 +112,10 @@ export const postAcceptInviteRoute: Handler = async (req) => {
   const body = parsed.body;
   try {
     const user = await acceptInvite({ code: body.code, handle: body.handle, password: body.password, displayName: typeof body.displayName === "string" ? body.displayName.trim().slice(0, 120) || undefined : undefined });
-    recordUserManagement(req, user.id, "accept invite", { role: user.role }, user.id);
-    return sessionResponse(req, user, mintUserSession(user), 201);
+    (await recordUserManagement(req, user.id, "accept invite", { role: user.role }, user.id));
+    return sessionResponse(req, user, (await mintUserSession(user)), 201);
   } catch (e) {
-    if (e instanceof InviteUnavailableError) return authorityDenied(req, e.message, 410);
+    if (e instanceof InviteUnavailableError) return (await authorityDenied(req, e.message, 410));
     if (e instanceof ValidationError) return error(e.message, 400);
     throw e;
   }

package/src/routes/authority-audit.ts

@@ -5,9 +5,9 @@ import { isAdminRequest } from "./users";
 
 /** GET /api/users/authority-denials — private, bounded admin audit list. */
 export const getAuthorityDenials: Handler = async (req) => {
-  const denied = authorizeRoute(req, { scope: "system:admin" });
+  const denied = (await authorizeRoute(req, { scope: "system:admin" }));
   if (denied) return denied;
-  if (!isAdminRequest(req)) return authorityDenied(req, "only admins can read authority denials");
+  if (!isAdminRequest(req)) return (await authorityDenied(req, "only admins can read authority denials"));
   const limit = parseQueryInt(new URL(req.url).searchParams.get("limit"), { min: 1, max: 500 });
   if (Number.isNaN(limit)) return error("limit must be an integer between 1 and 500");
   return json(await listActivityEventsAsync({ title: AUTHORITY_DENIED, limit: limit ?? 100 }));

package/src/routes/automations.ts

@@ -1,6 +1,7 @@
 // Auto-split from routes.ts (#299). Domain: automations.
 import { ValidationError } from "../db";
-import { createAutomationAsync, deleteAutomation, getAutomation, listAutomationRuns, listAutomations, runAutomationNowAsync, updateAutomationAsync, type AutomationDispatchResult } from "../automations";
+import { listAutomationRunsAsync } from "../automations/read-async";
+import { createAutomationAsync, deleteAutomationAsync, getAutomation, listAutomations, runAutomationNowAsync, updateAutomationAsync, type AutomationDispatchResult } from "../automations";
 import { emitCommand, error, json, parseBody, parseQueryInt, type Handler } from "./_shared";
 import { emitNewMessage, emitTaskChanged } from "../sse";
 import { emitRelayEvent } from "../events";
@@ -53,8 +54,8 @@ export const patchAutomation: Handler = async (req, params) => {
   }
 };
 
-export const deleteAutomationById: Handler = (_req, params) => {
-  if (!deleteAutomation(params.id!)) return error("automation not found", 404);
+export const deleteAutomationById: Handler = async (_req, params) => {
+  if (!(await deleteAutomationAsync(params.id!))) return error("automation not found", 404);
   emitRelayEvent({ type: "automation.deleted", source: "server", subject: params.id!, data: { automationId: params.id! } });
   return json({ ok: true });
 };
@@ -71,11 +72,11 @@ export const postAutomationRun: Handler = async (_req, params) => {
   }
 };
 
-export const getAutomationRuns: Handler = (req) => {
+export const getAutomationRuns: Handler = async (req) => {
   const url = new URL(req.url);
   const limitRaw = parseQueryInt(url.searchParams.get("limit"), { min: 1, max: 500 });
   if (Number.isNaN(limitRaw)) return error("limit must be an integer between 1 and 500");
-  return json(listAutomationRuns({
+  return json(await listAutomationRunsAsync({
     automationId: url.searchParams.get("automationId") ?? undefined,
     status: url.searchParams.get("status") ?? undefined,
     limit: limitRaw ?? 100,

package/src/routes/channel-binding-delete.ts

@@ -5,7 +5,7 @@ import { ValidationError } from "../db/connection";
 import { authorizeRoute, error, json, normalizeAgentSessionGuard, parseBody, type Handler } from "./_shared";
 
 export const deleteChannelBinding: Handler = async (req, params) => {
-  const denied = authorizeRoute(req, { scope: "channel:write" });
+  const denied = (await authorizeRoute(req, { scope: "channel:write" }));
   if (denied) return denied;
   const parsed = await parseBody<unknown>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);

package/src/routes/channel-output.ts

@@ -3,12 +3,12 @@ import { authContextFromRequest } from "../services/auth-context";
 import { ValidationError } from "../db/connection";
 import { authorizeRoute, error, json, parseBody, type Handler } from "./_shared";
 
-export const getChannelOutput: Handler = (req, params) => {
-  const denied = authorizeRoute(req, { scope: "channel:read", resource: { channel: params.id } });
+export const getChannelOutput: Handler = async (req, params) => {
+  const denied = (await authorizeRoute(req, { scope: "channel:read", resource: { channel: params.id } }));
   return denied ?? json(channelOutputControl(params.id!));
 };
 export const postChannelOutput: Handler = async (req, params) => {
-  const denied = authorizeRoute(req, { scope: "channel:egress", resource: { channel: params.id } });
+  const denied = (await authorizeRoute(req, { scope: "channel:egress", resource: { channel: params.id } }));
   if (denied) return denied;
   const parsed = await parseBody<unknown>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);

package/src/routes/claude-api-budget.ts

@@ -5,7 +5,7 @@ import { authorizeRoute, error, json, parseBody, type Handler } from "./_shared"
 import { apiBudgetId, isRecord } from "@humwick/sdk";
 
 export const apiBudgetStatusRoute: Handler = async (req, params) => {
-  const denied = authorizeRoute(req, { scope: "system:admin" });
+  const denied = (await authorizeRoute(req, { scope: "system:admin" }));
   if (denied) return denied;
   try { return json(await apiBudgetStatusAsync(apiBudgetId(params.budgetId))); }
   catch { return error("Unknown API budget", 404); }
@@ -16,7 +16,7 @@ export const apiBudgetStatusRoute: Handler = async (req, params) => {
  * it returns the status snapshot only and exposes no mutation.
  */
 export const apiBudgetSummaryRoute: Handler = async (req, params) => {
-  const denied = authorizeRoute(req, { scope: "agent:read" });
+  const denied = (await authorizeRoute(req, { scope: "agent:read" }));
   if (denied) return denied;
   try {
     const summary: ApiBudgetSummary = await apiBudgetStatusAsync(apiBudgetId(params.budgetId));
@@ -24,7 +24,7 @@ export const apiBudgetSummaryRoute: Handler = async (req, params) => {
   } catch { return error("Unknown API budget", 404); }
 };
 export const apiBudgetConfigureRoute: Handler = async (req, params) => {
-  const denied = authorizeRoute(req, { scope: "system:admin" });
+  const denied = (await authorizeRoute(req, { scope: "system:admin" }));
   if (denied) return denied;
   const body = await parseBody<unknown>(req);
   if (!body.ok) return error(body.error, body.status);
@@ -37,7 +37,7 @@ export const apiBudgetConfigureRoute: Handler = async (req, params) => {
 export const apiBudgetSessionRoute: Handler = async (req, params) => {
   if (params.action !== "reserve" && params.action !== "report") return error("Unknown budget operation", 404);
   const agentId = params.id!;
-  const denied = authorizeRoute(req, { scope: "agent:write", resource: { agentId } });
+  const denied = (await authorizeRoute(req, { scope: "agent:write", resource: { agentId } }));
   if (denied) return denied;
   const body = await parseBody<unknown>(req);
   if (!body.ok) return error(body.error, body.status);
@@ -55,7 +55,7 @@ export const apiBudgetSessionRoute: Handler = async (req, params) => {
 };
 
 export const apiBudgetAgentRoute: Handler = async (req, params) => {
-  const denied = authorizeRoute(req, { scope: "agent:read", resource: { agentId: params.id! } });
+  const denied = (await authorizeRoute(req, { scope: "agent:read", resource: { agentId: params.id! } }));
   if (denied) return denied;
   try {
     const budgetId = apiBudgetId(new URL(req.url).searchParams.get("budgetId") ?? "openai-api");

package/src/routes/commands-listing.ts

@@ -32,13 +32,17 @@ export const getCommands: Handler = async (req) => {
     limit: limitRaw ?? undefined,
     dispatchableOnly,
     oldestFirst: dispatchableOnly && status === "pending",
+    // #3391 — a listing omits each spawn's inline agentProfile (13.9 MB per 30 rows blocked the hub
+    // loop); `GET /api/commands/:id` returns the full row. The executor dispatch feed runs the rows it
+    // polls, so it keeps the profile.
+    slim: !dispatchableOnly,
   });
   return json(commands.map((command) => serializeCommandForRead(command, ctx)));
 };
 
 // The host only needs existence, not historical command params/results (#3063).
 export const getActiveCleanup: Handler = async (req) => {
-  const denied = authorizeRoute(req, { scope: "command:read" });
+  const denied = (await authorizeRoute(req, { scope: "command:read" }));
   if (denied) return denied;
   try {
     const target = cleanString(new URL(req.url).searchParams.get("target"), "target", { required: true, max: 240 });

package/src/routes/commands.ts

@@ -1,15 +1,17 @@
+import { fencePublishForPushAsync, setReviewRefFenceTokenAsync } from "../db/runtime-tail-async";
+import { updateCommandAsync, claimPendingCommandAsync } from "../commands-write";
+import { setOrchestratorUpgradeStateAsync } from "../db/orchestrators-async";
+import { deleteWorkspaceAsync } from "../db/lifecycle-tail-async";
 import { VaultError } from "../secrets-vault/keys";
 import { settleProjectRepoCreation } from "../services/project-repo-create";
 import { settleAgentExitCleanupAsync } from "../agent-exit-cleanup-async";
 // Auto-split from routes.ts (#299). Domain: commands.
 import { randomUUID } from "node:crypto";
 import { VALID_AGENT_ACTIONS, agentControlActionIcon, auditEvent, authorizeRoute, emitCommand, error, json, parseBody, type AgentControlAction, type Handler } from "./_shared";
-import { getReviewRefFenceToken, setReviewRefFenceToken } from "../db";
+import { getReviewRefFenceToken, ValidationError, getOrchestrator, getWorkspace, listOrchestrators, patchWorkspaceMetadataAsync, updateWorkspaceStatus } from "../db";
 import { cleanCommandReport, cleanParams, cleanString, optionalEnum } from "../validation";
-import { ValidationError, deleteWorkspace, getOrchestrator, getWorkspace, listOrchestrators, patchWorkspaceMetadataAsync, setOrchestratorUpgradeState, updateWorkspaceStatus } from "../db";
 import { applyCommandToRecipe } from "../recipe-runner";
-import { fencePublishForPush, getCommand, listAcceptedCommandsByOwner, updateCommand } from "../commands-db";
-import { claimPendingCommandAsync, updateCommandAsync } from "../commands-write";
+import { getCommand, listAcceptedCommandsByOwner } from "../commands-db";
 import {
   acceptLandingProgressAsync,
   acquireKernelPublishFenceAsync,
@@ -29,7 +31,7 @@ import { KERNEL_CORRELATION_PREFIX, isReservedKernelCorrelationId } from "../ser
 import { prepareScheduledCommandResultForStorage, settleScheduledCommandTimer } from "../services/scheduler-command";
 import { ServiceAuthError } from "../services/errors";
 import { applyIdleRefreshResult } from "../maintenance/workspaces";
-import { seedMigratedProviderConfigs } from "../provider-config-store";
+import { seedMigratedProviderConfigsAsync } from "../provider-config-store";
 import { notifyAgentSpawnFailed } from "../agent-lifecycle-events";
 import { scheduleRepoMerge } from "../workspace-auto-merge";
 import { settleMemoryInjectionAfterContextCommand } from "../memory-injection";
@@ -103,7 +105,7 @@ async function settleFailedOrchestratorUpgrade(command: Command): Promise<void>
   const up = orch?.upgrade;
   if (!orch || !up || up.status !== "pending" || up.commandId !== command.id) return;
   const errMsg = command.error ?? "orchestrator upgrade failed";
-  setOrchestratorUpgradeState(orch.id, { ...up, status: "failed", settledAt: Date.now(), error: errMsg });
+  (await setOrchestratorUpgradeStateAsync(orch.id, { ...up, status: "failed", settledAt: Date.now(), error: errMsg }));
   await auditEvent({
     clientId: `server-orchestrator-upgrade-command-failed-${orch.id}-${command.id}`,
     kind: "state",
@@ -170,7 +172,7 @@ export const getCommandById: Handler = async (req, params) => {
 // token it minted before claiming; this returns only rows that token accepted and that have not begun
 // running. It is intentionally separate from the normal pending poll, where accepted rows are hidden.
 export const postOwnedAcceptedCommands: Handler = async (req) => {
-  const denied = authorizeRoute(req, { scope: "command:write" });
+  const denied = (await authorizeRoute(req, { scope: "command:write" }));
   if (denied) return denied;
   const parsed = await parseBody<unknown>(req);
   if (!parsed.ok || !isRecord(parsed.body)) return error("command body must be an object", 400);
@@ -188,7 +190,7 @@ export const postOwnedAcceptedCommands: Handler = async (req) => {
 export const claimCommandById: Handler = async (req, params) => {
   const current = getCommand(params.id!);
   if (!current) return error("command not found", 404);
-  const denied = authorizeRoute(req, { scope: "command:write", resource: dispatchCommandAuthorizationResource(current) });
+  const denied = (await authorizeRoute(req, { scope: "command:write", resource: dispatchCommandAuthorizationResource(current) }));
   if (denied) return denied;
   const parsed = await parseBody<unknown>(req);
   const expectedType = parsed.ok && isRecord(parsed.body) ? cleanString(parsed.body.type, "type", { max: 100 }) : undefined;
@@ -223,12 +225,12 @@ export const claimCommandById: Handler = async (req, params) => {
   // persist it in the durable ledger. It is the ONLY credential that authorizes this command's terminal
   // settlement (POST /commands/:id/settle-review-publish), so no other command:write holder — including an
   // admin/`*` token — can spoof succeeded/failed/canceled on the claimed publish (generic PATCH + WS bus
-  // are refused at the updateCommand choke point). Returned to the executor only; never serialized to reads.
+  // are refused at the updateCommandAsync choke point). Returned to the executor only; never serialized to reads.
   let reviewFenceToken: string | undefined;
   if (claimed && claimed.type === "workspace.publish-review") {
     const storedFenceToken = getReviewRefFenceToken(claimed.id);
     reviewFenceToken = storedFenceToken ?? randomUUID();
-    if (!storedFenceToken) setReviewRefFenceToken(claimed.id, reviewFenceToken);
+    if (!storedFenceToken) (await setReviewRefFenceTokenAsync(claimed.id, reviewFenceToken));
   }
   // #2663 — a land that lost its CAS because an OLDER land on the same target's lane is still
   // pending is QUEUED, not out-raced, so name the head. Only a genuine CAS loss opens that: every
@@ -253,14 +255,14 @@ export const claimCommandById: Handler = async (req, params) => {
 };
 
 // #1452 round-13 HIGH#2 — token-gated settlement endpoint: the ONLY external path that may terminalize a
-// CLAIMED review publish (generic PATCH + WS bus are refused at the updateCommand choke point). The caller
+// CLAIMED review publish (generic PATCH + WS bus are refused at the updateCommandAsync choke point). The caller
 // must present the exact fence token minted at claim; a missing/mismatched token fails closed (409). Only
-// then does updateCommand run with executor authority. Confines settlement to the actual executor.
+// then does updateCommandAsync run with executor authority. Confines settlement to the actual executor.
 export const settleReviewPublishCommandById: Handler = async (req, params) => {
   const current = getCommand(params.id!);
   if (!current) return error("command not found", 404);
   if (current.type !== "workspace.publish-review") return error("not a review publish command", 400);
-  const denied = authorizeRoute(req, { scope: "command:write", resource: dispatchCommandAuthorizationResource(current) });
+  const denied = (await authorizeRoute(req, { scope: "command:write", resource: dispatchCommandAuthorizationResource(current) }));
   if (denied) return denied;
   const parsed = await parseBody<unknown>(req);
   if (!parsed.ok || !isRecord(parsed.body)) return error("command body must be an object", 400);
@@ -271,7 +273,7 @@ export const settleReviewPublishCommandById: Handler = async (req, params) => {
   if (!status) return error("status must be succeeded or failed", 400);
   const result = cleanParams(parsed.body.result, "result");
   const err = cleanString(parsed.body.error, "error", { max: 4000 });
-  const command = updateCommand(params.id!, { status: status as CommandStatus, result, error: err }, { executor: true });
+  const command = (await updateCommandAsync(params.id!, { status: status as CommandStatus, result, error: err }, { executor: true }));
   if (!command) return error("command not found", 404);
   emitCommand(command);
   return json(serializeCommandForRead(command, authContextFromRequest(req)));
@@ -285,7 +287,7 @@ export const settleReviewPublishCommandById: Handler = async (req, params) => {
 export const fencePublishCommandById: Handler = async (req, params) => {
   const current = getCommand(params.id!);
   if (!current) return error("command not found", 404);
-  const denied = authorizeRoute(req, { scope: "command:write", resource: dispatchCommandAuthorizationResource(current) });
+  const denied = (await authorizeRoute(req, { scope: "command:write", resource: dispatchCommandAuthorizationResource(current) }));
   if (denied) return denied;
   const parsed = await parseBody<unknown>(req);
   const body = parsed.ok && isRecord(parsed.body) ? parsed.body : {};
@@ -335,7 +337,7 @@ export const fencePublishCommandById: Handler = async (req, params) => {
       ...(fenced.reason ? { reason: fenced.reason } : {}) });
   }
   if (current.type === "workspace.merge" && current.landingContainmentMode === "legacy-unfenced-v0") {
-    const fenced = fencePublishForPush(params.id!, expectedType);
+    const fenced = (await fencePublishForPushAsync(params.id!, expectedType));
     return json({ fenced: Boolean(fenced),
       ...(fenced ? { command: serializeCommandForRead(fenced, authContextFromRequest(req)) } : {}) });
   }
@@ -386,7 +388,7 @@ export const fencePublishCommandById: Handler = async (req, params) => {
     });
     return json({ fenced: permit.permitted, ...(permit.permitId ? { permitId: permit.permitId } : {}), ...(permit.reason ? { reason: permit.reason } : {}) });
   }
-  const fenced = fencePublishForPush(params.id!, expectedType);
+  const fenced = (await fencePublishForPushAsync(params.id!, expectedType));
   return json({
     fenced: Boolean(fenced),
     ...(fenced ? { command: serializeCommandForRead(fenced, authContextFromRequest(req)) } : {}),
@@ -400,7 +402,7 @@ export const patchCommand: Handler = async (req, params) => {
   try {
     const current = getCommand(params.id!);
     if (!current) return error("command not found", 404);
-    const denied = authorizeRoute(req, { scope: "command:write", resource: dispatchCommandAuthorizationResource(current) });
+    const denied = (await authorizeRoute(req, { scope: "command:write", resource: dispatchCommandAuthorizationResource(current) }));
     if (denied) return denied;
     const status = optionalEnum(parsed.body.status, "status", VALID_COMMAND_STATUSES);
     const fencedLanding = (current.type === "workspace.merge" || isLandingCommandType(current.type))
@@ -462,23 +464,23 @@ export const patchCommand: Handler = async (req, params) => {
     noteCompactionCommandCompleted(command);
     // #2095 — durable "clear committed vs no-op" signal, fired on terminal compact/clear commands.
     noteCompactionResult(command);
-    settleSelfResumeContinuationIngestion(command);
-    enqueueContinuationInjectionAfterSelfResume(command);
-    enqueueLifecycleIdentityInjectionAfterContextCommand(command);
-    notifySelfResumeNoOp(command);
-    settleContextResetCarry(command);
-    settleSelfRestartManagedState(command);
-    settleInterruptRedirectMessage(command);
+    (await settleSelfResumeContinuationIngestion(command));
+    (await enqueueContinuationInjectionAfterSelfResume(command));
+    (await enqueueLifecycleIdentityInjectionAfterContextCommand(command));
+    await notifySelfResumeNoOp(command);
+    (await settleContextResetCarry(command));
+    (await settleSelfRestartManagedState(command));
+    (await settleInterruptRedirectMessage(command));
     // #1565 P4b — memory rides BESIDE the continuation as its own payload (§7), delta-gated on
     // compact; and a memory inject that SUCCEEDS is what advances that gate. Ordered LAST and
     // contained (#1565 F8): composing a block touches the DB, ownership and cwd resolution, and a
     // throw in any of that must not take the rest of the settle chain down with it. The continuation
     // enqueue stays first, so it is unaffected either way.
-    settleMemoryInjectionAfterContextCommand(command);
+    (await settleMemoryInjectionAfterContextCommand(command));
     // #1951 — startup context (validation commands, report-up, profile charter, caller context)
     // recomposed from the DB and re-injected beside the others, delta-gated on compact. Contained
     // the same way (a compose throw must not take the rest of the settle chain down with it).
-    settleStartupContextInjectionAfterContextCommand(command);
+    (await settleStartupContextInjectionAfterContextCommand(command));
     if (command.type === "scheduler.command") {
       await settleScheduledCommandTimer(command);
     }
@@ -548,7 +550,7 @@ export const patchCommand: Handler = async (req, params) => {
     if (command.type === "agent.spawn" && command.status === "failed") {
       const parent = isRecord(command.params) ? cleanString(command.params.spawnedBy, "params.spawnedBy", { max: 240 }) : undefined;
       if (parent) {
-        notifyAgentSpawnFailed({
+        await notifyAgentSpawnFailed({
           parent,
           spawnRequestId: isRecord(command.params) ? cleanString(command.params.spawnRequestId, "params.spawnRequestId", { max: 160 }) : undefined,
           provider: isRecord(command.params) ? cleanString(command.params.provider, "params.provider", { max: 40 }) : undefined,
@@ -559,7 +561,7 @@ export const patchCommand: Handler = async (req, params) => {
     if (command.type === "orchestrator.migrate-provider-config" && command.status === "succeeded" && isRecord(result)) {
       // Seed central rows from the reported host-local files with server authority (#465); idempotent, a
       // stored row wins. Seeds from the request: the persisted result holds only fingerprints (#3403).
-      const migration = seedMigratedProviderConfigs(result);
+      const migration = await seedMigratedProviderConfigsAsync(result);
       if (migration?.seeded.length) {
         const { host, seeded } = migration;
         await auditEvent({

package/src/routes/context-resets.ts

@@ -24,9 +24,9 @@ export const postAgentContextResetRoute: Handler = async (req, params) => {
       evidence: { instanceId: cleanString(body.instanceId, "instanceId", { max: 200 }) ?? null },
       observedAt,
     };
-    const carry = recordContextReset(fact);
+    const carry = (await recordContextReset(fact));
     // #3698 — a commanded reset is refreshed by its command's settle; an uncommanded one only here.
-    if (!fact.commandId) refreshContextAfterObservedReset(fact);
+    if (!fact.commandId) (await refreshContextAfterObservedReset(fact));
     return json({ ok: true, carryMessageId: carry?.id ?? null });
   } catch (e) {
     if (e instanceof ValidationError) return error(e.message, 400);