@humwick/server 0.130.1 → 0.130.3

package/src/services/issue-lifecycle.ts

@@ -1,17 +1,18 @@
+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,
   listSuccessfulCloseActionsForCommit,
-  upsertIssueLifecycleAction,
 } from "../db/issue-lifecycle";
-import { getIssueRef, resolveIssueRefByExternalKey, resolveIssueRefFromString, updateIssueRef } from "../db/issue-refs";
-import { associateIssue } from "../db/issue-associations";
+import { getIssueRef } from "../db/issue-refs";
+import { resolveIssueRefByExternalKeyAsync, resolveIssueRefFromStringAsync, updateIssueRefAsync, upsertIssueLifecycleActionAsync } from "../db/issue-refs-async";
+
 import { resolveIssueTrackerAdapter } from "../issue-tracker";
 import { defaultIssueRepo } from "../config";
 // `repoFromGitRemote` / `parseOwnerRepoFromRemote` live in the shared ./git-remote module
@@ -141,42 +142,53 @@ const ISSUE_REF_AT_START_RE = /^(https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z
 const REF_SEPARATOR_RE = /^(?:\s*,\s*|\s+(?:and|&)\s+)/i;
 
 // A run of issue refs ("#1, #2 and owner/repo#3") starting at the head of `segment`.
-// Bare refs resolve against `fallbackDefaultRepo`; unresolvable ones are skipped so a
-// land never fails here.
-function collectRefRun(segment: string, fallbackDefaultRepo: string | undefined, into: IssueRef[]): void {
+function refRun(segment: string): string[] {
+  const refs: string[] = [];
   let rest = segment;
   while (rest.trim()) {
     rest = rest.trimStart();
     const refMatch = rest.match(ISSUE_REF_AT_START_RE);
     if (!refMatch) break;
-    try {
-      into.push(resolveIssueRefFromString({ ref: refMatch[1]!, defaultRepo: fallbackDefaultRepo }));
-    } catch {
-      // Invalid or bare-without-default refs are ignored; the land itself must never fail here.
-    }
+    refs.push(refMatch[1]!);
     rest = rest.slice(refMatch[0].length);
     const separator = rest.match(REF_SEPARATOR_RE);
     if (!separator) break;
     rest = rest.slice(separator[0].length);
   }
+  return refs;
 }
 
-export function parseClosingIssueRefs(text: string | undefined, fallbackDefaultRepo = defaultIssueRepo()): IssueRef[] {
-  if (!text) return [];
+// Bare refs resolve against `fallbackDefaultRepo`; unresolvable ones are skipped so a land never fails here.
+async function resolveRefRuns(segments: Iterable<string>, fallbackDefaultRepo: string | undefined): Promise<IssueRef[]> {
   const refs: IssueRef[] = [];
-  for (const match of text.matchAll(CLOSING_KEYWORD_RE)) collectRefRun(match[1] ?? "", fallbackDefaultRepo, refs);
+  for (const segment of segments) {
+    for (const ref of refRun(segment)) {
+      try {
+        refs.push(await resolveIssueRefFromStringAsync({ ref, defaultRepo: fallbackDefaultRepo }));
+      } catch {
+        // Invalid or bare-without-default refs are ignored; the land itself must never fail here.
+      }
+    }
+  }
   return issueRefMap(refs);
 }
 
+export function parseClosingIssueRefsAsync(text: string | undefined, fallbackDefaultRepo = defaultIssueRepo()): Promise<IssueRef[]> {
+  return resolveRefRuns(text ? [...text.matchAll(CLOSING_KEYWORD_RE)].map((match) => match[1] ?? "") : [], fallbackDefaultRepo);
+}
+
 // Parenthesized backlink groups: the trailing `(#NNN)` convention agents (and a squash merge)
 // stamp on a subject without a closing keyword. Non-issue parens (conventional-commit scopes
 // like `fix(tokens)`, notes like `(see also)`) carry no `#` and fall out.
 const BACKLINK_GROUP_RE = /\(([^()]*#[0-9]+[^()]*)\)/g;
 
-export function parseBacklinkIssueRefs(text: string | undefined, fallbackDefaultRepo = defaultIssueRepo()): IssueRef[] {
-  if (!text) return [];
+export function parseBacklinkIssueRefsAsync(text: string | undefined, fallbackDefaultRepo = defaultIssueRepo()): Promise<IssueRef[]> {
+  return resolveRefRuns(text ? [...text.matchAll(BACKLINK_GROUP_RE)].map((group) => group[1] ?? "") : [], fallbackDefaultRepo);
+}
+
+async function eachSubject(subjects: string[], parse: (text: string) => Promise<IssueRef[]>): Promise<IssueRef[]> {
   const refs: IssueRef[] = [];
-  for (const group of text.matchAll(BACKLINK_GROUP_RE)) collectRefRun(group[1] ?? "", fallbackDefaultRepo, refs);
+  for (const subject of subjects) refs.push(...await parse(subject));
   return issueRefMap(refs);
 }
 
@@ -190,13 +202,13 @@ async function resolveIssueRefsForLand(input: LandedIssueLifecycleInput, links:
   const associated = issueRefMap(links.flatMap((link) => link.issues.filter((issue) => issue.relation === "delivers").map((issue) => issue.ref)));
   const fallbackDefaultRepo = await landDefaultRepo(input.workspace);
   const subjects = landedSubjectTexts(input);
-  const keyworded = issueRefMap(subjects.flatMap((subject) => parseClosingIssueRefs(subject, fallbackDefaultRepo)));
+  const keyworded = await eachSubject(subjects, (subject) => parseClosingIssueRefsAsync(subject, fallbackDefaultRepo));
   // A commit declaration is authored at the change boundary, unlike a Task association
   // which can legitimately be historical or span several work items. It is the sole close
   // target when present (#1694).
   if (keyworded.length > 0) return { source: "commit", refs: keyworded, declared: keyworded };
   if (!input.prLand && links.some((link) => link.buildLike)) {
-    const backlinks = issueRefMap(subjects.flatMap((subject) => parseBacklinkIssueRefs(subject, fallbackDefaultRepo)))
+    const backlinks = (await eachSubject(subjects, (subject) => parseBacklinkIssueRefsAsync(subject, fallbackDefaultRepo)))
       .filter((ref) => canCloseBacklink(ref, links));
     if (backlinks.length) return { source: "backlink", refs: backlinks, declared: backlinks };
   }
@@ -215,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");
 }
@@ -348,7 +360,7 @@ async function reconcileClosedIssueRefBeforeSkip(issueRef: IssueRef, opts: Issue
       // LOW-4 (#2520 review) — thread the live closeReason through: a completed close observed
       // here was dropped, so the cached ref stayed reason-less and could never count as a
       // completed close. updateIssueRef preserves the cached reason when live carries none.
-      issueRef: updateIssueRef(issueRef.id, { status, title: live.title, closeReason: live.closeReason, statusSyncedAt: Date.now() }) ?? issueRef,
+      issueRef: await updateIssueRefAsync(issueRef.id, { status, title: live.title, closeReason: live.closeReason, statusSyncedAt: Date.now() }) ?? issueRef,
       liveStatus: live.status,
     };
   } catch (error) {
@@ -406,7 +418,7 @@ export async function closeIssueRefForLand(
         logFailure(opts, `issue lifecycle epic-guard title lookup returned no title for ${latest.id} on ${key}`);
         return { issueRef: latest, action: "skipped", reason: "title-unavailable", landKey: key };
       }
-      latest = updateIssueRef(latest.id, { title, statusSyncedAt: Date.now() }) ?? latest;
+      latest = await updateIssueRefAsync(latest.id, { title, statusSyncedAt: Date.now() }) ?? latest;
     } catch (error) {
       logFailure(opts, `issue lifecycle epic-guard title lookup failed for ${latest.id} on ${key}: ${errMessage(error)}`);
       return { issueRef: latest, action: "skipped", reason: "title-unavailable", landKey: key };
@@ -423,22 +435,25 @@ export async function closeIssueRefForLand(
     return { issueRef: latest, action: "skipped", reason: "epic-issue", landKey: key };
   }
 
+  const closeAction = {
+    issueRefId: latest.id,
+    action: "close" as const,
+    landKey: key,
+    workspaceId: input.workspace.id,
+    branch: input.workspace.branch,
+    baseRef: input.workspace.baseRef ?? "main",
+    commitSha: input.mergedSha,
+    commitSubject: input.subject,
+    agentId: input.workspace.ownerAgentId,
+    source,
+  };
   let openSubIssues: IssueTrackerIssueSummary[];
   try {
     openSubIssues = await listOpenSubIssuesForLand(latest, opts);
   } catch (error) {
     const message = `sub-issue lookup failed: ${errMessage(error)}`;
-    upsertIssueLifecycleAction({
-      issueRefId: latest.id,
-      action: "close",
-      landKey: key,
-      workspaceId: input.workspace.id,
-      branch: input.workspace.branch,
-      baseRef: input.workspace.baseRef ?? "main",
-      commitSha: input.mergedSha,
-      commitSubject: input.subject,
-      agentId: input.workspace.ownerAgentId,
-      source,
+    await upsertIssueLifecycleActionAsync({
+      ...closeAction,
       status: "failed",
       error: message,
     });
@@ -458,23 +473,14 @@ export async function closeIssueRefForLand(
   const comment = closeAuditComment(input);
   try {
     await adapterFor(latest, opts).close(latest, { comment, labels: ["fixed"], closeReason: "completed" });
-    const closed = updateIssueRef(latest.id, { status: "closed", closeReason: "completed", statusSyncedAt: Date.now() }) ?? latest;
-    upsertIssueLifecycleAction({
-      issueRefId: latest.id,
-      action: "close",
-      landKey: key,
-      workspaceId: input.workspace.id,
-      branch: input.workspace.branch,
-      baseRef: input.workspace.baseRef ?? "main",
-      commitSha: input.mergedSha,
-      commitSubject: input.subject,
-      agentId: input.workspace.ownerAgentId,
-      source,
+    const closed = await updateIssueRefAsync(latest.id, { status: "closed", closeReason: "completed", statusSyncedAt: Date.now() }) ?? latest;
+    await upsertIssueLifecycleActionAsync({
+      ...closeAction,
       comment,
       status: "succeeded",
     });
     if (input.workspace.ownerAgentId) {
-      recordAndEmitIssueActivity({
+      (await recordAndEmitIssueActivity({
         agentId: input.workspace.ownerAgentId,
         action: "done",
         issueRefId: latest.id,
@@ -482,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
@@ -494,17 +500,8 @@ export async function closeIssueRefForLand(
     return { issueRef: closed, action: "closed", source, landKey: key };
   } catch (error) {
     const message = errMessage(error);
-    upsertIssueLifecycleAction({
-      issueRefId: latest.id,
-      action: "close",
-      landKey: key,
-      workspaceId: input.workspace.id,
-      branch: input.workspace.branch,
-      baseRef: input.workspace.baseRef ?? "main",
-      commitSha: input.mergedSha,
-      commitSubject: input.subject,
-      agentId: input.workspace.ownerAgentId,
-      source,
+    await upsertIssueLifecycleActionAsync({
+      ...closeAction,
       comment,
       status: "failed",
       error: message,
@@ -550,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"}`);
   }
@@ -564,34 +561,34 @@ export async function handleLandedIssueLifecycle(input: LandedIssueLifecycleInpu
   return { source: resolved.source, closed, reopened, skipped: [], mismatches };
 }
 
-function resolveReopenRef(input: ReopenIssueLifecycleInput): IssueRef {
+async function resolveReopenRef(input: ReopenIssueLifecycleInput): Promise<IssueRef> {
   if (input.issueRefId) {
     const issueRef = getIssueRef(input.issueRefId);
     if (!issueRef) throw new Error(`issue ref ${input.issueRefId} not found`);
     return issueRef;
   }
-  if (input.ref) return resolveIssueRefFromString({ 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 resolveIssueRefByExternalKey({
+    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");
 }
 
 export async function reopenIssueLifecycle(input: ReopenIssueLifecycleInput, opts: IssueLifecycleOptions = {}): Promise<ReopenIssueLifecycleResult> {
-  const issueRef = resolveReopenRef(input);
+  const issueRef = await resolveReopenRef(input);
   const key = manualReopenKey(issueRef);
   if (issueRef.status === "open") return { issueRef, action: "skipped", reason: "already-open", landKey: key };
   const comment = input.comment ?? "Reopened by Humwick issue lifecycle.";
   try {
     await adapterFor(issueRef, opts).reopen(issueRef, { comment });
-    const opened = updateIssueRef(issueRef.id, { status: "open", statusSyncedAt: Date.now() }) ?? issueRef;
-    upsertIssueLifecycleAction({
+    const opened = await updateIssueRefAsync(issueRef.id, { status: "open", statusSyncedAt: Date.now() }) ?? issueRef;
+    await upsertIssueLifecycleActionAsync({
       issueRefId: issueRef.id,
       action: "reopen",
       landKey: key,
@@ -600,11 +597,11 @@ 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);
-    upsertIssueLifecycleAction({
+    await upsertIssueLifecycleActionAsync({
       issueRefId: issueRef.id,
       action: "reopen",
       landKey: key,

package/src/services/issue-refs.ts

@@ -1,11 +1,6 @@
+import { deleteIssueRefAsync, listIssueRefsAsync, resolveIssueRefByExternalKeyAsync, resolveIssueRefFromStringAsync, updateIssueRefAsync, upsertIssueRefAsync } from "../db/issue-refs-async";
 import {
-  deleteIssueRef,
   getIssueRef,
-  listIssueRefs,
-  resolveIssueRefByExternalKey,
-  resolveIssueRefFromString,
-  updateIssueRef,
-  upsertIssueRef,
   type ListIssueRefsOptions,
   type ResolveIssueRefByExternalKeyInput,
   type ResolveIssueRefFromStringInput,
@@ -13,22 +8,22 @@ import {
   type UpsertIssueRefInput,
 } from "../db/issue-refs";
 
-export { getIssueRef, listIssueRefs, type ListIssueRefsOptions };
+export { getIssueRef, listIssueRefsAsync, type ListIssueRefsOptions };
 
-export function upsertIssueRefMapping(input: UpsertIssueRefInput) {
-  return upsertIssueRef(input);
+export function upsertIssueRefMappingAsync(input: UpsertIssueRefInput) {
+  return upsertIssueRefAsync(input);
 }
 
-export function resolveIssueRefMapping(input: ResolveIssueRefByExternalKeyInput | ResolveIssueRefFromStringInput) {
-  return "ref" in input ? resolveIssueRefFromString(input) : resolveIssueRefByExternalKey(input);
+export async function resolveIssueRefMappingAsync(input: ResolveIssueRefByExternalKeyInput | ResolveIssueRefFromStringInput) {
+  return "ref" in input ? (await resolveIssueRefFromStringAsync(input)) : (await resolveIssueRefByExternalKeyAsync(input));
 }
 
-export function patchIssueRefMapping(id: string, input: UpdateIssueRefInput) {
-  return updateIssueRef(id, input);
+export function patchIssueRefMappingAsync(id: string, input: UpdateIssueRefInput) {
+  return updateIssueRefAsync(id, input);
 }
 
-export function deleteIssueRefMapping(id: string) {
-  return deleteIssueRef(id);
+export function deleteIssueRefMappingAsync(id: string) {
+  return deleteIssueRefAsync(id);
 }
 
 // --- Caller-supplied issue-ref normalization (#2214/#1930) ---------------------------------

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

@@ -24,6 +24,8 @@ const releaseFile = process.env.CUTOVER_CHAOS_RELEASE_FILE;
 const resultFile = process.env.CUTOVER_CHAOS_RESULT_FILE;
 const owner = process.env.CUTOVER_CHAOS_OWNER ?? `worker-${process.pid}`;
 const leaseMs = Number(process.env.CUTOVER_CHAOS_LEASE_MS ?? "400");
+let now = Number(required("CUTOVER_CHAOS_NOW"));
+const clock = () => now;
 
 function required(name: string): string {
   const value = relayEnv(process.env, name);
@@ -60,7 +62,7 @@ function timerInput(idSuffix = String(process.pid)): CreateScheduledTimerRowInpu
     createdByKind: "system",
     createdByScopes: ["message:send"],
     deliveryFrom: "system",
-    nextRunAt: Date.now() + 100_000,
+    nextRunAt: now + 100_000,
     scheduleKind: "once",
     scheduleDef: { afterMs: 100_000 },
     body: `cutover-${idSuffix}`,
@@ -87,6 +89,7 @@ async function main(): Promise<void> {
     };
     const c = new TimerMessageCutoverCoordinator({
       ownerId: owner,
+      now: clock,
       leaseMs,
       tickMs: 25,
       quiesceTimeoutMs: 5_000,
@@ -94,12 +97,12 @@ async function main(): Promise<void> {
       faults,
     });
     await c.requestQuiesce();
-    if (boundary === "after-renewal") await Bun.sleep(Math.ceil(leaseMs * 0.75));
+    if (boundary === "after-renewal") now += Math.ceil(leaseMs * 0.75);
     await c.tick();
     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();
     }
@@ -112,7 +115,7 @@ async function main(): Promise<void> {
     const ticks = phaseTicks[boundary];
     if (ticks === undefined) throw new Error(`unknown deadline-watch phase ${boundary}`);
     const c = new TimerMessageCutoverCoordinator({
-      ownerId: owner, leaseMs: 10_000, tickMs: 25, quiesceTimeoutMs: 8_000, worstCaseDrainTransferMs: 10_000,
+      ownerId: owner, now: clock, leaseMs: 10_000, tickMs: 25, quiesceTimeoutMs: 8_000, worstCaseDrainTransferMs: 10_000,
     });
     await c.requestQuiesce();
     for (let i = 0; i < ticks; i++) await c.tick();
@@ -124,14 +127,14 @@ async function main(): Promise<void> {
 
   if (command === "claim-bound") {
     const c = new TimerMessageCutoverCoordinator({
-      ownerId: owner, leaseMs: 1_000, tickMs: 25, quiesceTimeoutMs: 300, worstCaseDrainTransferMs: 1_000,
+      ownerId: owner, now: clock, leaseMs: 1_000, tickMs: 25, quiesceTimeoutMs: 300, worstCaseDrainTransferMs: 1_000,
     });
     await c.requestQuiesce();
     await c.tick();
     await c.tick();
     const drain = await c.tick();
     if (boundary === "held") {
-      await Bun.sleep(340);
+      now += 340;
       await c.tick();
       await c.tick();
     }
@@ -141,7 +144,7 @@ async function main(): Promise<void> {
 
   if (command === "recover") {
     const c = new TimerMessageCutoverCoordinator({
-      ownerId: owner, leaseMs, tickMs: 25, quiesceTimeoutMs: 5_000, worstCaseDrainTransferMs: 6_000,
+      ownerId: owner, now: clock, leaseMs, tickMs: 25, quiesceTimeoutMs: 5_000, worstCaseDrainTransferMs: 6_000,
     });
     const outcomes = [];
     for (let i = 0; i < 5; i++) outcomes.push(await c.tick());
@@ -152,7 +155,7 @@ async function main(): Promise<void> {
   if (command === "close-gate") {
     marker();
     const c = new TimerMessageCutoverCoordinator({
-      ownerId: owner, leaseMs: 5_000, tickMs: 25, quiesceTimeoutMs: 5_000, worstCaseDrainTransferMs: 6_000,
+      ownerId: owner, now: clock, leaseMs: 5_000, tickMs: 25, quiesceTimeoutMs: 5_000, worstCaseDrainTransferMs: 6_000,
     });
     const acquired = await c.requestQuiesce();
     const outcome = acquired ? await c.tick() : null;

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 {
@@ -322,7 +323,7 @@ export class TimerIngressRejectedError extends Error {
 }
 
 export function createTimerIngress(options: TimerIngressOptions): TimerIngress {
-  installTimerIngressSchema();
+  installTimerIngressSchema({ ifNotInstalled: true });
   const apply = options.apply;
   const ownerId = options.ownerId ?? `${process.pid}-${randomUUID()}`;
   const now = options.now ?? Date.now;
@@ -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");
   }