@humwick/server 0.130.2 → 0.130.3

package/src/services/plan-dispatch.ts

@@ -18,7 +18,7 @@ import { launchWorkflowRun, prepareWorkflowRun } from "./workflow-runs";
 import { ensureSupervisor, invoke, type Supervisor } from "./workflow-supervisor";
 import { stampPins } from "./workflow-pins";
 import { emitPlan } from "./plan-graph";
-import { dependencyStage, memberReady, occupiedSlots, planMembers, prerequisiteState, slotFromRun, taskSucceeded, unsupportedPlanShape } from "./plan-dispatch-policy";
+import { dependencyStage, memberReady, occupiedSlots, planMembers, planNodeSettled, prerequisiteState, slotFromRun, taskSucceeded, unsupportedPlanShape } from "./plan-dispatch-policy";
 import type { AuthContext } from "./auth-context";
 import { planSlotOccupies, type Plan, type PlanDispatch, type PlanDispatchSlot, type TaskDetail } from "../types";
 
@@ -44,9 +44,13 @@ export async function startPlanDispatch(input: { planId?: unknown; expectedVersi
   if (plan.archived) throw new ValidationError(`plan ${plan.id} is archived`);
   const problems = unsupportedPlanShape(plan);
   if (problems.length) throw new ValidationError(problems.join("; "));
-  const members = planMembers(plan);
-  const tasks = await Promise.all(members.map((member) => getTaskDetailAsync(member.taskId)));
-  const memberIds = new Set(members.map((member) => member.taskId));
+  const nodes = new Map(plan.nodes.map((node) => [node.id, node]));
+  const allMembers = planMembers(plan);
+  const allTasks = await Promise.all(allMembers.map((member) => getTaskDetailAsync(member.taskId)));
+  const unfinished = allMembers.flatMap((member, index) => planNodeSettled(nodes.get(member.nodeId)!, allTasks[index]!) ? [] : [{ member, task: allTasks[index]! }]);
+  const members = unfinished.map(({ member }) => member);
+  const tasks = unfinished.map(({ task }) => task);
+  const memberIds = new Set(plan.nodes.map((node) => Number(node.refs?.taskId)));
   for (const member of tasks) {
     for (const id of member?.dependsOn ?? []) {
       if (memberIds.has(id)) continue;
@@ -55,7 +59,7 @@ export async function startPlanDispatch(input: { planId?: unknown; expectedVersi
     }
   }
   const repos = new Set(tasks.map((task) => task?.repo).filter(Boolean));
-  if (repos.size !== 1) throw new ValidationError(`UNSUPPORTED_PLAN_SHAPE: slice 1a dispatches one repo; the plan's Tasks name ${repos.size ? [...repos].join(", ") : "no repo"}`);
+  if (tasks.length && repos.size !== 1) throw new ValidationError(`UNSUPPORTED_PLAN_SHAPE: slice 1a dispatches one repo; the plan's Tasks name ${repos.size ? [...repos].join(", ") : "no repo"}`);
   let cwd: string | undefined;
   for (const [index, task] of tasks.entries()) {
     if (!task || task.status === "canceled") throw new ValidationError(`UNSUPPORTED_PLAN_SHAPE: T${members[index]!.taskId} is missing or canceled`);
@@ -115,6 +119,8 @@ function ensureListening(): void {
     if (event.type === "task.stage" || event.type === "task.status" || event.type === "task.updated") {
       const plans = watched.get(Number(event.data.id ?? event.subject));
       if (plans?.size) void fireAndForget("[plan-dispatch] reconcile", () => requestReconcile(plans));
+    } else if (event.type === "plan.changed" && event.subject && dispatching.has(event.subject)) {
+      void fireAndForget("[plan-dispatch] reconcile", () => requestReconcile([event.subject!]));
     } else if (dispatching.size && (event.type === "workflow.changed" || event.type === "branch.landed" || event.type === "ci.status")) {
       void fireAndForget("[plan-dispatch] reconcile", () => requestReconcile());
     }
@@ -184,9 +190,22 @@ async function reconcilePlan(planId: string): Promise<void> {
     changed ||= next !== slot;
     slots.set(slot.taskId, next);
   }
+  const nodes = new Map(plan.nodes.map((node) => [node.id, node]));
+  const nodesForTask = new Map(plan.nodes.filter((node) => node.refs?.taskId).map((node) => [Number(node.refs!.taskId), node]));
+  const prerequisites = new Map<string, string[]>();
+  for (const edge of plan.edges) {
+    if (!prerequisites.has(edge.to)) prerequisites.set(edge.to, []);
+    prerequisites.get(edge.to)!.push(edge.from);
+  }
+  const settledNode = async (nodeId: string, requiredStage?: Parameters<typeof taskSucceeded>[2]) => {
+    const node = nodes.get(nodeId)!;
+    const id = Number(node.refs?.taskId);
+    return planNodeSettled(node, Number.isSafeInteger(id) && id > 0 ? await task(id) : null, slots.get(id), requiredStage);
+  };
   if (dispatch.state === "active") {
     for (const { nodeId, taskId } of members) {
       const slot = slots.get(taskId);
+      if (!slot && await settledNode(nodeId)) continue;
       if (slot && (slot.status !== "launch-failed" && slot.status !== "failed" && slot.status !== "cancelled")) {
         const dispatched = planSlotOccupies(slot.status) ? await task(taskId) : null;
         if (dispatched) await escalateRegressions(plan, nodeId, dispatched, memberTaskIds, task);
@@ -207,14 +226,16 @@ async function reconcilePlan(planId: string): Promise<void> {
       for (const id of member.dependsOn) {
         const prerequisite = await task(id);
         const required = dependencyStage(member, id);
-        if (taskSucceeded(prerequisite, slots.get(id), required)) succeeded.add(id);
+        const node = nodesForTask.get(id);
+        if (node ? await settledNode(node.id, required) : taskSucceeded(prerequisite, slots.get(id), required)) succeeded.add(id);
         else {
           const state = prerequisiteState(prerequisite, required);
           if (state.state === "unreachable") {
-            notifyPlan(plan, `T${taskId} prerequisite unreachable`, `Plan ${plan.id}, node ${nodeId} (T${taskId}) waits on T${id}, which is ${state.reason}. Replace the edge with relay_task_remove_dependency then relay_task_add_dependency, cancel the node, or wait for T${id} to be reopened. The dependent keeps waiting.`, `plan:${plan.id}:prereq:T${id}:${state.reason}`, { kind: "plan.prerequisite-unreachable", planId, nodeId, taskId, prerequisiteTaskId: id, reason: state.reason, nextActions: ["replace-edge", "cancel-node", "wait-for-reopen"] });
+            await notifyPlan(plan, `T${taskId} prerequisite unreachable`, `Plan ${plan.id}, node ${nodeId} (T${taskId}) waits on T${id}, which is ${state.reason}. Replace the edge with relay_task_remove_dependency then relay_task_add_dependency, cancel the node, or wait for T${id} to be reopened. The dependent keeps waiting.`, `plan:${plan.id}:prereq:T${id}:${state.reason}`, { kind: "plan.prerequisite-unreachable", planId, nodeId, taskId, prerequisiteTaskId: id, reason: state.reason, nextActions: ["replace-edge", "cancel-node", "wait-for-reopen"] });
           }
         }
       }
+      if (!(await Promise.all((prerequisites.get(nodeId) ?? []).map((id) => settledNode(id)))).every(Boolean)) continue;
       if (!memberReady(member, undefined, (id) => succeeded.has(id))) continue;
       if (occupiedSlots(slots.values()) >= dispatch.concurrency) continue;
       const claimed = await write<{ slot?: PlanDispatchSlot; reserved: boolean }>("planDispatch.slot.reserve", { planId, taskId, nodeId });
@@ -223,7 +244,7 @@ async function reconcilePlan(planId: string): Promise<void> {
       if (fault === "after-reserve") { halted = true; throw new Error("plan dispatch test fault: the process stopped after reserving a slot"); }
       slots.set(taskId, await launch(plan, claimed.slot));
     }
-    const settled = await Promise.all(members.map(async ({ taskId }) => taskSucceeded(await task(taskId), slots.get(taskId))));
+    const settled = await Promise.all(plan.nodes.map((node) => settledNode(node.id)));
     if (settled.every(Boolean)) {
       await openAudit(plan, dispatch, members.map(({ taskId }) => tasks.get(taskId)).find(Boolean) ?? null);
       changed = true;
@@ -245,7 +266,7 @@ async function escalateRegressions(plan: Plan, nodeId: string, member: TaskDetai
     const state = prerequisiteState(prerequisite, required);
     if (state.state === "satisfied") continue;
     const now = prerequisite ? `status ${prerequisite.status}, stage ${prerequisite.deliverableStage ?? "none"}${state.state === "unreachable" ? `, ${state.reason}` : ""}` : "missing";
-    notifyPlan(plan, `T${member.id} prerequisite regressed`, `Plan ${plan.id}, node ${nodeId} (T${member.id}) was dispatched on T${id} reaching ${required}, which no longer holds (${now}). The run continues; check whether its work is still valid, or cancel the node.`, `plan:${plan.id}:prereq:T${id}:regressed`, { kind: "plan.prerequisite-unreachable", planId: plan.id, nodeId, taskId: member.id, prerequisiteTaskId: id, reason: "regressed", requiredStage: required, nextActions: ["check-run", "cancel-node", "wait-for-recovery"] });
+    await notifyPlan(plan, `T${member.id} prerequisite regressed`, `Plan ${plan.id}, node ${nodeId} (T${member.id}) was dispatched on T${id} reaching ${required}, which no longer holds (${now}). The run continues; check whether its work is still valid, or cancel the node.`, `plan:${plan.id}:prereq:T${id}:regressed`, { kind: "plan.prerequisite-unreachable", planId: plan.id, nodeId, taskId: member.id, prerequisiteTaskId: id, reason: "regressed", requiredStage: required, nextActions: ["check-run", "cancel-node", "wait-for-recovery"] });
   }
 }
 
@@ -279,7 +300,7 @@ async function launch(plan: Plan, slot: PlanDispatchSlot): Promise<PlanDispatchS
     const started = await launchWorkflowRun(prepared, { ...(inputs ? { inputs } : {}), ...(pins ? { pins } : {}), requestKey: `plan:${plan.id}:T${task.id}:a${slot.attempt}` }, AUTOPILOT_CTX);
     return (await write<PlanDispatchSlot | undefined>("planDispatch.slot.update", { taskId: slot.taskId, attempt: slot.attempt, runId: String(started.runId), status: String(started.status) })) ?? slot;
   } catch (error) {
-    notifyPlan(plan, `T${slot.taskId} could not start`, `Plan ${plan.id} could not start T${slot.taskId}'s workflow: ${errMessage(error)}. Its slot is free and its dependents wait. Fix the cause, then start its workflow by hand (relay_workflow_start); the plan adopts that run.`, `plan:${plan.id}:launch-failed:T${slot.taskId}:a${slot.attempt}`, { kind: "plan.dispatch-failed", planId: plan.id, taskId: slot.taskId });
+    await notifyPlan(plan, `T${slot.taskId} could not start`, `Plan ${plan.id} could not start T${slot.taskId}'s workflow: ${errMessage(error)}. Its slot is free and its dependents wait. Fix the cause, then start its workflow by hand (relay_workflow_start); the plan adopts that run.`, `plan:${plan.id}:launch-failed:T${slot.taskId}:a${slot.attempt}`, { kind: "plan.dispatch-failed", planId: plan.id, taskId: slot.taskId });
     return (await write<PlanDispatchSlot | undefined>("planDispatch.slot.update", { taskId: slot.taskId, attempt: slot.attempt, status: "launch-failed", error: errMessage(error).slice(0, 2000) })) ?? slot;
   }
 }
@@ -310,7 +331,7 @@ async function driveAudit(sup: Supervisor, plan: Plan): Promise<boolean> {
       const started = await launchWorkflowRun(prepared, { requestKey: `plan:${plan.id}:audit` }, AUTOPILOT_CTX);
       await write("planDispatch.audit.update", { planId: plan.id, runId: String(started.runId), status: String(started.status) });
     } catch (error) {
-      notifyPlan(plan, "audit could not start", `Plan ${plan.id}: every node landed, but its conformance audit (T${audit.taskId}) could not start: ${errMessage(error)}. Start ${PLAN_CONFORMANCE_WORKFLOW} on T${audit.taskId} by hand, or audit and record relay_plan_conformance yourself.`, `plan:${plan.id}:audit-failed`, { kind: "plan.dispatch-failed", planId: plan.id, taskId: audit.taskId });
+      await notifyPlan(plan, "audit could not start", `Plan ${plan.id}: every node landed, but its conformance audit (T${audit.taskId}) could not start: ${errMessage(error)}. Start ${PLAN_CONFORMANCE_WORKFLOW} on T${audit.taskId} by hand, or audit and record relay_plan_conformance yourself.`, `plan:${plan.id}:audit-failed`, { kind: "plan.dispatch-failed", planId: plan.id, taskId: audit.taskId });
       await write("planDispatch.audit.update", { planId: plan.id, status: "launch-failed" });
     }
     return true;
@@ -324,14 +345,14 @@ async function driveAudit(sup: Supervisor, plan: Plan): Promise<boolean> {
     dispatching.delete(plan.id);
     watchPlan(plan.id, new Set());
     const slots = plan.dispatch!.slots.map((slot) => `${slot.nodeId} T${slot.taskId} ${slot.runId ?? "no run"} ${slot.landedSha?.slice(0, 12) ?? ""}`.trim());
-    notifyPlan(plan, "done", [`Plan ${plan.id}${plan.title ? ` "${plan.title}"` : ""} is done: conformance passed on ${audit.mainSha} at version ${plan.version}.`, ...slots, `Audit T${audit.taskId} run ${audit.runId}.`].join("\n"), `plan:${plan.id}:result:v${plan.version}`, { kind: "plan.result", planId: plan.id, planVersion: plan.version, mainSha: audit.mainSha });
+    await notifyPlan(plan, "done", [`Plan ${plan.id}${plan.title ? ` "${plan.title}"` : ""} is done: conformance passed on ${audit.mainSha} at version ${plan.version}.`, ...slots, `Audit T${audit.taskId} run ${audit.runId}.`].join("\n"), `plan:${plan.id}:result:v${plan.version}`, { kind: "plan.result", planId: plan.id, planVersion: plan.version, mainSha: audit.mainSha });
   }
   return true;
 }
 
-function notifyPlan(plan: Plan, subject: string, body: string, idempotencyKey: string, payload: Json): void {
+async function notifyPlan(plan: Plan, subject: string, body: string, idempotencyKey: string, payload: Json): Promise<void> {
   const to = planNoticeTarget(plan);
-  if (to) notifySystemMessage(to, { subject: `Plan ${plan.title ?? plan.id}: ${subject}`, body, idempotencyKey, replyExpected: false, payload });
+  if (to) await notifySystemMessage(to, { subject: `Plan ${plan.title ?? plan.id}: ${subject}`, body, idempotencyKey, replyExpected: false, payload });
 }
 
 // --- serving ---------------------------------------------------------------------------------------

package/src/services/plan-graph.ts

@@ -1,11 +1,14 @@
+import { resolveIssueRefFromStringAsync } from "../db/issue-refs-async";
+import { removeAssociationAsync, associateIssueAsync } from "../db/runtime-tail-async";
+import { deletePlanAsync, createPlanRowAsync } from "../db/plans-async";
 import { hasScope, isRecord } from "@humwick/sdk";
-import { addTaskDependency, createPlanRow, deletePlan, getAgent, getEntry, getPlan, getPlanAsync, getPlanByTeam, getPlanByThread, getTaskDetail, listPlansWithBoundOwner, planThreadExists, removeTaskDependency, replacePlanNodeScoped, sendMessage, sendMessageWithResultAsync, setPlanArchivedAsync, ValidationError } from "../db";
+import { sendMessageAsync, addTaskDependency, getAgent, getEntry, getPlan, getPlanAsync, getPlanByTeam, getPlanByThread, getTaskDetail, listPlansWithBoundOwner, planThreadExists, removeTaskDependency, replacePlanNodeScoped, sendMessageWithResultAsync, setPlanArchivedAsync, ValidationError } from "../db";
 // The shared #2520 patch-time source derivation lives beside the writer op body it mirrors;
 // plan-graph op bodies are imported directly (the barrel only re-exports plan-graph-async).
 import { applyPatchStatusSourceDerivation, bindPlanNodeBody } from "../db/plan-graph";
 import { writeTransaction } from "../db/connection";
-import { associateIssue, planNodeIssueEntityId, removeAssociation } from "../db/issue-associations";
-import { resolveIssueRefFromString } from "../db/issue-refs";
+import { planNodeIssueEntityId } from "../db/issue-associations";
+
 import { emitRelayEvent } from "../events";
 import { cleanString, cleanStringArray, optionalEnum } from "../validation";
 import { resolveActorIssueRepo } from "../agent-issue-repo";
@@ -84,67 +87,6 @@ function cleanOwnerRef(value: unknown): PlanOwnerRef | undefined {
   return Object.keys(out).length ? out : undefined;
 }
 
-// #220: a bare `#NNN` issueId ref needs a default repo to resolve against — issue-refs.ts
-// throws without one, contrary to its own error text advertising the bare form as accepted.
-// Resolve it the same way #533 resolves chat `#NNN` linkify: the CALLING agent's own project
-// (cwd → project → issueRepo), falling back to the single global env default. This scopes the
-// default to the actor's actual repo rather than guessing from teamId — agents have no
-// team→project FK; cwd is the only durable link (see agent-issue-repo.ts).
-// Shared with the Task issue-link path (#2214) via resolveActorIssueRepo.
-function cleanRefs(value: unknown, actor: string): PlanNode["refs"] | undefined {
-  if (value === undefined || value === null) return undefined;
-  const ref = cleanRecordRef(value, "refs");
-  if (!ref) return undefined;
-  const out: PlanNode["refs"] = {};
-  const issueId = cleanString(ref.issueId, "refs.issueId", { max: 1000 });
-  if (issueId) {
-    out.issueId = resolveIssueRefFromString({ ref: issueId, defaultRepo: resolveActorIssueRepo(actor) }).id;
-  }
-  // #836: refs.taskId is the live binding seam to a durable Task. Validate it resolves to a
-  // deliverable Task; store the canonical numeric id as a string. Once bound, the node's
-  // label/scopeBlurb/status PROJECT from the Task (see projectPlanOverTasks) — no double-keeping.
-  const taskIdRaw = ref.taskId;
-  const taskIdStr = typeof taskIdRaw === "number" ? String(taskIdRaw) : cleanString(taskIdRaw, "refs.taskId", { max: 240 });
-  if (taskIdStr) {
-    const taskId = parseTaskId(taskIdStr);
-    if (taskId === undefined) throw new ValidationError("refs.taskId must be a positive task id");
-    if (!getTaskDetail(taskId)) throw new ValidationError(`refs.taskId ${taskId} is not a deliverable task`);
-    out.taskId = String(taskId);
-  }
-  // agentId/landingRef remain populated by live binding in later slices (#838); reject here.
-  const unsupported = ["agentId", "landingRef"].filter((key) => cleanString(ref[key], `refs.${key}`, { max: 240 }));
-  if (unsupported.length > 0) throw new ValidationError("agentId/landingRef refs are populated by live binding in a later slice");
-  return Object.keys(out).length ? out : undefined;
-}
-
-function syncPlanNodeIssueAssociation(planId: string, node: PlanNode): void {
-  if (!node.refs?.issueId) return;
-  associateIssue(node.refs.issueId, "plan-node", planNodeIssueEntityId(planId, node.id));
-}
-
-function removePlanNodeIssueAssociation(planId: string, node: PlanNode): void {
-  if (!node.refs?.issueId) return;
-  removeAssociation(node.refs.issueId, "plan-node", planNodeIssueEntityId(planId, node.id));
-}
-
-function syncChangedPlanNodeIssueAssociation(planId: string, before: PlanNode | undefined, after: PlanNode): void {
-  if (before?.refs?.issueId && before.refs.issueId !== after.refs?.issueId) {
-    removeAssociation(before.refs.issueId, "plan-node", planNodeIssueEntityId(planId, before.id));
-  }
-  if (after.refs?.issueId) syncPlanNodeIssueAssociation(planId, after);
-}
-
-function cleanBlackboardRefs(value: unknown, planTeamId?: string): string[] | undefined {
-  const refs = cleanStringArray(value, "node.blackboardRefs", { itemMax: 120, maxItems: 100 });
-  if (!refs?.length) return refs;
-  if (!planTeamId) throw new ValidationError("plan has no team; cannot reference blackboard entries");
-  for (const ref of refs) {
-    const entry = getEntry(ref);
-    if (!entry || entry.teamId !== planTeamId) throw new ValidationError(`blackboard entry not found for plan team: ${ref}`);
-  }
-  return refs;
-}
-
 function cleanStatusSource(value: unknown): PlanNode["statusSource"] {
   const statusSource = optionalEnum(value, "statusSource", ["manual", "bound"] as const, "manual");
   return statusSource;
@@ -181,27 +123,6 @@ function applyBoundStatus(node: PlanNode): PlanNode {
   return { ...node, status: boundStatusForAgent(getAgent(agentId)) ?? "pending" };
 }
 
-function cleanNode(input: PlanNodeInput, actor: string, planTeamId?: string): PlanNode {
-  if (!isRecord(input)) throw new ValidationError("node must be an object");
-  const scopeBlurb = cleanString(input.scopeBlurb, "node.scopeBlurb", { max: 2000 });
-  const ownerRef = cleanOwnerRef(input.ownerRef);
-  const lane = cleanString(input.lane, "node.lane", { max: 120 });
-  const refs = cleanRefs(input.refs, actor);
-  const blackboardRefs = cleanBlackboardRefs(input.blackboardRefs, planTeamId);
-  const statusSource = deriveStatusSource(input.statusSource, input.status, Boolean(refs?.taskId || refs?.issueId));
-  return applyBoundStatus({
-    id: cleanString(input.id, "node.id", { required: true, max: 120 })!,
-    label: cleanString(input.label, "node.label", { required: true, max: PLAN_NODE_LABEL_MAX })!,
-    ...(scopeBlurb ? { scopeBlurb } : {}),
-    ...(ownerRef ? { ownerRef } : {}),
-    ...(lane ? { lane } : {}),
-    status: optionalEnum(input.status, "node.status", PLAN_STATUSES, "pending") as PlanStatus,
-    statusSource,
-    ...(refs ? { refs } : {}),
-    ...(blackboardRefs ? { blackboardRefs } : {}),
-  });
-}
-
 // The aggregate writer owns persisted validation (issue/task/blackboard existence and bound
 // presence).  This companion only validates shape, producing clone-safe command data.
 function cleanNodeForAggregate(input: PlanNodeInput): PlanNode {
@@ -247,14 +168,6 @@ function cleanPatchForAggregate(patch: PlanNodePatch): Partial<PlanNode> {
   return out;
 }
 
-function cleanNodes(value: unknown, actor: string, planTeamId?: string): PlanNode[] {
-  if (value === undefined || value === null) return [];
-  if (!Array.isArray(value)) throw new ValidationError("nodes must be an array");
-  const nodes = value.map((item) => cleanNode(item as PlanNodeInput, actor, planTeamId));
-  assertUnique(nodes.map((node) => node.id), "node id");
-  return nodes;
-}
-
 function cleanEdge(input: unknown): PlanEdge {
   if (!isRecord(input)) throw new ValidationError("edge must be an object");
   return {
@@ -340,19 +253,19 @@ export function emitPlan(type: "plan.created" | "plan.changed" | "plan.deleted",
 
 // #1035: a plan anchors to a messages.thread_id, but a fresh coordinator has no thread yet —
 // forcing it to send a throwaway message just to mint one. When no threadId is supplied, mint the
-// thread server-side by self-threading a lightweight system message (the same sendMessage path the
+// thread server-side by self-threading a lightweight system message (the same sendMessageAsync path the
 // caller would have used). Sent AS the actor when that agent is registered, else the reserved
 // `system` sink, so the mint always passes the sender-registration gate.
-function mintPlanThread(ctx: AuthContext, channel: string | undefined): number {
+async function mintPlanThread(ctx: AuthContext, channel: string | undefined): Promise<number> {
   ensureCanMintThread(ctx);
   const actor = actorId(ctx);
   const sender = getAgent(actor) ? actor : "system";
-  const root = sendMessage({
+  const root = (await sendMessageAsync({
     from: sender,
     to: "system",
     body: "Plan thread root",
     ...(channel ? { channel } : {}),
-  });
+  }));
   return root.threadId ?? root.id;
 }
 
@@ -364,7 +277,7 @@ async function mintPlanThreadAsync(ctx: AuthContext, channel: string | undefined
   return root.threadId ?? root.id;
 }
 
-// #1043: the mint inserts a real message row through the db `sendMessage` path, which normally
+// #1043: the mint inserts a real message row through the db `sendMessageAsync` path, which normally
 // lives behind the `message:send` scope. `plans:write` alone must not be a side-door around it, so
 // gate the mint on `message:send`. Internal `system` principals (empty-scope trusted callers) and
 // full-reach `*` tokens pass through untouched — `hasScope` short-circuits `*`.
@@ -375,78 +288,16 @@ function ensureCanMintThread(ctx: AuthContext): void {
   }
 }
 
-export function createPlan(input: PlanCreateInput, ctx: AuthContext): Plan {
-  const channel = cleanString(input.channel, "channel", { max: 120 });
-  const actor = actorId(ctx);
-  const explicitTeamId = cleanString(input.teamId, "teamId", { max: 120 });
-  const teamId = explicitTeamId ?? (input.teamId === undefined || input.teamId === null ? getAgent(actor)?.teamId : undefined);
-  const nodes = cleanNodes(input.nodes, actor, teamId);
-  const edges = cleanEdges(input.edges);
-  validateEdges(nodes, edges);
-  const title = cleanString(input.title, "title", { max: 240 });
-  const objective = cleanString(input.objective, "objective", { max: 4000 });
-  const acceptance = cleanPlanAcceptance(input.acceptance);
-  // Resolve the thread only AFTER the payload validates (#1043): auto-minting first left an orphan
-  // 'Plan thread root' row behind on every rejected create.
-  const threadId = input.threadId === undefined || input.threadId === null
-    ? mintPlanThread(ctx, channel)
-    : cleanThreadId(input.threadId);
-  if (!planThreadExists(threadId)) throw new ValidationError(`thread ${threadId} not found`);
-  const plan = createPlanRow({
-    threadId,
-    teamId,
-    channel,
-    title,
-    objective,
-    nodes,
-    edges,
-    acceptance,
-    createdBy: actor,
-  });
-  for (const node of plan.nodes) syncPlanNodeIssueAssociation(plan.id, node);
-  emitPlan("plan.created", plan, actor);
-  return plan;
+export async function createPlan(input: PlanCreateInput, ctx: AuthContext): Promise<Plan> {
+  return createPlanAsync(input, ctx);
 }
 
-export function addPlanNode(planId: string, nodeInput: PlanNodeInput, ctx: AuthContext): Plan {
-  const actor = actorId(ctx);
-  // S6 #2079: fence behind the version-CAS; re-derive the node on the freshest snapshot each attempt.
-  let node!: PlanNode;
-  const updated = replacePlanNodeScoped(planId, (plan) => {
-    node = cleanNode(nodeInput, actor, plan.teamId);
-    if (plan.nodes.some((item) => item.id === node.id)) throw new ValidationError(`node ${node.id} already exists`);
-    return { ...plan, nodes: [...plan.nodes, node] };
-  }, actor);
-  syncPlanNodeIssueAssociation(updated.id, node); emitPlan("plan.changed", updated, actor);
-  return updated;
-}
-
-export function updatePlanNode(planId: string, nodeId: string, patch: PlanNodePatch, ctx: AuthContext): Plan {
-  const actor = actorId(ctx);
-  // S6 #2079: re-apply the patch onto the latest node map (by nodeId); a distinct-node edit survives.
-  let existing!: PlanNode; let next!: PlanNode;
-  const updated = replacePlanNodeScoped(planId, (plan) => {
-    const current = plan.nodes.find((node) => node.id === nodeId);
-    if (!current) throw new ValidationError(`node ${nodeId} not found`); existing = current;
-    const statusSource = patch.statusSource !== undefined ? cleanStatusSource(patch.statusSource) : current.statusSource;
-    const base: PlanNode = {
-      ...current,
-      ...(patch.label !== undefined ? { label: cleanString(patch.label, "label", { required: true, max: PLAN_NODE_LABEL_MAX })! } : {}),
-      ...(patch.scopeBlurb !== undefined ? optionalProp("scopeBlurb", cleanString(patch.scopeBlurb, "scopeBlurb", { max: 2000 })) : {}),
-      ...(patch.ownerRef !== undefined ? optionalProp("ownerRef", cleanOwnerRef(patch.ownerRef)) : {}),
-      ...(patch.lane !== undefined ? optionalProp("lane", cleanString(patch.lane, "lane", { max: 120 })) : {}),
-      ...(patch.status !== undefined ? { status: optionalEnum(patch.status, "status", PLAN_STATUSES) as PlanStatus } : {}),
-      ...(patch.refs !== undefined ? optionalProp("refs", cleanRefs(patch.refs, actor)) : {}),
-      ...(patch.blackboardRefs !== undefined ? optionalProp("blackboardRefs", cleanBlackboardRefs(patch.blackboardRefs, plan.teamId)) : {}),
-      statusSource,
-    };
-    // #2520 RESOLUTION — the ONE shared patch-time source derivation (lives beside the writer op
-    // body it mirrors; see applyPatchStatusSourceDerivation in db/plan-graph.ts).
-    next = applyBoundStatus(applyPatchStatusSourceDerivation(patch, current, base));
-    return { ...plan, nodes: plan.nodes.map((node) => node.id === nodeId ? next : node) };
-  }, actor);
-  syncChangedPlanNodeIssueAssociation(updated.id, existing, next); emitPlan("plan.changed", updated, actor);
-  return updated;
+export async function addPlanNode(planId: string, nodeInput: PlanNodeInput, ctx: AuthContext): Promise<Plan> {
+  return addPlanNodeAsync(planId, nodeInput, ctx);
+}
+
+export async function updatePlanNode(planId: string, nodeId: string, patch: PlanNodePatch, ctx: AuthContext): Promise<Plan> {
+  return updatePlanNodeAsync(planId, nodeId, patch, ctx);
 }
 
 function optionalProp<K extends keyof PlanNode>(key: K, value: PlanNode[K] | undefined): Partial<PlanNode> {
@@ -470,72 +321,20 @@ function assertEdgeKeepsAcyclic(plan: Plan, edge: PlanEdge): void {
   validateEdges(projected.nodes, dedupeEdges([...projected.edges, edge]));
 }
 
-export function addPlanEdge(planId: string, edgeInput: unknown, ctx: AuthContext): Plan {
-  const plan = existingPlan(planId);
-  const edge = cleanEdge(edgeInput);
-  assertEdgeKeepsAcyclic(plan, edge);
-  // #836: when BOTH endpoints are Task-bound, the canonical edge store is task_dependencies,
-  // not the plan JSON. Plan edge {from,to} means `to` depends on `from`. The combined-graph
-  // pre-check above already rejected cross-store cycles; the edge surfaces back via projection.
-  const fromTask = boundTaskId(plan, edge.from);
-  const toTask = boundTaskId(plan, edge.to);
-  if (fromTask !== undefined && toTask !== undefined) {
-    addTaskDependency(toTask, fromTask, actorId(ctx));
-    const projected = projectPlanOverTasks(existingPlan(planId));
-    emitPlan("plan.changed", projected, actorId(ctx));
-    return projected;
-  }
-  // S6 #2079: fence behind the version-CAS; re-append + re-check acyclicity on the fresh snapshot.
-  const updated = replacePlanNodeScoped(planId, (fresh) => {
-    assertEdgeKeepsAcyclic(fresh, edge);
-    return { ...fresh, edges: dedupeEdges([...fresh.edges, edge]) };
-  }, actorId(ctx));
-  emitPlan("plan.changed", updated, actorId(ctx)); return updated;
+export async function addPlanEdge(planId: string, edgeInput: unknown, ctx: AuthContext): Promise<Plan> {
+  return addPlanEdgeAsync(planId, edgeInput, ctx);
 }
 
-export function removePlanNode(planId: string, nodeId: string, ctx: AuthContext): Plan {
-  const actor = actorId(ctx);
-  // S6 #2079: fence the removal behind the version-CAS; re-resolve the node on the fresh snapshot.
-  let removed!: PlanNode;
-  const updated = replacePlanNodeScoped(planId, (plan) => {
-    const current = plan.nodes.find((node) => node.id === nodeId);
-    if (!current) throw new ValidationError(`node ${nodeId} not found`); removed = current;
-    return {
-      ...plan,
-      nodes: plan.nodes.filter((node) => node.id !== nodeId),
-      edges: plan.edges.filter((edge) => edge.from !== nodeId && edge.to !== nodeId),
-    };
-  }, actor);
-  removePlanNodeIssueAssociation(updated.id, removed); emitPlan("plan.changed", updated, actor);
-  return updated;
-}
-
-export function removePlanEdge(planId: string, edgeInput: unknown, ctx: AuthContext): Plan {
-  const plan = existingPlan(planId);
-  const edge = cleanEdge(edgeInput);
-  // A bound-pair edge can live in BOTH task_dependencies and the plan JSON, and projection unions
-  // them: clear both stores or the edge reappears (#2877).
-  const fromTask = boundTaskId(plan, edge.from);
-  const toTask = boundTaskId(plan, edge.to);
-  const depRemoved = fromTask !== undefined && toTask !== undefined && removeTaskDependency(toTask, fromTask, actorId(ctx));
-  // S6 #2079: fence behind the version-CAS; re-resolve the edge (and its not-found check) on fresh.
-  const updated = replacePlanNodeScoped(planId, (fresh) => {
-    const edges = fresh.edges.filter((item) => item.from !== edge.from || item.to !== edge.to);
-    if (!depRemoved && edges.length === fresh.edges.length) throw new ValidationError(`edge ${edge.from}->${edge.to} not found`);
-    return { ...fresh, edges };
-  }, actorId(ctx));
-  const projected = projectPlanOverTasks(updated);
-  emitPlan("plan.changed", projected, actorId(ctx));
-  return projected;
-}
-
-export function deletePlanGraph(planId: string, ctx: AuthContext): { id: string; deleted: true } {
-  const plan = existingPlan(planId);
-  const actor = actorId(ctx);
-  deletePlan(plan.id, actor);
-  for (const node of plan.nodes) removePlanNodeIssueAssociation(plan.id, node);
-  emitPlan("plan.deleted", plan, actor);
-  return { id: plan.id, deleted: true };
+export async function removePlanNode(planId: string, nodeId: string, ctx: AuthContext): Promise<Plan> {
+  return (await removePlanNodeAsync(planId, nodeId, ctx)).plan;
+}
+
+export async function removePlanEdge(planId: string, edgeInput: unknown, ctx: AuthContext): Promise<Plan> {
+  return removePlanEdgeAsync(planId, edgeInput, ctx);
+}
+
+export async function deletePlanGraph(planId: string, ctx: AuthContext): Promise<{ id: string; deleted: true }> {
+  return deletePlanGraphAsync(planId, ctx);
 }
 
 export async function archivePlanGraphAsync(planId: string, archived: boolean, ctx: AuthContext): Promise<Plan> {
@@ -547,29 +346,12 @@ export async function archivePlanGraphAsync(planId: string, archived: boolean, c
 
 // In-process (legacy/unit-test) sibling of the gateway-backed applyBoundOwnersAsync path (production
 // never takes this branch). S6 #2079: fence each write behind the version-CAS; re-derive on fresh.
-export function updateBoundPlanNodesForAgent(agentId: string, status: PlanStatus, actor = "server"): Plan[] {
-  const boundFlip = (node: PlanNode): boolean =>
-    node.statusSource === "bound" && node.ownerRef?.agentId === agentId && node.status !== "landed" && node.status !== status;
-  const updated: Plan[] = [];
-  for (const plan of listPlansWithBoundOwner(agentId)) {
-    // Skip-no-op on the initial snapshot: don't even fence a write when there's nothing to flip.
-    if (!plan.nodes.some(boundFlip)) continue;
-    // Preserve that contract THROUGH a CAS-conflict retry: if a re-read snapshot no longer needs a
-    // flip (a concurrent writer already applied it), return null so no version bump / event fires.
-    let wrote = false;
-    const next = replacePlanNodeScoped(plan.id, (fresh) => {
-      wrote = fresh.nodes.some(boundFlip);
-      return wrote ? { ...fresh, nodes: fresh.nodes.map((node) => (boundFlip(node) ? { ...node, status } : node)) } : null;
-    }, actor);
-    if (!wrote) continue; // the retry resolved to a no-op — nothing was written, so don't emit/collect
-    emitPlan("plan.changed", next, actor); updated.push(next);
-  }
-  return updated;
+export async function updateBoundPlanNodesForAgent(agentId: string, status: PlanStatus, actor = "server"): Promise<Plan[]> {
+  return updateBoundPlanNodesForAgentAsync(agentId, status, actor);
 }
 
-export function updateBoundPlanNodesFromAgent(agentId: string, actor = "server"): Plan[] {
-  const status = boundStatusForAgent(getAgent(agentId));
-  return status ? updateBoundPlanNodesForAgent(agentId, status, actor) : [];
+export async function updateBoundPlanNodesFromAgent(agentId: string, actor = "server"): Promise<Plan[]> {
+  return updateBoundPlanNodesFromAgentAsync(agentId, boundStatusForAgent(getAgent(agentId)), actor);
 }
 
 /** Gateway-only live-binding path. The read precheck avoids submitting a no-op writer job. */
@@ -581,7 +363,7 @@ export async function updateBoundPlanNodesForAgentAsync(agentId: string, status:
 }
 
 export async function updateBoundPlanNodesFromAgentAsync(agentId: string, status: PlanStatus | undefined, actor = "server"): Promise<Plan[]> {
-  return status ? updateBoundPlanNodesForAgentAsync(agentId, status, actor) : [];
+  return status ? (await updateBoundPlanNodesForAgentAsync(agentId, status, actor)) : [];
 }
 
 // #836: `view: "tasks"` returns the pure task-backed DAG synthesized from a team's deliverable
@@ -623,12 +405,8 @@ export interface BindPlanNodeInput {
   taskId?: number;
 }
 
-export function bindPlanNodeToTask(planId: string, nodeId: string, input: BindPlanNodeInput, ctx: AuthContext): { plan: Plan; taskId: number } {
-  const actor = actorId(ctx);
-  const result = writeTransaction(() => bindPlanNodeBody({ planId, nodeId, taskId: input.taskId, actor }, Date.now()));
-  emitPlan("plan.changed", result.plan, actor);
-  emitPlanTaskEvents(result.taskEvents);
-  return { plan: result.plan, taskId: result.taskId! };
+export async function bindPlanNodeToTask(planId: string, nodeId: string, input: BindPlanNodeInput, ctx: AuthContext): Promise<{ plan: Plan; taskId: number }> {
+  return bindPlanNodeToTaskAsync(planId, nodeId, input, ctx);
 }
 
 // HTTP and MCP can await. Keep the synchronous entry points above for the event reducers and
@@ -698,6 +476,6 @@ export async function bindPlanNodeToTaskAsync(planId: string, nodeId: string, in
   // The aggregate ack is after COMMIT. Emit every consumer-facing task intent only here,
   // never from the worker, so failed aggregate writes are observably silent.
   emitPlan("plan.changed", result.plan, actor);
-  emitPlanTaskEvents(result.taskEvents);
+  await emitPlanTaskEvents(result.taskEvents);
   return { plan: result.plan, taskId: result.taskId! };
 }

package/src/services/plan-import.ts

@@ -60,7 +60,7 @@ export async function importPlan(input: Record<string, unknown>, ctx: AuthContex
   const { dryRun, ...args } = preparePlanImport(input, ctx);
   if (dryRun) return await getGateway().read("planGraph.import.preview", args) as unknown as PlanImportResult;
   const result = await getGateway().write("planGraph.import", args) as unknown as PlanImportWriteResult;
-  emitPlanTaskEvents(result.taskEvents);
+  await emitPlanTaskEvents(result.taskEvents);
   if (result.plan) emitPlan(args.expectedVersion === 0 ? "plan.created" : "plan.changed", result.plan, args.actor);
   return result.receipt;
 }

package/src/services/plan-live-bindings.ts

@@ -1,8 +1,9 @@
-import { getTeam, getTeamAsync } from "../db";
-import { getGateway } from "../db/gateway";
+import { updateBoundPlanNodesFromAgentAsync, updateBoundPlanNodesForAgentAsync } from "./plan-graph";
+import { getTeamAsync } from "../db";
+import { trackRelayEvent } from "../relay-event-drain";
 import { subscribeRelayEvents, type RelayEvent } from "../events";
 import { routeNotification } from "../notification-router";
-import { updateBoundPlanNodesForAgent, updateBoundPlanNodesForAgentAsync, updateBoundPlanNodesFromAgent, updateBoundPlanNodesFromAgentAsync } from "./plan-graph";
+
 
 let unsubscribe: (() => void) | undefined;
 
@@ -48,7 +49,7 @@ async function notifyBoundExit(event: RelayEvent, updatedPlans: Awaited<ReturnTy
     const target = team?.coordinatorId ?? `team:${plan.teamId}`;
     const blockedNodes = plan.nodes.filter((node) => node.statusSource === "bound" && node.ownerRef?.agentId === agentId && node.status === "blocked");
     if (blockedNodes.length === 0) continue;
-    routeNotification({
+    await routeNotification({
       type: "plan.bound_agent_exited",
       scope: { agentId, planId: plan.id, teamId: plan.teamId },
       recipients: [target],
@@ -92,39 +93,9 @@ async function handlePlanBindingEventAsync(event: RelayEvent): Promise<void> {
 }
 
 function handlePlanBindingEvent(event: RelayEvent): void {
-  // The in-process backend exists only for legacy/unit tests. Keep its old synchronous reducer
-  // contract so these tests do not accidentally test scheduling; worker-backed production never
-  // takes this branch and has no event-loop SQLite access.
-  if (getGateway().stats.backend === "in-process") {
-    if (event.type === "agent.status") {
-      const agentId = agentIdFromEvent(event);
-      if (agentId) updateBoundPlanNodesFromAgent(agentId, event.source || "server");
-      return;
-    }
-    if (event.type === "branch.landed") {
-      const agentId = stringField(event.data.author);
-      if (agentId) updateBoundPlanNodesForAgent(agentId, "landed", event.source || "server");
-      return;
-    }
-    if (event.type === "agent.exited") {
-      const agentId = agentIdFromEvent(event);
-      if (!agentId || isGracefulExitReason(stringField(event.data.reason))) return;
-      const updated = updateBoundPlanNodesForAgent(agentId, "blocked", event.source || "server");
-      const reason = stringField(event.data.reason);
-      for (const plan of updated) {
-        if (!plan.teamId) continue;
-        const team = getTeam(plan.teamId);
-        const nodes = plan.nodes.filter((node) => node.statusSource === "bound" && node.ownerRef?.agentId === agentId && node.status === "blocked");
-        if (nodes.length) routeNotification({ type: "plan.bound_agent_exited", scope: { agentId, planId: plan.id, teamId: plan.teamId }, recipients: [team?.coordinatorId ?? `team:${plan.teamId}`], message: { subject: "Bound plan node blocked", body: `Agent \`${agentId}\` exited${reason ? ` (${reason})` : ""}; blocked plan node(s) ${nodes.map((node) => `\`${node.id}\``).join(", ")} in \`${plan.id}\`.`, payload: { kind: "plan.bound_agent_exited", planId: plan.id, agentId, nodeIds: nodes.map((node) => node.id), reason }, replyExpected: false } });
-      }
-      return;
-    }
-  }
-  // Event listeners are synchronous. Serialize the asynchronous aggregate submissions so an
-  // agent's rapid status sequence reaches the FIFO writer in event order.
-  pending = pending.then(() => handlePlanBindingEventAsync(event)).catch((error) => {
-    console.error("plan live binding update failed", error);
-  });
+  const run = pending.then(() => handlePlanBindingEventAsync(event));
+  pending = run.catch(() => {});
+  trackRelayEvent(run, "plan.live-binding");
 }
 
 export function startPlanLiveBindings(): void {

package/src/services/plan-task-create.ts

@@ -72,7 +72,7 @@ export async function createPlanTaskAsync(input: CreateTaskEntityInput, extras:
   };
   // The caller's key makes a retry return the first result instead of a second Task or node.
   const result = await getGateway().write("planGraph.task.create", args, { idempotencyKey: options.idempotencyKey ?? randomUUID() }) as unknown as CreatePlanTaskResult;
-  emitPlanTaskEvents(result.taskEvents);
+  await emitPlanTaskEvents(result.taskEvents);
   if (result.plan) emitPlan("plan.changed", result.plan, createdBy);
   // A replay returns the first write's result; the receipt reads the Task as it is now.
   const task = await getTaskDetailAsync(result.task.id) ?? result.task;