@humwick/server 0.130.1 → 0.130.3

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

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

@@ -1,3 +1,4 @@
+import { insertTaskEventAsync } from "../db/runtime-tail-async";
 // #833 — the Task ↔ GitHub issue weave-through. This is the WRITE-THROUGH lens that
 // the design refinement (weave-in, not duplicate) calls for: a comment on a Task does
 // not land in a relay table that can drift — it writes a structured comment THROUGH to
@@ -32,7 +33,7 @@ import { getTaskDetail } from "../db/task-entity";
 import { getTaskDetailAsync } from "../db/task-entity-async";
 import { getIssueRef } from "../db/issue-refs";
 import { listSuccessfulCloseActionsForIssueRef } from "../db/issue-lifecycle";
-import { insertTaskEvent, getTaskEvent } from "../db/task-core";
+import { getTaskEvent } from "../db/task-core";
 import { listTaskEvents } from "../db/tasks";
 import { type TaskCommentThroughKind, type TaskCommentThroughRecord } from "../db/task-comment-through";
 import { failCommentThroughAsync, finalizeCommentThroughAsync, reserveCommentThroughAsync } from "../db/task-comment-through-async";
@@ -249,7 +250,7 @@ async function reconcileReclaim(params: {
   body: string;
   githubLinks: TaskIssueLink[];
   reservation: TaskCommentThroughRecord;
-  recordReceipt: (posted: TaskIssueLink[], failed: Array<{ link: TaskIssueLink; error: string }>) => TaskEvent;
+  recordReceipt: (posted: TaskIssueLink[], failed: Array<{ link: TaskIssueLink; error: string }>) => Promise<TaskEvent>;
   opts: WeaveOptions;
 }): Promise<WeaveWriteResult> {
   const { taskId, kind, slotKey, payload, body, githubLinks, reservation, recordReceipt, opts } = params;
@@ -281,7 +282,7 @@ async function reconcileReclaim(params: {
   }
 
   // Every link now satisfied (already-present + freshly-posted) → finalize exactly once.
-  const event = recordReceipt(posted, []);
+  const event = await recordReceipt(posted, []);
   await finalizeCommentThroughAsync(reservation.id, event.id);
   await emitChanged(taskId);
   return { taskId, posted, failed: [], event, deduped: recon.missing.length === 0 };
@@ -351,8 +352,8 @@ export async function commentOnTaskThrough(input: CommentOnTaskInput, opts: Weav
   // The success-scoped receipt writer (shared by the normal-post and reconcile-found paths):
   // an AUDIT of what actually landed on GitHub (posted only), not a second store of the
   // discussion. GitHub stays canonical; the Task renders by reading it back.
-  const recordReceipt = (posted: TaskIssueLink[], failed: Array<{ link: TaskIssueLink; error: string }>): TaskEvent =>
-    insertTaskEvent(taskId, {
+  const recordReceipt = async (posted: TaskIssueLink[], failed: Array<{ link: TaskIssueLink; error: string }>): Promise<TaskEvent> =>
+    (await insertTaskEventAsync(taskId, {
       source: author,
       type: "comment.posted",
       severity: "info",
@@ -365,7 +366,7 @@ export async function commentOnTaskThrough(input: CommentOnTaskInput, opts: Weav
         posted: posted.map((l) => ({ issueRefId: l.issueRefId, repo: l.repo, externalKey: l.externalKey, url: l.url })),
         ...(failed.length > 0 ? { failed: failed.map((f) => ({ issueRefId: f.link.issueRefId, error: f.error })) } : {}),
       },
-    }, Date.now());
+    }, Date.now()));
 
   // Idempotency = reserve→post→finalize (NOT scan→post→insert): the (taskId,kind,clientId)
   // slot is claimed TRANSACTIONALLY before the awaited GitHub append, so concurrent same-key
@@ -401,7 +402,7 @@ export async function commentOnTaskThrough(input: CommentOnTaskInput, opts: Weav
     );
   }
 
-  const event = recordReceipt(result.posted, result.failed);
+  const event = (await recordReceipt(result.posted, result.failed));
   if (reservation) await finalizeCommentThroughAsync(reservation.id, event.id);
   await emitChanged(taskId);
   return { taskId, posted: result.posted, failed: result.failed, event, deduped: false };
@@ -452,8 +453,8 @@ export async function postTaskMilestoneComment(input: MilestoneCommentInput, opt
   const body = `${summary}${input.commitSha ? `\ncommit: \`${input.commitSha.slice(0, 12)}\`` : ""}${gatesLine(input.gates)}`;
   const payload: TaskCommentPayload = { v: TASK_COMMENT_FORMAT_VERSION, kind: "milestone", taskId, author, milestone, ...(slotKey ? { key: slotKey } : {}) };
 
-  const recordReceipt = (posted: TaskIssueLink[], failed: Array<{ link: TaskIssueLink; error: string }>): TaskEvent =>
-    insertTaskEvent(taskId, {
+  const recordReceipt = async (posted: TaskIssueLink[], failed: Array<{ link: TaskIssueLink; error: string }>): Promise<TaskEvent> =>
+    (await insertTaskEventAsync(taskId, {
       source: author,
       type: "milestone.posted",
       severity: "info",
@@ -468,7 +469,7 @@ export async function postTaskMilestoneComment(input: MilestoneCommentInput, opt
         posted: posted.map((l) => ({ issueRefId: l.issueRefId, repo: l.repo, externalKey: l.externalKey, url: l.url })),
         ...(failed.length > 0 ? { failed: failed.map((f) => ({ issueRefId: f.link.issueRefId, error: f.error })) } : {}),
       },
-    }, Date.now());
+    }, Date.now()));
 
   // Same reserve→post→finalize + reconcile-on-reclaim discipline as discussion, so a re-fired
   // land posts at most one summary even across concurrency and post-before-finalize crashes.
@@ -502,7 +503,7 @@ export async function postTaskMilestoneComment(input: MilestoneCommentInput, opt
     );
   }
 
-  const event = recordReceipt(result.posted, result.failed);
+  const event = (await recordReceipt(result.posted, result.failed));
   if (reservation) await finalizeCommentThroughAsync(reservation.id, event.id);
   await emitChanged(taskId);
   return { taskId, posted: result.posted, failed: result.failed, event, deduped: false };