@humwick/server 0.130.2 → 0.130.3

package/src/services/bus-command-update.ts

@@ -51,23 +51,23 @@ export async function updateCommandFromBus(input: {
       await settleScheduledCommandTimer(updated);
     }
     emitCommandEvent(updated, `command.${updated.status}`);
-    settleSelfResumeContinuationIngestion(updated);
+    (await settleSelfResumeContinuationIngestion(updated));
     noteCompactionCommandCompleted(updated);
     // #2095 — durable "clear committed vs no-op" signal, fired on terminal compact/clear commands.
     noteCompactionResult(updated);
-    enqueueContinuationInjectionAfterSelfResume(updated);
-    enqueueLifecycleIdentityInjectionAfterContextCommand(updated);
-    notifySelfResumeNoOp(updated);
-    settleContextResetCarry(updated);
-    settleSelfRestartManagedState(updated);
-    settleInterruptRedirectMessage(updated);
+    (await enqueueContinuationInjectionAfterSelfResume(updated));
+    (await enqueueLifecycleIdentityInjectionAfterContextCommand(updated));
+    await notifySelfResumeNoOp(updated);
+    (await settleContextResetCarry(updated));
+    (await settleSelfRestartManagedState(updated));
+    (await settleInterruptRedirectMessage(updated));
     // #1565 P4b — memory rides BESIDE the continuation as its own payload (§7), delta-gated on
     // compact. Ordered LAST and contained (#1565 F8) — see the same call in routes/commands.ts.
-    settleMemoryInjectionAfterContextCommand(updated);
+    (await settleMemoryInjectionAfterContextCommand(updated));
     // #1951 — the startup context (validation commands, report-up, profile charter, caller context)
     // rides beside them too, recomposed from the DB and delta-gated on compact. Contained the same
     // way: a compose throw here must not abort the settle chain.
-    settleStartupContextInjectionAfterContextCommand(updated);
+    (await settleStartupContextInjectionAfterContextCommand(updated));
   }
   return { status: "succeeded", result: updated ? { command: updated } : undefined };
 }

package/src/services/checkout-refresh-state.ts

@@ -6,6 +6,7 @@ export function checkoutRefreshHealth(row: CheckoutRefreshStatus, now = Date.now
   if (!row.result?.enabled) return undefined;
   if (["pending", "accepted", "running"].includes(row.status) && row.result.status === "waiting") return "waiting";
   if (row.result.reason) return "blocked";
+  if (row.status === "succeeded" && ["current", "refreshed"].includes(row.result.status)) return "healthy";
   return !row.result.successAt || now - row.result.successAt > 180_000 ? "stale" : "healthy";
 }
 

package/src/services/checkout-refresh.test-fixture.ts

@@ -1,12 +1,13 @@
 import { createCommand, updateCommand } from "../commands-db";
 
 /** Record a host checkout's latest refresh receipt, as the executor reports a finished attempt. */
-export function recordRefreshReceipt(projectId: string, orchestratorId: string, rootPath: string, outcome: "hook-failed" | "current" | "behind" | "refreshing"): void {
+export function recordRefreshReceipt(projectId: string, orchestratorId: string, rootPath: string, outcome: "hook-failed" | "current" | "behind" | "refreshing" | "busy"): void {
   const command = createCommand({ type: "project.checkout.refresh", source: "system", target: `orchestrator-${orchestratorId}`,
     params: { projectId, rootPath, orchestratorId, remoteUrl: "https://example.invalid/repo.git", enabled: true } });
-  const dependency = { fingerprint: "inputs", attemptId: "attempt", status: outcome === "hook-failed" || outcome === "refreshing" ? "pending" : "current" };
+  const dependency = { fingerprint: "inputs", attemptId: "attempt", status: outcome === "hook-failed" || outcome === "refreshing" || outcome === "busy" ? "pending" : "current" };
   updateCommand(command.id, { status: outcome === "refreshing" ? "running" : "succeeded", result: { rootPath, enabled: true, attemptedAt: Date.now(), backups: [], headSha: "head", dependency,
     ...(outcome === "hook-failed" ? { status: "error", reason: "dependency hook failed: npm ci exited 1" }
+      : outcome === "busy" ? { status: "skipped", reason: "host gate admission busy; retry next refresh cycle" }
       : outcome === "behind" ? { status: "skipped", behind: 3, reason: "fetch failed" }
       : outcome === "refreshing" ? { status: "refreshing" } : { status: "current", successAt: Date.now() }) } });
 }

package/src/services/command-host.ts

@@ -2,11 +2,14 @@ import { stringValue } from "@humwick/sdk";
 import type { Orchestrator } from "@humwick/sdk";
 import { getAgent, listOrchestrators, ValidationError } from "../db";
 import type { AuthContext } from "./auth-context";
+import { listManagedOrchestratorsForAgent } from "../orchestrator-lookup";
 import { isPathWithinBase, sameHostIdentity } from "../utils";
 
 /** The orchestrator the caller agent is registered on, online or not: its stamped
- * `meta.orchestratorId`, else its `machine` matched by host identity (the runner's raw os.hostname()
- * differs in case/separators). */
+ * `meta.orchestratorId`, else the one host whose managed-agent roster runs it, else its `machine`
+ * matched by host identity (the runner's raw os.hostname() differs in case/separators). The roster
+ * covers unpinned system launches (stewards, managed policies) on a host whose OS hostname is not
+ * its orchestrator name, e.g. WSL "XPS15" on xps15-wsl (#3822). */
 function callerHost(ctx: AuthContext, hosts: Orchestrator[]): Orchestrator | undefined {
   const agent = ctx.callerAgentId ? getAgent(ctx.callerAgentId) : undefined;
   if (!agent) return undefined;
@@ -15,6 +18,8 @@ function callerHost(ctx: AuthContext, hosts: Orchestrator[]): Orchestrator | und
     const byId = hosts.find((item) => item.id === stamped);
     if (byId) return byId;
   }
+  const rostered = listManagedOrchestratorsForAgent({ agentId: agent.id });
+  if (rostered.length === 1) return rostered[0];
   if (!agent.machine) return undefined;
   return hosts.find((item) => sameHostIdentity(item.hostname, agent.machine) || sameHostIdentity(item.id, agent.machine));
 }

package/src/services/coordinator-digest.ts

@@ -1,3 +1,4 @@
+import { framed } from "../hub-metrics";
 import { errMessage } from "@humwick/sdk";
 import { flushCoordinatorDigestsAsync } from "../db/coordinator-digest-async";
 import { emitNewMessages } from "../sse";
@@ -18,11 +19,11 @@ export function startCoordinatorDigestLoop(): () => Promise<void> {
   let stopped = false;
   let timer: ReturnType<typeof setTimeout> | undefined;
   let pending: Promise<void>;
-  const tick = async () => {
+  const tick = framed("timer coordinator-digest", async () => {
     try { await flushCoordinatorDigests(); }
     catch (error) { console.error(`coordinator digest flush failed: ${errMessage(error)}`); }
     finally { if (!stopped) timer = setTimeout(() => { pending = tick(); }, 1000).unref(); }
-  };
+  });
   pending = tick();
   const stop = () => { stopped = true; clearTimeout(timer); removeShutdownHook(); return pending; };
   const removeShutdownHook = onShutdown("coordinator-digest", stop);

package/src/services/dispatch-command.ts

@@ -1,6 +1,7 @@
+import { createCommandAsync, createKernelCommandIfAbsentAsync } from "../commands-write";
 import { writeChildEnv } from "@humwick/sdk/env";
 import { rejectCallerSealedEnv } from "../spawn-env";
-import { commandSecretMaskValues } from "../command-secrets";
+import { commandSecretMaskValues, omitCommandFenceSecrets, redactCommandSecrets, revealCommandSecrets } from "../command-secrets";
 import { spawnDelegationState } from "../db/spawn-delegation-state";
 import { authorizeShutdown } from "./shutdown-agent";
 import { stewardGenerationCanceled } from "../db/workspace-steward-fence";
@@ -17,11 +18,9 @@ import { stewardGenerationCanceled } from "../db/workspace-steward-fence";
 // owned by the spawn (#349) / shutdown (#347) slices — they are NOT generic dispatch and stay
 // out of this service.
 import { isRecord, stringValue, ValidationError } from "@humwick/sdk";
-import { createCommand } from "../commands-db";
-import { createCommandAsync, createKernelCommandIfAbsentAsync } from "../commands-write";
+
 import { emitCommandEvent } from "../command-events";
 import { componentConstraintsAllow, hasComponentScope, isComponentAuthorizedFor, isOpenApprovalConstraints } from "../security";
-import { omitCommandFenceSecrets, redactCommandSecrets, revealCommandSecrets } from "../command-secrets";
 import { listOrchestrators } from "../db";
 import { ServiceAuthError } from "./errors";
 import type { AuthContext } from "./auth-context";
@@ -211,10 +210,10 @@ function assertPathAxesWithinConstraint(input: CreateCommandInput, component: Co
  * scope gate at the transport edge — HTTP middleware `isScopedRequestAuthorized`, bus
  * `withRegistered`). HTTP `authorizeRoute` and bus `busCommandAuthorized` both reduce to this:
  * "no component token ⇒ allow; else `isComponentAuthorizedFor(command:write, resource)`". */
-function assertCommandAuthorized(ctx: AuthContext, input: CreateCommandInput, schedulerFire = false): void {
+async function assertCommandAuthorized(ctx: AuthContext, input: CreateCommandInput, schedulerFire = false): Promise<void> {
   if (ctx.callerAgentId && spawnDelegationState(ctx.callerAgentId).participating) {
     if (input.type === "agent.spawn") throw new ValidationError("agent.spawn requires the spawn service to preserve delegated lineage");
-    if (input.type === "agent.shutdown") authorizeShutdown(ctx, { agentId: stringValue(input.params?.agentId), spawnRequestId: stringValue(input.params?.spawnRequestId), requestedVia: "bus" });
+    if (input.type === "agent.shutdown") (await authorizeShutdown(ctx, { agentId: stringValue(input.params?.agentId), spawnRequestId: stringValue(input.params?.spawnRequestId), requestedVia: "bus" }));
   }
   if (ctx.callerAgentId && stewardGenerationCanceled(ctx.callerAgentId, ctx.constraints?.spawnRequestIds?.[0])) {
     throw new ServiceAuthError("steward job canceled by land withdrawal; host mutations are fenced");
@@ -304,9 +303,9 @@ export function serializeCommandForRead(command: Command, ctx: AuthContext): Com
 }
 
 /** Dispatch options. `allowReservedCorrelation` threads the R2 (#1409) kernel-correlation opt-in to
- *  `createCommand` — set ONLY by the kernel command bridge, whose `correlation_id` is a legitimately
+ *  `createCommandAsync` — set ONLY by the kernel command bridge, whose `correlation_id` is a legitimately
  *  `kcmd:`-namespaced dedup key. Every other (external) `dispatchCommand` caller omits it, so the
- *  reservation stays enforced at the `createCommand` choke point. */
+ *  reservation stays enforced at the `createCommandAsync` choke point. */
 export interface DispatchCommandOptions {
   readonly allowReservedCorrelation?: boolean;
   /** #2392 — INTERNAL ONLY. Set exclusively by the two scheduler FIRE paths
@@ -340,10 +339,10 @@ function withServerCommandProvenance(input: CreateCommandInput, options: Dispatc
   };
 }
 
-export function dispatchCommand(input: CreateCommandInput, ctx: AuthContext, options: DispatchCommandOptions = {}): Command {
+export async function dispatchCommand(input: CreateCommandInput, ctx: AuthContext, options: DispatchCommandOptions = {}): Promise<Command> {
   const sanitizedInput = withServerCommandProvenance(input, options);
-  assertCommandAuthorized(ctx, sanitizedInput, options.schedulerFire === true);
-  const command = createCommand(sanitizedInput, { allowReservedCorrelation: options.allowReservedCorrelation === true });
+  (await assertCommandAuthorized(ctx, sanitizedInput, options.schedulerFire === true));
+  const command = (await createCommandAsync(sanitizedInput, { allowReservedCorrelation: options.allowReservedCorrelation === true }));
   // A freshly created command is always `pending`; emit the literal "command.requested"
   // (the relay auto-fans-out the follow-up "command.dispatched"). HTTP used the status-derived
   // `emitCommand`, bus used `emitCommandEvent(_, "command.requested")` — identical for pending.
@@ -359,7 +358,7 @@ export async function dispatchCommandAsync(
   options: DispatchCommandOptions = {},
 ): Promise<Command> {
   const sanitizedInput = withServerCommandProvenance(input, options);
-  assertCommandAuthorized(ctx, sanitizedInput, options.schedulerFire === true);
+  (await assertCommandAuthorized(ctx, sanitizedInput, options.schedulerFire === true));
   const command = await createCommandAsync(sanitizedInput, {
     allowReservedCorrelation: options.allowReservedCorrelation === true,
   }, ctx.callerAgentId ?? ctx.actor.id, ctx.constraints?.projectId);
@@ -381,7 +380,7 @@ export async function dispatchKernelCommandAsync(
   options: Pick<DispatchCommandOptions, "schedulerFire" | "schedulerRequestedVia"> = {},
 ): Promise<Command> {
   const sanitizedInput = withServerCommandProvenance(input, options);
-  assertCommandAuthorized(ctx, sanitizedInput, options.schedulerFire === true);
+  (await assertCommandAuthorized(ctx, sanitizedInput, options.schedulerFire === true));
   const { command, created } = await createKernelCommandIfAbsentAsync(sanitizedInput, ctx.callerAgentId ?? ctx.actor.id, ctx.constraints?.projectId);
   if (created) emitCommandEvent(command, "command.requested");
   return command;

package/src/services/effective-launch-driver.ts

@@ -1,10 +1,14 @@
 #!/usr/bin/env bun
+import { setConfigAsync, setAgentProfileAsync } from "../config-store-write";
+import { upsertOrchestratorAsync } from "../db/orchestrators-async";
+import { allowLocalLandingHost } from "./spawn-placement.test-fixture";
+import { upsertAgentAsync } from "../db/agents-async";
 import { relayEnv, writeChildEnv } from "@humwick/sdk/env";
 import { appendFileSync, closeSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { hostname } from "node:os";
 import { dirname, join } from "node:path";
-import { getAgent, getOrchestrator, initDb, upsertAgent, upsertOrchestrator } from "../db";
+import { getAgent, getOrchestrator, initDb } from "../db";
 import { assemblePreparedSpawnChain, prepareCommandChain, prepareSpawnChain, type PreparedSpawnChain } from "./spawn-chain-inspector";
 import { ClaudeApiAdapter } from "../../runner/src/adapters/claude-api";
 import type { ApiBudgetAccounting } from "../../runner/src/api-budget-accounting";
@@ -27,7 +31,7 @@ import { listCommands } from "../commands-db";
 import { restartSpawnParamsForAgent, restartSpawnParamsForAgentAsync } from "./restart-spawn";
 import { landOnOrigin } from "./project-role.test-fixture";
 import { prepareServiceAccessConfig } from "../../runner/src/adapters/service-access";
-import { deleteAgentProfile, setAgentProfile, setConfig } from "../config-store";
+import { deleteAgentProfile } from "../config-store";
 import { setRoutingPolicy } from "../routing-policy-store";
 
 const SPAWN_AGENT_ORCHESTRATOR_ID = "effective-launch";
@@ -36,16 +40,17 @@ const SPAWN_AGENT_ORCHESTRATOR_ID = "effective-launch";
 async function spawnAgentCommandParams(request: EffectiveLaunchRequest): Promise<Record<string, unknown>> {
   // This host's own orchestrator: the spawn reads repo content locally, as on the relay host.
   const auto = request.autoRouting;
-  upsertOrchestrator({ id: SPAWN_AGENT_ORCHESTRATOR_ID, hostname: hostname(), providers: auto?.providers ?? [request.provider], baseDir: request.cwd });
+  (await upsertOrchestratorAsync({ id: SPAWN_AGENT_ORCHESTRATOR_ID, hostname: hostname(), providers: auto?.providers ?? [request.provider], baseDir: request.cwd }));
+  allowLocalLandingHost(SPAWN_AGENT_ORCHESTRATOR_ID);
   if (auto) {
     setRoutingPolicy(auto.policy, { updatedBy: "effective-launch" });
-    for (const provider of auto.providers) setConfig("provider-enablement", provider, { enabled: !auto.disabled?.includes(provider) }, "effective-launch");
+    for (const provider of auto.providers) (await setConfigAsync("provider-enablement", provider, { enabled: !auto.disabled?.includes(provider) }, "effective-launch"));
     const result = await spawnAgent({ provider: "auto", dispatch: auto.dispatch, orchestratorId: SPAWN_AGENT_ORCHESTRATOR_ID, cwd: request.cwd,
       taskless: true, workflow: false, approvalMode: "open", waitForRegistrationMs: 0, requestedVia: "effective-launch", requestedBy: "effective-launch" } as SpawnAgentInput, authContextFromSystem());
     return result.command.params;
   }
   if (request.dispatchTask && request.role !== undefined) {
-    const task = createTaskEntity({ title: "Dispatch a role", intent: "Dispatch a role", dispatch: request.dispatchTask.dispatch, createdBy: "effective-launch" });
+    const task = await createTaskEntity({ title: "Dispatch a role", intent: "Dispatch a role", dispatch: request.dispatchTask.dispatch, createdBy: "effective-launch" });
     const dispatched = await relayDispatchTool({ kind: "server", actor: "effective-launch" }, "relay_task_dispatch", {
       taskId: task.id, role: request.role, cwd: request.cwd, orchestratorId: SPAWN_AGENT_ORCHESTRATOR_ID, pin: { provider: request.provider }, createReview: false, workflow: false,
     });
@@ -77,7 +82,7 @@ async function spawnAgentCommandParams(request: EffectiveLaunchRequest): Promise
 async function restartCommandParams(spawned: Record<string, unknown>, request: EffectiveLaunchRequest & { role: string; restart: { land: Record<string, string> } }): Promise<Record<string, unknown>> {
   const agentId = spawned.agentId as string;
   const meta = { provider: request.provider, cwd: request.cwd, spawnRequestId: spawned.spawnRequestId, profile: spawned.profile, model: spawned.model, effort: spawned.effort, approvalMode: spawned.approvalMode, workspaceMode: spawned.workspaceMode };
-  upsertAgent({ id: agentId, name: agentId, kind: "provider", status: "online", ready: true, machine: SPAWN_AGENT_ORCHESTRATOR_ID, meta });
+  (await upsertAgentAsync({ id: agentId, name: agentId, kind: "provider", status: "online", ready: true, machine: SPAWN_AGENT_ORCHESTRATOR_ID, meta }));
   landOnOrigin(request.cwd, request.restart.land, "role edit after the spawn", { fetch: true });
   const params = await restartSpawnParamsForAgentAsync(getAgent(agentId)!, getOrchestrator(SPAWN_AGENT_ORCHESTRATOR_ID), undefined, spawned.spawnRequestId as string);
   if (!params) throw new Error(`restarting ${agentId} built no successor spawn`);
@@ -86,7 +91,7 @@ async function restartCommandParams(spawned: Record<string, unknown>, request: E
 
 async function restartWithoutProfileParams(spawned: Record<string, unknown>, request: EffectiveLaunchRequest & { profile: string; restart: { deleteProfile: true; mode: "sync" | "async" } }): Promise<Record<string, unknown>> {
   const id = spawned.agentId as string;
-  registerAgent({ id, name: id, kind: "provider", status: "idle", ready: true, instanceId: "before-profile-deletion",
+  await registerAgent({ id, name: id, kind: "provider", status: "idle", ready: true, instanceId: "before-profile-deletion",
     meta: { provider: request.provider, cwd: request.cwd, profile: request.profile, spawnRequestId: spawned.spawnRequestId,
       harnessSubagents: request.spawn?.harnessSubagents, approvalMode: spawned.approvalMode } }, authContextFromSystem());
   if (!deleteAgentProfile(request.profile)) throw new Error(`profile not deleted: ${request.profile}`);
@@ -147,7 +152,7 @@ export async function main(): Promise<void> {
   mkdirSync(process.env.CLAUDE_CONFIG_DIR, { recursive: true, mode: 0o700 });
   mkdirSync(process.env.CODEX_HOME, { recursive: true, mode: 0o700 });
   initDb(":memory:");
-  if (request.profileDefinition) setAgentProfile(request.profileDefinition);
+  if (request.profileDefinition) (await setAgentProfileAsync(request.profileDefinition));
 
   if (relayEnv(process.env, "AGENT_RELAY_EFFECTIVE_LAUNCH_FAULT") === "enable-runner-managed-tool-deferral") {
     const manifest = getManifest(request.provider)?.mcpToolManifest;
@@ -179,7 +184,7 @@ export async function main(): Promise<void> {
       prepared = request.commandParams
         ? prepareCommandChain(request.commandParams, { ...chainRequest, spawn: { headless: true } }, observe)
         : request.managedPolicy
-        ? prepareCommandChain(buildManagedSpawnParams(request.managedPolicy, "sp_effective_managed", { createdBy: "effective-launch", authority: SYSTEM_LAUNCH }), chainRequest, observe)
+        ? prepareCommandChain((await buildManagedSpawnParams(request.managedPolicy, "sp_effective_managed", { createdBy: "effective-launch", authority: SYSTEM_LAUNCH })), chainRequest, observe)
         : prepareSpawnChain(chainRequest, observe);
     }
     trace("adapter-assembly", "start");

package/src/services/host-changed-paths.test-fixture.ts

@@ -1,13 +1,14 @@
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { changedPathsSinceMergeBase, readProjectFiles, type ProjectDirExtension } from "@humwick/sdk";
+import { readProjectFiles, type ProjectDirExtension } from "@humwick/sdk";
+import { workspaceChangedPaths } from "../../orchestrator/src/workspace-probe/changed-paths";
 
 /**
  * In-process stand-in for an OWNING orchestrator host (#2535 cross-host test coverage). The
  * delivery diff gate routes through the owner's `GET /api/workspace/changed-paths`; these
  * helpers let a test's `globalThis.fetch` stub ANSWER that route the way a real host does —
- * by computing the changed paths with the REAL shared SDK baseline against the simulated
+ * by running the REAL host probe (`workspaceChangedPaths`) against the simulated
  * host's own disk view, which can differ from what the server process can see:
  *
  * - `mapHostRepo(serverVisiblePath, hostRepoDir)` — the host resolves `serverVisiblePath` to
@@ -95,10 +96,8 @@ export async function changedPathsResponse(url: URL): Promise<Response | undefin
   if (failure === "truncated") return Response.json({ ok: false, reason: "git diff unavailable (probe output truncated on the owning host)" });
   const dir = hostDir(serverVisiblePath);
   if (!existsSync(dir)) return Response.json({ ok: false, reason: "worktree unavailable", missing: true });
-  const result = await changedPathsSinceMergeBase(async (_worktreePath, args) => {
-    const r = spawnSync("git", ["-C", dir, ...args], { encoding: "utf8", maxBuffer: 16 * 1024 * 1024, stdio: ["ignore", "pipe", "pipe"] });
-    return { ok: r.status === 0, out: r.stdout ?? "", err: r.stderr ?? "" };
-  }, {
+  // The REAL owning-host probe (base fetch + shared SDK baseline) against the host's disk view.
+  const result = await workspaceChangedPaths({
     worktreePath: dir,
     baseRef: url.searchParams.get("baseRef") ?? undefined,
     baseSha: url.searchParams.get("baseSha") ?? undefined,

package/src/services/host-project-readiness.ts

@@ -5,10 +5,10 @@ import { checkoutRefreshEnabled } from "../config";
 import { cleanHostProjectToolchainStatus } from "../project-toolchain";
 import { probeHostRepo } from "./spawn-repo-probe";
 
-/** A refresh receipt whose dependency hook failed: the checkout's dependencies do not match its head. Behind or in-progress refreshes carry no reason, so they stay ready. */
+/** A refresh receipt whose dependency hook failed: the checkout's dependencies do not match its head. Skipped or in-progress refreshes stay ready; their reason is not a hook failure. */
 function failedDependencyHook(row: CheckoutRefreshStatus): string | undefined {
   const result = row.result;
-  return result?.enabled && result.dependency?.status === "pending" && result.reason ? result.reason : undefined;
+  return result?.enabled && result.status === "error" && result.dependency?.status === "pending" && result.reason ? result.reason : undefined;
 }
 
 /**

package/src/services/host-providers.ts

@@ -44,7 +44,7 @@ function cleanToggle(body: unknown): HostProviderWrite {
 /** Env-migration seed through the same per-host chain as operator writes, with audit. */
 export async function seedHostProviders(hostId: string, envProviders: readonly string[], switchableCatalog: readonly SpawnProvider[]) {
   return serializeHostWrite(hostId, async () => {
-    const seeded = seedHostProvidersFromEnv(hostId, envProviders, switchableCatalog);
+    const seeded = (await seedHostProvidersFromEnv(hostId, envProviders, switchableCatalog));
     if (!seeded) return null;
     const disabled = Object.entries(seeded.providers).filter(([, t]) => !t.enabled).map(([p]) => p);
     await auditEvent({

package/src/services/host-utilization.ts

@@ -55,16 +55,16 @@ export async function recordHostUtilization(input: RecordHostUtilizationInput):
     return false;
   }
   recordHostUtilizationSample(input.hostId, input.machine, input.now ?? Date.now());
-  if (recorded?.gateAlert) notifyGateCapacity(input.hostId, recorded.hostLabel ?? input.hostId, recorded.gateAlert, input.now ?? Date.now());
-  if (recorded?.diskAlert) notifyDisk(input.hostId, recorded.hostLabel ?? input.hostId, recorded.diskAlert);
+  if (recorded?.gateAlert) (await notifyGateCapacity(input.hostId, recorded.hostLabel ?? input.hostId, recorded.gateAlert, input.now ?? Date.now()));
+  if (recorded?.diskAlert) (await notifyDisk(input.hostId, recorded.hostLabel ?? input.hostId, recorded.diskAlert));
   return true;
 }
 
 /** Operator ntfy plus the steward/coordinator target — the same two recipients as the critical-job watchdog. */
-function notifyDisk(hostId: string, label: string, alert: DiskAlert): void {
+async function notifyDisk(hostId: string, label: string, alert: DiskAlert): Promise<void> {
   const notice = composeDiskNotice(hostId, label, alert);
   const payload = { ...alert, kind: `host-disk.${alert.kind}`, hostId };
-  const human = notifyWorkspaceHumanEscalation({
+  const human = (await notifyWorkspaceHumanEscalation({
     subject: notice.subject,
     body: notice.body,
     priority: notice.priority,
@@ -72,15 +72,15 @@ function notifyDisk(hostId: string, label: string, alert: DiskAlert): void {
     source: "host-disk",
     payload,
     idempotencyKey: notice.idempotencyKey,
-  });
+  }));
   const target = stewardFallbackTarget();
-  const routed = target ? notifyTarget("maintenance.degraded", {}, target, notice.subject, notice.body, payload, notice.idempotencyKey) : null;
+  const routed = target ? await notifyTarget("maintenance.degraded", {}, target, notice.subject, notice.body, payload, notice.idempotencyKey) : null;
   console.warn(`[relay] ${notice.subject}${human.accepted || routed ? "" : " — nobody was notified (no ntfy channel or steward target)"}`);
 }
 
-function notifyGateCapacity(hostId: string, label: string, alert: GateCapacityAlert, now: number): void {
+async function notifyGateCapacity(hostId: string, label: string, alert: GateCapacityAlert, now: number): Promise<void> {
   const notice = composeGateCapacityNotice(hostId, label, alert, now);
-  const result = notifyWorkspaceHumanEscalation({
+  const result = (await notifyWorkspaceHumanEscalation({
     subject: notice.subject,
     body: notice.body,
     priority: notice.priority,
@@ -88,6 +88,6 @@ function notifyGateCapacity(hostId: string, label: string, alert: GateCapacityAl
     source: "gate-capacity",
     payload: { ...alert, kind: `gate-capacity.${alert.kind}`, hostId },
     idempotencyKey: notice.idempotencyKey,
-  });
+  }));
   console.warn(`[relay] ${notice.subject}${result.accepted ? "" : ` — operator NOT paged: ${result.reason}`}`);
 }

package/src/services/idle-agent-digest.ts

@@ -1,3 +1,4 @@
+import { updateIdleDigestScanAsync, startIdleDigestWindowAsync, finishIdleDigestScanAsync } from "../db/runtime-tail-async";
 // #3428 — the one idle-children classifier and the coordinator digest built on it. Each team's
 // coordinator gets at most one digest per window, and only when something qualifies. Provably safe
 // children can be stopped automatically; the digest reports them only once termination is confirmed.
@@ -13,7 +14,7 @@ import {
   listWorkspaces,
   workflowRunIdOf,
 } from "../db";
-import { finishIdleDigestScan, getIdleDigestWindow, startIdleDigestWindow, updateIdleDigestScan } from "../db/idle-digest";
+import { getIdleDigestWindow } from "../db/idle-digest";
 import { workflowOwnsAgent } from "../db/workflow-task-read-ops";
 import { getIdleDigestConfig, idleDigestMayRun, teamIdleDigestSettings } from "../idle-digest-config";
 import { providerIdleAnchor } from "../idle-self-care";
@@ -45,7 +46,7 @@ export interface IdleChildRow {
   action: string;
 }
 
-interface SafeCandidate { row: IdleChildRow; instanceId?: string; epoch: number; idleAt: number }
+export interface SafeCandidate { row: IdleChildRow; instanceId?: string; epoch: number; idleAt: number }
 
 export interface IdleDigestStop {
   agentId: string;
@@ -164,7 +165,7 @@ export async function classifyIdleChildren(children: AgentCard[], now: number):
 
 /** Why a safe candidate may no longer be stopped, read from the fresh card. Runs before the stop and
  * again inside shutdownAgent at command admission, after its host probe and audit, in one write transaction. */
-function stopRefusal(candidate: SafeCandidate, current: AgentCard, now: number): { reason: string; openTasks: OwnedTask[] } | undefined {
+export function stopRefusal(candidate: SafeCandidate, current: AgentCard, now: number): { reason: string; openTasks: OwnedTask[] } | undefined {
   if (current.instanceId !== candidate.instanceId || current.epoch !== candidate.epoch) return { reason: "incarnation-changed", openTasks: [] };
   const eligibility = childEligibility(current, now);
   if (eligibility.excluded) return { reason: eligibility.excluded, openTasks: [] };
@@ -189,12 +190,16 @@ async function stopSafeChild(candidate: SafeCandidate, now: number, teamId: stri
   try {
     // requestedBy names the parent, so the child's exit does not also wake it: this digest reports it.
     const { command } = await shutdownAgent({
-      agentId: agent.id, requestedVia: "maintenance", reason: IDLE_DIGEST_REAP_REASON, admit,
+      agentId: agent.id, requestedVia: "maintenance", reason: IDLE_DIGEST_REAP_REASON, idleCandidate: candidate,
       requestedBy: agent.spawnedBy ?? "idle-digest", auditMetadata: { idleDigest: true, teamId },
     }, authContextFromSystem());
     return { stop: { ...base, commandId: command.id, outcome: "pending" } };
   } catch (error) {
-    if (error instanceof AutomaticShutdownRefused) return asRefused();
+    if (error instanceof AutomaticShutdownRefused) {
+      const current = getAgent(agent.id);
+      if (current) refusal = stopRefusal(candidate, current, now);
+      return asRefused();
+    }
     // The guard's fresh probe found unique work or could not verify the branch: a check row, not a failed stop.
     if (error instanceof UnlandedWorkRefusal || error instanceof UnverifiedWorkRefusal) {
       const { verdict } = error;
@@ -251,18 +256,18 @@ function idleDigestSubject(scan: IdleDigestScan): string {
 }
 
 /** Deliver once every stop has resolved, or the settle window lapsed; an empty window sends nothing. */
-function settleScan(teamId: string, coordinatorId: string, scan: IdleDigestScan, now: number): "waiting" | "sent" | "empty" {
+async function settleScan(teamId: string, coordinatorId: string, scan: IdleDigestScan, now: number): Promise<"waiting" | "sent" | "empty"> {
   const resolved = { ...scan, stops: scan.stops.map(resolveStop) };
   if (resolved.stops.some((stop) => stop.outcome === "pending") && now - scan.at < STOP_SETTLE_MS) {
-    updateIdleDigestScan(teamId, resolved);
+    (await updateIdleDigestScanAsync(teamId, resolved));
     return "waiting";
   }
   const body = renderIdleDigest(resolved);
   if (!body) {
-    finishIdleDigestScan(teamId);
+    (await finishIdleDigestScanAsync(teamId));
     return "empty";
   }
-  const [message] = routeNotification({
+  const [message] = await routeNotification({
     type: "agent.idle_digest",
     scope: { agentId: coordinatorId },
     recipients: [coordinatorId],
@@ -274,7 +279,7 @@ function settleScan(teamId: string, coordinatorId: string, scan: IdleDigestScan,
       replyExpected: false,
     },
   });
-  finishIdleDigestScan(teamId, message ? { at: now, messageId: message.id } : undefined);
+  (await finishIdleDigestScanAsync(teamId, message ? { at: now, messageId: message.id } : undefined));
   return "sent";
 }
 
@@ -306,11 +311,11 @@ export async function runIdleAgentDigest(context: { signal?: AbortSignal; now?:
         }
       }
       scan = { at: now, check: classes.check, safe: settings.autoReapSafe ? [] : classes.safe.map((c) => c.row), stops };
-      startIdleDigestWindow(team.id, now, scan);
+      (await startIdleDigestWindowAsync(team.id, now, scan));
       result.scanned.push(team.id);
       result.stopsRequested += stops.filter((stop) => stop.commandId).length;
     }
-    const outcome = settleScan(team.id, team.coordinatorId, scan, now);
+    const outcome = await settleScan(team.id, team.coordinatorId, scan, now);
     if (outcome === "waiting") result.waiting.push(team.id);
     if (outcome === "sent") result.sent.push(team.id);
   }

package/src/services/idle-epics.ts

@@ -16,8 +16,8 @@ function inFlight(task: Task): boolean {
     && (task.status !== "open" || !!task.ownerAgentId);
 }
 
-function reportUnresolvable(teamId: string, issue: IssueRef): void {
-  routeNotification({
+async function reportUnresolvable(teamId: string, issue: IssueRef): Promise<void> {
+  await routeNotification({
     type: "team.idle", scope: { teamId }, recipients: [`coordinator:${teamId}`],
     message: { kind: "system", from: "system", subject: "Tracker reference unresolvable",
       body: `${issue.repo}#${issue.externalKey} was not found on two tracker refreshes. Automatic refresh stopped; correct or remove the reference.`,
@@ -32,7 +32,7 @@ export async function refreshTeamEpicHierarchy(teamId: string, signal?: AbortSig
   for (const issue of teamEpicWork(teamId).issues) {
     if (signal?.aborted) break;
     if (issueTrackerNotFoundCount(issue.id) >= 2) {
-      reportUnresolvable(teamId, issue);
+      await reportUnresolvable(teamId, issue);
       continue;
     }
     let statusLoaded = false;
@@ -48,7 +48,7 @@ export async function refreshTeamEpicHierarchy(teamId: string, signal?: AbortSig
     } catch (error) {
       if (!statusLoaded && error instanceof GitHubApiError && error.statusCode === 404
         && await recordIssueTrackerNotFoundAsync(issue.id) >= 2) {
-        reportUnresolvable(teamId, issue);
+        await reportUnresolvable(teamId, issue);
         continue;
       }
       const failure = `Tracker refresh failed for ${issue.repo}#${issue.externalKey}: ${errMessage(error)}; retained prior snapshot.`;

package/src/services/interrupt-agent.ts

@@ -1,8 +1,10 @@
+import { deleteMessageAsync } from "../db/message-reads-async";
+import { sendMessageAsync } from "../db/message-send";
 import { isHumanAgentId } from "@humwick/sdk";
 import { randomUUID } from "node:crypto";
-import { createCommandInternal } from "../commands-db";
+import { createAgentControlAsync } from "../db/agent-control-async";
 import { emitCommandEvent } from "../command-events";
-import { ValidationError, createActivityEventAsync, deleteMessage, getAgent, getMessage, sendMessage } from "../db";
+import { ValidationError, createActivityEventAsync, getAgent, getMessage } from "../db";
 import { emitActivityEvent, emitMessageDeleted, emitNewMessage } from "../sse";
 import type { ActivityEventInput, AgentCard, Command, CreateCommandInput } from "../types";
 import type { AuthContext } from "./auth-context";
@@ -41,11 +43,11 @@ function assertInterruptSupported(agent: AgentCard, mode: InterruptMode): void {
   }
 }
 
-function sessionMessageForRedirect(agentId: string, ctx: AuthContext, body: string, commandId: string) {
+async function sessionMessageForRedirect(agentId: string, ctx: AuthContext, body: string, commandId: string) {
   const from = ctx.callerAgentId && getAgent(ctx.callerAgentId) ? ctx.callerAgentId : "system";
   // This ownership marker is created only by this server-side redirect flow. Terminal settlement
   // must never trust activity rows: activity:write callers may write arbitrary observability metadata.
-  return sendMessage({ from, to: agentId, kind: "session", body, meta: { createdByCommandId: commandId } });
+  return (await sendMessageAsync({ from, to: agentId, kind: "session", body, meta: { createdByCommandId: commandId } }));
 }
 
 function revalidateAgentInstance(snapshot: AgentCard): AgentCard {
@@ -56,7 +58,7 @@ function revalidateAgentInstance(snapshot: AgentCard): AgentCard {
   return current;
 }
 
-export function settleInterruptRedirectMessage(command: Command): boolean {
+export async function settleInterruptRedirectMessage(command: Command): Promise<boolean> {
   if (command.type !== "agent.interrupt" || !["failed", "timed_out", "rejected", "canceled"].includes(command.status)) return false;
   if (command.params.action !== "interrupt" || command.params.agentId !== command.target) return false;
   const redirect = command.params.redirect;
@@ -69,7 +71,7 @@ export function settleInterruptRedirectMessage(command: Command): boolean {
   // Exact primary-key lookup plus the server-stamped message owner is the authorization link. The
   // activity row is observability only and cannot authorize this destructive deletion.
   if (message.meta?.createdByCommandId !== command.id) return false;
-  if (!deleteMessage(message.id)) return false;
+  if (!(await deleteMessageAsync(message.id))) return false;
   emitMessageDeleted(message.id);
   return true;
 }
@@ -81,7 +83,7 @@ export function settleInterruptRedirectMessage(command: Command): boolean {
 export async function dispatchInterrupt(input: InterruptAgentInput, ctx: AuthContext): Promise<InterruptAgentResult> {
   const agent = getAgent(input.agentId);
   if (!agent) throw new ShutdownTargetError(`agent ${input.agentId} not found`);
-  authorizeShutdown(ctx, { agentId: input.agentId, requestedVia: input.requestedVia });
+  (await authorizeShutdown(ctx, { agentId: input.agentId, requestedVia: input.requestedVia }));
   assertInterruptSupported(agent, input.mode);
 
   if (input.mode === "stop" && agent.status !== "busy") {
@@ -134,11 +136,12 @@ export async function dispatchInterrupt(input: InterruptAgentInput, ctx: AuthCon
   // the await is rejected rather than receiving predecessor-bound interrupt state.
   const event = await createActivityEventAsync(activityInput);
   const current = revalidateAgentInstance(agent);
-  const sessionMessage = body ? sessionMessageForRedirect(current.id, ctx, body, commandId) : undefined;
+  const sessionMessage = body ? (await sessionMessageForRedirect(current.id, ctx, body, commandId)) : undefined;
   if (sessionMessage && commandInput.params.redirect && typeof commandInput.params.redirect === "object") {
     (commandInput.params.redirect as Record<string, unknown>).messageId = sessionMessage.id;
   }
-  const command = createCommandInternal({ input: commandInput, id: commandId });
+  const { command: admitted } = await createAgentControlAsync({ agent, commandInput, commandId });
+  const command = admitted!;
   if (sessionMessage) emitNewMessage(sessionMessage);
   emitCommandEvent(command, "command.requested");
   emitActivityEvent(event);

package/src/services/issue-activity.ts

@@ -4,7 +4,7 @@ import {
   type IssueActivityAction,
   type RecordIssueActivityInput,
 } from "../db/activity";
-import { listAgentIssueActivityAsync, listIssueActivityAgentsAsync } from "../db/activity-async";
+import { recordIssueActivityAsync, listAgentIssueActivityAsync, listIssueActivityAgentsAsync } from "../db/activity-async";
 import { emitActivityEvent } from "../sse";
 
 export {
@@ -16,8 +16,8 @@ export {
   type RecordIssueActivityInput,
 };
 
-export function recordAndEmitIssueActivity(input: RecordIssueActivityInput) {
-  const event = recordIssueActivity(input);
+export async function recordAndEmitIssueActivity(input: RecordIssueActivityInput) {
+  const event = await recordIssueActivityAsync(input);
   emitActivityEvent(event);
   return event;
 }