@humwick/server 0.130.1 → 0.130.3

package/src/recipe-runner.ts

@@ -1,6 +1,7 @@
+import { createCommandAsync } from "./commands-write";
 import { writeChildEnv } from "@humwick/sdk/env";
 import { randomUUID } from "node:crypto";
-import { createCommand, type CreateCommandWriteArgs } from "./commands-db";
+import { type CreateCommandWriteArgs } from "./commands-db";
 import { effectiveProviderCatalogListAsync, listOrchestrators } from "./db";
 import { resolveProviderSelection } from "@humwick/sdk/provider-catalog";
 import { getRecipeAsync } from "./recipe-loader";
@@ -15,7 +16,7 @@ import {
   validateRecipeArtifactRefsAsync,
 } from "./recipe-async";
 import type { AttachmentRef, Command, RecipeInstance } from "./types";
-import { SYSTEM_LAUNCH, runnerRuntimeTokenEnv } from "./runtime-tokens";
+import { SYSTEM_LAUNCH, runnerRuntimeTokenEnvAsync } from "./runtime-tokens";
 import { generateSpawnAgentId } from "./services/spawn-identity";
 
 interface StartRecipeInput {
@@ -114,7 +115,7 @@ export async function startRecipe(input: StartRecipeInput): Promise<StartRecipeR
           env: {
             ...(agent.env ?? {}),
             ...(attachments.length ? writeChildEnv({}, { AGENT_RELAY_RECIPE_ARTIFACTS: JSON.stringify(attachments) }) : {}),
-            ...runnerRuntimeTokenEnv({ authority: SYSTEM_LAUNCH,
+            ...await runnerRuntimeTokenEnvAsync({ authority: SYSTEM_LAUNCH,
               agentId,
               orchestratorId: orchestrator.id,
               cwd,
@@ -148,13 +149,13 @@ export async function stopRecipe(instanceId: string, stoppedBy = "cli"): Promise
     // canceled by beginStop; a claimed one is already ordered before this stop and cannot be
     // targeted with an agent.shutdown command until its spawn result supplies a real agent id.
     if (agent.agentId.startsWith("pending:")) continue;
-    const command = createCommand({
+    const command = (await createCommandAsync({
       type: "agent.shutdown",
       source: stoppedBy,
       target: agent.agentId,
       params: { recipeInstanceId: instance.id, role: agent.role },
       ttlMs: 30_000,
-    });
+    }));
     commands.push(command);
     await updateRecipeAgentInstanceAsync(instance.id, agent.agentId, "stopping");
   }

package/src/repo-config-source.ts

@@ -6,7 +6,8 @@
 import { dirname, resolve } from "node:path";
 import { isRecord, stringValue } from "@humwick/sdk";
 import { isTrustedOrchestratorApiUrl, relayAuthHeaders } from "./config";
-import { getConfig, setConfig } from "./config-store";
+import { getConfig } from "./config-store";
+import { setConfigAsync } from "./config-store-write";
 import { listOrchestrators, reportedRepoRootForCwd } from "./db";
 import { hostIsRelayHost } from "./relay-host-locality";
 import { normalizeHostToken, parseJson, sameHostIdentity } from "./utils";
@@ -70,11 +71,16 @@ export function hostRepoConfigSource<T>(spec: HostRepoConfigSpec<T>): HostRepoCo
     return null;
   }
 
-  function writeCached(host: string, keys: readonly string[], found: RepoConfigSource<T> | null): void {
+  /** #1870 S7: writes on the writer thread, and only when the answer changed. `at` is evidence, not a
+   *  TTL, so re-stamping an identical answer on every read only bumped the version and history. */
+  async function writeCached(host: string, keys: readonly string[], found: RepoConfigSource<T> | null): Promise<void> {
     const at = Date.now();
+    const answer = JSON.stringify(found);
     for (const key of keys) {
       try {
-        setConfig<CachedRepoConfigSource<T>>(spec.cacheNamespace, cacheKey(host, key), { found, at }, spec.cacheNamespace);
+        const current = getConfig<CachedRepoConfigSource<T>>(spec.cacheNamespace, cacheKey(host, key))?.value;
+        if (current?.at && JSON.stringify(current.found) === answer) continue;
+        await setConfigAsync<CachedRepoConfigSource<T>>(spec.cacheNamespace, cacheKey(host, key), { found, at }, spec.cacheNamespace);
       } catch {
         // The cache is an optimization for the sync paths; failing to record it must never fail a caller.
       }
@@ -149,7 +155,7 @@ export function hostRepoConfigSource<T>(spec: HostRepoConfigSpec<T>): HostRepoCo
       if (hostIsRelayHost(host)) return { known: true, found: await spec.findLocalAsync(cwd) };
       const read = await readFromHost(cwd, host!);
       if (read.known) {
-        writeCached(host!, cacheWriteKeys(cwd, read.found, opts.alsoCacheFor), read.found);
+        await writeCached(host!, cacheWriteKeys(cwd, read.found, opts.alsoCacheFor), read.found);
         return read;
       }
       return cachedLookup(host!, cwd);

package/src/retention-config-store.ts

@@ -1,4 +1,5 @@
-import { getConfig, setConfig } from "./config-store";
+import { setConfigAsync } from "./config-store-write";
+import { getConfig } from "./config-store";
 import {
   RETENTION_CONFIG_DEFAULTS,
   RETENTION_KEY,
@@ -27,6 +28,6 @@ export function getRetentionConfigEntry(): ConfigEntry<RetentionConfig> {
   };
 }
 
-export function setRetentionConfig(value: unknown, updatedBy?: string): ConfigEntry<RetentionConfig> {
-  return setConfig(RETENTION_NAMESPACE, RETENTION_KEY, value as RetentionConfig, updatedBy);
+export async function setRetentionConfig(value: unknown, updatedBy?: string): Promise<ConfigEntry<RetentionConfig>> {
+  return (await setConfigAsync(RETENTION_NAMESPACE, RETENTION_KEY, value as RetentionConfig, updatedBy));
 }

package/src/reviewer-pipeline.ts

@@ -1,6 +1,7 @@
+import { createCommandAsync } from "./commands-write";
 import { isRecord } from "@humwick/sdk";
 import { planSend } from "./agent-ref";
-import { createCommand } from "./commands-db";
+
 import { getSpawnPolicy } from "./config-store";
 import { deferLandSettleSideEffect } from "./land-settle-dispatch";
 import { getLifecycleManager } from "./lifecycle-manager";
@@ -68,7 +69,7 @@ export async function handleReviewerMergeResult(command: Command, result: Record
   // it must reach the reviewer even if they're offline a while — not a bystander notice. So, like the
   // landing receipt, it is written SYNCHRONOUSLY on the settle path; only the bystander announcement
   // ping and the eager spawn defer off the hot path below.
-  routeNotification({
+  await routeNotification({
     type: "workspace.review_request",
     scope: { workspaceId: workspace.id, repoRoot: workspace.repoRoot },
     recipients: [target],
@@ -102,8 +103,8 @@ export async function handleReviewerMergeResult(command: Command, result: Record
   // (`handleReviewerMergeResult` runs inside `settleWorkspaceMergeCommand`). They defer off the hot
   // path; the spawn self-heals via `reconcilePolicy` even if a deferred dispatch is missed, and the
   // review-request obligation it consumes is already durably queued synchronously above.
-  deferLandSettleSideEffect("reviewer-review-request", () => {
-    emitWorkspaceTaskSemanticNotifications({
+  deferLandSettleSideEffect("reviewer-review-request", async () => {
+    await emitWorkspaceTaskSemanticNotifications({
       workspace: reviewWorkspace,
       transition: "review-requested",
       actor: "reviewer-pipeline",
@@ -144,7 +145,7 @@ export async function handleReviewerPipelineScan(
 
   if (decision === "APPROVED") {
     if (!prNumber && !prUrl) return { skipped: "missing-pr" };
-    const command = createCommand({
+    const command = (await createCommandAsync({
       type: "workspace.pr-arm-auto-merge",
       source: "system",
       target: orchestratorAgentId,
@@ -161,7 +162,7 @@ export async function handleReviewerPipelineScan(
         requestedBy: "reviewer-pipeline",
         requestedAt: now,
       },
-    });
+    }));
     await patchWorkspaceMetadataAsync(workspace.id, {
       autoMergeArmed: true,
       autoMergeArmCommandId: command.id,
@@ -176,7 +177,7 @@ export async function handleReviewerPipelineScan(
     const last = text(workspace.metadata.lastReviewDecision);
     if (last === "CHANGES_REQUESTED") return { skipped: "changes-requested-already-notified" };
     const notifiedOwner = workspace.ownerAgentId
-      ? notifyReviewChangesRequested(workspace, preview, prUrl, prNumber)
+      ? await notifyReviewChangesRequested(workspace, preview, prUrl, prNumber)
       : undefined;
     await patchWorkspaceMetadataAsync(workspace.id, {
       lastReviewDecision: decision,
@@ -198,17 +199,17 @@ function workspaceActiveArm(workspace: WorkspaceRecord): boolean {
   return workspace.metadata.autoMergeArmed === true || typeof workspace.metadata.autoMergeArmCommandId === "string";
 }
 
-function notifyReviewChangesRequested(
+async function notifyReviewChangesRequested(
   workspace: WorkspaceRecord,
   preview: WorkspaceMergePreview,
   prUrl: string | undefined,
   prNumber: number | undefined,
-): string | undefined {
+): Promise<string | undefined> {
   const target = workspace.ownerAgentId;
   if (!target) return undefined;
   // Durable (ttl null): the owner must learn changes were requested on THEIR workspace even after
   // being offline — store-ahead, not a freshness-gated bystander notice.
-  routeNotification({
+  await routeNotification({
     type: "workspace.review_changes_requested",
     scope: { workspaceId: workspace.id, repoRoot: workspace.repoRoot, author: target },
     recipients: [target],

package/src/routes/_route.ts

@@ -1,7 +1,7 @@
 import { scopeResourceReads } from "./viewer-read";
-import { captureSyncFrame, runWithLoopCallsite } from "../loop-block-attribution";
+import { captureSyncFrame } from "../loop-block-attribution";
 import { withRelayEventDrain } from "../relay-event-drain";
-import { trackCaller } from "../hub-metrics";
+import { runInFrame } from "../hub-metrics";
 import { error, type Handler } from "./_shared";
 import type { LoopCallsiteContext } from "../loop-block-attribution";
 
@@ -42,8 +42,8 @@ export function runMatchedRoute(
   req: Request,
   finish: (response: Response) => Promise<Response>,
 ): Promise<Response> {
-  return runWithLoopCallsite(matched.loop.scope, () => trackCaller(matched.loop.scope.callsite, () => withRelayEventDrain(async () =>
-    finish(await captureSyncFrame(matched.loop.frame, () => matched.handler(req, matched.params))))));
+  return runInFrame(matched.loop.scope, () => withRelayEventDrain(async () =>
+    finish(await captureSyncFrame(matched.loop.frame, () => matched.handler(req, matched.params)))));
 }
 
 export function matchRoutes(

package/src/routes/_shared.ts

@@ -1,9 +1,10 @@
+import { sendMessageWithResultAsync } from "../db/message-send";
 import { hasPresentedCredential, relayHeader, canonicalHumanAgentId, DEFAULT_USER_ID, errMessage, fireAndForget, isHumanAgentId, isRecord, userIdFromAddress, userSinkId } from "@humwick/sdk";
 import { authorityDenied } from "../authority-audit";
 // Auto-split from routes.ts (#299). Domain: _shared.
 import { agentVisibleTo, visibleAgentIds, viewerScope, type ViewerScope } from "../db/viewer-scope";
 import { MAX_BODY_BYTES, getIntegrationTokens } from "../config";
-import { ValidationError, createActivityEventAsync, createCallbackDeliveryAsync, finishCallbackDeliveryAsync, getAgent, getTaskAsync, normalizeReactionEmoji, sendMessageWithResult } from "../db";
+import { ValidationError, createActivityEventAsync, createCallbackDeliveryAsync, finishCallbackDeliveryAsync, getAgent, getTaskAsync, normalizeReactionEmoji } from "../db";
 import { cleanEpoch, cleanString, optionalEnum } from "../validation";
 import { emitActivityEvent, emitMessageQueued, emitNewMessage } from "../sse";
 import { authorizeAgentForUser, type AgentAction } from "../agent-authz";
@@ -25,19 +26,19 @@ export const json = (data: unknown, status = 200) =>
 export const error = (msg: string, status = 400) =>
   json({ error: msg }, status);
 
-export function authorizeRoute(req: Request, check: Parameters<typeof isRequestAuthorizedFor>[1]): Response | null {
+export async function authorizeRoute(req: Request, check: Parameters<typeof isRequestAuthorizedFor>[1]): Promise<Response | null> {
   if (!hasPresentedCredential(req)) return null;
-  return isRequestAuthorizedFor(req, check) ? null : authorityDenied(req, "forbidden");
+  return isRequestAuthorizedFor(req, check) ? null : (await authorityDenied(req, "forbidden"));
 }
 
 /** A write about agent `agentId` by that agent's own credential: the agent, its agent:write check and the parsed body. */
 export async function agentWriteRequest(req: Request, agentId: string): Promise<{ agent: NonNullable<ReturnType<typeof getAgent>>; body: Record<string, unknown> } | Response> {
   const agent = getAgent(agentId);
   if (!agent) return error("agent not found", 404);
-  const denied = authorizeRoute(req, {
+  const denied = (await authorizeRoute(req, {
     scope: "agent:write",
     resource: { agentId: agent.id, policyName: metaString(agent.meta, "policyName"), spawnRequestId: metaString(agent.meta, "spawnRequestId") },
-  });
+  }));
   if (denied) return denied;
   const parsed = await parseBody<Record<string, unknown>>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
@@ -49,9 +50,9 @@ export async function agentWriteRequest(req: Request, agentId: string): Promise<
 // `command:fleet`-scoped token is authorized here without the sandbox constraint; every other
 // caller falls back to the normal constrained `command:write` check. Use ONLY at those three call
 // sites — everywhere else must keep going through `authorizeRoute`.
-export function authorizeFleetRoute(req: Request, resource?: Parameters<typeof isFleetActionAuthorized>[1]): Response | null {
+export async function authorizeFleetRoute(req: Request, resource?: Parameters<typeof isFleetActionAuthorized>[1]): Promise<Response | null> {
   if (!hasPresentedCredential(req)) return null;
-  return isFleetActionAuthorized(req, resource) ? null : authorityDenied(req, "forbidden");
+  return isFleetActionAuthorized(req, resource) ? null : (await authorityDenied(req, "forbidden"));
 }
 
 export function authAuditMetadata(req: Request): Record<string, unknown> {
@@ -181,8 +182,8 @@ export function requestUserAddress(req: Request): string {
  * Single-user worlds fail-open inside {@link authorizeAgentForUser}, so existing routes are
  * unchanged until #389 upgrades {@link requestUserId} to the real session user.
  */
-export function authorizeAgentRoute(req: Request, agentId: string, action: AgentAction, auditAction: string = action): Response | null {
-  return authorizeAgentForUser(requestUserId(req), agentId, action) ? null : authorityDenied(req, "agent visibility or role", 403, agentId, auditAction);
+export async function authorizeAgentRoute(req: Request, agentId: string, action: AgentAction, auditAction: string = action): Promise<Response | null> {
+  return authorizeAgentForUser(requestUserId(req), agentId, action) ? null : (await authorityDenied(req, "agent visibility or role", 403, agentId, auditAction));
 }
 
 /** Machine callers retain their existing reach; user sessions share one read scope. */
@@ -468,7 +469,7 @@ function reactionNotificationSender(parent: Message, actorId: string): string {
   return parent.channel && getAgent(parent.channel) ? parent.channel : "user";
 }
 
-export function sendReactionNotificationToAuthor(parent: Message, actorId: string, emoji: string, action: "add" | "remove"): void {
+export async function sendReactionNotificationToAuthor(parent: Message, actorId: string, emoji: string, action: "add" | "remove"): Promise<void> {
   if (isHumanAgentId(parent.from) || parent.from === "system") return;
   const targetAgent = getAgent(parent.from);
   if (!targetAgent || targetAgent.kind === "channel") return;
@@ -477,7 +478,7 @@ export function sendReactionNotificationToAuthor(parent: Message, actorId: strin
   const now = Date.now();
   const actor = reactionActorView(actorId);
   const verb = action === "remove" ? "removed reaction" : "reacted";
-  const result = sendMessageWithResult({
+  const result = (await sendMessageWithResultAsync({
     from,
     to: parent.from,
     kind: "system",
@@ -505,7 +506,7 @@ export function sendReactionNotificationToAuthor(parent: Message, actorId: strin
         },
       },
     },
-  });
+  }));
   if (result.created) {
     if (result.message.deliveryStatus === "queued") emitMessageQueued(result.message);
     else emitNewMessage(result.message);

package/src/routes/agent-effort.ts

@@ -13,12 +13,12 @@ import { agentWriteRequest, authAuditMetadata, authorizeAgentRoute, authorizeRou
 export async function postAgentEffortAction(req: Request, agentId: string, body: Record<string, unknown>): Promise<Response> {
   const agent = getAgent(agentId);
   if (!agent) return error("agent not found", 404);
-  const driveDenied = authorizeAgentRoute(req, agent.id, "drive", "effort");
+  const driveDenied = (await authorizeAgentRoute(req, agent.id, "drive", "effort"));
   if (driveDenied) return driveDenied;
-  const denied = authorizeRoute(req, {
+  const denied = (await authorizeRoute(req, {
     scope: "agent:write",
     resource: { agentId: agent.id, policyName: metaString(agent.meta, "policyName"), spawnRequestId: metaString(agent.meta, "spawnRequestId") },
-  });
+  }));
   if (denied) return denied;
   try {
     const result = await dispatchAgentAction({
@@ -54,12 +54,12 @@ export const postAgentEffortObservedRoute: Handler = async (req, params) => {
   try {
     const version = body.version;
     if (typeof version !== "number" || !Number.isSafeInteger(version) || version < 1) throw new ValidationError("version must be a positive integer");
-    const observed = reportEffortObserved(agent.id, {
+    const observed = (await reportEffortObserved(agent.id, {
       instanceId: cleanString(body.instanceId, "instanceId", { required: true, max: 200 })!,
       version,
       effort: cleanString(body.effort, "effort", { required: true, max: 32 })!,
       previousEffort: cleanString(body.previousEffort, "previousEffort", { max: 32 }) ?? null,
-    });
+    }));
     return json(observed);
   } catch (e) {
     if (e instanceof ValidationError || e instanceof EffortReportRejected) return error(e.message, 400);

package/src/routes/agent-heartbeat-quota.ts

@@ -0,0 +1,23 @@
+import type { HeartbeatResult, ProviderQuotaUpdateInput } from "@humwick/sdk";
+import { acquireProviderQuotaLeaseAsync } from "../db";
+import { getProviderQuotaConfig } from "../provider-quota-config-store";
+import { upsertProviderQuotaAsync } from "../provider-quota-async";
+import { emitRelayEvent } from "../events";
+
+/** Same lease and writer as standalone quota reports, with config resolved on the hub (#3608). */
+export async function publishHeartbeatQuota(input: ProviderQuotaUpdateInput, leaseToken?: string): Promise<NonNullable<HeartbeatResult["providerQuota"]>> {
+  const config = getProviderQuotaConfig(input.provider);
+  if (!config.enabled) return { reported: false, retryAfterMs: 60_000 };
+  const holder = `runner:${input.sourceAgentId}`;
+  const lease = await acquireProviderQuotaLeaseAsync({
+    provider: input.provider, accountKey: input.accountKey, orchestratorId: holder, leaseToken,
+    ttlMs: Math.min(10 * 60_000, config.pollIntervalMs + 60_000),
+  });
+  if (!lease.acquired || !lease.lease) return { reported: false, retryAfterMs: Math.min(lease.retryAfterMs ?? config.pollIntervalMs, config.pollIntervalMs) };
+  const result = await upsertProviderQuotaAsync(input, { requiredLeaseHolder: holder });
+  if (result.outcome.kind === "stored") {
+    const record = result.outcome.record;
+    emitRelayEvent({ type: "provider-quota.updated", source: "server", subject: `${record.provider}:${record.accountKey}`, data: {} });
+  }
+  return { reported: result.outcome.kind === "stored", retryAfterMs: config.pollIntervalMs, leaseToken: lease.lease.leaseToken };
+}

package/src/routes/agent-keep.ts

@@ -9,7 +9,7 @@ export const putAgentKeep: Handler = async (req, params) => {
   const parsed = await parseBody<unknown>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
   if (!isRecord(parsed.body)) return error("keep required");
-  const denied = authorizeRoute(req, { scope: "agent:write" });
+  const denied = (await authorizeRoute(req, { scope: "agent:write" }));
   if (denied) return denied;
   try {
     const result = await setAgentKeep({

package/src/routes/agent-profiles.ts

@@ -1,12 +1,12 @@
 import { PromptVersionConflictError } from "../prompt-version-errors";
 import { versionedPromptsEnabled } from "../versioned-prompts";
 import { promptActor } from "../services/prompt-version-writer";
-import { setConfigAsync } from "../config-store-write";
+import { deleteAgentProfileAsync, setAgentProfileAsync, setConfigAsync } from "../config-store-write";
 import { memoryRetirementMessage } from "../memory-retirement";
 // Auto-split from routes.ts (#299). Domain: agent-profiles.
 import { ValidationError, withResolvedProvisioningAsync } from "../db";
 import { cleanString, optionalEnum } from "../validation";
-import { deleteAgentProfile, getAgentProfile, listAgentProfiles, resolveAgentProfileKey, setAgentProfile, validateAgentProfile } from "../config-store";
+import { getAgentProfile, listAgentProfiles, resolveAgentProfileKey, validateAgentProfile } from "../config-store";
 import { RELAY_TOOL_GROUPS } from "../mcp";
 import { emitConfigChanged } from "../sse";
 import { error, isAdminRequest, json, normalizeConfigPathParam, parseBody, type Handler } from "./_shared";
@@ -140,8 +140,8 @@ export const putAgentProfileRoute: Handler = async (req, params) => {
       return json(saved);
     }
     const profile = existing?.value.builtIn && isAdminRequest(req)
-      ? setAgentProfile({ ...parsed.body, name } as AgentProfile, updatedBy, { overrideBuiltIn: true })
-      : setAgentProfile({ ...parsed.body, name } as AgentProfile, updatedBy);
+      ? await setAgentProfileAsync({ ...parsed.body, name } as AgentProfile, updatedBy, { overrideBuiltIn: true })
+      : await setAgentProfileAsync({ ...parsed.body, name } as AgentProfile, updatedBy);
     emitConfigChanged(profile.namespace, profile.key, profile.version);
     return json(profile, existing ? 200 : profile.version === 1 ? 201 : 200);
   } catch (e) {
@@ -151,14 +151,14 @@ export const putAgentProfileRoute: Handler = async (req, params) => {
   }
 };
 
-export const deleteAgentProfileRoute: Handler = (req, params) => {
+export const deleteAgentProfileRoute: Handler = async (req, params) => {
   try {
     const name = normalizeConfigPathParam(params.name, "name");
     const existing = getAgentProfile(name);
     if (!existing) return error(memoryRetirementMessage(name) ?? "agent profile not found", 404);
     const updatedBy = versionedPromptsEnabled() ? promptActor(req) : cleanString(new URL(req.url).searchParams.get("updatedBy") ?? undefined, "updatedBy", { max: 200 });
     if (existing.value.builtIn && !isAdminRequest(req)) return error("built-in agent profiles are managed by Relay", 400);
-    deleteAgentProfile(name, updatedBy, { resetBuiltInOverride: existing.value.builtIn });
+    await deleteAgentProfileAsync(name, updatedBy, { resetBuiltInOverride: existing.value.builtIn });
     emitConfigChanged(existing.namespace, existing.key, existing.version + 1);
     return json({ ok: true });
   } catch (e) {

package/src/routes/agent-reporting.ts

@@ -6,7 +6,7 @@ import { cleanString } from "../validation";
 import { authorizeAgentRoute, authorizeRoute, error, json } from "./_shared";
 
 export async function postAgentReportingAction(req: Request, agentId: string, body: Record<string, unknown>): Promise<Response> {
-  const denied = authorizeAgentRoute(req, agentId, "drive") ?? authorizeRoute(req, { scope: "agent:write", resource: { agentId } });
+  const denied = (await authorizeAgentRoute(req, agentId, "drive")) ?? (await authorizeRoute(req, { scope: "agent:write", resource: { agentId } }));
   if (denied) return denied;
   try {
     return json({ ok: true, ...await setAgentReportVerbosity({ agentId, reportVerbosity: body.reportVerbosity, reason: cleanString(body.reason, "reason", { max: 500 }), requestedVia: "http" }, authContextFromRequest(req)) });

package/src/routes/agent-self-effort.ts

@@ -9,10 +9,10 @@ import { ShutdownAuthError, ShutdownTargetError } from "../services/shutdown-age
 import { authAuditMetadata, authorizeAgentRoute, authorizeRoute, dashboardAttribution, error, json, metaString, parseBody, requestUserAddress, type Handler } from "./_shared";
 import { isRecord } from "../types";
 
-export const getAgentSelfEffort: Handler = (req, params) => {
+export const getAgentSelfEffort: Handler = async (req, params) => {
   const agent = getAgent(params.id!);
   if (!agent) return error("agent not found", 404);
-  const denied = authorizeAgentRoute(req, agent.id, "view");
+  const denied = (await authorizeAgentRoute(req, agent.id, "view"));
   if (denied) return denied;
   return json({ agentId: agent.id, selfEffort: spawnSelfEffortPolicy(agent) ?? null });
 };
@@ -24,12 +24,12 @@ export const putAgentSelfEffort: Handler = async (req, params) => {
   const body = parsed.body;
   const agent = getAgent(params.id!);
   if (!agent) return error("agent not found", 404);
-  const driveDenied = authorizeAgentRoute(req, agent.id, "drive");
+  const driveDenied = (await authorizeAgentRoute(req, agent.id, "drive"));
   if (driveDenied) return driveDenied;
-  const denied = authorizeRoute(req, {
+  const denied = (await authorizeRoute(req, {
     scope: "agent:write",
     resource: { agentId: agent.id, policyName: metaString(agent.meta, "policyName"), spawnRequestId: metaString(agent.meta, "spawnRequestId") },
-  });
+  }));
   if (denied) return denied;
   try {
     const result = await grantSelfEffort({

package/src/routes/agent-sessions.ts

@@ -4,7 +4,7 @@ import { isHumanAgentId, PROVIDER_SUBMIT_UNCONFIRMED, RELAY_TOKEN_HEADER, SUBMIT
 import { authorizeAgentControl } from "../agent-authz";
 import { VALID_AGENT_ACTIONS, agentControlActionIcon, auditEvent, authAuditMetadata, authorizeAgentRoute, authorizeRoute, canViewAgentRoute, cleanAttachmentRefs, dashboardAttribution, emitCommand, error, json, metaString, parseBody, requestUserAddress, requestUserId, spawnRequestId, type AgentControlAction, type Handler } from "./_shared";
 import { arbitrateDrive, currentDriver, drivingMessage, releaseDrive, type DriveArbitration } from "../agent-drive-arbiter";
-import { ValidationError, getAgent, getAgentTimelineAsync, getOrchestrator, markReadyAsync, mergeAgentMetaAsync, sendMessage } from "../db";
+import { sendMessageAsync, ValidationError, getAgent, getAgentTimelineAsync, getOrchestrator, markReadyAsync, mergeAgentMetaAsync } from "../db";
 import { announcePresence, viewersForAgent } from "../dashboard-presence";
 import { cleanString, optionalEnum } from "../validation";
 import { createCommandAsync } from "../commands-write";
@@ -40,10 +40,10 @@ export const postAgentSelfRestartRecheck: Handler = async (req, params) => {
   // orchestrator's own runtime token authorizes this exactly as it authorizes the agent.restart it
   // is executing — no over-refusal that would silently abort every self-restart.
   const orchestrator = agent ? managedControlOrchestrator(agent) : null;
-  const denied = authorizeRoute(req, {
+  const denied = (await authorizeRoute(req, {
     scope: "command:write",
     resource: { agentId: params.id!, orchestratorId: orchestrator?.id, policyName: metaString(agent?.meta, "policyName"), spawnRequestId: metaString(agent?.meta, "spawnRequestId") },
-  });
+  }));
   if (denied) return denied;
   if (!agent) return json({ ok: false, reason: `self-restart safe-point re-check: agent ${params.id} not found` });
   const violation = await evaluateSelfRestartSafePoint(agent);
@@ -161,11 +161,11 @@ export const postAgentAction: Handler = async (req, params) => {
     if (!agent) return error("agent not found", 404);
     // #392: the acting user must be allowed to drive this agent (fail-open single-user). Gated
     // before the capability probe so an unauthorized user learns nothing about what the agent supports.
-    const driveDenied = authorizeAgentRoute(req, agent.id, "drive", action);
+    const driveDenied = (await authorizeAgentRoute(req, agent.id, "drive", action));
     if (driveDenied) return driveDenied;
     // #3567 — the one lifecycle-control check (the services re-run it for bus/MCP); self excepted.
     const actionCtx = authContextFromRequest(req);
-    const controlDenied = actionCtx.callerAgentId === agent.id ? null : authorizeAgentControl(actionCtx, agent, action);
+    const controlDenied = actionCtx.callerAgentId === agent.id ? null : (await authorizeAgentControl(actionCtx, agent, action));
     if (controlDenied) return error(controlDenied.message, 403);
     // #2664 — releasing a hold that is already gone (recovered, or a double click) is an idempotent no-op.
     if (action === "releaseSubmitHold" && agentIsControlEligible(agent) && !agentSubmitHoldActive(agent)) return json({ ok: true, action, released: false }, 200);
@@ -181,10 +181,10 @@ export const postAgentAction: Handler = async (req, params) => {
     if (action === "interrupt") {
       const arb = await arbitrateDrive(requestUserId(req), agent.id);
       if (!arb.allowed) return driveBlockedResponse(arb);
-      const denied = authorizeRoute(req, {
+      const denied = (await authorizeRoute(req, {
         scope: "agent:write",
         resource: controlResource,
-      });
+      }));
       if (denied) return denied;
       try {
         const result = await dispatchInterrupt({
@@ -208,10 +208,10 @@ export const postAgentAction: Handler = async (req, params) => {
     // bus + MCP surfaces. The route still enforces the coarse `agent:write` scope +
     // constraint-list; the service adds the fine parent→child gate.
     if (action === "shutdown") {
-      const denied = authorizeRoute(req, {
+      const denied = (await authorizeRoute(req, {
         scope: "agent:write",
         resource: controlResource,
-      });
+      }));
       if (denied) return denied;
       try {
         if (parsed.body.hard !== undefined && typeof parsed.body.hard !== "boolean") throw new ValidationError("hard must be a boolean");
@@ -243,10 +243,10 @@ export const postAgentAction: Handler = async (req, params) => {
     const resumeId = action === "resume" ? await latestResumeIdForAgent(agent) : undefined;
     if (action === "resume" && !orchestrator) return error("no online orchestrator available to resume agent", 409);
     if (action === "resume" && !resumeId) return error("no resume id recorded for agent", 422);
-    const denied = authorizeRoute(req, {
+    const denied = (await authorizeRoute(req, {
       scope: "agent:write",
       resource: { ...controlResource, orchestratorId: orchestrator?.id },
-    });
+    }));
     if (denied) return denied;
     // #1953 RC3 — a dashboard restart/resume of a disabled steward is refused (see helper).
     // #1955 (#1953-review nit 2) — AFTER authorizeRoute: run pre-auth, the 409 disclosed to an
@@ -320,7 +320,7 @@ export const postAgentPrompt: Handler = async (req, params) => {
     const agent = getAgent(params.id!);
     if (!agent) return error("agent not found", 404);
     // #392: only a user authorized to drive this agent may prompt it (fail-open single-user).
-    const driveDenied = authorizeAgentRoute(req, agent.id, "drive");
+    const driveDenied = (await authorizeAgentRoute(req, agent.id, "drive"));
     if (driveDenied) return driveDenied;
     // #394: submitting a prompt takes/refreshes the drive lease. A second human driving the same
     // agent is blocked here (single-user is a no-op), so two operators can't double-submit into one
@@ -328,10 +328,10 @@ export const postAgentPrompt: Handler = async (req, params) => {
     const arb = await arbitrateDrive(requestUserId(req), agent.id);
     if (!arb.allowed) return driveBlockedResponse(arb);
     if (agent.status === "offline") return error("agent is offline", 422);
-    const denied = authorizeRoute(req, {
+    const denied = (await authorizeRoute(req, {
       scope: "message:send",
       resource: { target: agent.id, agentId: requestUserAddress(req) },
-    });
+    }));
     if (denied) return denied;
     // #2664 — the runner holds exactly one unconfirmed prompt for the operator's resend; a new one
     // must not queue behind (or replace) it. Refused before any message row exists.
@@ -341,13 +341,13 @@ export const postAgentPrompt: Handler = async (req, params) => {
     // canonical `user` sink, so today's single operator routes/renders exactly as before; once
     // auth (#389) sets the real session user, the bubble carries the real `user:<id>`.
     const fromUser = requestUserAddress(req);
-    const message = sendMessage({
+    const message = (await sendMessageAsync({
       from: fromUser,
       to: agent.id,
       kind: "session",
       body,
       ...(attachments ? { payload: { attachments } } : {}),
-    });
+    }));
     const command = await createCommandAsync({
       type: "prompt.inject",
       source: "dashboard",
@@ -397,7 +397,7 @@ export const postAgentPermissionDecision: Handler = async (req, params) => {
     const agent = getAgent(params.id!);
     if (!agent) return error("agent not found", 404);
     // #392: approving/denying a permission is driving the agent (fail-open single-user).
-    const driveDenied = authorizeAgentRoute(req, agent.id, "drive");
+    const driveDenied = (await authorizeAgentRoute(req, agent.id, "drive"));
     if (driveDenied) return driveDenied;
     // #394: a plan-approve / AskUserQuestion answer drives the turn — only the lease holder (or an
     // admin override) may answer, so two humans can't race competing decisions into one prompt.
@@ -405,10 +405,10 @@ export const postAgentPermissionDecision: Handler = async (req, params) => {
     if (!arb.allowed) return driveBlockedResponse(arb);
     const metaPolicyName = typeof agent.meta?.policyName === "string" ? agent.meta.policyName : undefined;
     const metaSpawnRequestId = typeof agent.meta?.spawnRequestId === "string" ? agent.meta.spawnRequestId : undefined;
-    const denied = authorizeRoute(req, {
+    const denied = (await authorizeRoute(req, {
       scope: "agent:write",
       resource: { agentId: agent.id, policyName: metaPolicyName, spawnRequestId: metaSpawnRequestId },
-    });
+    }));
     if (denied) return denied;
     const result = await dispatchAgentPermissionDecision({
       agentId: agent.id,
@@ -487,7 +487,7 @@ export const postAgentDrive: Handler = async (req, params) => {
     const agent = getAgent(params.id!);
     if (!agent) return error("agent not found", 404);
     // Driving the wheel requires the same #392 drive authorization the prompt/interrupt routes use.
-    const driveDenied = authorizeAgentRoute(req, agent.id, "drive");
+    const driveDenied = (await authorizeAgentRoute(req, agent.id, "drive"));
     if (driveDenied) return driveDenied;
     const userId = requestUserId(req);
 
@@ -545,10 +545,10 @@ export const postAgentTerminalSession: Handler = async (req, params) => {
     const metaTmuxSession = typeof agent.meta?.tmuxSession === "string" ? agent.meta.tmuxSession : undefined;
     const metaPolicyName = typeof agent.meta?.policyName === "string" ? agent.meta.policyName : undefined;
     const metaSpawnRequestId = typeof agent.meta?.spawnRequestId === "string" ? agent.meta.spawnRequestId : undefined;
-    const denied = authorizeRoute(req, {
+    const denied = (await authorizeRoute(req, {
       scope: "terminal:attach",
       resource: { agentId: agent.id, orchestratorId: orchestrator.id, policyName: metaPolicyName, spawnRequestId: metaSpawnRequestId, terminalAttach: true },
-    });
+    }));
     if (denied) return denied;
     // Provider-owned attach surfaces are more specific than the runner's tmux pane.
     // Codex runs its real interactive TUI as a guest attached to the app-server thread;
@@ -588,7 +588,7 @@ export const deleteAgentTerminalSession: Handler = async (req, params) => {
   if (!agent) return error("agent not found", 404);
   const orchestrator = managedControlOrchestrator(agent);
   if (!orchestrator) return error("agent does not have an online orchestrator", 422);
-  const denied = authorizeRoute(req, {
+  const denied = (await authorizeRoute(req, {
     scope: "terminal:attach",
     resource: {
       agentId: agent.id,
@@ -597,7 +597,7 @@ export const deleteAgentTerminalSession: Handler = async (req, params) => {
       spawnRequestId: typeof agent.meta?.spawnRequestId === "string" ? agent.meta.spawnRequestId : undefined,
       terminalAttach: true,
     },
-  });
+  }));
   if (denied) return denied;
   const session = params.session!;
   return proxyOrchestratorDelete(req, orchestrator.id, `/api/terminal-guests/${encodeURIComponent(session)}`);

package/src/routes/agents-spawn.ts

@@ -85,7 +85,7 @@ export const postAgent: Handler = async (req) => {
     // timeline note, parent-wake, audit) live in src/services/register-agent.ts so the HTTP,
     // bus, and orchestrator-report paths cannot drift (epic #342).
     const input = normalizeAgentInput(parsed.body);
-    const agent = registerAgent(input, authContextFromRequest(req));
+    const agent = await registerAgent(input, authContextFromRequest(req));
     return json(agent, 201);
   } catch (e) {
     if (e instanceof ValidationError) return error(e.message, 400);
@@ -208,7 +208,7 @@ export const postAgentSpawn: Handler = async (req) => {
     // strip the heavy inlined provisioning file contents from the echoed-back summary.
     return json({
       ok: true, spawnRequestId: result.spawnRequestId, harnessSubagents: result.harnessSubagents, orchestratorId: result.orchestratorId, placementReason: result.placementReason, provider: result.provider, command: summarizeSpawnCommandForCaller(result.command),
-      ...(result.task ? { task: result.task } : {}), ...(result.warnings ? { warnings: result.warnings } : {}), ...(result.dispatchDecision ? { dispatchDecision: result.dispatchDecision } : {}), ...(workflow.reason ? { workflow: { started: false, reason: workflow.reason } } : {}),
+      ...(result.task ? { task: result.task } : {}), ...(result.warnings ? { warnings: result.warnings } : {}), ...(result.spawnPolicy ? { spawnPolicy: result.spawnPolicy } : {}), ...(result.dispatchDecision ? { dispatchDecision: result.dispatchDecision } : {}), ...(workflow.reason ? { workflow: { started: false, reason: workflow.reason } } : {}),
     }, 202);
   } catch (e) {
     if (e instanceof McpAuthError) return error(e.message, 403);