@humwick/server 0.130.2 → 0.130.3

package/src/services/issue-associations.ts

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

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

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

package/src/services/issue-lifecycle.ts

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

package/src/services/issue-refs.ts

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

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

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

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