@humwick/server 0.130.2 → 0.130.3

package/src/services/plan-terminal-refs.ts

@@ -68,16 +68,6 @@ export async function advanceTerminalPlanRefsAsync(trigger: TerminalRefTrigger):
  * (replacePlanNodeScoped), and a residual failure degrades to warn-and-continue exactly like the
  * async twin — a propagation failure must never fail the durable status/stage write.
  */
-export function advanceTerminalPlanRefs(trigger: TerminalRefTrigger): Plan[] {
-  const { taskIds, issueRefIds, actor } = normalize(trigger);
-  if (taskIds.length === 0 && issueRefIds.length === 0) return [];
-  try {
-    const results = applyTerminalPlanRefsBody({ taskIds, issueRefIds, actor }, Date.now());
-    const plans = results.map((result) => result.plan);
-    emitChanged(plans, actor);
-    return plans;
-  } catch (error) {
-    console.warn(`plan-terminal-refs propagation failed (${trigger.taskId !== undefined ? `task ${trigger.taskId}` : trigger.issueRefId !== undefined ? `issue ${trigger.issueRefId}` : "trigger"}): ${errMessage(error)}`);
-    return [];
-  }
+export async function advanceTerminalPlanRefs(trigger: TerminalRefTrigger): Promise<Plan[]> {
+  return advanceTerminalPlanRefsAsync(trigger);
 }

package/src/services/plan-wake-digest.ts

@@ -11,7 +11,7 @@ export const PLAN_WAKE_DIGEST_MAX_BYTES = 1024;
 const INTRO = "Open team Plans: keep plans current and drive acceptance; relay_decision only when really blocked. In-progress age = plan update age.";
 const MORE = "More plans/nodes: relay_plan_list; relay_plan_get mode=resume.";
 
-function compactText(value: string, maxBytes: number): string {
+export function compactText(value: string, maxBytes: number): string {
   const text = value.slice(0, maxBytes).replace(/\s+/g, " ").trim();
   if (Buffer.byteLength(value) <= maxBytes) return text;
   let result = "";
@@ -42,9 +42,14 @@ function refsDone(node: PlanNode): boolean {
   return true;
 }
 
-function planLine(stored: Plan, now: number): string {
+/** The one node classification both the wake digest and the ready-node notice read (#3660). */
+export function liveFrontier(stored: Plan) {
   const plan = projectPlanOverTasks(stored);
-  const frontier = planResumeFrontier(plan);
+  return { plan, frontier: planResumeFrontier(plan) };
+}
+
+function planLine(stored: Plan, now: number): string {
+  const { plan, frontier } = liveFrontier(stored);
   const parts: string[] = [];
   if (frontier.ready.length) parts.push(`ready: ${nodeList(frontier.ready)}`);
   if (frontier.inProgress.length) {

package/src/services/profile-trust.ts

@@ -47,9 +47,9 @@ export async function updateProfileProjectTrustAsync(name: string, update: Proje
 }
 
 /** Approve an observed `sha256:…` (fingerprint) or `commit:…` value; the mode follows the prefix. */
-export function approveProfileProjectTrust(input: { name: string; capability: ProjectTrustCapability; repoKey: string; value: string; by: string }): ProjectTrustApproval {
+export async function approveProfileProjectTrust(input: { name: string; capability: ProjectTrustCapability; repoKey: string; value: string; by: string }): Promise<ProjectTrustApproval> {
   const profileName = existingProfile(input.name).value.name;
   const mode = input.value.startsWith("commit:") ? "commit" : input.value.startsWith("sha256:") ? "fingerprint" : undefined;
   if (!mode) throw new ValidationError(`approved value must start with "sha256:" or "commit:", as shown in the refusal`);
-  return approveProjectCapabilityReview({ profileName, repoKey: input.repoKey, capability: input.capability, mode, approvedValue: input.value, approvedBy: input.by });
+  return (await approveProjectCapabilityReview({ profileName, repoKey: input.repoKey, capability: input.capability, mode, approvedValue: input.value, approvedBy: input.by }));
 }

package/src/services/project.ts

@@ -1,5 +1,6 @@
+import { setProjectIssueRepoAsync, ensureProjectAsync, addProjectRootAsync } from "../db/projects-async";
 import { basename } from "node:path";
-import { getProjectBySlug, getProjectBySlugAsync, addProjectRoot, addProjectRootAsync, ensureProject, ensureProjectAsync, projectByRemoteUrl, projectByRemoteUrlAsync, resolveProjectForCwd, resolveProjectForCwdAsync, rootsForProject, rootsForProjectAsync, setProjectIssueRepo, setProjectIssueRepoAsync, workspaceRepoRootForCwd } from "../db";
+import { getProjectBySlug, getProjectBySlugAsync, projectByRemoteUrl, projectByRemoteUrlAsync, resolveProjectForCwd, resolveProjectForCwdAsync, rootsForProject, rootsForProjectAsync, workspaceRepoRootForCwd } from "../db";
 import { ingestClaudeMd } from "../project-ingest";
 import { resolveProjectForCanonicalCwd, type CanonicalCwdMatch } from "./project-cwd";
 import { canonicalRoot, canonicalRootAsync, findGitRepoRoot, findGitRepoRootAsync } from "./canonical-root";
@@ -42,23 +43,23 @@ interface AutoSeedProjectResult {
  * project-entry mutations are intentionally outside this projects-root migration. New
  * async-capable callers must use {@link ensureProjectRootAsync}.
  */
-export function ensureProjectRoot(input: EnsureProjectRootInput): EnsureProjectRootResult {
-  const project = ensureProject({
+export async function ensureProjectRoot(input: EnsureProjectRootInput): Promise<EnsureProjectRootResult> {
+  const project = (await ensureProjectAsync({
     slug: input.slug,
     matchingRemoteUrl: input.matchingRemoteUrl,
     ...(input.title !== undefined ? { title: input.title } : {}),
     ...(input.description !== undefined ? { description: input.description } : {}),
     ...(input.tenantId !== undefined ? { tenantId: input.tenantId } : {}),
     ...(input.issueRepo !== undefined ? { issueRepo: input.issueRepo } : {}),
-  });
+  }));
   const remoteUrl = input.remoteUrl ?? remoteUrlFromGitRemote(input.rootPath);
-  const roots = addProjectRoot(project.id, input.rootPath, { remoteUrl, ref: input.ref, orchestratorId: input.orchestratorId });
+  const roots = (await addProjectRootAsync(project.id, input.rootPath, { remoteUrl, ref: input.ref, orchestratorId: input.orchestratorId }));
   // Auto-derive issueRepo from the root's git remote (#533) when not explicitly provided.
   // `onlyIfNull` ensures an explicit override (or earlier derivation) is never clobbered.
   if (input.issueRepo === undefined && !project.issueRepo) {
     const derived = repoFromGitRemote(input.rootPath);
     if (derived) {
-      const updated = setProjectIssueRepo(project.id, derived, { onlyIfNull: true });
+      const updated = (await setProjectIssueRepoAsync(project.id, derived, { onlyIfNull: true }));
       if (updated) return { project: updated, roots };
     }
   }
@@ -117,17 +118,17 @@ async function resolveProjectForWorkspaceCwdAsync(cwd: string): Promise<Canonica
  * Synchronous compatibility seam for legacy callers. New async-capable registration/spawn
  * paths use {@link autoSeedProjectForCwdAsync} so root writes reach the writer gateway.
  */
-export function autoSeedProjectForCwd(cwd: string, authorId: string): AutoSeedProjectResult | null {
+export async function autoSeedProjectForCwd(cwd: string, authorId: string): Promise<AutoSeedProjectResult | null> {
   const match = resolveProjectForCanonicalCwd(cwd);
   if (match.project) {
     const repoRoot = match.repoRoot ?? cwd;
     // A remote-URL match owns no root containing this checkout yet — register it so every
     // later resolve is plain containment again, and never re-derives the remote.
-    if (match.matchedByRemote) addProjectRoot(match.project.id, repoRoot, { remoteUrl: remoteUrlFromGitRemote(repoRoot) });
+    if (match.matchedByRemote) (await addProjectRootAsync(match.project.id, repoRoot, { remoteUrl: remoteUrlFromGitRemote(repoRoot) }));
     let project = match.project;
     if (!project.issueRepo) {
       const derived = repoFromGitRemote(repoRoot);
-      const updated = derived ? setProjectIssueRepo(project.id, derived, { onlyIfNull: true }) : null;
+      const updated = derived ? (await setProjectIssueRepoAsync(project.id, derived, { onlyIfNull: true })) : null;
       if (updated) project = updated;
     }
     return { project, repoRoot, roots: rootsForProject(project.id) };
@@ -139,7 +140,7 @@ export function autoSeedProjectForCwd(cwd: string, authorId: string): AutoSeedPr
   if (!slug) return null;
 
   if (getProjectBySlug(slug)?.status === "archived" || resolveProjectForCwd(repoRoot, { includeArchived: true })?.status === "archived" || projectByRemoteUrl(remoteUrlFromGitRemote(repoRoot), { includeArchived: true })?.status === "archived") return null;
-  const { project, roots } = ensureProjectRoot({ slug, rootPath: repoRoot });
+  const { project, roots } = (await ensureProjectRoot({ slug, rootPath: repoRoot }));
   try {
     // Legacy synchronous callers cannot await filesystem ingestion. Their async
     // counterparts below perform it without blocking the server loop.

package/src/services/prompt-templates.ts

@@ -1,25 +1,26 @@
+import { upsertTemplateAsync, resetTemplateAsync } from "../db/runtime-tail-async";
 import { getGateway } from "../db/gateway";
 import { promptTemplateFallback } from "../prompt-template-fallback";
 import { defaultPromptTemplates } from "../prompt-resolver";
 import { memoryRetirementMessage } from "../memory-retirement";
 import { ValidationError } from "../db/connection";
-import { getTemplate, listTemplates, resetTemplate, upsertTemplate, type PromptTemplateRecord } from "../db";
+import { getTemplate, listTemplates, type PromptTemplateRecord } from "../db";
 
 export function listPromptTemplates(category?: string): PromptTemplateRecord[] {
   return listTemplates(category).filter((entry) => !memoryRetirementMessage(entry.slug));
 }
 
-export function updatePromptTemplate(slug: string, template: string): PromptTemplateRecord | null {
+export async function updatePromptTemplate(slug: string, template: string): Promise<PromptTemplateRecord | null> {
   const retirement = memoryRetirementMessage(slug);
   if (retirement) throw new ValidationError(retirement);
-  upsertTemplate(slug, template);
+  (await upsertTemplateAsync(slug, template));
   return getTemplate(slug);
 }
 
-export function resetPromptTemplate(slug: string): PromptTemplateRecord | null {
+export async function resetPromptTemplate(slug: string): Promise<PromptTemplateRecord | null> {
   const retirement = memoryRetirementMessage(slug);
   if (retirement) throw new ValidationError(retirement);
-  resetTemplate(slug);
+  (await resetTemplateAsync(slug));
   return getTemplate(slug);
 }
 

package/src/services/provider-hold-nudge.ts

@@ -97,7 +97,7 @@ export async function sendStillHeldNudges(nowMs: number = Date.now(), signal?: A
     ) {
       if (await providerHoldCloseWasAggregated(agent.id, pendingClose.kind, pendingClose.seq)) {
         const { pendingCloseAt: _pendingClose, ...closed } = pendingClose;
-        persistProviderHold(agent.id, closed);
+        (await persistProviderHold(agent.id, closed));
       } else {
         await notifyProviderHoldClosed(agent, pendingClose, nowMs);
       }
@@ -105,20 +105,20 @@ export async function sendStillHeldNudges(nowMs: number = Date.now(), signal?: A
 
     if (!agent.spawnedBy) {
       if (blocked && agent.kind === "provider" && agent.status !== "offline" && agentProviderState(agent)) {
-        const hold = openProviderHold(agent.id, agentProviderState(agent), nowMs, { continuing: true });
+        const hold = (await openProviderHold(agent.id, agentProviderState(agent), nowMs, { continuing: true }));
         if (hold.humanPagedAt === undefined && nowMs - hold.startedAt >= TOP_LEVEL_PAGE_THRESHOLD_MS()) {
           const holdMs = Math.max(0, nowMs - hold.startedAt);
           const state = agentProviderState(agent)!;
           const label = state.label ?? state.reason ?? hold.kind;
-          const result = notifyWorkspaceHumanEscalation({
+          const result = (await notifyWorkspaceHumanEscalation({
             subject: `Agent blocked: ${agent.label ?? agent.name ?? agent.id}`,
             body: `${agent.label ?? agent.name ?? agent.id} on ${agent.machine ?? "unknown host"} has been blocked for ${formatHoldDuration(holdMs)}: ${label} (${hold.kind}).`,
             payload: { kind: "agent.provider_blocked", agentId: agent.id, holdId: hold.holdId, holdMs, providerState: state },
             source: "provider-state-audit",
             tags: ["agent-relay", "provider"],
             idempotencyKey: `provider-human-blocked:${agent.id}:${hold.holdId}`,
-          });
-          if (result.accepted) persistProviderHold(agent.id, { ...hold, humanPagedAt: nowMs });
+          }));
+          if (result.accepted) (await persistProviderHold(agent.id, { ...hold, humanPagedAt: nowMs }));
         }
       }
       continue;
@@ -142,7 +142,7 @@ export async function sendStillHeldNudges(nowMs: number = Date.now(), signal?: A
   const quietFlaps = await quietProviderFlapsForAgents(flapCandidates.map((agent) => agent.id), nowMs);
   for (const agent of flapCandidates) {
     if (signal?.aborted) break;
-    for (const flap of quietFlaps.get(agent.id) ?? []) notifyProviderFlap(agent, flap, isProviderBlocked(agent));
+    for (const flap of quietFlaps.get(agent.id) ?? []) await notifyProviderFlap(agent, flap, isProviderBlocked(agent));
   }
 
   for (const agent of nudgeCandidates) {
@@ -153,7 +153,7 @@ export async function sendStillHeldNudges(nowMs: number = Date.now(), signal?: A
     // `continuing: true` — the sweep only ever sees an already-blocked agent. Self-healing: a
     // hold whose block edge the relay missed (restart mid-hold, pre-#1615 record) is adopted here
     // rather than going unwatched.
-    const hold = openProviderHold(agent.id, state, nowMs, { continuing: true });
+    const hold = (await openProviderHold(agent.id, state, nowMs, { continuing: true }));
     const sinceLastSignal = nowMs - (hold.lastNudgeAt ?? hold.startedAt);
     if (sinceLastSignal < nextNudgeIntervalMs(hold.nudgeCount)) continue;
 
@@ -162,7 +162,7 @@ export async function sendStillHeldNudges(nowMs: number = Date.now(), signal?: A
     const resetSuffix = typeof state.resetAt === "number" ? ` · resets ${formatClockUtc(state.resetAt)}` : "";
     const label = agent.label ?? agent.name ?? agent.id;
 
-    routeNotification({
+    await routeNotification({
       type: "agent.provider_still_held",
       scope: { agentId: agent.id, parent: agent.spawnedBy },
       recipients: [agent.spawnedBy],
@@ -183,7 +183,7 @@ export async function sendStillHeldNudges(nowMs: number = Date.now(), signal?: A
       },
     });
 
-    persistProviderHold(agent.id, { ...hold, nudgeCount: hold.nudgeCount + 1, lastNudgeAt: nowMs });
+    (await persistProviderHold(agent.id, { ...hold, nudgeCount: hold.nudgeCount + 1, lastNudgeAt: nowMs }));
     notified.push(agent.id);
   }
 

package/src/services/provider-hold-record.ts

@@ -1,3 +1,4 @@
+import { mergeAgentMetaAsync } from "../db/agents-async";
 // #1615 — durable identity + delivery bookkeeping for a provider hold.
 //
 // The #1610 sweep derived both from values that are neither stable nor durable: the unblock
@@ -10,14 +11,14 @@
 //
 // This module gives a hold ONE identity, minted server-side on the edge the relay actually
 // observes and persisted in the agent's SQLite meta (`meta.providerHold`). The runner never
-// sends that key, and `mergeAgentMeta` is a shallow merge, so a status frame can't clobber it.
+// sends that key, and `mergeAgentMetaAsync` is a shallow merge, so a status frame can't clobber it.
 // Every notification for a hold — block, still-held nudges, unblock — keys on that id, so:
 //   * permanent idempotency now bounds messages PER HOLD instead of per agent-lifetime;
 //   * a restart mid-hold resumes the same key sequence instead of replaying it;
 //   * `startedAt` is read from the provider ONCE, when the episode opens, and frozen — an
 //     adapter that re-stamps `enteredAt` on every poll can no longer stall the nudge clock.
 import { isRecord } from "@humwick/sdk";
-import { getAgent, mergeAgentMeta } from "../db";
+import { getAgent } from "../db";
 import type { ProviderState } from "../provider-state";
 
 /**
@@ -85,8 +86,8 @@ export function readProviderHold(agent: HasMeta | null | undefined): ProviderHol
 }
 
 /** Persist the record. Shallow-merged, so it survives every runner status frame. */
-export function persistProviderHold(agentId: string, record: ProviderHoldRecord): ProviderHoldRecord {
-  mergeAgentMeta(agentId, { providerHold: record });
+export async function persistProviderHold(agentId: string, record: ProviderHoldRecord): Promise<ProviderHoldRecord> {
+  (await mergeAgentMetaAsync(agentId, { providerHold: record }));
   return record;
 }
 
@@ -96,10 +97,10 @@ function seedStartedAt(state: ProviderState | null | undefined, nowMs: number):
   return typeof entered === "number" && Number.isFinite(entered) ? Math.min(entered, nowMs) : nowMs;
 }
 
-function mintProviderHold(agentId: string, prior: ProviderHoldRecord | null, state: ProviderState | null | undefined, nowMs: number): ProviderHoldRecord {
+async function mintProviderHold(agentId: string, prior: ProviderHoldRecord | null, state: ProviderState | null | undefined, nowMs: number): Promise<ProviderHoldRecord> {
   const seq = (prior?.seq ?? 0) + 1;
   const startedAt = seedStartedAt(state, nowMs);
-  return persistProviderHold(agentId, { holdId: `h${seq}-${startedAt}`, seq, startedAt, kind: providerHoldKind(state), nudgeCount: 0 });
+  return (await persistProviderHold(agentId, { holdId: `h${seq}-${startedAt}`, seq, startedAt, kind: providerHoldKind(state), nudgeCount: 0 }));
 }
 
 /**
@@ -110,15 +111,15 @@ function mintProviderHold(agentId: string, prior: ProviderHoldRecord | null, sta
  * that finds an un-cleared record means the relay missed the clear, so that record is abandoned
  * rather than resurrected with an hours-stale `startedAt`.
  */
-export function openProviderHold(agentId: string, state: ProviderState | null | undefined, nowMs: number, opts: { continuing: boolean }): ProviderHoldRecord {
+export async function openProviderHold(agentId: string, state: ProviderState | null | undefined, nowMs: number, opts: { continuing: boolean }): Promise<ProviderHoldRecord> {
   const prior = readProviderHold(getAgent(agentId));
   const open = prior !== null && prior.clearedAt === undefined;
   if (prior && open && opts.continuing) return prior;
   if (prior && !open && prior.kind === providerHoldKind(state) && nowMs - prior.clearedAt! <= HOLD_COALESCE_MS) {
     const { clearedAt: _cleared, pendingCloseAt: _pendingClose, ...reopened } = prior;
-    return persistProviderHold(agentId, reopened);
+    return (await persistProviderHold(agentId, reopened));
   }
-  return mintProviderHold(agentId, prior, state, nowMs);
+  return (await mintProviderHold(agentId, prior, state, nowMs));
 }
 
 /**
@@ -129,9 +130,9 @@ export function openProviderHold(agentId: string, state: ProviderState | null |
  * fallback start so the reported duration stays honest. The maintenance sweep sends the closing
  * notice only after `pendingCloseAt` has survived the coalescing window.
  */
-export function closeProviderHold(agentId: string, previous: ProviderState | null | undefined, clearedAt: number): ProviderHoldRecord | null {
+export async function closeProviderHold(agentId: string, previous: ProviderState | null | undefined, clearedAt: number): Promise<ProviderHoldRecord | null> {
   const prior = readProviderHold(getAgent(agentId));
   if (prior && prior.clearedAt !== undefined) return prior;
-  const record = prior ?? mintProviderHold(agentId, null, previous, clearedAt);
-  return persistProviderHold(agentId, { ...record, clearedAt, pendingCloseAt: clearedAt });
+  const record = prior ?? (await mintProviderHold(agentId, null, previous, clearedAt));
+  return (await persistProviderHold(agentId, { ...record, clearedAt, pendingCloseAt: clearedAt }));
 }

package/src/services/provider-state-audit.ts

@@ -1,4 +1,5 @@
-import { createActivityEvent } from "../db";
+import { createActivityEventAsync } from "../db/activity-async";
+
 import { routeNotification } from "../notification-router";
 import { agentProviderState, formatHoldDuration, type ProviderState } from "../provider-state";
 import { redactSecrets } from "../../runner/src/adapters/tool-summary";
@@ -30,7 +31,7 @@ export async function auditProviderStateTransition(agentId: string, before: Agen
   try {
     // #1912 §4 retained: bus status-frame ingress invokes this synchronously immediately after
     // accepting the card mutation. A detached async audit would lose that ordering boundary.
-    createActivityEvent({
+    (await createActivityEventAsync({
       clientId: `server-agent-${agentId}-provider-state-${nextKey ?? "cleared"}-${Date.now()}`,
       kind: "state",
       title: blocked ? `Agent blocked: ${label}` : "Agent provider unblocked",
@@ -43,35 +44,35 @@ export async function auditProviderStateTransition(agentId: string, before: Agen
         previousProviderState: previous ?? null,
         providerState: next ?? null,
       },
-    });
+    }));
     if (!after) return;
     if (!after.spawnedBy) {
       if (blocked) {
-        openProviderHold(agentId, next, nowMs, { continuing: previous?.state === "blocked" });
+        (await openProviderHold(agentId, next, nowMs, { continuing: previous?.state === "blocked" }));
       } else if (previous?.state === "blocked") {
         const clearedAt = typeof next?.enteredAt === "number" ? next.enteredAt : nowMs;
-        closeProviderHold(agentId, previous, clearedAt);
+        (await closeProviderHold(agentId, previous, clearedAt));
       }
       return;
     }
     if (blocked) {
       // A prior flap that has been quiet for a full window is conclusively settled before this
       // fresh edge is evaluated. The `currentlyHeld` value is the state we observe NOW.
-      for (const flap of await quietProviderFlaps(agentId, nowMs)) notifyProviderFlap(after, flap, true);
+      for (const flap of await quietProviderFlaps(agentId, nowMs)) await notifyProviderFlap(after, flap, true);
       // A blocked→blocked reason change continues the SAME episode (the hold never lifted), so it
       // must not re-announce; `continuing` also stops a fresh block edge from resurrecting a record
       // left open by a clear the relay missed.
-      const hold = openProviderHold(agentId, next, nowMs, { continuing: previous?.state === "blocked" });
+      const hold = (await openProviderHold(agentId, next, nowMs, { continuing: previous?.state === "blocked" }));
       if (hold.blockNotifiedAt !== undefined) return;
       const announcement = await providerHoldAnnouncement(agentId, hold.kind, hold.seq, nowMs);
       if (announcement.kind === "summary") {
-        notifyProviderFlap(after, announcement.flap, true);
+        await notifyProviderFlap(after, announcement.flap, true);
         return;
       }
       if (announcement.kind === "suppressed") {
         return;
       }
-      routeNotification({
+      await routeNotification({
         type: "agent.provider_blocked",
         scope: { agentId, parent: after.spawnedBy },
         recipients: [after.spawnedBy],
@@ -83,7 +84,7 @@ export async function auditProviderStateTransition(agentId: string, before: Agen
           idempotencyKey: `provider-blocked:${agentId}:${hold.holdId}`,
         },
       });
-      persistProviderHold(agentId, { ...hold, blockNotifiedAt: nowMs });
+      (await persistProviderHold(agentId, { ...hold, blockNotifiedAt: nowMs }));
       return;
     }
     // The closing bracket on a block: only fires when the transition actually came FROM blocked
@@ -92,7 +93,7 @@ export async function auditProviderStateTransition(agentId: string, before: Agen
     // The runner stamps `enteredAt` on every state, so `next.enteredAt` is when the hold actually
     // cleared — preferred over `nowMs` so the duration is exact even if this audit runs late.
     const clearedAt = typeof next?.enteredAt === "number" ? next.enteredAt : nowMs;
-    closeProviderHold(agentId, previous, clearedAt);
+    (await closeProviderHold(agentId, previous, clearedAt));
   } catch {
     // Audit trail writes must never block bus status updates.
   }
@@ -108,17 +109,17 @@ export async function notifyProviderHoldClosed(agent: AgentCard, hold: ProviderH
   if (!agent.spawnedBy) {
     if (hold.humanPagedAt === undefined) return;
     const holdMs = Math.max(0, (hold.clearedAt ?? nowMs) - hold.startedAt);
-    const result = notifyWorkspaceHumanEscalation({
+    const result = (await notifyWorkspaceHumanEscalation({
       subject: `Agent unblocked: ${agent.label ?? agent.name ?? agent.id}`,
       body: `${agent.label ?? agent.name ?? agent.id} on ${agent.machine ?? "unknown host"} unblocked after ${formatHoldDuration(holdMs)} (${hold.kind}).`,
       payload: { kind: "agent.provider_unblocked", agentId: agent.id, holdId: hold.holdId, holdMs },
       source: "provider-state-audit",
       tags: ["agent-relay", "provider"],
       idempotencyKey: `provider-human-unblocked:${agent.id}:${hold.holdId}`,
-    });
+    }));
     if (result.accepted) {
       const { pendingCloseAt: _pendingClose, ...closed } = hold;
-      persistProviderHold(agent.id, { ...closed, unblockNotifiedAt: nowMs });
+      (await persistProviderHold(agent.id, { ...closed, unblockNotifiedAt: nowMs }));
     }
     return;
   }
@@ -127,7 +128,7 @@ export async function notifyProviderHoldClosed(agent: AgentCard, hold: ProviderH
   const label = typeof state?.label === "string" ? state.label : "provider blocked";
   const holdMs = Math.max(0, (hold.clearedAt ?? nowMs) - hold.startedAt);
   const holdSuffix = ` (held ${formatHoldDuration(holdMs)}${hold.kind ? `, ${hold.kind}` : ""})`;
-  routeNotification({
+  await routeNotification({
     type: "agent.provider_unblocked",
     scope: { agentId: agent.id, parent: agent.spawnedBy },
     recipients: [agent.spawnedBy],
@@ -147,15 +148,15 @@ export async function notifyProviderHoldClosed(agent: AgentCard, hold: ProviderH
     },
   });
   const { pendingCloseAt: _pendingClose, ...closed } = hold;
-  persistProviderHold(agent.id, { ...closed, unblockNotifiedAt: nowMs });
+  (await persistProviderHold(agent.id, { ...closed, unblockNotifiedAt: nowMs }));
 }
 
 /** Route one uniquely-keyed flap summary or its terminal settle correction. */
-export function notifyProviderFlap(agent: AgentCard, flap: ProviderFlap, currentlyHeld: boolean): void {
+export async function notifyProviderFlap(agent: AgentCard, flap: ProviderFlap, currentlyHeld: boolean): Promise<void> {
   if (!agent.spawnedBy) return;
   const terminal = flap.settledAt !== undefined;
   const durationMs = Math.max(0, (flap.settledAt ?? flap.lastEpisodeAt) - flap.flapStartedAt);
-  routeNotification({
+  await routeNotification({
     type: "agent.provider_flapping",
     scope: { agentId: agent.id, parent: agent.spawnedBy },
     recipients: [agent.spawnedBy],

package/src/services/provisioning-harness/driver.ts

@@ -95,7 +95,7 @@ export async function main(): Promise<void> {
     trace("record", "complete", launch.processes);
 
     trace("lifecycle", "start");
-    const lifecycle = captureLifecycleBoundaries(prepared, request, context.systemPromptAppend);
+    const lifecycle = (await captureLifecycleBoundaries(prepared, request, context.systemPromptAppend));
     lifecycle.boundaries.spawn.launch = { command: launch.command, argv: launch.argv, cwd: launch.cwd };
     trace("lifecycle", "complete", lifecycle.boundaries);
 

package/src/services/provisioning-harness/fixture-matrix.ts

@@ -22,11 +22,11 @@ export async function fixtureStartupMatrix(): Promise<ContextInventory[]> {
     cpSync(join(import.meta.dir, "fixtures/project"), cwd, { recursive: true });
     mkdirSync(join(cwd, ".git"));
     initDb(":memory:");
-    seedHarnessHost(cwd);
-    seedMemory(cwd, { scenario: { id: "startup-inventory", cwd, profile: "worker", provider: "codex", now: 1_700_000_000_000, boundaries: [], fixtures: { memory: [
+    (await seedHarnessHost(cwd));
+    (await seedMemory(cwd, { scenario: { id: "startup-inventory", cwd, profile: "worker", provider: "codex", now: 1_700_000_000_000, boundaries: [], fixtures: { memory: [
       { id: "manual", cell: "project", title: "Harness project manual", body: "HARNESS_PROJECT_MANUAL_RULE", inject: "pinned" },
       { id: "indexed", cell: "project", title: "Harness indexed rule", body: "HARNESS_INDEXED_BODY_IS_NOT_RESIDENT", inject: "indexed" },
-    ] } }, options: { mcp: "fixture-only" } });
+    ] } }, options: { mcp: "fixture-only" } }));
     return await startupContextInventory(cwd);
   } finally {
     await flushRelayEvents();

package/src/services/provisioning-harness/lifecycle.ts

@@ -1,6 +1,8 @@
-import { createCommand, listCommands, updateCommand } from "../../commands-db";
+import { updateCommandAsync, createCommandAsync } from "../../commands-write";
+import { upsertAgentAsync } from "../../db/agents-async";
+import { listCommands } from "../../commands-db";
 import { getManifest } from "@humwick/providers";
-import { upsertAgent } from "../../db";
+
 import { enqueueMemoryInjectionAfterContextCommand, sweepMissedMemoryInjections } from "../../memory-injection";
 import { parseMemorySeam } from "../../memory-seam";
 import { enqueueStartupContextInjectionAfterContextCommand } from "../../startup-context-injection";
@@ -32,9 +34,9 @@ function capabilities(provider: "claude" | "codex"): ProviderCapabilities {
     lastUpdatedAt: 1,
   };
 }
-function registerCapturedAgent(prepared: PreparedProvisioningSpawn, request: ProvisioningDriverRequest): AgentCard {
+async function registerCapturedAgent(prepared: PreparedProvisioningSpawn, request: ProvisioningDriverRequest): Promise<AgentCard> {
   const params = prepared.command.params;
-  return upsertAgent({
+  return (await upsertAgentAsync({
     id: String(params.agentId),
     name: `Harness ${request.scenario.profile}`,
     kind: "provider",
@@ -49,7 +51,7 @@ function registerCapturedAgent(prepared: PreparedProvisioningSpawn, request: Pro
       spawnRequestId: String(params.spawnRequestId),
       approvalMode: "open",
     },
-  });
+  }));
 }
 
 function injectionRows(command: Command): Array<{ reason: string; content: string }> {
@@ -71,18 +73,18 @@ const BOUNDARY_SETTLE_ERROR: Record<Exclude<BoundarySettleStatus, "succeeded">,
   timed_out: "command timed out",
 };
 
-function contextBoundary(
+async function contextBoundary(
   type: "agent.clearContext" | "agent.compact",
   agent: AgentCard,
   request: ProvisioningDriverRequest,
-): { capture: BoundaryCapture; commands: Command[] } {
+): Promise<{ capture: BoundaryCapture; commands: Command[] }> {
   const boundary: SettleableBoundary = type === "agent.clearContext" ? "clear" : "compact";
   const continuation = [
     `You have been resumed by Agent Relay — provisioning harness ${boundary}.`,
     `Objective: ${request.scenario.fixtures?.continuation?.objective ?? "validate effective provisioning"}.`,
     `Working state: ${request.scenario.fixtures?.continuation?.workingState ?? "capture boundary parity"}.`,
   ].join("\n\n");
-  const command = createCommand({
+  const command = (await createCommandAsync({
     type,
     source: "system",
     target: agent.id,
@@ -95,16 +97,16 @@ function contextBoundary(
       },
       ...(boundary === "compact" ? { instructions: continuation } : {}),
     },
-  });
+  }));
   // #2291 — the status the runner reported, NOT an assumed success. This line read
   // `{ status: "succeeded" }` unconditionally, which is the single status under which every
   // boundary re-delivery seam fires: the harness could not express the failure mode that dropped
   // memory on 14 of one coordinator's 17 boundaries, so it never caught it.
   const status = request.scenario.boundaryStatus?.[boundary] ?? "succeeded";
-  const settled = updateCommand(command.id, {
+  const settled = (await updateCommandAsync(command.id, {
     status,
     ...(status === "succeeded" ? {} : { error: BOUNDARY_SETTLE_ERROR[status] }),
-  })!;
+  }))!;
   // #2293 — WHEN the reactive settle chain runs, modelled as the field runs it.
   //
   // `timed_out` is not a status any runner reports: the ONLY producer on a clear/compact is the DB
@@ -115,16 +117,16 @@ function contextBoundary(
   // crash scenario (#1023 window 2: the relay died between persisting the status and enqueuing).
   const crashed = request.scenario.boundarySettleCrash?.includes(boundary) === true;
   if (!crashed && status !== "timed_out") {
-    enqueueContinuationInjectionAfterSelfResume(settled);
-    enqueueLifecycleIdentityInjectionAfterContextCommand(settled);
-    enqueueMemoryInjectionAfterContextCommand(settled, request.scenario.now);
-    enqueueStartupContextInjectionAfterContextCommand(settled, request.scenario.now);
+    (await enqueueContinuationInjectionAfterSelfResume(settled));
+    (await enqueueLifecycleIdentityInjectionAfterContextCommand(settled));
+    (await enqueueMemoryInjectionAfterContextCommand(settled, request.scenario.now));
+    (await enqueueStartupContextInjectionAfterContextCommand(settled, request.scenario.now));
   }
   // …and then the periodic backstops, which in the field run every REAP_INTERVAL_MS regardless.
   // Running them on EVERY capture (not only the crashed ones) is deliberate: on the reactive
   // captures they prove the sweeps do not double-inject against a settle that already ran.
-  sweepMissedContinuationInjections(request.scenario.now);
-  sweepMissedMemoryInjections(request.scenario.now);
+  (await sweepMissedContinuationInjections(request.scenario.now));
+  (await sweepMissedMemoryInjections(request.scenario.now));
   const injections = injectionRows(settled);
   const commands = [settled, ...listCommands({ target: agent.id, type: "agent.injectContext", limit: 100 }).filter((item) => item.correlationId === settled.id)];
   return {
@@ -147,12 +149,12 @@ function preparedSeam(agent: AgentCard): BoundaryCapture["memorySeam"] {
   return seam as BoundaryCapture["memorySeam"];
 }
 
-export function captureLifecycleBoundaries(
+export async function captureLifecycleBoundaries(
   prepared: PreparedProvisioningSpawn,
   request: ProvisioningDriverRequest,
   spawnSystemPromptAppend: string,
-): { boundaries: Record<ContextBoundary, BoundaryCapture>; lifecycleCommands: Command[] } {
-  const agent = registerCapturedAgent(prepared, request);
+): Promise<{ boundaries: Record<ContextBoundary, BoundaryCapture>; lifecycleCommands: Command[] }> {
+  const agent = (await registerCapturedAgent(prepared, request));
   const restartParams = restartInstructionParamsForAgent(agent, {
     spawnRequestId: String(agent.meta?.spawnRequestId),
     cwd: request.scenario.cwd,
@@ -168,8 +170,8 @@ export function captureLifecycleBoundaries(
   });
   const restartArgs = assemblePreparedSpawnChain(restartPrepared);
   const restartAppend = systemPromptAppendFromSpawnArgs(request.scenario.provider, restartArgs, restartPrepared.runnerConfig);
-  const clear = contextBoundary("agent.clearContext", agent, request);
-  const compact = contextBoundary("agent.compact", agent, request);
+  const clear = (await contextBoundary("agent.clearContext", agent, request));
+  const compact = (await contextBoundary("agent.compact", agent, request));
   return {
     boundaries: {
       spawn: {