@humwick/server 0.130.2 → 0.130.4

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

package/src/services/issue-associations.ts

@@ -1,10 +1,7 @@
-import {
-  associateIssue,
-  listEntitiesForIssue,
-  listIssuesForEntity,
-  removeAssociation,
-} from "../db/issue-associations";
-import { getIssueRef, resolveIssueRefByExternalKey, resolveIssueRefFromString } from "../db/issue-refs";
+import { resolveIssueRefFromStringAsync, resolveIssueRefByExternalKeyAsync } from "../db/issue-refs-async";
+import { removeAssociationAsync, associateIssueAsync } from "../db/runtime-tail-async";
+import { listEntitiesForIssue, listIssuesForEntity } from "../db/issue-associations";
+import { getIssueRef } from "../db/issue-refs";
 import type { IssueAssociationEntityType, IssueAssociationIssue, IssueProvider } from "../types";
 import { ValidationError } from "../db/connection";
 
@@ -24,36 +21,36 @@ interface AssociateIssueInput extends ResolveAssociationIssueInput {
   entityId: string;
 }
 
-export function resolveAssociationIssueRef(input: ResolveAssociationIssueInput) {
+export async function resolveAssociationIssueRef(input: ResolveAssociationIssueInput) {
   if (input.issueRefId) {
     const issueRef = getIssueRef(input.issueRefId);
     if (!issueRef) throw new ValidationError(`issue ref ${input.issueRefId} not found`);
     return issueRef;
   }
   if (input.ref) {
-    return resolveIssueRefFromString({
+    return (await resolveIssueRefFromStringAsync({
       ref: input.ref,
       defaultRepo: input.defaultRepo ?? input.repo,
       provider: input.provider,
       title: input.title,
-    });
+    }));
   }
   if (input.provider && input.repo && input.externalKey) {
-    return resolveIssueRefByExternalKey({
+    return (await resolveIssueRefByExternalKeyAsync({
       provider: input.provider,
       repo: input.repo,
       externalKey: input.externalKey,
       url: input.url,
       title: input.title,
-    });
+    }));
   }
   throw new ValidationError("issueRefId, ref, or provider/repo/externalKey required");
 }
 
-export function associateIssueRef(input: AssociateIssueInput) {
-  const issueRef = resolveAssociationIssueRef(input);
+export async function associateIssueRef(input: AssociateIssueInput) {
+  const issueRef = (await resolveAssociationIssueRef(input));
   return {
-    association: associateIssue(issueRef.id, input.entityType, input.entityId),
+    association: (await associateIssueAsync(issueRef.id, input.entityType, input.entityId)),
     issueRef,
   };
 }
@@ -66,7 +63,7 @@ export function listIssueEntities(issueRefId: string) {
   return listEntitiesForIssue(issueRefId);
 }
 
-export function removeIssueAssociation(input: AssociateIssueInput): { deleted: boolean } {
-  const issueRef = resolveAssociationIssueRef(input);
-  return { deleted: removeAssociation(issueRef.id, input.entityType, input.entityId) };
+export async function removeIssueAssociation(input: AssociateIssueInput): Promise<{ deleted: boolean }> {
+  const issueRef = (await resolveAssociationIssueRef(input));
+  return { deleted: (await removeAssociationAsync(issueRef.id, input.entityType, input.entityId)) };
 }

package/src/services/issue-lifecycle-comments.ts

@@ -1,5 +1,6 @@
+import { recordIssueLifecycleCommentAsync } from "../db/runtime-tail-async";
 import { createHash } from "node:crypto";
-import { hasIssueLifecycleComment, recordIssueLifecycleComment } from "../db/long-running-work";
+import { hasIssueLifecycleComment } from "../db/long-running-work";
 import type { IssueTrackerAdapter } from "../issue-tracker";
 import type { IssueRef } from "../types";
 
@@ -8,5 +9,5 @@ export async function commentIssueLifecycleOnce(adapter: IssueTrackerAdapter, re
   const commentKey = createHash("sha256").update(body).digest("hex");
   if (hasIssueLifecycleComment(ref.id, landKey, commentKey)) return;
   await adapter.comment(ref, body);
-  recordIssueLifecycleComment(ref.id, landKey, commentKey);
+  (await recordIssueLifecycleCommentAsync(ref.id, landKey, commentKey));
 }

package/src/services/issue-lifecycle.ts

@@ -1,9 +1,10 @@
+import { associateIssueAsync, insertTaskEventAsync } from "../db/runtime-tail-async";
 import { commentIssueLifecycleOnce } from "./issue-lifecycle-comments";
 import { deferIssueClose, pendingDoneWhenTasks } from "./issue-completion";
 import { canCloseBacklink, landTaskIssueLinks, recordReferencesOnlyLand } from "./land-issue-relations";
 import { errMessage } from "@humwick/sdk";
 import { resolveLandedTaskIds, type LandedTaskAttributionInput } from "./landed-task-attribution";
-import { getTaskDetail, insertTaskEvent, listTaskEvents } from "../db";
+import { getTaskDetail, listTaskEvents } from "../db";
 import { listEntitiesForIssue, listIssuesForEntity } from "../db/issue-associations";
 import {
   getSuccessfulIssueLifecycleAction,
@@ -11,7 +12,7 @@ import {
 } from "../db/issue-lifecycle";
 import { getIssueRef } from "../db/issue-refs";
 import { resolveIssueRefByExternalKeyAsync, resolveIssueRefFromStringAsync, updateIssueRefAsync, upsertIssueLifecycleActionAsync } from "../db/issue-refs-async";
-import { associateIssue } from "../db/issue-associations";
+
 import { resolveIssueTrackerAdapter } from "../issue-tracker";
 import { defaultIssueRepo } from "../config";
 // `repoFromGitRemote` / `parseOwnerRepoFromRemote` live in the shared ./git-remote module
@@ -226,18 +227,18 @@ function taskIssueLinkMismatches(taskIds: number[], declared: IssueRef[] | undef
   });
 }
 
-function recordIssueLinkMismatch(taskId: number, mismatch: IssueLinkMismatch, input: LandedIssueLifecycleInput): void {
+async function recordIssueLinkMismatch(taskId: number, mismatch: IssueLinkMismatch, input: LandedIssueLifecycleInput): Promise<void> {
   const key = landKey(input);
   if (listTaskEvents(taskId).some((event) => event.type === "issue-link-mismatch" && event.metadata.landKey === key)) return;
   const body = `Landed commit declared issue(s) ${mismatch.declared.map((key) => `#${key}`).join(", ")}, while Task T${taskId} remains linked to ${mismatch.associated.map((key) => `#${key}`).join(", ")}. Used the commit declaration for issue lifecycle; Task links were not changed.`;
-  insertTaskEvent(taskId, {
+  (await insertTaskEventAsync(taskId, {
     source: "issue-lifecycle",
     type: "issue-link-mismatch",
     severity: "warning",
     title: "Commit issue declaration differs from Task link",
     body,
     metadata: { landKey: key, declared: mismatch.declared, associated: mismatch.associated, source: "commit-declaration" },
-  }, Date.now());
+  }, Date.now()));
   const task = getTaskDetail(taskId);
   if (task) emitTaskChanged(task, "task.issue-link-mismatch");
 }
@@ -479,7 +480,7 @@ export async function closeIssueRefForLand(
       status: "succeeded",
     });
     if (input.workspace.ownerAgentId) {
-      recordAndEmitIssueActivity({
+      (await recordAndEmitIssueActivity({
         agentId: input.workspace.ownerAgentId,
         action: "done",
         issueRefId: latest.id,
@@ -487,7 +488,7 @@ export async function closeIssueRefForLand(
         title: "Issue closed on land",
         body: comment,
         metadata: { workspaceId: input.workspace.id, branch: input.workspace.branch, commitSha: input.mergedSha, source },
-      });
+      }));
     }
     // #2520 — relay's own completed close is a terminal trigger for the plan nodes bound to
     // this ref. Awaited post-commit effect: the close is already durable, and the plan update
@@ -546,9 +547,9 @@ export async function handleLandedIssueLifecycle(input: LandedIssueLifecycleInpu
   const taskIds = resolveLandedTaskIds(input);
   const links = landTaskIssueLinks(taskIds);
   const resolved = await resolveIssueRefsForLand(input, links);
-  recordReferencesOnlyLand(links, resolved.refs, landKey(input));
+  (await recordReferencesOnlyLand(links, resolved.refs, landKey(input)));
   const mismatches = taskIssueLinkMismatches(taskIds, resolved.declared);
-  for (const mismatch of mismatches) recordIssueLinkMismatch(mismatch.taskId, mismatch, input);
+  for (const mismatch of mismatches) (await recordIssueLinkMismatch(mismatch.taskId, mismatch, input));
   if (resolved.refs.length === 0 && taskIds.length > 0 && taskIds.every((id) => listIssuesForEntity("task", String(id)).length === 0)) {
     logFailure(opts, `issue lifecycle found landed task(s) without linked issue refs: tasks=${taskIds.join(",")} workspace=${input.workspace.id} branch=${input.workspace.branch ?? "unknown"}`);
   }
@@ -566,15 +567,15 @@ async function resolveReopenRef(input: ReopenIssueLifecycleInput): Promise<Issue
     if (!issueRef) throw new Error(`issue ref ${input.issueRefId} not found`);
     return issueRef;
   }
-  if (input.ref) return resolveIssueRefFromStringAsync({ ref: input.ref, defaultRepo: input.defaultRepo ?? input.repo, provider: input.provider, title: input.title });
+  if (input.ref) return (await resolveIssueRefFromStringAsync({ ref: input.ref, defaultRepo: input.defaultRepo ?? input.repo, provider: input.provider, title: input.title }));
   if (input.provider && input.repo && input.externalKey) {
-    return resolveIssueRefByExternalKeyAsync({
+    return (await resolveIssueRefByExternalKeyAsync({
       provider: input.provider,
       repo: input.repo,
       externalKey: input.externalKey,
       url: input.url,
       title: input.title,
-    });
+    }));
   }
   throw new Error("issueRefId, ref, or provider/repo/externalKey required");
 }
@@ -596,7 +597,7 @@ export async function reopenIssueLifecycle(input: ReopenIssueLifecycleInput, opt
       status: "succeeded",
       source: "explicit",
     });
-    if (input.entityType && input.entityId) associateIssue(issueRef.id, input.entityType, input.entityId);
+    if (input.entityType && input.entityId) (await associateIssueAsync(issueRef.id, input.entityType, input.entityId));
     return { issueRef: opened, action: "reopened", landKey: key };
   } catch (error) {
     const message = errMessage(error);

package/src/services/issue-refs.ts

@@ -1,7 +1,6 @@
-import { deleteIssueRefAsync, resolveIssueRefByExternalKeyAsync, resolveIssueRefFromStringAsync, updateIssueRefAsync, upsertIssueRefAsync } from "../db/issue-refs-async";
+import { deleteIssueRefAsync, listIssueRefsAsync, resolveIssueRefByExternalKeyAsync, resolveIssueRefFromStringAsync, updateIssueRefAsync, upsertIssueRefAsync } from "../db/issue-refs-async";
 import {
   getIssueRef,
-  listIssueRefs,
   type ListIssueRefsOptions,
   type ResolveIssueRefByExternalKeyInput,
   type ResolveIssueRefFromStringInput,
@@ -9,14 +8,14 @@ import {
   type UpsertIssueRefInput,
 } from "../db/issue-refs";
 
-export { getIssueRef, listIssueRefs, type ListIssueRefsOptions };
+export { getIssueRef, listIssueRefsAsync, type ListIssueRefsOptions };
 
 export function upsertIssueRefMappingAsync(input: UpsertIssueRefInput) {
   return upsertIssueRefAsync(input);
 }
 
-export function resolveIssueRefMappingAsync(input: ResolveIssueRefByExternalKeyInput | ResolveIssueRefFromStringInput) {
-  return "ref" in input ? resolveIssueRefFromStringAsync(input) : resolveIssueRefByExternalKeyAsync(input);
+export async function resolveIssueRefMappingAsync(input: ResolveIssueRefByExternalKeyInput | ResolveIssueRefFromStringInput) {
+  return "ref" in input ? (await resolveIssueRefFromStringAsync(input)) : (await resolveIssueRefByExternalKeyAsync(input));
 }
 
 export function patchIssueRefMappingAsync(id: string, input: UpdateIssueRefInput) {

package/src/services/kernel-timers-cutover-chaos-worker.ts

@@ -102,7 +102,7 @@ async function main(): Promise<void> {
     await c.tick();
     await c.tick();
     if (boundary === "before-release") {
-      c.requestAbort("chaos release");
+      await c.requestAbort("chaos release");
       await c.tick();
       await c.tick();
     }