@humwick/server 0.130.2 → 0.130.3

package/src/services/task-delivery.ts

@@ -1,20 +1,6 @@
-import {
-  getTaskDetail,
-  getWorkspace,
-  insertTaskEvent,
-  markTaskDeliverableEffectsCompleteAsync,
-  ownedIsolatedWorkspace,
-  recordGateAsync,
-  recordTaskDeliverableAsync,
-  recordTaskDeliverableWithLandingIngressAsync,
-  setTaskStage,
-  setTaskStatus,
-  setTaskStatusAsync,
-  transitionWorkspaceLandStateAsync,
-  workspaceLandAuthorization, workspaceLandAuthorizationWithdrawn,
-  ValidationError,
-  type CompleteDeliveryArmOutcome,
-} from "../db";
+import { setTaskStatusAsync, setTaskStageAsync } from "../db/task-entity-async";
+import { insertTaskEventAsync } from "../db/runtime-tail-async";
+import { getTaskDetail, getWorkspace, markTaskDeliverableEffectsCompleteAsync, ownedIsolatedWorkspace, recordGateAsync, recordTaskDeliverableAsync, recordTaskDeliverableWithLandingIngressAsync, transitionWorkspaceLandStateAsync, workspaceLandAuthorization, workspaceLandAuthorizationWithdrawn, ValidationError, type CompleteDeliveryArmOutcome } from "../db";
 import { refreshWorkspaceGitState } from "../workspace-probe";
 import { pinWorkspaceDeliveryTip } from "../workspace-delivery-tip";
 import { recoverIsolatedWorkspace, type WorkspaceRecoveryHint } from "./workspace-recovery";
@@ -25,7 +11,7 @@ import { emitTaskChanged, emitNewMessages } from "../sse";
 import { agentBoundTaskIds, hasTaskReadAdminScope } from "../task-authz";
 import { applyWorkspaceAction } from "../workspace-actions";
 import { LAND_IN_FLIGHT_STATUSES, LAND_REQUEST_STALE_ON_HEAD_ADVANCE_STATUSES } from "../workspace-phase";
-import { findLatestCommandByCorrelation } from "../commands-db";
+import { findLatestCommandByCorrelationAsync } from "../commands-write";
 import { mergeCommandNeedsRetry } from "../workspace-merge-progress";
 import { workspaceLandNeedsRearm } from "../workspace-land-retry";
 import { emitTaskSemanticNotification } from "./task-semantic-events";
@@ -120,7 +106,7 @@ function shouldRebindToWorkspace(task: TaskDetail, ws: WorkspaceRecord | undefin
   return Boolean(task.branch && ws?.branch && task.branch !== ws.branch);
 }
 
-function resolveWorkspace(ctx: AuthContext, input: Pick<DeliverTaskInput, "workspaceId" | "workspace" | "idempotencyKey">, taskId: number, opts: { allowRebind?: boolean } = {}): WorkspaceRecord | undefined {
+async function resolveWorkspace(ctx: AuthContext, input: Pick<DeliverTaskInput, "workspaceId" | "workspace" | "idempotencyKey">, taskId: number, opts: { allowRebind?: boolean } = {}): Promise<WorkspaceRecord | undefined> {
   const caller = ctx.callerAgentId;
   const explicit = input.workspaceId?.trim();
   let ws = explicit ? getWorkspace(explicit) : caller ? ownedIsolatedWorkspace(caller) : undefined;
@@ -133,7 +119,7 @@ function resolveWorkspace(ctx: AuthContext, input: Pick<DeliverTaskInput, "works
   // server-authoritative recovery (signed spawn-request association + immutable agent.spawn params +
   // orchestrator baseDir containment); the descriptor is an untrusted hint, never trusted verbatim.
   if (!ws && input.workspace) {
-    const recovery = recoverIsolatedWorkspace(ctx, input.workspace, explicit);
+    const recovery = (await recoverIsolatedWorkspace(ctx, input.workspace, explicit));
     if (recovery.ok) ws = recovery.workspace;
   }
   if (!ws) return undefined;
@@ -149,18 +135,18 @@ function resolveWorkspace(ctx: AuthContext, input: Pick<DeliverTaskInput, "works
   return ws;
 }
 
-function rebindTaskToWorkspaceIfNeeded(task: TaskDetail, ws: WorkspaceRecord | undefined, actor: string): TaskDetail {
+async function rebindTaskToWorkspaceIfNeeded(task: TaskDetail, ws: WorkspaceRecord | undefined, actor: string): Promise<TaskDetail> {
   if (!shouldRebindToWorkspace(task, ws)) return task;
-  setTaskStatus(task.id, {
+  (await setTaskStatusAsync(task.id, {
     status: "in_progress",
     note: `fix-forward rebind to workspace ${ws.id} (${ws.branch})`,
     actor,
-  });
-  return setTaskStage(task.id, {
+  }));
+  return (await setTaskStageAsync(task.id, {
     deliverableStage: "committed-on-branch",
     branch: ws.branch,
     actor,
-  });
+  }));
 }
 
 function cleanReason(value: unknown, disposition: "blocked" | "failed"): string {
@@ -189,7 +175,7 @@ function skippedRequiredGateReports(reason: string): Required<Pick<TaskDeliveryG
 // Non-landing dispositions (blocked/failed/needs-review, and a verdict-only complete that closes on
 // delivery with no land) keep their honest existing wording. #2518 adds the third shape: a complete
 // delivery ACCEPTED but HELD for coordinator review — it says exactly that and never claims landing.
-function notifyDelivery(taskId: number, eventId: number, metadata: TaskDeliverableEventMetadata, landing: boolean): void {
+async function notifyDelivery(taskId: number, eventId: number, metadata: TaskDeliverableEventMetadata, landing: boolean): Promise<void> {
   const task = getTaskDetail(taskId);
   if (!task) return;
   const linkedIssues = task.issues.map((issue) => ({ provider: issue.provider, repo: issue.repo, externalKey: issue.externalKey, title: issue.title, status: issue.status }));
@@ -227,7 +213,7 @@ function notifyDelivery(taskId: number, eventId: number, metadata: TaskDeliverab
   const notArmedWarning = metadata.landNotArmedReason && unmergedAhead > 0
     ? `\n⚠ NOT landed: ${unmergedAhead} unmerged commit(s) remain on ${metadata.workspaceId ?? "the workspace"} (no land armed — ${metadata.landNotArmedReason}). Land it explicitly if this work belongs on main.`
     : "";
-  const delivered = routeNotification({
+  const delivered = await routeNotification({
     type: "task.deliverable",
     scope: {
       taskId: String(taskId),
@@ -309,7 +295,7 @@ export async function deliverTask(input: DeliverTaskInput, ctx: AuthContext): Pr
   // `complete` changes, from a hard reject to the same owner-authorized resolve the land path had.
   // The TASK-record rebind itself (rebindTaskToWorkspaceIfNeeded) is still gated on `wantsLand`.
   let workspace = input.disposition === "complete" || input.workspaceId
-    ? resolveWorkspace(ctx, input, taskId, { allowRebind: input.disposition === "complete" })
+    ? (await resolveWorkspace(ctx, input, taskId, { allowRebind: input.disposition === "complete" }))
     : undefined;
   // A workspace that could actually carry a land: isolated, live on disk, and on a branch. Mirrors
   // the preconditions enforced below (:live isolated workspace / :exact resolved source ref), so a
@@ -459,7 +445,7 @@ export async function deliverTask(input: DeliverTaskInput, ctx: AuthContext): Pr
     }
     if (ahead > 0) landNotArmed = { reason: workspaceLandBlocked(workspace) ? "workspace-land-blocked" : landDecision.reason, unmergedAhead: ahead };
   }
-  const currentTask = wantsLand && !noWork ? rebindTaskToWorkspaceIfNeeded(before, workspace, actor) : before;
+  const currentTask = wantsLand && !noWork ? (await rebindTaskToWorkspaceIfNeeded(before, workspace, actor)) : before;
   const sourceRef = wantsLand ? replayLand?.sourceRef ?? workspace?.branch?.trim() : undefined;
   // Only the HEAD returned by THIS host probe can authorize ingress. Persisted metadata may be
   // stale, and the caller's commit list is a self-report; neither is authority for a mutable ref.
@@ -520,7 +506,7 @@ export async function deliverTask(input: DeliverTaskInput, ctx: AuthContext): Pr
     // Pin the delivered tip captured at delivery; the host publishes it ONLY if reachable from the
     // verified workspace tip, else REFUSES (H1 — fail closed), so no unrelated local commit rides in.
     const deliveredSha = input.commits?.length ? input.commits[input.commits.length - 1]?.sha : undefined;
-    reviewPublish = dispatchReviewPublish(reviewWorkspace, { requestedBy: actor, taskId, sha: deliveredSha, emit: emitCommand });
+    reviewPublish = (await dispatchReviewPublish(reviewWorkspace, { requestedBy: actor, taskId, sha: deliveredSha, emit: emitCommand }));
   }
   const deliveryInput = {
       ...input,
@@ -617,9 +603,9 @@ export async function deliverTask(input: DeliverTaskInput, ctx: AuthContext): Pr
     const detail = getTaskDetail(taskId) ?? currentTask;
     if (detail) {
       emitTaskChanged(detail, "task.deliverable");
-      notifyDelivery(taskId, delivery.event.id, eventMeta ?? (delivery.event.metadata as unknown as TaskDeliverableEventMetadata), wantsLand && armOutcome === "armed");
+      await notifyDelivery(taskId, delivery.event.id, eventMeta ?? (delivery.event.metadata as unknown as TaskDeliverableEventMetadata), wantsLand && armOutcome === "armed");
       if (input.disposition === "failed") {
-        emitTaskSemanticNotification({ task: detail, transition: "gate-failed", actor, occurrenceKey: `event:${delivery.event.id}`, outcome: { disposition: "failed" } });
+        await emitTaskSemanticNotification({ task: detail, transition: "gate-failed", actor, occurrenceKey: `event:${delivery.event.id}`, outcome: { disposition: "failed" } });
       }
     }
   }
@@ -685,7 +671,7 @@ export async function deliverTask(input: DeliverTaskInput, ctx: AuthContext): Pr
     // into same-head `already-requested`; only terminal non-PR attempts qualify,
     // so a currently running merge or a PR waiting on GitHub is never doubled.
     const priorMerge = LAND_IN_FLIGHT_STATUSES.has(liveWorkspace.status)
-      ? findLatestCommandByCorrelation("workspace.merge", liveWorkspace.id)
+      ? await findLatestCommandByCorrelationAsync("workspace.merge", liveWorkspace.id)
       : null;
     const retryableMergePlan = mergeCommandNeedsRetry(priorMerge);
     const withdrawnLand = !hadLandAuthorization
@@ -697,7 +683,7 @@ export async function deliverTask(input: DeliverTaskInput, ctx: AuthContext): Pr
       // exhausted. applyWorkspaceAction clears the old retry incident before re-arming it.
       || retryableMergePlan || workspaceLandNeedsRearm(liveWorkspace) || withdrawnLand;
     if (reenterLand) {
-      markAgentWorkFinal(actor, "task-deliver");
+      (await markAgentWorkFinal(actor, "task-deliver"));
       const result = await applyWorkspaceAction(liveWorkspace, {
         action: "ready",
         agentId: actor,

package/src/services/task-entity.ts

@@ -1,54 +1,11 @@
+import { setTaskStatusAsync, setTaskStageAsync, markTaskAgentReapedAsync } from "../db/task-entity-async";
+import { confirmWorkspaceCarryPendingForTaskAsync } from "../db/runtime-tail-async";
+import { removeSubscriptionsForTaskAsync } from "../db/lifecycle-tail-async";
 // #834 — service facade for the durable Task entity. Transports (HTTP routes, MCP tools)
 // call THIS, not the db writers directly (transport-thinness, epic #342): the service owns
 // the db mutation + the SSE emission so the transport stays thin. The kind partition and all
 // validation live in the db layer (src/db/task-entity.ts); this layer adds eventing.
-import {
-  addTaskDependencyAsync,
-  addTaskRelationAsync,
-  assignTaskAgent,
-  assignTaskAgentAsync,
-  clearTaskParentAsync,
-  confirmWorkspaceCarryPendingForTask,
-  createDeliverableTask,
-  createDeliverableTaskAsync,
-  deliverableTaskIdsByOwnerAgent,
-  deliverableTaskIdsByOwnerAgentAsync,
-  deliverableTaskIdsBySpawnRequestId,
-  deliverableTaskIdsBySpawnRequestIdAsync,
-  getAgent,
-  getTaskDetail,
-  getTaskDetailAsync, getTaskViewAsync,
-  listAgents,
-  listDeliverableTaskSummariesAsync,
-  listDeliverableTasksAsync,
-  listTaskEvents,
-  listTaskEventsAsync,
-  listWorkspaces,
-  markTaskAgentReaped,
-  markTaskAgentReapedAsync,
-  recordGate,
-  recordGateAsync,
-  recordTaskDispatchDecisionAsync,
-  removeTaskDependencyAsync,
-  removeTaskRefAsync,
-  removeTaskRelationAsync,
-  setTaskParentAsync,
-  setTaskStage,
-  setTaskStageAsync,
-  setTaskStatus,
-  setTaskStatusAsync,
-  updateDeliverableTask,
-  updateDeliverableTaskAsync,
-  ValidationError,
-  type ListDeliverableTasksFilter,
-  type RecordTaskDispatchDecisionInput,
-  type RecordGateInput,
-  type RemoveTaskRefInput,
-  type SetTaskStageInput,
-  type SetTaskStatusInput,
-  type TaskEntityWriteOptions,
-  type UpdateDeliverableTaskInput,
-} from "../db";
+import { addTaskDependencyAsync, addTaskRelationAsync, assignTaskAgent, assignTaskAgentAsync, clearTaskParentAsync, createDeliverableTask, createDeliverableTaskAsync, deliverableTaskIdsByOwnerAgent, deliverableTaskIdsByOwnerAgentAsync, deliverableTaskIdsBySpawnRequestId, deliverableTaskIdsBySpawnRequestIdAsync, getAgent, getTaskDetail, getTaskDetailAsync, getTaskViewAsync, listAgents, listDeliverableTaskSummariesAsync, listDeliverableTasksAsync, listTaskEvents, listTaskEventsAsync, listWorkspaces, recordGate, recordGateAsync, recordTaskDispatchDecisionAsync, removeTaskDependencyAsync, removeTaskRefAsync, removeTaskRelationAsync, setTaskParentAsync, updateDeliverableTask, updateDeliverableTaskAsync, ValidationError, type ListDeliverableTasksFilter, type RecordTaskDispatchDecisionInput, type RecordGateInput, type RemoveTaskRefInput, type SetTaskStageInput, type SetTaskStatusInput, type TaskEntityWriteOptions, type UpdateDeliverableTaskInput } from "../db";
 
 import { validationCompletionStatus } from "../task-completion.ts";
 import { findSpawnCommandByRequestId } from "../commands-db";
@@ -56,7 +13,6 @@ import { findSpawnCommandByRequestId } from "../commands-db";
 import { emitTaskChanged } from "../sse";
 import { isCarryPendingBlocker } from "./carry-pending";
 import type { CommandStatus, Task, TaskBlocker, TaskCommitRef, TaskDeliverableEventMetadata, TaskDetail, TaskEvent, TaskGateState, TaskListItem, TaskStatus, TaskTerminalStage, WorkspaceRecord } from "../types";
-import { removeSubscriptionsForTask } from "../db/notification-subscriptions";
 import { emitRelayEvent } from "../events";
 import { routeNotification } from "../notification-router";
 import { isAgentExitDoneWhen } from "./task-done-when";
@@ -73,19 +29,8 @@ import { taskOwnerTarget } from "../task-owner";
 export type { CreateTaskEntityInput } from "./task-issue-link";
 export { addTaskEntityRef, addTaskEntityRefAsync, attachTaskRefs } from "./task-issue-link";
 
-export function createTaskEntity(input: CreateTaskEntityInput): TaskDetail {
-  cleanIssueRefRelation(input.relation);
-  const created = createDeliverableTask(input);
-  const detail = addInitialIssueRefs(created.id, input);
-  autoSubscribeTaskCoordinator(input.createdBy, detail.id);
-  emitTaskChanged(detail, "task.created");
-  emitTaskSemanticNotification({
-    task: detail,
-    transition: "created",
-    actor: input.createdBy,
-    occurrenceKey: latestTaskEventOccurrence(detail.id, "task.created"),
-  });
-  return detail;
+export async function createTaskEntity(input: CreateTaskEntityInput): Promise<TaskDetail> {
+  return createTaskEntityAsync(input);
 }
 
 /** The off-loop twin of createTaskEntity (S3.2 L-D2 #1904) — the sanctioned HTTP/MCP create path. */
@@ -93,9 +38,9 @@ export async function createTaskEntityAsync(input: CreateTaskEntityInput, option
   cleanIssueRefRelation(input.relation);
   const created = await createDeliverableTaskAsync(input, options);
   const detail = await addInitialIssueRefsAsync(created.id, input, options);
-  autoSubscribeTaskCoordinator(input.createdBy, detail.id);
+  (await autoSubscribeTaskCoordinator(input.createdBy, detail.id));
   emitTaskChanged(detail, "task.created");
-  emitTaskSemanticNotification({
+  await emitTaskSemanticNotification({
     task: detail,
     transition: "created",
     actor: input.createdBy,
@@ -118,10 +63,8 @@ export function listTaskEntitySummariesAsync(filter: ListDeliverableTasksFilter
   return listDeliverableTaskSummariesAsync(filter);
 }
 
-export function updateTaskEntity(id: number, input: UpdateDeliverableTaskInput): TaskDetail {
-  const detail = updateDeliverableTask(id, input);
-  emitTaskChanged(detail, "task.updated");
-  return detail;
+export async function updateTaskEntity(id: number, input: UpdateDeliverableTaskInput): Promise<TaskDetail> {
+  return updateTaskEntityAsync(id, input);
 }
 
 /** The off-loop twin of updateTaskEntity (S3.2 L-D2 #1904). */
@@ -136,30 +79,22 @@ export async function updateTaskEntityAsync(id: number, input: UpdateDeliverable
 // interface that cannot yet await, S3.2 L-D2 #1904 follow-up) and the off-loop path
 // (setTaskEntityStatusAsync) apply IDENTICAL business logic over their differently-sourced `before`/
 // `detail` rows, instead of forking the notification/work-finality logic in two places.
-export function emitStatusChangeEffects(before: TaskDetail | null, detail: TaskDetail, actor: string | undefined, occurrenceKey: string | undefined): void {
+export async function emitStatusChangeEffects(before: TaskDetail | null, detail: TaskDetail, actor: string | undefined, occurrenceKey: string | undefined): Promise<void> {
   emitTaskChanged(detail, "task.status");
   const transition = taskTransitionForStatus(detail.status, detail.blockedBy);
   if (actor !== "task-lifecycle" && transition && shouldEmitStatusTransition(before, detail, transition)) {
-    emitTaskSemanticNotification({ task: detail, transition, actor, occurrenceKey });
+    await emitTaskSemanticNotification({ task: detail, transition, actor, occurrenceKey });
   }
-  if (isTerminalTaskStatus(detail.status)) removeSubscriptionsForTask(detail.id);
+  if (isTerminalTaskStatus(detail.status)) await removeSubscriptionsForTaskAsync(detail.id);
   // #1084 — a task reaching `done` is an explicit, platform-owned completion signal for its
   // owning agent's work window: close it, forwarding only the held final group. The #2520
   // plan-ref propagation trigger lives with its CALLERS (below): the sync twin runs the
   // in-process op body; the async path awaits the gateway-backed seam.
-  if (before?.status !== "done" && detail.status === "done") markAgentWorkFinal(detail.ownerAgentId, "task-done");
+  if (before?.status !== "done" && detail.status === "done") (await markAgentWorkFinal(detail.ownerAgentId, "task-done"));
 }
 
-export function setTaskEntityStatus(id: number, input: SetTaskStatusInput): TaskDetail {
-  const before = getTaskDetail(id);
-  const detail = setTaskStatus(id, input);
-  emitStatusChangeEffects(before, detail, input.actor, latestTaskEventOccurrence(detail.id, `status:${detail.status}`));
-  if (before?.status !== "done" && detail.status === "done") {
-    // #2520 — durable status=done trigger for ref-driven plan-node terminal propagation
-    // (in-process twin: the bus-dispatcher seam cannot await; no fire-and-forget promises).
-    advanceTerminalPlanRefs({ taskId: detail.id, actor: input.actor });
-  }
-  return detail;
+export async function setTaskEntityStatus(id: number, input: SetTaskStatusInput): Promise<TaskDetail> {
+  return setTaskEntityStatusAsync(id, input);
 }
 
 /**
@@ -175,7 +110,7 @@ export function setTaskEntityStatus(id: number, input: SetTaskStatusInput): Task
 export async function setTaskEntityStatusAsync(id: number, input: SetTaskStatusInput, options?: TaskEntityWriteOptions): Promise<TaskDetail> {
   const before = await getTaskDetailAsync(id);
   const detail = await setTaskStatusAsync(id, input, options);
-  emitStatusChangeEffects(before, detail, input.actor, await latestTaskEventOccurrenceAsync(detail.id, `status:${detail.status}`));
+  await emitStatusChangeEffects(before, detail, input.actor, await latestTaskEventOccurrenceAsync(detail.id, `status:${detail.status}`));
   if (before?.status !== "done" && detail.status === "done") {
     // #2520 — awaited on the sanctioned async path so the trigger's plan writes settle in order.
     await advanceTerminalPlanRefsAsync({ taskId: detail.id, actor: input.actor });
@@ -188,33 +123,14 @@ export function isTerminalTaskStatus(status: Task["status"]): boolean {
 }
 
 // #1456 — the un-bypassable carry-pending landing gate is enforced in the LOWEST stage writer
-// (`db/task-entity.ts` setTaskStage), so it covers EVERY entrypoint — the land pipeline, the
+// (`db/task-entity.ts` setTaskStageAsync), so it covers EVERY entrypoint — the land pipeline, the
 // no-mergedSha out-of-band reconciliation, PR/squash, a manual `relay_task_set_stage`, and the
 // deploy path (`stampDeployedTasks`, which calls the primitive directly). This service wrapper adds
 // only eventing; it does NOT re-check (guarding the wrapper too would be a second, drift-prone code
 // path — round-4: guard the primitive, not the wrapper). The land pipeline (driveTaskOnLand)
 // short-circuits earlier with a superseded event; the primitive throw is the backstop for the rest.
-export function setTaskEntityStage(id: number, input: SetTaskStageInput): TaskDetail {
-  const before = getTaskDetail(id);
-  let detail = setTaskStage(id, input);
-  emitTaskChanged(detail, "task.stage");
-  const transition = taskTransitionForStage(detail.deliverableStage);
-  if (input.actor !== "task-lifecycle" && transition && before?.deliverableStage !== detail.deliverableStage) {
-    emitTaskSemanticNotification({
-      task: detail,
-      transition,
-      actor: input.actor,
-      branch: detail.branch,
-      occurrenceKey: latestTaskEventOccurrence(detail.id, `stage:${detail.deliverableStage}`),
-    });
-  }
-  const deliverableStage = detail.deliverableStage ?? "none";
-  if (LANDED_STAGES.has(deliverableStage)) {
-    // #2520 — a landed/deploying/deployed stage is terminal success for ref-driven propagation.
-    advanceTerminalPlanRefs({ taskId: detail.id, actor: input.actor });
-  }
-  if (before?.status !== detail.status) emitStatusChangeEffects(before, detail, input.actor, undefined);
-  return detail;
+export async function setTaskEntityStage(id: number, input: SetTaskStageInput): Promise<TaskDetail> {
+  return setTaskEntityStageAsync(id, input);
 }
 
 /** The off-loop twin of setTaskEntityStage (S3.2 L-D2 #1904). */
@@ -224,7 +140,7 @@ export async function setTaskEntityStageAsync(id: number, input: SetTaskStageInp
   emitTaskChanged(detail, "task.stage");
   const transition = taskTransitionForStage(detail.deliverableStage);
   if (input.actor !== "task-lifecycle" && transition && before?.deliverableStage !== detail.deliverableStage) {
-    emitTaskSemanticNotification({
+    await emitTaskSemanticNotification({
       task: detail,
       transition,
       actor: input.actor,
@@ -237,7 +153,7 @@ export async function setTaskEntityStageAsync(id: number, input: SetTaskStageInp
     // #2520 — the off-loop stage trigger for ref-driven plan-node terminal propagation.
     await advanceTerminalPlanRefsAsync({ taskId: detail.id, actor: input.actor });
   }
-  if (before?.status !== detail.status) emitStatusChangeEffects(before, detail, input.actor, undefined);
+  if (before?.status !== detail.status) await emitStatusChangeEffects(before, detail, input.actor, undefined);
   return detail;
 }
 
@@ -254,39 +170,11 @@ export async function setTaskEntityStageAsync(id: number, input: SetTaskStageInp
 // #831). The `deliverable.superseded` event already alerts the coordinator, who handles any
 // issue-close/reap manually in the rare revert window. Automatic host-side tree-level carry
 // verification (and lifecycle re-drive) is tracked as the #1458 follow-up.
-export function confirmTaskCarry(id: number, opts: { actor?: string; note?: string; commit?: TaskCommitRef; branch?: string } = {}): TaskDetail {
-  const task = getTaskDetail(id);
-  if (!task) throw new ValidationError("task not found");
-  const blockers = task.blockedBy ?? [];
-  const remaining = blockers.filter((b: TaskBlocker) => !isCarryPendingBlocker(b));
-  const hadCarryPending = remaining.length !== blockers.length;
-  const note = opts.note?.trim() || "delivered change confirmed carried onto the current base (#1456)";
-  let detail = task;
-  if (hadCarryPending) {
-    // `allowCarryPendingClear` authorizes the primitive latch (BLOCKER 1) to drop the carry-pending
-    // blocker(s) — this confirm is the ONLY path that may. Scoped: preserves unrelated blockers.
-    detail = remaining.length > 0
-      ? setTaskEntityStatus(id, { status: "blocked", blockedBy: remaining, note, actor: opts.actor, allowCarryPendingClear: true })
-      : setTaskEntityStatus(id, { status: "in_progress", note, actor: opts.actor, allowCarryPendingClear: true });
-  }
-  // Clear the workspace-durable marker too (round-4 BLOCKER 3): a late-bound Task can be gated purely
-  // by the workspace's unconfirmed head with no task-level blocker, and the marker would otherwise
-  // re-gate the very land this confirm authorizes. Cleared for the Task's bound workspace(s).
-  confirmWorkspaceCarryPendingForTask(task);
-  // Optionally complete the land the carry-pending gate refused. Both obligation carriers are cleared
-  // above, so the stage gate now permits the advance; doneWhen closes the Task as usual.
-  if (opts.commit) {
-    detail = setTaskEntityStage(id, {
-      deliverableStage: "landed-on-main",
-      ...(opts.branch ? { branch: opts.branch } : {}),
-      commit: opts.commit,
-      actor: opts.actor,
-    });
-  }
-  return detail;
+export async function confirmTaskCarry(id: number, opts: { actor?: string; note?: string; commit?: TaskCommitRef; branch?: string } = {}): Promise<TaskDetail> {
+  return confirmTaskCarryAsync(id, opts);
 }
 
-/** The off-loop twin of confirmTaskCarry (S3.2 L-D2 #1904). `confirmWorkspaceCarryPendingForTask`
+/** The off-loop twin of confirmTaskCarry (S3.2 L-D2 #1904). `confirmWorkspaceCarryPendingForTaskAsync`
  * (workspaces/carry-pending-marker.ts) is a genuinely cross-domain, not-yet-migrated write — left on the
  * sync facade like the retained sync callers elsewhere in this migration; it is a single small metadata
  * write, not a hot path, so it does not defeat the point of awaiting the task-entity writes around it. */
@@ -303,7 +191,7 @@ export async function confirmTaskCarryAsync(id: number, opts: { actor?: string;
       ? await setTaskEntityStatusAsync(id, { status: "blocked", blockedBy: remaining, note, actor: opts.actor, allowCarryPendingClear: true })
       : await setTaskEntityStatusAsync(id, { status: "in_progress", note, actor: opts.actor, allowCarryPendingClear: true });
   }
-  confirmWorkspaceCarryPendingForTask(task);
+  (await confirmWorkspaceCarryPendingForTaskAsync(task));
   if (opts.commit) {
     detail = await setTaskEntityStageAsync(id, {
       deliverableStage: "landed-on-main",
@@ -335,20 +223,8 @@ function shouldEmitStatusTransition(before: TaskDetail | null, detail: TaskDetai
   return false;
 }
 
-export function recordTaskEntityGate(id: number, input: RecordGateInput): { gate: TaskGateState; gates: TaskGateState[] } {
-  const gate = recordGate(id, input);
-  const detail = getTaskDetail(id);
-  if (detail) emitTaskChanged(detail, "task.gate");
-  if (detail && gate.status === "fail") {
-    emitTaskSemanticNotification({
-      task: detail,
-      transition: "gate-failed",
-      actor: input.actor,
-      occurrenceKey: latestTaskEventOccurrence(detail.id, `gate:${gate.gate}`),
-      outcome: { gate: gate.gate, status: gate.status, ...(gate.detail ? { detail: gate.detail } : {}) },
-    });
-  }
-  return { gate, gates: detail?.gates ?? [] };
+export async function recordTaskEntityGate(id: number, input: RecordGateInput): Promise<{ gate: TaskGateState; gates: TaskGateState[] }> {
+  return recordTaskEntityGateAsync(id, input);
 }
 
 /** The off-loop twin of recordTaskEntityGate (S3.2 L-D2 #1904). */
@@ -357,7 +233,7 @@ export async function recordTaskEntityGateAsync(id: number, input: RecordGateInp
   const detail = await getTaskDetailAsync(id);
   if (detail) emitTaskChanged(detail, "task.gate");
   if (detail && gate.status === "fail") {
-    emitTaskSemanticNotification({
+    await emitTaskSemanticNotification({
       task: detail,
       transition: "gate-failed",
       actor: input.actor,
@@ -419,10 +295,8 @@ export async function removeTaskEntityRefAsync(id: number, input: RemoveTaskRefI
  * `registerAgent` — the same synchronous plugin/hook constraint as `setTaskEntityStatus` above. Every
  * other production caller (routes/tasks.ts, the MCP task tools) now calls `assignTaskEntityAgentAsync`.
  */
-export function assignTaskEntityAgent(id: number, agentId: string, role?: string, actor?: string): TaskDetail {
-  const detail = assignTaskAgent(id, agentId, role, actor);
-  emitTaskChanged(detail, "task.updated");
-  return detail;
+export async function assignTaskEntityAgent(id: number, agentId: string, role?: string, actor?: string): Promise<TaskDetail> {
+  return assignTaskEntityAgentAsync(id, agentId, role, actor);
 }
 
 /** The off-loop twin of assignTaskEntityAgent (S3.2 L-D2 #1904) — the sanctioned HTTP/MCP path. */
@@ -600,10 +474,10 @@ async function latestDeliverableEventAsync(taskId: number): Promise<TaskEvent |
   return [...(await listTaskEventsAsync(taskId))].reverse().find((event) => event.type === "deliverable");
 }
 
-function restoreDeliveredDisposition(task: TaskDetail, event: TaskEvent): void {
+async function restoreDeliveredDisposition(task: TaskDetail, event: TaskEvent): Promise<void> {
   const metadata = event.metadata as unknown as Partial<TaskDeliverableEventMetadata>;
   if (metadata.disposition === "failed" && task.status !== "failed") {
-    setTaskEntityStatus(task.id, {
+    await setTaskEntityStatus(task.id, {
       status: "failed",
       ...(typeof metadata.reason === "string" && metadata.reason.trim() ? { note: metadata.reason } : {}),
       actor: "task-lifecycle",
@@ -611,7 +485,7 @@ function restoreDeliveredDisposition(task: TaskDetail, event: TaskEvent): void {
     return;
   }
   if (metadata.disposition === "blocked" && task.status !== "blocked" && Array.isArray(metadata.blockedBy) && metadata.blockedBy.length > 0) {
-    setTaskEntityStatus(task.id, {
+    await setTaskEntityStatus(task.id, {
       status: "blocked",
       blockedBy: metadata.blockedBy,
       ...(typeof metadata.reason === "string" && metadata.reason.trim() ? { note: metadata.reason } : {}),
@@ -643,46 +517,9 @@ async function restoreDeliveredDispositionAsync(task: TaskDetail, event: TaskEve
 // #889 — finalize bound tasks for a reaped agent whose doneWhen is "agent-exit" / "reaped".
 // Called by the transient reaper after requesting shutdown so ephemeral run-and-exit workers
 // don't leave their auto-scaffolded Task stuck in_progress forever.
-// Never overrides an already-terminal status. Idempotent (reapedAt guard inside markTaskAgentReaped).
-export function finalizeEphemeralTasksOnReap(agentId: string, opts: { spawnRequestId?: string; reason?: string; producedWork?: boolean; evidence?: string } = {}): number[] {
-  const ids = new Set<number>();
-  for (const id of deliverableTaskIdsByOwnerAgent(agentId)) ids.add(id);
-  if (opts.spawnRequestId) {
-    for (const id of deliverableTaskIdsBySpawnRequestId(opts.spawnRequestId)) ids.add(id);
-  }
-  const finalized: number[] = [];
-  for (const taskId of ids) {
-    const task = getTaskDetail(taskId);
-    if (!task) continue;
-    if (task.status === "done" || task.status === "failed" || task.status === "canceled") continue;
-    if (!isAgentExitDoneWhen(task.doneWhen)) continue;
-    if (opts.producedWork === false) {
-      try {
-        const deliverable = latestDeliverableEvent(taskId);
-        if (deliverable) {
-          if (!task.reapedAt) markTaskAgentReaped(taskId, { agentId, reason: opts.reason ?? "agent-exit" });
-          restoreDeliveredDisposition(task, deliverable);
-          finalized.push(taskId);
-          continue;
-        }
-        if (!task.reapedAt) markTaskAgentReaped(taskId, { agentId, reason: opts.reason ?? "agent-exit" });
-        setTaskEntityStatus(taskId, { status: "canceled", note: "worker reaped without landing or producing work; task canceled", actor: "task-lifecycle" });
-        notifyEmptyTransientReap(agentId, task, opts);
-        finalized.push(taskId);
-      } catch {
-        // best-effort; failures must not surface into the reaper scan
-      }
-      continue;
-    }
-    try {
-      if (!task.reapedAt) markTaskAgentReaped(taskId, { agentId, reason: opts.reason ?? "agent-exit" });
-      setTaskEntityStatus(taskId, { status: validationCompletionStatus(task.validationItems), note: "doneWhen=agent-exit satisfied by worker reap", actor: "task-lifecycle" });
-      finalized.push(taskId);
-    } catch {
-      // best-effort; failures must not surface into the reaper scan
-    }
-  }
-  return finalized;
+// Never overrides an already-terminal status. Idempotent (reapedAt guard inside markTaskAgentReapedAsync).
+export async function finalizeEphemeralTasksOnReap(agentId: string, opts: { spawnRequestId?: string; reason?: string; producedWork?: boolean; evidence?: string } = {}): Promise<number[]> {
+  return finalizeEphemeralTasksOnReapAsync(agentId, opts);
 }
 
 /** The off-loop twin of finalizeEphemeralTasksOnReap (S3.2 L-D2 #1904) — the sanctioned scheduled-job
@@ -710,7 +547,7 @@ export async function finalizeEphemeralTasksOnReapAsync(agentId: string, opts: {
         }
         if (!task.reapedAt) await markTaskAgentReapedAsync(taskId, { agentId, reason: opts.reason ?? "agent-exit" });
         await setTaskEntityStatusAsync(taskId, { status: "canceled", note: "worker reaped without landing or producing work; task canceled", actor: "task-lifecycle" });
-        notifyEmptyTransientReap(agentId, task, opts);
+        await notifyEmptyTransientReap(agentId, task, opts);
         finalized.push(taskId);
       } catch {
         // best-effort; failures must not surface into the reaper scan
@@ -728,7 +565,7 @@ export async function finalizeEphemeralTasksOnReapAsync(agentId: string, opts: {
   return finalized;
 }
 
-function notifyEmptyTransientReap(agentId: string, task: TaskDetail, opts: { spawnRequestId?: string; reason?: string; evidence?: string }): void {
+async function notifyEmptyTransientReap(agentId: string, task: TaskDetail, opts: { spawnRequestId?: string; reason?: string; evidence?: string }): Promise<void> {
   const agent = getAgent(agentId);
   const parent = agent?.spawnedBy;
   const recipients = [...new Set([parent, taskOwnerTarget(task)].filter((value): value is string => Boolean(value && value.trim())))];
@@ -743,7 +580,7 @@ function notifyEmptyTransientReap(agentId: string, task: TaskDetail, opts: { spa
     evidence: opts.evidence ?? "no-produced-work",
   };
   emitRelayEvent({ type: "agent.transient_empty_reap", source: "task-lifecycle", subject: agentId, data: payload });
-  routeNotification({
+  await routeNotification({
     type: "agent.transient_empty_reap",
     scope: { agentId, parent, taskId: String(task.id) },
     recipients,

package/src/services/task-issue-link.ts

@@ -1,3 +1,5 @@
+import { addTaskRefAsync } from "../db/task-entity-async";
+import { insertTaskEventAsync } from "../db/runtime-tail-async";
 // #834/#2214 — the Task ↔ issue ATTACH seam: everything that turns "this Task is about issue N"
 // into a real `issue_associations` row, split out of the task-entity service (which owns status /
 // stage / gates / attribution) so both stay under the file-size ratchet and this rule has one home.
@@ -11,18 +13,9 @@
 //   - after create — `relay_task_add_ref` / `POST /api/tasks/:id/refs` via attachTaskRefs.
 // Both resolve a bare `#N` through the same default-repo chain (see issueRepoForCreate).
 import { errMessage } from "@humwick/sdk";
-import {
-  addTaskRef,
-  addTaskRefAsync,
-  getTaskDetail,
-  getTaskDetailAsync,
-  ValidationError,
-  type AddTaskRefInput,
-  type CreateDeliverableTaskInput,
-  type TaskEntityWriteOptions,
-} from "../db";
+import { getTaskDetail, getTaskDetailAsync, ValidationError, type AddTaskRefInput, type CreateDeliverableTaskInput, type TaskEntityWriteOptions } from "../db";
 import { isBareIssueRef } from "../db/issue-refs";
-import { insertTaskEvent } from "../db/task-core";
+
 import { resolveActorIssueRepo } from "../agent-issue-repo";
 import { emitTaskChanged } from "../sse";
 import { cleanIssueRefRelation } from "../db/task-issue-relation";
@@ -54,31 +47,31 @@ export function issueRepoForCreate(input: CreateTaskEntityInput): string | undef
 // A ref the caller ASKED for that could not be linked must not vanish into a server log: record it
 // on the Task's own ledger so it shows up in history (and in a spawned worker's hydrated brief).
 // Creation itself still succeeds — a Task without its issue link is degraded, not invalid.
-function recordIssueLinkFailure(taskId: number, issue: string, defaultRepo: string | undefined, error: unknown): void {
+async function recordIssueLinkFailure(taskId: number, issue: string, defaultRepo: string | undefined, error: unknown): Promise<void> {
   const message = errMessage(error);
   console.warn(`task ${taskId} issue ref '${issue}' could not be linked on create: ${message}`);
   try {
-    insertTaskEvent(taskId, {
+    (await insertTaskEventAsync(taskId, {
       source: "agent-relay",
       type: "ref.issue.link_failed",
       severity: "warning",
       title: `Issue ref '${issue}' could not be linked`,
       body: message,
       metadata: { issue, ...(defaultRepo ? { defaultRepo } : {}) },
-    }, Date.now());
+    }, Date.now()));
   } catch (eventError) {
     console.warn(`task ${taskId} could not record issue-link failure: ${errMessage(eventError)}`);
   }
 }
 
-export function addInitialIssueRefs(taskId: number, input: CreateTaskEntityInput): TaskDetail {
+export async function addInitialIssueRefs(taskId: number, input: CreateTaskEntityInput): Promise<TaskDetail> {
   const defaultRepo = issueRepoForCreate(input);
   let detail = getTaskDetail(taskId)!;
   for (const { issue, relation } of initialIssueRefs(input)) {
     try {
-      detail = addTaskRef(taskId, { issue, relation, defaultRepo, actor: input.createdBy });
+      detail = (await addTaskRefAsync(taskId, { issue, relation, defaultRepo, actor: input.createdBy }));
     } catch (error) {
-      recordIssueLinkFailure(taskId, issue, defaultRepo, error);
+      (await recordIssueLinkFailure(taskId, issue, defaultRepo, error));
     }
   }
   return detail;
@@ -95,7 +88,7 @@ export async function addInitialIssueRefsAsync(taskId: number, input: CreateTask
         ...(options?.idempotencyKey ? { idempotencyKey: `${options.idempotencyKey}:initial-ref:${index}` } : {}),
       });
     } catch (error) {
-      recordIssueLinkFailure(taskId, issue, defaultRepo, error);
+      (await recordIssueLinkFailure(taskId, issue, defaultRepo, error));
     }
   }
   return detail;
@@ -115,8 +108,8 @@ function needsIssueRepo(input: AddTaskRefInput): boolean {
   return isBareIssueRef(input.issue) && !input.defaultRepo?.trim();
 }
 
-export function addTaskEntityRef(id: number, input: AddTaskRefInput): TaskDetail {
-  const detail = addTaskRef(id, needsIssueRepo(input) ? withResolvedIssueRepo(input, getTaskDetail(id)) : input);
+export async function addTaskEntityRef(id: number, input: AddTaskRefInput): Promise<TaskDetail> {
+  const detail = (await addTaskRefAsync(id, needsIssueRepo(input) ? withResolvedIssueRepo(input, getTaskDetail(id)) : input));
   emitTaskChanged(detail, "task.updated");
   return detail;
 }