@humwick/server 0.130.2 → 0.130.4

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

@@ -123,7 +123,7 @@ function writeResult(result: Record<string, unknown>): void {
  *  live-slow-applier boundary, a LIVE stall handshaken over marker files). */
 function faultsFor(boundary: string): TimerIngressFaults {
   switch (boundary) {
-    case "accept-before-commit": return { beforeAcceptCommit: selfKill };
+    case "accept-before-commit": return {}; // Armed on the writer thread in main().
     case "accept-after-commit": return { afterAcceptCommit: selfKill };
     case "apply-after-claim": return { afterClaim: selfKill };
     case "apply-after-target": return { afterApply: selfKill };
@@ -253,6 +253,11 @@ async function recoverLoop(host: ModuleHost, ingress: TimerIngress): Promise<voi
 
 async function main(): Promise<void> {
   initDb(DB_PATH);
+  if (BOUNDARY === "accept-before-commit") {
+    const { getGateway } = await import("../db/gateway");
+    const kind = CMD === "accept-cancel" ? "Cancel" : "Create";
+    await getGateway().write("seam.armFault", { name: `timerIngress.accept${kind}.beforeCommit`, action: "kill" });
+  }
   const host = buildHost();
 
   if (CMD === "accept-create") {

package/src/services/kernel-timers-ingress.ts

@@ -121,6 +121,7 @@
  *       undriven seed only parks later).
  *
  */
+import { framed } from "../hub-metrics";
 import { randomUUID } from "node:crypto";
 import { errMessage } from "@humwick/sdk";
 import {
@@ -669,9 +670,8 @@ export function createTimerIngress(options: TimerIngressOptions): TimerIngress {
 
     start() {
       if (ticker) return;
-      const pass = () => {
-        void api.applyOnce().catch((error) => console.warn(`timer ingress applier pass failed: ${errMessage(error)}`));
-      };
+      const pass = framed("timer kernel-timer-ingress", () =>
+        api.applyOnce().catch((error) => console.warn(`timer ingress applier pass failed: ${errMessage(error)}`)));
       pass(); // boot recovery: converge whatever a prior process left unsettled
       ticker = setInterval(pass, tickMs);
     },

package/src/services/kernel-timers-message-authority-chaos-worker.ts

@@ -1,14 +1,7 @@
+import { upsertAgentAsync } from "../db/agents-async";
 import { createControllableClock, createSqliteModuleHost, createSeededRng, type WorkflowStepCommitFaults } from "@humwick/kernel";
 import { timers } from "@humwick/kernel/timers.pilot";
-import {
-  getDb,
-  getScheduledTimer,
-  initDb,
-  insertScheduledTimer,
-  TimerMessageAuthorityParticipantStore,
-  TimerMessageAuthorityStore,
-  upsertAgent,
-} from "../db";
+import { getDb, getScheduledTimer, initDb, insertScheduledTimer, TimerMessageAuthorityParticipantStore, TimerMessageAuthorityStore } from "../db";
 import { migrateInputFor } from "./kernel-timers-migrate";
 
 const [dbPath, command, boundary = "none", shape = "once"] = process.argv.slice(2);
@@ -49,7 +42,7 @@ const host = createSqliteModuleHost({
 host.register(timers);
 
 if (command === "seed") {
-  upsertAgent({ id: "stage5-agent", name: "stage5-agent", status: "online", ready: true });
+  upsertAgentAsync({ id: "stage5-agent", name: "stage5-agent", status: "online", ready: true });
   const inserted = insertScheduledTimer({
     target: "stage5-agent",
     createdBy: "stage5-agent",

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

@@ -1,7 +1,8 @@
+import { upsertAgentAsync } from "../db/agents-async";
 import { relayEnv } from "@humwick/sdk/env";
 import { Database } from "bun:sqlite";
 import { existsSync, writeFileSync } from "node:fs";
-import { applyConnectionPragmas, getDb, initDb, insertScheduledTimer, setDb, upsertAgent } from "../db";
+import { applyConnectionPragmas, getDb, initDb, insertScheduledTimer, setDb } from "../db";
 import { decideLegacyTimerMessageFire } from "../db/timer-message-fire";
 import { executeTimerMessageOperator } from "./kernel-timers-operator";
 import { createToken } from "../token-db";
@@ -73,7 +74,7 @@ const audit = { actor: "dashboard:chaos", authenticated: true, authorized: true
 async function main(): Promise<void> {
   if (action === "seed") {
     initDb(dbPath);
-    upsertAgent({ id: "chaos-agent", name: "chaos-agent", status: "online", ready: true });
+    (await upsertAgentAsync({ id: "chaos-agent", name: "chaos-agent", status: "online", ready: true }));
     seed("message-a");
     seed("message-b");
     seed("message-c");

package/src/services/kernel-timers-outbox.ts

@@ -124,7 +124,7 @@ export async function drainKernelRelayOutbox(host: ModuleHost, options: DrainOut
     try {
       // At-least-once: a re-drained row re-presents the SAME `base:run:N` key, so `sendMessageService`
       // returns the already-stored message (`created:false`) instead of storing a second — no double-send.
-      const message = send(sendInputOf(row), sendAuthContext(row));
+      const message = await send(sendInputOf(row), sendAuthContext(row));
       await host.invoke(timers, "markRelaySendSent", DRAINER_IDENTITY, { id: row.id, messageId: message.message.id });
       result.sent += 1;
     } catch (error) {

package/src/services/kernel-timers-stage10-operator.ts

@@ -181,7 +181,7 @@ export async function runStage10OperatorTransfer(
     if (!await recordG1TransferAsync(input.requestId, options.ownerId, fenced.epoch, g1)) {
       return access.result(input, commandId, "running");
     }
-  } else coordinator.markReverseTransferDesired(targetMode, sourceMode);
+  } else (await coordinator.markReverseTransferDesired(targetMode, sourceMode));
 
   let batchNumber = 0;
   for (;;) {

package/src/services/kernel-timers.ts

@@ -1,3 +1,4 @@
+import { framed } from "../hub-metrics";
 import { errMessage } from "@humwick/sdk";
 import { createModuleHost, type ModuleHost } from "@humwick/kernel";
 import type { WorkflowRuntime } from "@humwick/kernel/workflow-runtime";
@@ -213,11 +214,11 @@ export function startKernelServedTimers(options: { autoTick?: boolean } = {}): K
 
   // Boot + interval both drive the single-flight pass. Capturing `running` per tick means a tick that
   // fires after teardown returns early rather than pumping a torn-down supervisor.
-  const pump = () => {
+  const pump = framed("timer kernel-timers", () => {
     const current = running;
     if (!current) return;
-    void pumpRunningTimers(current).catch((error) => console.warn(`kernel timers pump failed: ${errMessage(error)}`));
-  };
+    return pumpRunningTimers(current).catch((error) => console.warn(`kernel timers pump failed: ${errMessage(error)}`));
+  });
   // Tests that drive the supervisor only by awaited pumps opt out of the boot pass and the interval.
   if (options.autoTick === false) return running;
   pump();

package/src/services/land-gate-placement.ts

@@ -1,4 +1,6 @@
-import type { Command, LandGatesConfig, Orchestrator, WorkspaceRecord } from "@humwick/sdk";
+import type { Command, LandGatesConfig, Orchestrator, WorkspaceRecord, WorktreeProvisionConfig } from "@humwick/sdk";
+import { DELEGATED_LAND_DEPS_REQUIRED } from "@humwick/sdk/worktree-config";
+import { LandConfigurationError } from "../workspace-land-refusal";
 import { recordTaskEventAsync } from "../db/task-async";
 import { boundTaskIdsForWorkspace } from "./workspace-task-binding";
 import { listOrchestrators } from "../db";
@@ -13,7 +15,7 @@ export function gateHostMeetsRequirements(host: Orchestrator, requirements: NonN
 
 /** Absence preserves local landing; declared requirements opt into fleet placement. */
 export async function selectLandGateHost(workspace: WorkspaceRecord, owner: Orchestrator,
-  remoteIdentity: string, requirements?: LandGatesConfig["requirements"],
+  remoteIdentity: string, requirements?: LandGatesConfig["requirements"], depsStrategy?: WorktreeProvisionConfig["depsStrategy"],
 ): Promise<{ orchestrator: Orchestrator; repoRoot: string; delegated: boolean }> {
   if (!requirements) return { orchestrator: owner, repoRoot: workspace.repoRoot, delegated: false };
   const views = new Map(listHostViews(Date.now()).map((host) => [host.id, host]));
@@ -39,6 +41,13 @@ export async function selectLandGateHost(workspace: WorkspaceRecord, owner: Orch
   };
   const delegates = eligible.filter((host) => host.id !== owner.id && host.capabilities?.delegatedLandGateV1 === true)
     .sort((a, b) => availableSlots(b) - availableSlots(a));
+  if (delegates.length && depsStrategy === "symlink") {
+    if (gateHostMeetsRequirements(owner, requirements)) {
+      throw new Error(`owner ${owner.hostname} temporarily unavailable for local symlink dependency gates`
+        + (notReady.length ? `: ${notReady.join("; ")}` : " (gate admission disabled)"));
+    }
+    throw new LandConfigurationError(`${DELEGATED_LAND_DEPS_REQUIRED}; owner ${owner.hostname} does not meet gate host requirements`);
+  }
   const mapped = delegates.length ? await repoCwdsByHost(workspace.sourceCwd || workspace.repoRoot,
     remoteIdentity, delegates.map((host) => host.id), true) : undefined;
   for (const host of delegates) {

package/src/services/land-issue-relations.ts

@@ -1,4 +1,5 @@
-import { getTask, getTaskDetail, insertTaskEvent, listTaskEvents } from "../db";
+import { insertTaskEventAsync } from "../db/runtime-tail-async";
+import { getTask, getTaskDetail, listTaskEvents } from "../db";
 import { listIssuesForEntity } from "../db/issue-associations";
 import { defaultTaskIssueRelation } from "../db/task-issue-relation";
 import { emitTaskChanged } from "../sse";
@@ -29,17 +30,17 @@ export function canCloseBacklink(ref: IssueRef, links: LandTaskIssueLinks): bool
   return (linkedTasks.length ? linkedTasks : links).some((link) => link.buildLike);
 }
 
-export function recordReferencesOnlyLand(links: LandTaskIssueLinks, selected: IssueRef[], landKey: string): void {
+export async function recordReferencesOnlyLand(links: LandTaskIssueLinks, selected: IssueRef[], landKey: string): Promise<void> {
   const selectedIds = new Set(selected.map((ref) => ref.id));
   for (const link of links) {
     const refs = link.issues.filter((issue) => issue.relation === "references" && issue.ref.status !== "closed" && !selectedIds.has(issue.ref.id));
     if (!refs.length || listTaskEvents(link.taskId).some((event) => event.type === "issue-left-open" && event.metadata.landKey === landKey)) continue;
-    insertTaskEvent(link.taskId, {
+    (await insertTaskEventAsync(link.taskId, {
       source: "issue-lifecycle", type: "issue-left-open", severity: "info",
       title: "Issue left open: references-only",
       body: `Left open because this Task references these issues: ${refs.map((issue) => `${issue.ref.repo}#${issue.ref.externalKey}`).join(", ")}.`,
       metadata: { landKey, reason: "references-only", issueRefIds: refs.map((issue) => issue.ref.id) },
-    }, Date.now());
+    }, Date.now()));
     const task = getTaskDetail(link.taskId);
     if (task) emitTaskChanged(task, "task.issue-left-open");
   }

package/src/services/land-restart-retry.ts

@@ -1,4 +1,5 @@
-import { createActivityEvent, updateWorkspaceStatusAsync } from "../db";
+import { createActivityEventAsync } from "../db/activity-async";
+import { updateWorkspaceStatusAsync } from "../db";
 import { deferLandSettleSideEffect } from "../land-settle-dispatch";
 import { routeNotification } from "../notification-router";
 import { resolveCoordinatorAgentId } from "../steward-identity";
@@ -37,17 +38,17 @@ export async function settleRestartKilledLand(command: Command, workspace: Works
     ...mergeRetryEnqueuedAtPatch(mergeResult, command),
   });
   if (transitioned) {
-    deferLandSettleSideEffect("land-restart-retry", () => notifyLandRedispatching(transitioned, command, headSha));
+    deferLandSettleSideEffect("land-restart-retry", async () => await notifyLandRedispatching(transitioned, command, headSha));
   }
   return transitioned;
 }
 
-function notifyLandRedispatching(workspace: WorkspaceRecord, command: Command, headSha: string | undefined): void {
+async function notifyLandRedispatching(workspace: WorkspaceRecord, command: Command, headSha: string | undefined): Promise<void> {
   const branch = workspace.branch ?? workspace.id;
   const base = workspace.baseRef ?? "main";
   const head = headSha ? ` at \`${headSha.slice(0, 12)}\`` : "";
   const body = `\`${branch}\` → \`${base}\`: ${LAND_RESTART_RETRY_REASON}. Relay re-dispatches the same land${head} automatically and re-runs its gate. No action needed; do not re-deliver. A land result follows.`;
-  createActivityEvent({
+  (await createActivityEventAsync({
     clientId: `land-restart-retry-${command.id}`,
     kind: "state",
     title: "Land killed by restart; re-dispatching",
@@ -56,12 +57,12 @@ function notifyLandRedispatching(workspace: WorkspaceRecord, command: Command, h
     icon: "ti-refresh-alert",
     view: "orchestrators",
     metadata: { source: "server", workspaceId: workspace.id, commandId: command.id },
-  });
+  }));
   const author = workspace.ownerAgentId;
   const coordinator = resolveCoordinatorAgentId(author);
   const recipients = withWorkspaceTaskOwnerRoles([author, coordinator], workspace);
   if (!recipients.length) return;
-  routeNotification({
+  await routeNotification({
     type: "workspace.land_redispatched",
     scope: { author, parent: coordinator ?? undefined, repoRoot: workspace.repoRoot, workspaceId: workspace.id },
     recipients,

package/src/services/landed-ancestry.ts

@@ -1,3 +1,4 @@
+import { createActivityEventAsync } from "../db/activity-async";
 import { repoDefaultBranch } from "@humwick/sdk/land-gates";
 import { withWorkspaceTaskOwnerRoles } from "../task-owner-notices";
 // #1713 — the coordinator's "landed" signal, derived from GIT ANCESTRY rather than a command's
@@ -15,7 +16,7 @@ import { withWorkspaceTaskOwnerRoles } from "../task-owner-notices";
 //                     transport error). We do NOT guess "landed" — we degrade to an actionable
 //                     "verify manually" signal that names the sha and the stalled merge command id.
 import { landFailureEventKey } from "../land-failure-event-key";
-import { createActivityEvent } from "../db";
+
 import { stewardFallbackTarget } from "../config";
 import { emitRelayEvent } from "../events";
 import { routeNotification } from "../notification-router";
@@ -372,7 +373,7 @@ function landUnconfirmedText(input: LandUnconfirmedInput): { subject: string; bo
  * obligation) to the branch owner's coordinator and the fallback steward, and always leaves a
  * durable relay event + activity event so the outcome is auditable even if no one is reachable.
  */
-export function notifyLandUnconfirmed(input: LandUnconfirmedInput): void {
+export async function notifyLandUnconfirmed(input: LandUnconfirmedInput): Promise<void> {
   const { workspace, kind } = input;
   const owner = workspace.ownerAgentId ?? undefined;
   const coordinator = resolveCoordinatorAgentId(owner);
@@ -398,7 +399,7 @@ export function notifyLandUnconfirmed(input: LandUnconfirmedInput): void {
 
   // #1912 §4 retained: command settlement schedules this through a synchronous deferred callback;
   // it cannot await without changing the settle/error contract for land completion.
-  createActivityEvent({
+  (await createActivityEventAsync({
     clientId: `workspace-land-unconfirmed-${workspace.id}-${input.commandId ?? "nocmd"}-${kind}`,
     kind: "state",
     title: kind === "not-ancestor"
@@ -411,11 +412,11 @@ export function notifyLandUnconfirmed(input: LandUnconfirmedInput): void {
     icon: "ti-alert-octagon",
     view: "orchestrators",
     metadata: { source: "server", maintenanceJobId: "workspace-land-unconfirmed", workspaceId: workspace.id, mergeCommandId: input.commandId, landOutcome: kind },
-  });
+  }));
 
   const recipients = withWorkspaceTaskOwnerRoles([owner, coordinator, fallback], workspace);
   if (recipients.length === 0) return;
-  routeNotification({
+  await routeNotification({
     type: "workspace.land_unconfirmed",
     scope: { workspaceId: workspace.id, repoRoot: workspace.repoRoot, ...(owner ? { author: owner } : {}), ...(coordinator ? { parent: coordinator } : {}) },
     recipients,

package/src/services/legacy-landing-host.ts

@@ -1,5 +1,5 @@
 import { cleanDeliveryGatePolicy, cleanLandGateRequirements } from "@humwick/sdk/land-gates";
-import type { CapturedDeliveryGateRequirement, LandGatesConfig } from "@humwick/sdk";
+import type { CapturedDeliveryGateRequirement, LandGatesConfig, WorktreeProvisionConfig } from "@humwick/sdk";
 import { errMessage, exactLandingSourceIdentity, RELAY_TOKEN_HEADER, isRecord, stringValue, type LandingContainmentMode } from "@humwick/sdk";
 import { isTrustedOrchestratorApiUrl, relayToken } from "../config";
 import { classifyLegacyLanding, type LandingLaneIdentity } from "../landing-lane-key";
@@ -14,6 +14,7 @@ export interface HostResolvedLandingIdentity extends LandingLaneIdentity {
   readonly sourceHeadSha: string;
   readonly baseHeadSha?: string;
   readonly gateRequirements?: LandGatesConfig["requirements"];
+  readonly gateDepsStrategy?: WorktreeProvisionConfig["depsStrategy"];
   readonly deliveryGate?: CapturedDeliveryGateRequirement;
   readonly landGateTimeoutBudgetMs?: number;
 }
@@ -131,6 +132,8 @@ export async function discoverLandingIdentityOnHost(
   return { ...classified.laneIdentity, sourceHeadSha: source.sourceHeadSha, ...(baseHeadSha ? { baseHeadSha } : {}),
     ...(delivery.deliveryRequire ? { deliveryGate: { command: delivery.delivery!, require: delivery.deliveryRequire } } : {}),
     ...(gateRequirements ? { gateRequirements } : {}),
+    ...(body.gateDepsStrategy === "command" || body.gateDepsStrategy === "none" || body.gateDepsStrategy === "symlink"
+      ? { gateDepsStrategy: body.gateDepsStrategy } : {}),
     ...(typeof body.landGateTimeoutBudgetMs === "number" && Number.isSafeInteger(body.landGateTimeoutBudgetMs) && body.landGateTimeoutBudgetMs >= 0
       ? { landGateTimeoutBudgetMs: body.landGateTimeoutBudgetMs } : {}) };
 }

package/src/services/legacy-landing-recovery.ts

@@ -1,5 +1,7 @@
-import { commandExecutorConfirmedGone, getCommandClaimOwnerToken, updateCommand } from "../commands-db.ts";
-import { releaseMergeLease } from "../db/merge-lease.ts";
+import { releaseMergeLeaseAsync } from "../db/runtime-tail-async";
+import { updateCommandAsync } from "../commands-write";
+import { commandExecutorConfirmedGone, getCommandClaimOwnerToken } from "../commands-db.ts";
+
 import { recordExecutionProofAsync, terminalizeLegacyLandingAsync } from "../commands-landing-async.ts";
 import { resolveCommandExecutorOwner } from "../merge-drain.ts";
 import type { Command, Orchestrator } from "../types.ts";
@@ -30,9 +32,9 @@ export async function reconcileLegacyLandingExecution(
       && commandExecutorConfirmedGone(command, getCommandClaimOwnerToken(command.id),
         resolveCommandExecutorOwner(command, orchestrators), now);
     if (!pastLease && !ownerGone) return null;
-    const terminal = updateCommand(command.id, { status: "timed_out", error: ownerGone
-      ? LEGACY_UNFENCED_RESTART_ERROR : "command timed out" }, { executor: true });
-    if (terminal) releaseMergeLease({ commandId: terminal.id });
+    const terminal = (await updateCommandAsync(command.id, { status: "timed_out", error: ownerGone
+      ? LEGACY_UNFENCED_RESTART_ERROR : "command timed out" }, { executor: true }));
+    if (terminal) (await releaseMergeLeaseAsync({ commandId: terminal.id }));
     return terminal;
   }
   if (command.landingContainmentMode !== "cgroup-v2-close-v1") return null;
@@ -82,7 +84,7 @@ export async function reconcileLegacyLandingExecution(
   const ownerState = resolveCommandExecutorOwner(command, orchestrators);
   if (!commandExecutorConfirmedGone(command, claimOwnerToken, ownerState, now)) {
     if (typeof command.expiresAt === "number" && command.expiresAt <= now && ownerState?.status !== "online") {
-      alertUnprovenLandLaneHolder(command);
+      await alertUnprovenLandLaneHolder(command);
     }
     return null;
   }

package/src/services/managed-running.ts

@@ -12,13 +12,13 @@
 // Composed by `registerAgent` (HTTP + bus registration) and called directly by the
 // orchestrator-report projection in lifecycle-manager. It does NOT upsert the agent
 // row — the agent registers itself over HTTP/bus; this only reconciles managed state.
-import { createActivityEvent, resolveQueuedDirectMessages, resolveQueuedPolicyMessages } from "../db";
-import { getManagedAgentState, updateManagedAgentState } from "../config-store";
+import { createActivityEventAsync } from "../db";
+import { getManagedAgentState } from "../config-store";
 import { emitRelayEvent } from "../events";
 import { emitMessageAvailable, emitMessageDeliveryUpdated, emitNewMessage } from "../sse";
 import type { AuthContext } from "./auth-context";
 import type { ManagedAgentState, Message } from "../types";
-import { resolveQueuedCoordinatorMessages } from "../db/coordinator-delivery.ts";
+import { updateManagedAgentStateAsync, resolveQueuedDirectMessagesAsync, resolveQueuedPolicyMessagesAsync, resolveQueuedCoordinatorMessagesAsync } from "../db/lifecycle-tail-async";
 
 interface ManagedRunningInput {
   policyName?: string;
@@ -44,11 +44,11 @@ interface ManagedRunningInput {
  *  - the managed-state change emits via `emitManagedState` (source "lifecycle-manager"
  *    + an activity-feed transition row), never the source-"server" `emitManagedAgentStateChanged`.
  */
-export function markManagedAgentRunning(
+export async function markManagedAgentRunning(
   input: ManagedRunningInput,
   ctx: AuthContext,
   opts: { now?: () => number } = {},
-): void {
+): Promise<void> {
   if (!input.policyName || !input.spawnRequestId) return;
   // #1797 — the reconcile REBINDS `managed_agent_state.agent_id` (and, via
   // `updateManagedAgentState`, the retained `last_agent_id`), which `managedStewardBoundAgentId` →
@@ -88,7 +88,7 @@ export function markManagedAgentRunning(
   const now = opts.now ?? (() => Date.now());
 
   const fromState = state.status;
-  const patch: Parameters<typeof updateManagedAgentState>[1] = {
+  const patch: Parameters<typeof updateManagedAgentStateAsync>[1] = {
     status: "running",
     agentId: input.agentId || state.agentId,
     tmuxSession: input.tmuxSession ?? state.tmuxSession,
@@ -101,11 +101,11 @@ export function markManagedAgentRunning(
   };
   // #3615 — repeated roster reports still flush queued messages, without rewriting running state.
   if (Object.entries(patch).some(([key, value]) => state[key as keyof ManagedAgentState] !== value)) {
-    const next = updateManagedAgentState(input.policyName, patch);
-    if (next) emitManagedState(next, fromState);
+    const next = await updateManagedAgentStateAsync(input.policyName, patch);
+    if (next) await emitManagedState(next, fromState);
   }
 
-  const available = resolveQueuedPolicyMessages(input.policyName, input.agentId || state.agentId || "");
+  const available = await resolveQueuedPolicyMessagesAsync(input.policyName, input.agentId || state.agentId || "");
   if (available.length) {
     emitMessageAvailable(input.policyName, input.agentId || state.agentId || "", available);
     for (const message of available) {
@@ -126,31 +126,31 @@ export function markManagedAgentRunning(
 // the came-up-running op.
 let transitionSeq = 0;
 
-export function emitManagedState(
+export async function emitManagedState(
   state: ManagedAgentState,
   fromState: string | undefined,
   reason?: string,
   now: () => number = () => Date.now(),
-): void {
+): Promise<void> {
   emitRelayEvent({
     type: "policy.state.changed",
     source: "lifecycle-manager",
     subject: state.policyName,
     data: state as unknown as Record<string, unknown>,
   });
-  if (fromState !== state.status) recordManagedTransition(state, fromState, reason, now);
+  if (fromState !== state.status) await recordManagedTransition(state, fromState, reason, now);
 }
 
-function recordManagedTransition(
+async function recordManagedTransition(
   state: ManagedAgentState,
   fromState: string | undefined,
   reason: string | undefined,
   now: () => number,
-): void {
+): Promise<void> {
   const why = reason ?? state.lastError ?? undefined;
   // #1912 §4 retained: this is shared by synchronous registration, restart settlement, and
   // orchestrator-report projection. Its transition + queue flush need one future async redesign.
-  createActivityEvent({
+  await createActivityEventAsync({
     clientId: `lifecycle-${state.policyName}-${state.status}-${now()}-${++transitionSeq}`,
     kind: "state",
     title: `${state.policyName}: ${fromState ?? "—"} → ${state.status}`,
@@ -177,8 +177,8 @@ function recordManagedTransition(
  * No-op when there are no queued direct messages. Returns the flushed messages so
  * callers (e.g. the resweep safety net, #706) can report how many were recovered.
  */
-export function flushQueuedDirectMessages(agentId: string): Message[] {
-  const available = [...resolveQueuedDirectMessages(agentId), ...resolveQueuedCoordinatorMessages(agentId)];
+export async function flushQueuedDirectMessages(agentId: string): Promise<Message[]> {
+  const available = [...await resolveQueuedDirectMessagesAsync(agentId), ...await resolveQueuedCoordinatorMessagesAsync(agentId)];
   if (!available.length) return [];
   emitMessageAvailable("direct", agentId, available);
   for (const message of available) {

package/src/services/memory-areas.ts

@@ -4,7 +4,7 @@
 
 import { AREAS_FILE, SYSTEM_AREAS, SYSTEM_AREA_DESCRIPTIONS, areasAtCommit, injectsAtStartup, isSystemArea, type AreaDefinition, type AreasConfig } from "@humwick/sdk/areas";
 import { stringValue } from "@humwick/sdk";
-import { countActivePinnedEntriesInArea, getAgent, ValidationError } from "../db";
+import { countActivePinnedEntriesInAreaAsync, getAgent, ValidationError } from "../db";
 import type { Project, ProjectEntry } from "../types";
 import type { AuthContext } from "./auth-context";
 import { callerHost, callerProjectId } from "./memory-identity";
@@ -125,10 +125,10 @@ export async function resolveWriteAreas(
 /** When a written entry reaches agents, by its areas. An entry the startup block does not carry
  *  arrives when an agent first touches a path area it names (#3409, #3508). A pinned `project-wide`
  *  entry loads into every agent's startup block, so its write reports how many the cell carries. */
-export function areaDeliveryReport(entry: ProjectEntry): { deliveredOnTouch?: true; projectWideActive?: number; note?: string } {
+export async function areaDeliveryReport(entry: ProjectEntry): Promise<{ deliveredOnTouch?: true; projectWideActive?: number; note?: string }> {
   if (!injectsAtStartup(entry)) return entry.areas?.some((area) => !isSystemArea(area)) ? { deliveredOnTouch: true } : {};
   if (!entry.areas?.includes(PROJECT_WIDE)) return {};
-  const projectWideActive = countActivePinnedEntriesInArea(entry.projectId, PROJECT_WIDE);
+  const projectWideActive = await countActivePinnedEntriesInAreaAsync(entry.projectId, PROJECT_WIDE);
   return {
     projectWideActive,
     note: `${projectWideActive} active project-wide entries load into every agent's startup block; prefer a path or process area when one fits.`,

package/src/services/merge-pause.ts

@@ -1,11 +1,5 @@
-import {
-  acquireMergePause as acquireMergePauseRow,
-  getMergePause,
-  listMergePauses,
-  releaseMergePause as releaseMergePauseRow,
-  renewMergePause as renewMergePauseRow,
-  type MergePauseRecord,
-} from "../db";
+import { acquireMergePauseAsync as acquireMergePauseRowAsync, renewMergePauseAsync as renewMergePauseRowAsync, releaseMergePauseAsync as releaseMergePauseRowAsync } from "../db/runtime-tail-async";
+import { getMergePause, listMergePauses, type MergePauseRecord } from "../db";
 
 export type { MergePauseRecord };
 
@@ -17,21 +11,21 @@ export function getAutoMergePause(id: string): MergePauseRecord | null {
   return getMergePause(id);
 }
 
-export function pauseAutoMerge(input: {
+export async function pauseAutoMerge(input: {
   repoRoot: string;
   baseRef?: string;
   holder: string;
   reason?: string;
   ttlMs?: number;
   now?: number;
-}): { ok: true; pause: MergePauseRecord } | { ok: false; pause: MergePauseRecord } {
-  return acquireMergePauseRow(input);
+}): Promise<{ ok: true; pause: MergePauseRecord } | { ok: false; pause: MergePauseRecord }> {
+  return (await acquireMergePauseRowAsync(input));
 }
 
-export function renewAutoMergePause(id: string, ttlMs?: number): MergePauseRecord | null {
-  return renewMergePauseRow(id, ttlMs);
+export async function renewAutoMergePause(id: string, ttlMs?: number): Promise<MergePauseRecord | null> {
+  return (await renewMergePauseRowAsync(id, ttlMs));
 }
 
-export function resumeAutoMerge(input: { id?: string; repoRoot?: string; baseRef?: string }): boolean {
-  return releaseMergePauseRow(input);
+export async function resumeAutoMerge(input: { id?: string; repoRoot?: string; baseRef?: string }): Promise<boolean> {
+  return (await releaseMergePauseRowAsync(input));
 }