@sema-agent/core 1.452.0 → 2.0.0

package/dist/core/task-registry.js

@@ -1,94 +1,29 @@
 import { randomBytes } from "node:crypto";
-import { Type } from "typebox";
-import { uuidv7 } from "../internal/harness.js";
 import { defineTool, errorResult } from "./tools.js";
 import { hasBackgroundShell } from "./background-shell.js";
 import { shutdownDebug } from "./shutdown-debug.js";
-import { summarizeWorkflowRun } from "./workflow-run-store.js";
-import { canAccessAgentRecord, BackgroundAgentStoreError, } from "./background-agent-store.js";
+import { canAccessAgentRecord, } from "./background-agent-store.js";
 import { delimitUntrusted } from "./untrusted-text.js";
-import { boundedRedactedSummary } from "./untrusted-egress.js";
-import { clipWithFilePointer } from "./tool-errors.js";
-function mintCompletionId(target) {
-    if (target.completionId === undefined)
-        target.completionId = uuidv7();
-    return target.completionId;
-}
-function commitCompletionIdIfEmpty(target, value) {
-    if (target.completionId === undefined)
-        target.completionId = value;
-    return target.completionId;
-}
-const defaultMonitorTimers = {
-    setInterval: (fn, ms) => {
-        const h = setInterval(() => void fn(), ms);
-        h.unref?.();
-        return h;
-    },
-    clearInterval: (h) => clearInterval(h),
-    now: () => Date.now(),
-};
+import { registerMonitorLane, pollMonitorLane, stopMonitorLane } from "./task-registry-monitor.js";
+import { registerWorkflowLane, pollWorkflowLane, stopWorkflowLane } from "./task-registry-workflow.js";
+import { mintCompletionId, canAccessWorkflowRun, formatWorkflowRun, clipTaskOutput, assertOwnership, sleepPollStep, statusFromBackground, rollSpoolText, accountDroppedBytes, droppedGapNote, alreadyTerminalStopNote, TASK_OUTPUT_MAX_CHARS, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE, canAccess, DURABLE_AGENT_HANDLE_RE, } from "./task-registry-shared.js";
+export { normalizeAgentName, DURABLE_AGENT_HEARTBEAT_MS, DURABLE_AGENT_HANDLE_RE, BG_AGENT_REAP_STOP_ERROR } from "./task-registry-shared.js";
+import { TASK_OUTPUT_TOOL_NAME, TASK_STOP_TOOL_NAME, TASK_OUTPUT_ALIASES, TASK_STOP_ALIASES, TASK_OUTPUT_CONTRACT, TASK_STOP_CONTRACT, TASK_OUTPUT_MISSING_ID_MESSAGE, TASK_STOP_MISSING_ID_MESSAGE, TASK_STOP_PARAMS, resolveTaskIdArg, REGISTRY_TASK_TOOL_CAPS, composeTaskOutputDescription, composeTaskOutputParams, composeTaskStopDescription, } from "./task-tool-shape.js";
+import { durableAgentArmedLane, durableAgentRowProbeLane, beginDurableClaimLane, endDurableClaimLane, reapDurableAgentsLane, releaseDurableTranscriptAnchorLane, bindBackgroundAgentSessionLane, registerBackgroundAgentLane, parkBackgroundAgentLane, reconcileParkedAgentsLane, claimParkedAgentLane, rollbackParkedClaimLane, consumeParkedFlipLane, finalizeParkedResumeLane, settleBackgroundAgentLane, abortBackgroundAgentsForOwnerLane, serveDurableAgentRowLane, resolveBackgroundAgentByNameLane, markRetainedContinuationLane, reviveBackgroundAgentLane, settleRevivedAgentLane, unmarkRetainedContinuationLane, attachAgentNotifyLane, deliverToRunningAgentLane, runningBackgroundAgentLabelsLane, pollBackgroundAgentLane, stopBackgroundAgentLane, } from "./task-registry-agent.js";
+export { canAccessWorkflowRun, clipTaskOutput, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE };
 const BLOCK_DEFAULT_TIMEOUT_MS = 30_000;
 const BLOCK_MAX_TIMEOUT_MS = 600_000;
-const BLOCK_POLL_INTERVAL_MS = 400;
 function blockDeadline(timeoutMs, now) {
     const t = Math.min(BLOCK_MAX_TIMEOUT_MS, Math.max(1, Math.floor(timeoutMs ?? BLOCK_DEFAULT_TIMEOUT_MS)));
     return now + t;
 }
-const sleepPollStep = (deadline, signal) => sleepMs(deadline === undefined ? BLOCK_POLL_INTERVAL_MS : Math.max(1, Math.min(BLOCK_POLL_INTERVAL_MS, deadline - Date.now())), signal);
-const sleepMs = (ms, signal) => new Promise((resolve) => {
-    const t = setTimeout(done, ms);
-    function done() {
-        clearTimeout(t);
-        signal?.removeEventListener("abort", done);
-        resolve();
-    }
-    signal?.addEventListener("abort", done, { once: true });
-});
 const BLOCK_WAIT_WRITEOUT_RESERVE_MS = 5_000;
-export const DURABLE_AGENT_HEARTBEAT_MS = 60_000;
-export const DURABLE_AGENT_HANDLE_RE = /^a[0-9a-f]{6,32}$/;
 const TASK_PREFIX = {
     background_bash: "b",
     workflow: "w",
     background_agent: "a",
     monitor: "m",
 };
-export const BG_AGENT_REAP_STOP_ERROR = "stopped (parent task ended or TaskStop)";
-export const MONITOR_BATCH_WINDOW_MS = 200;
-export const MONITOR_DEFAULT_TIMEOUT_MS = 300_000;
-export const MONITOR_MAX_TIMEOUT_MS = 3_600_000;
-export const MONITOR_MAX_BATCHES_PER_MINUTE = 50;
-const MONITOR_EVENT_RESULT_CAP = 2_000;
-function clipMonitorEvent(s) {
-    return s.length <= MONITOR_EVENT_RESULT_CAP ? s : `${s.slice(0, MONITOR_EVENT_RESULT_CAP)}\n…[+${s.length - MONITOR_EVENT_RESULT_CAP} chars truncated]`;
-}
-const TASK_OUTPUT_DEFAULT_CHARS = 32_000;
-const TASK_OUTPUT_MAX_CHARS = 160_000;
-const TASK_OUTPUT_ALIASES = ["BashOutput", "AgentOutputTool", "BashOutputTool", "AgentOutput", "WorkflowStatus"];
-const TASK_STOP_ALIASES = ["KillShell", "KillBash"];
-const TASK_OUTPUT_MIN_CHARS = 512;
-function taskMaxOutputChars() {
-    const raw = process.env.TASK_MAX_OUTPUT_LENGTH;
-    if (!raw)
-        return TASK_OUTPUT_DEFAULT_CHARS;
-    if (!/^\d+$/.test(raw.trim()))
-        return TASK_OUTPUT_DEFAULT_CHARS;
-    const n = parseInt(raw.trim(), 10);
-    if (!Number.isFinite(n) || n <= 0)
-        return TASK_OUTPUT_DEFAULT_CHARS;
-    return Math.min(Math.max(n, TASK_OUTPUT_MIN_CHARS), TASK_OUTPUT_MAX_CHARS);
-}
-export function clipTaskOutput(s, fullOutputPath) {
-    return clipWithFilePointer(s, taskMaxOutputChars(), fullOutputPath);
-}
-function firstString(...values) {
-    for (const value of values) {
-        if (typeof value === "string" && value.trim() !== "")
-            return value.trim();
-    }
-    return undefined;
-}
 function noTask(taskId) {
     return {
         content: JSON.stringify({ error: "task not found" }),
@@ -96,49 +31,6 @@ function noTask(taskId) {
         isError: true,
     };
 }
-export function normalizeAgentName(s) {
-    return s
-        .normalize("NFKC")
-        .replace(/[\p{Cc}\p{Cf}]/gu, (t) => (/\s/.test(t) ? t : ""))
-        .trim()
-        .toLowerCase()
-        .replace(/\s+/g, "-");
-}
-function editDistance(a, b) {
-    if (a === b)
-        return 0;
-    const m = a.length;
-    const n = b.length;
-    const d = Array.from({ length: m + 1 }, (_, i) => Array.from({ length: n + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)));
-    for (let i = 1; i <= m; i++) {
-        for (let j = 1; j <= n; j++) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
-            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
-                d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
-            }
-        }
-    }
-    return d[m][n];
-}
-function closestName(query, candidates) {
-    let best;
-    let bestDist = 3;
-    const seen = new Set();
-    for (const c of candidates) {
-        if (seen.has(c))
-            continue;
-        seen.add(c);
-        if (Math.abs(c.length - query.length) > 2)
-            continue;
-        const dist = editDistance(query, c);
-        if (dist <= 2 && dist < bestDist) {
-            bestDist = dist;
-            best = c;
-        }
-    }
-    return best;
-}
 function noTaskForStop(taskId, enrich) {
     let content = `No task found with ID: ${taskId}`;
     if (enrich?.suggestion !== undefined)
@@ -156,427 +48,120 @@ function bashTerminalResult(spool) {
     const err = spool.stderr.slice(-2_000);
     return err.length > 0 ? `${out}${out.length > 0 ? "\n" : ""}--- stderr (tail) ---\n${err}` : out;
 }
-function statusFromBackground(status, exitCode) {
-    if (status === "running")
-        return "running";
-    if (status === "killed")
-        return "killed";
-    if (status === "failed")
-        return "failed";
-    if (status === "exited")
-        return exitCode === 0 ? "completed" : "failed";
-    return "failed";
-}
-function rollSpoolText(spool, s, cap) {
-    if (s.length <= cap)
-        return s;
-    const half = Math.floor(cap / 2);
-    spool.rolledChars += s.length - 2 * half;
-    return s.slice(0, half) + s.slice(s.length - half);
-}
 function bashMirrorGapNote(handle) {
     return handle.outputFile !== undefined && handle.spool?.mirrorFailed === true
         ? " [!] The output file is INCOMPLETE (one or more writes to it failed) — trust the result text / TaskOutput over the file."
         : "";
 }
-function accountDroppedBytes(spool, poll) {
-    const d = poll.bytesDroppedBeforeCursor ?? 0;
-    if (d > 0)
-        spool.droppedBytes = (spool.droppedBytes ?? 0) + d;
-    else if (poll.truncated === true)
-        spool.dropUnknown = true;
-}
-function droppedGapNote(spool) {
-    if ((spool.droppedBytes ?? 0) > 0)
-        return ` [!] ${spool.droppedBytes} earlier byte(s) of output were permanently dropped before this window (execution-environment tail buffer evicted) — the event stream and this spool are INCOMPLETE.`;
-    if (spool.dropUnknown === true)
-        return " [!] An unknown amount of earlier output was permanently dropped before this window (execution-environment tail buffer evicted) — the event stream and this spool are INCOMPLETE.";
-    return "";
-}
-function firstDropNote(spool) {
-    if (spool.dropNotified === true)
-        return "";
-    const note = droppedGapNote(spool);
-    if (note !== "")
-        spool.dropNotified = true;
-    return note;
-}
-function alreadyTerminalStopNote(id, status) {
-    return `${id} already ${status} — nothing to stop; poll TaskOutput for its final state.`;
-}
 function monitorInTimeoutWindow(handle) {
     return handle.status === "running" && handle.deadlineAt !== undefined && handle.timers.now() < handle.deadlineAt;
 }
-function canAccess(handle, access) {
-    if (handle.scope === undefined || access.scope === undefined || access.scope !== handle.scope)
-        return false;
-    if (handle.owner === undefined)
-        return false;
-    if (access.owner === handle.owner)
-        return true;
-    if (handle.sessionScoped && access.sessionId !== undefined && access.sessionId === handle.owner)
-        return true;
-    if (handle.type === "workflow" && access.sessionId !== undefined && handle.originatingSessionId === access.sessionId)
-        return true;
-    return false;
-}
-function assertOwnership(input, site) {
-    if (input.owner === undefined || input.scope === undefined) {
-        throw new Error(`TaskRegistry.${site}: owner AND scope are both required (access is default-deny on both axes; use scope "default" for a single-tenant deployment)`);
-    }
-}
-export function canAccessWorkflowRun(run, access) {
-    if (access.scope === undefined || run.scope !== access.scope)
-        return false;
-    if (access.owner !== undefined && run.sourceTaskId !== undefined && run.sourceTaskId === access.owner)
-        return true;
-    if (access.sessionId !== undefined && run.originatingSessionId !== undefined && run.originatingSessionId === access.sessionId)
-        return true;
-    return false;
-}
-const WORKFLOW_PARTIAL_RESULTS_MAX = 5;
-const WORKFLOW_AGENT_ROWS_MAX = 60;
-function workflowAgentRow(a, ordinal) {
-    return {
-        ordinal,
-        label: a.label,
-        ...(a.phase !== undefined ? { phase: a.phase } : {}),
-        status: a.status,
-        ...(a.errorCode !== undefined ? { errorCode: a.errorCode } : {}),
-        ...(a.errorMessage !== undefined
-            ? { error: delimitUntrusted(`workflow agent ${a.label} error`, boundedRedactedSummary(a.errorMessage, 200)) }
-            : {}),
-        ...(a.startedAt !== undefined && a.endedAt !== undefined ? { elapsedMs: a.endedAt - a.startedAt } : {}),
-        ...(a.replayed === true ? { replayed: true } : {}),
-    };
-}
-function formatWorkflowRun(run) {
-    const summary = summarizeWorkflowRun(run);
-    const done = run.agents.filter((a) => a.status === "completed" || a.status === "failed").length;
-    const failed = run.agents.filter((a) => a.status === "failed").length;
-    const allRows = run.agents.map((a, i) => ({ a, i }));
-    const overCap = allRows.length > WORKFLOW_AGENT_ROWS_MAX;
-    const keptRows = overCap
-        ? (() => {
-            const urgent = allRows.filter((r) => r.a.status !== "completed");
-            const budget = Math.max(0, WORKFLOW_AGENT_ROWS_MAX - urgent.length);
-            const fill = allRows.filter((r) => r.a.status === "completed").slice(0, budget);
-            return [...urgent, ...fill].sort((x, y) => x.i - y.i);
-        })()
-        : allRows;
-    const agentRows = keptRows.map((r) => workflowAgentRow(r.a, r.i));
-    const finishedAgents = run.status === "failed" ? run.agents.filter((a) => a.status === "completed" && a.output !== undefined && a.output !== "") : [];
-    return {
-        content: JSON.stringify({
-            task_id: run.id,
-            runId: run.id,
-            type: "workflow",
-            status: run.status,
-            ...(summary.name ? { name: summary.name } : {}),
-            ...(summary.currentPhase ? { currentPhase: summary.currentPhase } : {}),
-            agents: { done, total: run.agents.length, failed },
-            agent_runs: agentRows,
-            ...(overCap ? { agent_runs_note: `showing ${agentRows.length} of ${run.agents.length} agent rows (every non-completed row kept; completed rows trimmed).` } : {}),
-            startedAt: run.startedAt,
-            ...(run.endedAt !== undefined ? { endedAt: run.endedAt, elapsedMs: run.endedAt - run.startedAt } : {}),
-            ...(run.resume !== undefined
-                ? {
-                    resume: {
-                        from_run_id: run.resume.fromRunId,
-                        journal_entries: run.resume.journalEntries,
-                        replayed: run.resume.replayed,
-                        ...(run.resume.divergedAtOrdinal !== undefined
-                            ? { replay_stopped_at: run.resume.divergedAtOrdinal, replay_stopped_reason: run.resume.divergedReason }
-                            : {}),
-                    },
-                }
-                : {}),
-            ...(run.journalSkips !== undefined && run.journalSkips > 0 ? { journal_skipped: run.journalSkips } : {}),
-            ...(run.status === "failed" && run.error ? { error: delimitUntrusted("workflow error", boundedRedactedSummary(run.error, 500)) } : {}),
-            ...(run.status === "completed" && run.result !== undefined
-                ? { result: delimitUntrusted("workflow result", run.resultFull ?? run.result) }
-                : {}),
-            ...(finishedAgents.length > 0
-                ? {
-                    partial_results: finishedAgents.slice(0, WORKFLOW_PARTIAL_RESULTS_MAX).map((a) => ({
-                        agent: a.label,
-                        output: delimitUntrusted(`workflow agent ${a.label} output`, a.output),
-                    })),
-                    ...(finishedAgents.length > WORKFLOW_PARTIAL_RESULTS_MAX
-                        ? { partial_results_note: `showing ${WORKFLOW_PARTIAL_RESULTS_MAX} of ${finishedAgents.length} completed agent outputs; the full set remains retrievable from the workflow run record (getWorkflowRun / the workflow journal).` }
-                        : {}),
-                }
-                : {}),
-            note: run.status === "running"
-                ? "still running — poll again shortly."
-                : run.status === "completed"
-                    ? run.result !== undefined
-                        ? "completed — `result` above is the workflow's return value."
-                        : "completed — this run predates result persistence; its result was delivered on the completion notification."
-                    : finishedAgents.length > 0
-                        ? `failed — see error. ${finishedAgents.length} agent(s) had already completed before the run ended; their outputs are inlined under \`partial_results\`.`
-                        : "failed — see error.",
-        }),
-        details: {
-            task_id: run.id,
-            type: "workflow",
-            status: run.status,
-            retrieval_status: "success",
-            ...(run.completionId !== undefined ? { completionId: run.completionId } : {}),
-            details: summary,
-        },
-    };
-}
 export class TaskRegistry {
     handles = new Map();
     sessionReapHooks = new Set();
     bgQuiescenceWatchers = new Map();
     legacyToTaskId = new Map();
-    writerId = randomBytes(8).toString("hex");
-    reapingHandles = new Set();
-    claimingHandles = new Set();
-    durableHeartbeatTimer;
-    ensureDurableHeartbeat() {
-        if (this.durableHeartbeatTimer !== undefined)
-            return;
-        const t = setInterval(() => {
-            let liveLanes = 0;
-            for (const h of this.handles.values()) {
-                if (h.type !== "background_agent")
-                    continue;
-                const bh = h;
-                if (!bh.durable || bh.durable.poisoned)
-                    continue;
-                if (bh.status === "running") {
-                    liveLanes++;
-                    this.durableAgentWrite(bh, {});
-                }
-                else if (bh.durable.flushFailed) {
-                    if ((bh.durable.redrives = (bh.durable.redrives ?? 0) + 1) > 60) {
-                        bh.durable.poisoned = true;
-                        process.emitWarning(`sema durable-agents: terminal flush for ${bh.durable.record.handle} unrecoverable after 60 heartbeat re-drives — durable writes for this row stop here`);
-                        continue;
-                    }
-                    liveLanes++;
-                    this.durableAgentWrite(bh, {});
-                }
-            }
-            if (liveLanes === 0) {
-                clearInterval(t);
-                this.durableHeartbeatTimer = undefined;
-            }
-        }, DURABLE_AGENT_HEARTBEAT_MS);
-        t.unref?.();
-        this.durableHeartbeatTimer = t;
-    }
-    durableAgentWrite(handle, patch, clear) {
-        const lane = handle.durable;
-        if (!lane || lane.poisoned)
-            return;
-        lane.chain = lane.chain.then(async () => {
-            if (lane.poisoned)
-                return;
-            Object.assign(lane.record, patch);
-            if (clear !== undefined)
-                for (const k of clear)
-                    delete lane.record[k];
-            lane.record.updatedAt = Date.now();
-            const poison = (why) => {
-                lane.poisoned = true;
-                process.emitWarning(`sema durable-agents: ${why} for ${lane.record.handle} — durable writes for this row stop here`);
-            };
-            const adoptOwnRow = async () => {
-                try {
-                    const live = await lane.store.get(lane.record.handle, lane.record.scope);
-                    if (!live)
-                        return "gone";
-                    if (live.writerId !== lane.record.writerId)
-                        return "foreign";
-                    if (live.writerEpoch !== lane.record.writerEpoch)
-                        return "foreign";
-                    lane.record.rev = live.rev;
-                    lane.written = true;
-                    return "adopted";
-                }
-                catch {
-                    return "unreadable";
-                }
-            };
-            for (let attempt = 0; attempt < 3; attempt++) {
-                if (lane.poisoned)
-                    return;
-                if (attempt > 0) {
-                    await new Promise((r) => {
-                        const t = setTimeout(r, 50 * attempt);
-                        t.unref?.();
-                    });
-                }
-                try {
-                    if (!lane.written) {
-                        await lane.store.put(structuredClone(lane.record));
-                        lane.written = true;
-                        lane.flushFailed = false;
-                        lane.redrives = 0;
-                        return;
-                    }
-                    const ok = await lane.store.update(lane.record.handle, lane.record.scope, structuredClone(lane.record), {
-                        rev: lane.record.rev,
-                    });
-                    if (ok) {
-                        lane.record.rev += 1;
-                        lane.flushFailed = false;
-                        lane.redrives = 0;
-                        return;
-                    }
-                    const verdict = await adoptOwnRow();
-                    if (lane.poisoned)
-                        return;
-                    if (verdict === "adopted")
-                        continue;
-                    if (verdict === "unreadable")
-                        continue;
-                    poison(verdict === "gone" ? "row reaped mid-write" : "CAS lost to a foreign writer");
-                    return;
-                }
-                catch (e) {
-                    if (e instanceof BackgroundAgentStoreError && e.code === "agent_record.already_exists") {
-                        const verdict = await adoptOwnRow();
-                        if (lane.poisoned)
-                            return;
-                        if (verdict === "adopted")
-                            continue;
-                        if (verdict === "unreadable")
-                            continue;
-                        if (verdict === "gone")
-                            continue;
-                        poison("handle collision (foreign durable row left untouched)");
-                        return;
-                    }
-                    shutdownDebug(`durable-agents write failed for ${lane.record.handle} (attempt ${attempt + 1}/3)`, { error: String(e) });
-                }
-            }
-            lane.flushFailed = true;
-        });
-    }
+    core = (() => {
+        const self = this;
+        return {
+            handles: self.handles,
+            mintTaskId: (type) => self.mintTaskId(type),
+            markStopSource: (id, source) => self.markStopSource(id, source),
+            notifyTerminalOnce: (handle, send) => self.notifyTerminalOnce(handle, send),
+            pokeBgQuiescence: (owner) => self.pokeBgQuiescence(owner),
+            get writerId() { return self.writerId; },
+            get reapingHandles() { return self.reapingHandles; },
+            get claimingHandles() { return self.claimingHandles; },
+            get durableHeartbeatTimer() { return self.durableHeartbeatTimer; },
+            set durableHeartbeatTimer(v) { self.durableHeartbeatTimer = v; },
+            get deliverConfirmTimeoutMs() { return self.deliverConfirmTimeoutMs; },
+        };
+    })();
     durableAgentArmed(id) {
-        const h = this.handles.get(id);
-        if (!h || h.type !== "background_agent")
-            return false;
-        const lane = h.durable;
-        return lane !== undefined && !lane.poisoned;
+        return durableAgentArmedLane(this.core, id);
     }
     durableAgentRowProbe(id) {
-        const h = this.handles.get(id);
-        if (!h || h.type !== "background_agent")
-            return undefined;
-        const lane = h.durable;
-        if (!lane)
-            return undefined;
-        return async () => {
-            await lane.chain.catch(() => undefined);
-            return lane.written && !lane.poisoned && !lane.flushFailed;
-        };
+        return durableAgentRowProbeLane(this.core, id);
     }
     beginDurableClaim(id) {
-        const live = this.handles.get(id);
-        if (live !== undefined && (live.status === "running" || live.status === "pending"))
-            return false;
-        if (this.reapingHandles.has(id) || this.claimingHandles.has(id))
-            return false;
-        this.claimingHandles.add(id);
-        return true;
+        return beginDurableClaimLane(this.core, id);
     }
     endDurableClaim(id) {
-        this.claimingHandles.delete(id);
+        return endDurableClaimLane(this.core, id);
     }
     async reapDurableAgents(scope, deps, policy) {
-        const now = policy.now ?? Date.now();
-        if (policy.staleRunningMaxAgeMs !== undefined) {
-            await deps.store.reap(scope, now, { staleRunningMaxAgeMs: policy.staleRunningMaxAgeMs });
-        }
-        if (policy.maxAgeMs === undefined && policy.keep === undefined)
-            return { rowsReaped: 0, sessionsReleased: 0, skippedNoSessions: 0 };
-        const terminal = (await deps.store.listByScope(scope)).filter((r) => r.status !== "running" && r.status !== "parked");
-        terminal.sort((a, b) => b.spawnedAt - a.spawnedAt);
-        const doomed = new Map();
-        if (policy.maxAgeMs !== undefined) {
-            for (const r of terminal) {
-                if ((r.settledAt ?? r.spawnedAt) < now - policy.maxAgeMs)
-                    doomed.set(r.handle, r);
-            }
-        }
-        if (policy.keep !== undefined) {
-            for (const r of terminal.slice(Math.max(0, policy.keep)))
-                doomed.set(r.handle, r);
-        }
-        let rowsReaped = 0;
-        let sessionsReleased = 0;
-        let skippedNoSessions = 0;
-        for (const r of doomed.values()) {
-            if (this.claimingHandles.has(r.handle))
-                continue;
-            this.reapingHandles.add(r.handle);
-            try {
-                let live;
-                try {
-                    live = await deps.store.get(r.handle, scope);
-                }
-                catch {
-                    continue;
-                }
-                if (!live || live.status === "running" || live.status === "parked")
-                    continue;
-                const inProc = this.handles.get(r.handle);
-                if (inProc !== undefined && (inProc.status === "running" || inProc.status === "pending" || inProc.status === "parked"))
-                    continue;
-                if (live.sessionId !== undefined && deps.sessions === undefined) {
-                    skippedNoSessions++;
-                    continue;
-                }
-                try {
-                    if (!(await deps.store.delete(r.handle, scope, { rev: live.rev })))
-                        continue;
-                }
-                catch {
-                    continue;
-                }
-                rowsReaped++;
-                if (deps.mailbox !== undefined) {
-                    try {
-                        await deps.mailbox.drop(scope, r.handle);
-                    }
-                    catch {
-                    }
-                }
-                if (live.sessionId !== undefined && deps.sessions !== undefined) {
-                    try {
-                        await deps.sessions.unpin?.(live.sessionId);
-                        await deps.sessions.release(live.sessionId);
-                        sessionsReleased++;
-                    }
-                    catch {
-                    }
-                }
-            }
-            finally {
-                this.reapingHandles.delete(r.handle);
-            }
-        }
-        return { rowsReaped, sessionsReleased, skippedNoSessions };
+        return reapDurableAgentsLane(this.core, scope, deps, policy);
     }
     releaseDurableTranscriptAnchor(id) {
-        const handle = this.handles.get(id);
-        if (!handle || handle.type !== "background_agent")
-            return;
-        this.durableAgentWrite(handle, {}, ["sessionId"]);
+        return releaseDurableTranscriptAnchorLane(this.core, id);
     }
     bindBackgroundAgentSession(id, sessionId) {
-        const handle = this.handles.get(id);
-        if (!handle || handle.type !== "background_agent")
-            return;
-        handle.sessionId = sessionId;
-        this.durableAgentWrite(handle, { sessionId });
+        return bindBackgroundAgentSessionLane(this.core, id, sessionId);
+    }
+    registerBackgroundAgent(input) {
+        return registerBackgroundAgentLane(this.core, input);
+    }
+    parkBackgroundAgent(id, park) {
+        return parkBackgroundAgentLane(this.core, id, park);
+    }
+    async reconcileParkedAgents(stores, scope, now, opts) {
+        return reconcileParkedAgentsLane(this.core, stores, scope, now, opts);
+    }
+    async claimParkedAgent(stores, handle, access) {
+        return claimParkedAgentLane(stores, handle, access);
+    }
+    async rollbackParkedClaim(stores, ticket) {
+        return rollbackParkedClaimLane(this.core, stores, ticket);
+    }
+    async consumeParkedFlip(id, stores, ticket) {
+        return consumeParkedFlipLane(this.core, id, stores, ticket);
+    }
+    finalizeParkedResume(id) {
+        return finalizeParkedResumeLane(this.core, id);
+    }
+    settleBackgroundAgent(id, outcome) {
+        return settleBackgroundAgentLane(this.core, id, outcome);
+    }
+    abortBackgroundAgentsForOwner(access, opts) {
+        return abortBackgroundAgentsForOwnerLane(this.core, access, opts);
+    }
+    serveDurableAgentRow(row) {
+        return serveDurableAgentRowLane(row);
+    }
+    resolveBackgroundAgentByName(name, access, opts) {
+        return resolveBackgroundAgentByNameLane(this.core, name, access, opts);
+    }
+    markRetainedContinuation(id) {
+        return markRetainedContinuationLane(this.core, id);
     }
+    reviveBackgroundAgent(id, access, abort) {
+        return reviveBackgroundAgentLane(this.core, id, access, abort);
+    }
+    settleRevivedAgent(id, cycle, outcome) {
+        return settleRevivedAgentLane(this.core, id, cycle, outcome);
+    }
+    unmarkRetainedContinuation(id) {
+        return unmarkRetainedContinuationLane(this.core, id);
+    }
+    attachAgentNotify(id, notify, cycle) {
+        return attachAgentNotifyLane(this.core, id, notify, cycle);
+    }
+    async deliverToRunningAgent(id, access, notification, opts) {
+        return deliverToRunningAgentLane(this.core, id, access, notification, opts);
+    }
+    runningBackgroundAgentLabels(access) {
+        return runningBackgroundAgentLabelsLane(this.core, access);
+    }
+    async pollBackgroundAgent(handle, deadline, signal) {
+        return pollBackgroundAgentLane(handle, deadline, signal);
+    }
+    async stopBackgroundAgent(handle) {
+        return stopBackgroundAgentLane(this.core, handle);
+    }
+    writerId = randomBytes(8).toString("hex");
+    reapingHandles = new Set();
+    claimingHandles = new Set();
+    durableHeartbeatTimer;
     mintTaskId(type) {
         const prefix = TASK_PREFIX[type];
         for (let i = 0; i < 32; i++) {
@@ -626,99 +211,6 @@ export class TaskRegistry {
         }
         return false;
     }
-    registerBackgroundAgent(input) {
-        assertOwnership(input, "registerBackgroundAgent");
-        if (input.id !== undefined && !DURABLE_AGENT_HANDLE_RE.test(input.id)) {
-            throw new Error(`TaskRegistry: background-agent id ${JSON.stringify(input.id)} does not match the a<hex> handle form`);
-        }
-        const id = input.id ?? this.mintTaskId("background_agent");
-        if (input.durableSeed !== undefined) {
-            const prior = this.handles.get(id);
-            if (prior !== undefined) {
-                const parkedHandoff = prior.status === "parked" && input.initialStatus === "parked";
-                if (prior.type !== "background_agent" || prior.status === "running" || prior.status === "pending" || (prior.status === "parked" && !parkedHandoff)) {
-                    throw new Error(`TaskRegistry: task id already registered: ${id}`);
-                }
-                const priorLane = prior.durable;
-                if (priorLane !== undefined)
-                    priorLane.poisoned = true;
-                this.handles.delete(id);
-            }
-        }
-        if (this.handles.has(id))
-            throw new Error(`TaskRegistry: task id already registered: ${id}`);
-        const now = input.now ?? Date.now();
-        this.handles.set(id, {
-            id,
-            type: "background_agent",
-            status: input.initialStatus ?? "running",
-            ...(input.parkedCheckpointToken !== undefined ? { parkedCheckpointToken: input.parkedCheckpointToken } : {}),
-            ...(input.resolveParkedStop !== undefined ? { resolveParkedStop: input.resolveParkedStop } : {}),
-            ...(input.sessionScoped ? { sessionScoped: true } : {}),
-            ...(input.description !== undefined ? { description: input.description } : {}),
-            ...(input.name !== undefined ? { name: input.name } : {}),
-            ...(input.agentType !== undefined ? { agentType: input.agentType } : {}),
-            ...(input.parentTaskId !== undefined ? { parentTaskId: input.parentTaskId } : {}),
-            ...(input.parentSessionId !== undefined ? { parentSessionId: input.parentSessionId } : {}),
-            ...(input.rootSessionId !== undefined ? { rootSessionId: input.rootSessionId } : {}),
-            ...(input.deliveryChannel !== undefined ? { channelState: input.deliveryChannel } : {}),
-            ...(input.retainedContinuation !== undefined ? { retainedContinuation: input.retainedContinuation } : {}),
-            ...(input.owner !== undefined ? { owner: input.owner } : {}),
-            ...(input.scope !== undefined ? { scope: input.scope } : {}),
-            ...(input.toolUseId !== undefined ? { toolUseId: input.toolUseId } : {}),
-            cycleSeq: input.durableSeed !== undefined ? (input.durableSeed.record.seq ?? 1) : 1,
-            createdAt: now,
-            updatedAt: now,
-            abort: input.abort,
-        });
-        if (input.store) {
-            const handle = this.handles.get(id);
-            if (input.durableSeed !== undefined) {
-                const seeded = structuredClone(input.durableSeed.record);
-                seeded.rev = input.durableSeed.rev;
-                handle.durable = {
-                    store: input.store,
-                    record: seeded,
-                    chain: Promise.resolve(),
-                    written: true,
-                    poisoned: false,
-                    flushFailed: false,
-                };
-                this.ensureDurableHeartbeat();
-                return id;
-            }
-            handle.durable = {
-                store: input.store,
-                record: {
-                    handle: id,
-                    scope: input.scope,
-                    owner: input.owner,
-                    sessionScoped: input.sessionScoped === true,
-                    ...(input.parentSessionId !== undefined ? { parentSessionId: input.parentSessionId } : {}),
-                    ...(input.rootSessionId !== undefined ? { rootSessionId: input.rootSessionId } : {}),
-                    ...(input.parentTaskId !== undefined ? { parentTaskId: input.parentTaskId } : {}),
-                    ...(input.name !== undefined ? { name: input.name } : {}),
-                    ...(input.agentType !== undefined ? { agentType: input.agentType } : {}),
-                    ...(input.description !== undefined ? { description: input.description } : {}),
-                    ...(input.model !== undefined ? { model: input.model } : {}),
-                    ...(input.teamName !== undefined ? { teamName: input.teamName } : {}),
-                    writerId: this.writerId,
-                    writerEpoch: 1,
-                    spawnedAt: now,
-                    updatedAt: now,
-                    status: "running",
-                    rev: 0,
-                },
-                chain: Promise.resolve(),
-                written: false,
-                poisoned: false,
-                flushFailed: false,
-            };
-            this.durableAgentWrite(handle, {});
-            this.ensureDurableHeartbeat();
-        }
-        return id;
-    }
     getAccessibleTask(taskId, access) {
         const h = this.handles.get(taskId);
         if (!h || !canAccess(h, access))
@@ -820,399 +312,6 @@ export class TaskRegistry {
     getCompletionId(id) {
         return this.handles.get(id)?.completionId;
     }
-    parkBackgroundAgent(id, park) {
-        const handle = this.handles.get(id);
-        if (!handle || handle.type !== "background_agent")
-            return undefined;
-        if (handle.status !== "running")
-            return undefined;
-        handle.status = "parked";
-        handle.parkedCheckpointToken = park.checkpointToken;
-        handle.resolveParkedStop = park.resolveStop;
-        handle.notify = undefined;
-        for (const [, , qResolve] of handle.preAttachQueue ?? [])
-            qResolve?.({ ok: false, reason: "not_running" });
-        handle.preAttachQueue = undefined;
-        for (const r of [...(handle.inFlightDirect ?? [])])
-            r({ ok: false, reason: "not_running" });
-        handle.inFlightDirect = undefined;
-        handle.updatedAt = Date.now();
-        if (park.seq !== undefined)
-            handle.cycleSeq = park.seq;
-        this.pokeBgQuiescence(handle.owner);
-        this.durableAgentWrite(handle, {
-            status: "parked",
-            parkedCheckpointToken: park.checkpointToken,
-            parkedAt: Date.now(),
-            ...(park.seq !== undefined ? { seq: park.seq } : {}),
-        }, ["parkClaimId"]);
-        return "parked";
-    }
-    async reconcileParkedAgents(stores, scope, now, opts) {
-        let liveFailed = 0;
-        for (const handle of this.handles.values()) {
-            if (handle.type !== "background_agent" || handle.status !== "parked")
-                continue;
-            if (handle.scope !== undefined && handle.scope !== scope)
-                continue;
-            const token = handle.parkedCheckpointToken;
-            let state;
-            if (token === undefined)
-                state = "missing";
-            else {
-                try {
-                    const cp = await stores.checkpointStore.get(token);
-                    state = cp === null ? "missing" : cp.status;
-                }
-                catch {
-                    state = "unreadable";
-                }
-            }
-            if (state !== "expired" && state !== "missing")
-                continue;
-            if (handle.status !== "parked")
-                continue;
-            handle.status = "failed";
-            handle.error = `approval checkpoint ${state} while parked (reconciled)`;
-            handle.parkedCheckpointToken = undefined;
-            handle.resolveParkedStop = undefined;
-            handle.updatedAt = now;
-            mintCompletionId(handle);
-            this.pokeBgQuiescence(handle.owner);
-            this.durableAgentWrite(handle, { status: "failed", error: handle.error, settledAt: now, stoppedBy: "system", completionId: handle.completionId }, ["parkedCheckpointToken", "parkClaimId", "parkedAt"]);
-            liveFailed++;
-        }
-        const { reconcileParkedAgents: storeReconcile } = await import("./background-agent-store.js");
-        const liveHandles = new Set();
-        for (const h of this.handles.values())
-            if (h.type === "background_agent")
-                liveHandles.add(h.id);
-        const storeHalf = await storeReconcile(stores, scope, now, {
-            ...(opts?.staleClaimMaxAgeMs !== undefined ? { staleClaimMaxAgeMs: opts.staleClaimMaxAgeMs } : {}),
-            excludeHandles: liveHandles,
-        });
-        return { failed: storeHalf.failed + liveFailed, rolledBack: storeHalf.rolledBack };
-    }
-    async claimParkedAgent(stores, handle, access) {
-        if (access.scope === undefined)
-            return { ok: false, reason: "not_found" };
-        let row;
-        try {
-            row = await stores.agentStore.get(handle, access.scope);
-        }
-        catch {
-            return { ok: false, reason: "store_unreachable" };
-        }
-        if (!row || !canAccessAgentRecord(row, access))
-            return { ok: false, reason: "not_found" };
-        if (row.status !== "parked")
-            return { ok: false, reason: "not_parked" };
-        const token = row.parkedCheckpointToken;
-        if (token === undefined || row.sessionId === undefined)
-            return { ok: false, reason: "binding_broken" };
-        let cp;
-        try {
-            cp = (await stores.checkpointStore.get(token));
-        }
-        catch {
-            return { ok: false, reason: "store_unreachable" };
-        }
-        if (cp === null || cp.sessionId !== row.sessionId)
-            return { ok: false, reason: "binding_broken" };
-        if (cp.status !== "pending")
-            return { ok: false, reason: "checkpoint_not_pending" };
-        const claimId = randomBytes(8).toString("hex");
-        const reserved = structuredClone(row);
-        reserved.parkClaimId = claimId;
-        reserved.updatedAt = Date.now();
-        let won;
-        try {
-            won = await stores.agentStore.updateIf(handle, access.scope, reserved, {
-                rev: row.rev,
-                status: "parked",
-                parkedCheckpointToken: token,
-                parkClaimId: null,
-            });
-        }
-        catch {
-            return { ok: false, reason: "store_unreachable" };
-        }
-        if (!won)
-            return { ok: false, reason: "claim_lost" };
-        return {
-            ok: true,
-            ticket: { handle, scope: access.scope, token, claimId, reservedRev: row.rev + 1, row: structuredClone(row) },
-        };
-    }
-    async rollbackParkedClaim(stores, ticket) {
-        let cpStatus;
-        try {
-            const cp = (await stores.checkpointStore.get(ticket.token));
-            cpStatus = cp === null ? "missing" : cp.status;
-        }
-        catch {
-            return "retry";
-        }
-        const now = Date.now();
-        const rollbackCompletionIdCandidate = uuidv7();
-        const settleLocalParkedHandle = (error) => {
-            const h = this.handles.get(ticket.handle);
-            if (h !== undefined && h.type === "background_agent" && h.status === "parked") {
-                h.status = "failed";
-                h.error = error;
-                h.parkedCheckpointToken = undefined;
-                h.resolveParkedStop = undefined;
-                h.updatedAt = now;
-                commitCompletionIdIfEmpty(h, rollbackCompletionIdCandidate);
-                this.pokeBgQuiescence(h.owner);
-            }
-        };
-        let liveRow;
-        try {
-            liveRow = await stores.agentStore.get(ticket.handle, ticket.scope);
-        }
-        catch {
-            return "retry";
-        }
-        if (!liveRow || liveRow.parkClaimId !== ticket.claimId)
-            return "lost";
-        if (cpStatus === "pending") {
-            const restored = structuredClone(liveRow);
-            delete restored.parkClaimId;
-            restored.updatedAt = now;
-            restored.writerEpoch = (liveRow.writerEpoch ?? 0) + 1;
-            const liveHandle = this.handles.get(ticket.handle);
-            if (liveHandle?.type === "background_agent" &&
-                liveHandle.durable !== undefined &&
-                liveHandle.durable.record.writerId === liveRow.writerId &&
-                (liveHandle.durable.record.writerEpoch ?? 0) === (liveRow.writerEpoch ?? 0)) {
-                liveHandle.durable.record.writerEpoch = restored.writerEpoch;
-            }
-            try {
-                const won = await stores.agentStore.updateIf(ticket.handle, ticket.scope, restored, {
-                    rev: liveRow.rev,
-                    status: "parked",
-                    parkedCheckpointToken: ticket.token,
-                    parkClaimId: ticket.claimId,
-                });
-                if (!won)
-                    return "lost";
-                try {
-                    const cp2 = (await stores.checkpointStore.get(ticket.token));
-                    if (cp2 !== null && cp2.status === "pending")
-                        return "rolled_back";
-                    const post = await stores.agentStore.get(ticket.handle, ticket.scope);
-                    if (post && post.status === "parked") {
-                        const term = structuredClone(post);
-                        term.status = "failed";
-                        term.error = `approval checkpoint ${cp2 === null ? "missing" : cp2.status} under the resume claim (claim rollback)`;
-                        term.stoppedBy = "system";
-                        term.settledAt = now;
-                        term.updatedAt = now;
-                        term.completionId = rollbackCompletionIdCandidate;
-                        delete term.parkedCheckpointToken;
-                        delete term.parkClaimId;
-                        delete term.parkedAt;
-                        if (await stores.agentStore.updateIf(ticket.handle, ticket.scope, term, { rev: post.rev, status: "parked" })) {
-                            settleLocalParkedHandle(term.error);
-                            return "failed";
-                        }
-                    }
-                    return "lost";
-                }
-                catch {
-                    return "rolled_back";
-                }
-            }
-            catch {
-                return "retry";
-            }
-        }
-        const error = cpStatus === "resolved"
-            ? "approval consumed but the resume could not proceed — outcome unknown (claim rollback)"
-            : `approval checkpoint ${cpStatus} under the resume claim (claim rollback)`;
-        if (liveRow.status !== "parked")
-            return "lost";
-        const failed = structuredClone(liveRow);
-        failed.status = "failed";
-        failed.error = error;
-        failed.stoppedBy = "system";
-        failed.settledAt = now;
-        failed.updatedAt = now;
-        failed.completionId = rollbackCompletionIdCandidate;
-        delete failed.parkedCheckpointToken;
-        delete failed.parkClaimId;
-        delete failed.parkedAt;
-        try {
-            const won = await stores.agentStore.updateIf(ticket.handle, ticket.scope, failed, {
-                rev: liveRow.rev,
-                status: "parked",
-                parkClaimId: ticket.claimId,
-            });
-            if (won)
-                settleLocalParkedHandle(error);
-            return won ? "failed" : "lost";
-        }
-        catch {
-            return "retry";
-        }
-    }
-    async consumeParkedFlip(id, stores, ticket) {
-        const handle = this.handles.get(id);
-        if (!handle || handle.type !== "background_agent" || handle.status !== "parked")
-            return false;
-        const lane = handle.durable;
-        const doFlip = async () => {
-            let live;
-            try {
-                live = await stores.agentStore.get(ticket.handle, ticket.scope);
-            }
-            catch {
-                return undefined;
-            }
-            if (!live || live.status !== "parked" || live.parkClaimId !== ticket.claimId || live.parkedCheckpointToken !== ticket.token)
-                return undefined;
-            const flipped = structuredClone(live);
-            flipped.status = "running";
-            flipped.writerId = this.writerId;
-            flipped.writerEpoch = (live.writerEpoch ?? 0) + 1;
-            flipped.updatedAt = Date.now();
-            flipped.seq = (live.seq ?? 1) + 1;
-            delete flipped.parkedCheckpointToken;
-            delete flipped.parkedAt;
-            try {
-                const won = await stores.agentStore.updateIf(ticket.handle, ticket.scope, flipped, {
-                    rev: live.rev,
-                    status: "parked",
-                    parkedCheckpointToken: ticket.token,
-                    parkClaimId: ticket.claimId,
-                });
-                if (!won)
-                    return undefined;
-            }
-            catch {
-                return undefined;
-            }
-            flipped.rev = live.rev + 1;
-            return flipped;
-        };
-        let flipped;
-        if (lane !== undefined && !lane.poisoned) {
-            const p = lane.chain.then(doFlip, doFlip);
-            lane.chain = p.then((f) => {
-                if (f !== undefined) {
-                    lane.record = structuredClone(f);
-                    lane.written = true;
-                }
-            });
-            flipped = await p;
-        }
-        else {
-            flipped = await doFlip();
-        }
-        if (flipped === undefined)
-            return false;
-        handle.status = "running";
-        handle.parkedCheckpointToken = undefined;
-        handle.resolveParkedStop = undefined;
-        handle.updatedAt = Date.now();
-        handle.completionId = undefined;
-        if (flipped.seq !== undefined)
-            handle.cycleSeq = flipped.seq;
-        return true;
-    }
-    finalizeParkedResume(id) {
-        const handle = this.handles.get(id);
-        if (!handle || handle.type !== "background_agent")
-            return;
-        this.durableAgentWrite(handle, {}, ["parkClaimId"]);
-    }
-    settleBackgroundAgent(id, outcome) {
-        const handle = this.handles.get(id);
-        if (!handle || handle.type !== "background_agent")
-            return undefined;
-        if (handle.status !== "running") {
-            if (handle.status === "killed") {
-                mintCompletionId(handle);
-                let backfilled = false;
-                if (handle.result === undefined && outcome.result !== undefined && outcome.result !== "") {
-                    handle.result = outcome.result;
-                    handle.resultIsPartial = true;
-                    backfilled = true;
-                    if (outcome.resultFull !== undefined)
-                        handle.resultFull = outcome.resultFull;
-                }
-                if (handle.error === undefined && outcome.error !== undefined && outcome.error !== BG_AGENT_REAP_STOP_ERROR) {
-                    handle.error = outcome.error;
-                    backfilled = true;
-                }
-                if (backfilled) {
-                    handle.updatedAt = Date.now();
-                    this.durableAgentWrite(handle, {
-                        ...(handle.result !== undefined ? { finalOutput: handle.result } : {}),
-                        ...(handle.resultFull !== undefined ? { finalOutputFull: handle.resultFull } : {}),
-                        ...(handle.resultIsPartial ? { resultIsPartial: true } : {}),
-                        ...(handle.error !== undefined ? { error: handle.error } : {}),
-                        ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
-                    });
-                }
-            }
-            return handle.status === "completed" || handle.status === "failed" || handle.status === "killed" ? handle.status : undefined;
-        }
-        handle.status = outcome.status;
-        mintCompletionId(handle);
-        handle.notify = undefined;
-        for (const [, , qResolve] of handle.preAttachQueue ?? [])
-            qResolve?.({ ok: false, reason: "not_running" });
-        handle.preAttachQueue = undefined;
-        for (const r of [...(handle.inFlightDirect ?? [])])
-            r({ ok: false, reason: "not_running" });
-        handle.inFlightDirect = undefined;
-        if (outcome.status === "killed" && handle.stoppedBy === undefined) {
-            handle.stoppedBy = outcome.stoppedBy ?? handle.stopSource ?? "system";
-        }
-        if (outcome.result !== undefined)
-            handle.result = outcome.result;
-        if (outcome.resultFull !== undefined)
-            handle.resultFull = outcome.resultFull;
-        if (outcome.status === "killed" && outcome.result !== undefined && outcome.result !== "") {
-            handle.resultIsPartial = true;
-        }
-        if (outcome.error !== undefined && !(outcome.status === "killed" && outcome.error === BG_AGENT_REAP_STOP_ERROR)) {
-            handle.error = outcome.error;
-        }
-        handle.updatedAt = Date.now();
-        if (outcome.seq !== undefined)
-            handle.cycleSeq = outcome.seq;
-        this.pokeBgQuiescence(handle.owner);
-        this.durableAgentWrite(handle, {
-            status: outcome.status,
-            ...(outcome.seq !== undefined ? { seq: outcome.seq } : {}),
-            settledAt: Date.now(),
-            ...(handle.stoppedBy !== undefined ? { stoppedBy: handle.stoppedBy } : {}),
-            ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
-            ...(handle.result !== undefined ? { finalOutput: handle.result } : {}),
-            ...(handle.resultFull !== undefined ? { finalOutputFull: handle.resultFull } : {}),
-            ...(handle.resultIsPartial ? { resultIsPartial: true } : {}),
-            ...(handle.error !== undefined ? { error: handle.error } : {}),
-        }, ["parkedCheckpointToken", "parkClaimId", "parkedAt"]);
-        return outcome.status;
-    }
-    abortBackgroundAgentsForOwner(access, opts) {
-        let aborted = 0;
-        for (const handle of this.handles.values()) {
-            if (handle.type !== "background_agent" || handle.status !== "running" || !canAccess(handle, access))
-                continue;
-            if (opts?.skipSessionScoped && handle.sessionScoped)
-                continue;
-            if (opts?.sessionScopedOnly && !handle.sessionScoped)
-                continue;
-            this.markStopSource(handle.id, "parent");
-            handle.abort.abort();
-            aborted++;
-        }
-        return aborted;
-    }
     markStopSourceForOwner(access, source, opts) {
         let marked = 0;
         for (const handle of this.handles.values()) {
@@ -1639,243 +738,10 @@ export class TaskRegistry {
         return out;
     }
     registerMonitor(input) {
-        assertOwnership(input, "registerMonitor");
-        const id = this.mintTaskId("monitor");
-        const now = input.now ?? Date.now();
-        const timers = input.timers ?? defaultMonitorTimers;
-        const persistent = input.persistent === true;
-        const timeoutMs = persistent
-            ? undefined
-            : Math.min(MONITOR_MAX_TIMEOUT_MS, Math.max(1, Math.floor(input.timeoutMs ?? MONITOR_DEFAULT_TIMEOUT_MS)));
-        const handle = {
-            id,
-            type: "monitor",
-            status: "running",
-            ...(input.description !== undefined ? { description: input.description } : {}),
-            ...(input.owner !== undefined ? { owner: input.owner } : {}),
-            ...(input.scope !== undefined ? { scope: input.scope } : {}),
-            ...(input.toolUseId !== undefined ? { toolUseId: input.toolUseId } : {}),
-            ...(persistent ? { persistent: true } : {}),
-            ...(input.sessionScoped ? { sessionScoped: true } : {}),
-            createdAt: now,
-            updatedAt: now,
-            env: input.env,
-            shellId: input.shellId,
-            spool: { stdout: "", stderr: "", rolledChars: 0 },
-            lineBuf: "",
-            seq: 0,
-            batchTimes: [],
-            batchWindowMs: Math.max(1, Math.floor(input.batchWindowMs ?? MONITOR_BATCH_WINDOW_MS)),
-            maxBatchesPerMinute: Math.max(1, Math.floor(input.maxBatchesPerMinute ?? MONITOR_MAX_BATCHES_PER_MINUTE)),
-            ...(timeoutMs !== undefined ? { timeoutMs, deadlineAt: timers.now() + timeoutMs } : {}),
-            timers,
-            ...(input.onEvent !== undefined ? { onEvent: input.onEvent } : {}),
-        };
-        this.handles.set(id, handle);
-        this.startMonitorWatcher(id);
-        return id;
-    }
-    absorbMonitorPoll(handle, v) {
-        const spool = handle.spool;
-        accountDroppedBytes(spool, v);
-        const ROLL_CAP = 2 * TASK_OUTPUT_MAX_CHARS;
-        spool.stdout = rollSpoolText(spool, spool.stdout + v.stdout, ROLL_CAP);
-        spool.stderr = rollSpoolText(spool, spool.stderr + v.stderr, ROLL_CAP);
-        handle.lineBuf += v.stdout;
-        const parts = handle.lineBuf.split(/\r?\n/);
-        handle.lineBuf = parts.pop() ?? "";
-        return parts.filter((l) => l !== "");
-    }
-    emitMonitorEvent(handle, n) {
-        try {
-            handle.onEvent?.(n);
-        }
-        catch {
-        }
-    }
-    startMonitorWatcher(id) {
-        const handle = this.handles.get(id);
-        if (!handle || handle.type !== "monitor")
-            return;
-        const timers = handle.timers;
-        let ticking = false;
-        const MAX_RETRYABLE_POLL_FAILURES = 3;
-        let pollFailures = 0;
-        const stop = () => {
-            if (handle.watcher !== undefined) {
-                timers.clearInterval(handle.watcher);
-                handle.watcher = undefined;
-            }
-        };
-        const emit = (n) => this.emitMonitorEvent(handle, n);
-        const pendingFinalLines = (lines) => {
-            const out = handle.lineBuf !== "" ? [...lines, handle.lineBuf] : lines;
-            handle.lineBuf = "";
-            return out;
-        };
-        const terminal = (status, summary, finalLines) => {
-            handle.updatedAt = Date.now();
-            mintCompletionId(handle);
-            stop();
-            this.notifyTerminalOnce(handle, () => emit({
-                task_id: id,
-                task_type: "monitor",
-                ...(handle.toolUseId !== undefined ? { toolUseId: handle.toolUseId } : {}),
-                status,
-                ...(status === "killed" && handle.stoppedBy !== undefined ? { stoppedBy: handle.stoppedBy } : {}),
-                summary: `${(handle.description ?? "monitor").slice(0, 200)} — ${summary}${droppedGapNote(handle.spool)}`,
-                ...(finalLines.length > 0 ? { lines: finalLines, result: clipMonitorEvent(finalLines.join("\n")), ...(status === "killed" ? { partial: true } : {}) } : {}),
-                ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
-            }));
-        };
-        const tick = async () => {
-            if (ticking)
-                return;
-            ticking = true;
-            handle.tickInFlight = true;
-            try {
-                if (this.handles.get(id) !== handle)
-                    return stop();
-                if (handle.status !== "running")
-                    return stop();
-                const r = await handle.env.pollBackground(handle.shellId);
-                if (this.handles.get(id) !== handle || handle.status !== "running")
-                    return stop();
-                if (!r.ok) {
-                    if ((r.error.code === "timeout" || r.error.code === "io") && ++pollFailures <= MAX_RETRYABLE_POLL_FAILURES)
-                        return;
-                    handle.status = "failed";
-                    return terminal("failed", `monitor lost its process (${r.error.message}); watch ended.`, pendingFinalLines([]));
-                }
-                pollFailures = 0;
-                const spool = handle.spool;
-                const lines = this.absorbMonitorPoll(handle, r.value);
-                handle.status = statusFromBackground(r.value.status, r.value.exitCode);
-                if (r.value.status !== "running") {
-                    spool.exitCode = r.value.exitCode;
-                    if (handle.status === "killed" && handle.stoppedBy === undefined)
-                        handle.stoppedBy = handle.stopSource ?? (r.value.timedOut === true ? "timeout" : "system");
-                    if (r.value.timedOut === true) {
-                        spool.timedOut = true;
-                        if (r.value.timeoutSec !== undefined)
-                            spool.timeoutSec = r.value.timeoutSec;
-                    }
-                    const label = r.value.status === "exited"
-                        ? `exited(code ${r.value.exitCode}); watch ended.`
-                        : r.value.timedOut === true
-                            ? `timed out after ${r.value.timeoutSec !== undefined ? `${r.value.timeoutSec}s` : "its background time budget"} (the execution environment's background time budget); the process was killed and the watch ended.`
-                            : `${r.value.status}; watch ended.`;
-                    return terminal(handle.status === "completed" ? "completed" : handle.status === "killed" ? "killed" : "failed", label, pendingFinalLines(lines));
-                }
-                const now = timers.now();
-                if (handle.deadlineAt !== undefined && now >= handle.deadlineAt) {
-                    this.markStopSource(id, "timeout");
-                    const k = await handle.env.killBackground(handle.shellId);
-                    if (this.handles.get(id) !== handle || handle.status !== "running")
-                        return stop();
-                    if (!k.ok && k.error.code !== "not_found") {
-                        handle.status = "failed";
-                        return terminal("failed", `timed out after ${handle.timeoutMs}ms, but the kill failed (${k.error.message}); the process may still be running. Watch ended.`, pendingFinalLines(lines));
-                    }
-                    handle.status = "killed";
-                    handle.stoppedBy = handle.stopSource ?? "timeout";
-                    return terminal("killed", `timed out after ${handle.timeoutMs}ms; the process was killed and the watch ended.`, pendingFinalLines(lines));
-                }
-                if (lines.length === 0) {
-                    if (r.value.stdout.length > 0 || r.value.stderr.length > 0)
-                        handle.updatedAt = Date.now();
-                    return;
-                }
-                const cutoff = now - 60_000;
-                handle.batchTimes = handle.batchTimes.filter((t) => t > cutoff);
-                handle.batchTimes.push(now);
-                if (handle.batchTimes.length > handle.maxBatchesPerMinute) {
-                    this.markStopSource(id, "system");
-                    const k = await handle.env.killBackground(handle.shellId);
-                    if (this.handles.get(id) !== handle || handle.status !== "running")
-                        return stop();
-                    if (!k.ok && k.error.code !== "not_found") {
-                        handle.status = "failed";
-                        return terminal("failed", `auto-stop triggered (more than ${handle.maxBatchesPerMinute} notification batches within a minute), but the kill failed (${k.error.message}); the process may still be running. Watch ended.`, pendingFinalLines(lines));
-                    }
-                    handle.status = "killed";
-                    handle.stoppedBy = handle.stopSource ?? "system";
-                    return terminal("killed", `auto-stopped: it produced too many events (more than ${handle.maxBatchesPerMinute} notification batches within a minute). ` +
-                        `The process was killed; its full output remains readable via TaskOutput. Restart it with a quieter command (filter its output) if you still need the watch.`, pendingFinalLines(lines));
-                }
-                handle.seq += 1;
-                handle.updatedAt = Date.now();
-                emit({
-                    task_id: id,
-                    task_type: "monitor",
-                    ...(handle.toolUseId !== undefined ? { toolUseId: handle.toolUseId } : {}),
-                    status: "event",
-                    seq: handle.seq,
-                    lines,
-                    summary: `${(handle.description ?? "monitor").slice(0, 200)} — ${lines.length} new output line(s)${firstDropNote(spool)}`,
-                    result: clipMonitorEvent(lines.join("\n")),
-                });
-            }
-            catch (e) {
-                if (this.handles.get(id) !== handle || handle.status !== "running")
-                    return stop();
-                if (++pollFailures <= MAX_RETRYABLE_POLL_FAILURES)
-                    return;
-                handle.status = "failed";
-                terminal("failed", `monitor watcher crashed (${e instanceof Error ? e.message : String(e)}); watch ended.`, pendingFinalLines([]));
-            }
-            finally {
-                ticking = false;
-                handle.tickInFlight = undefined;
-            }
-        };
-        handle.watcher = timers.setInterval(tick, handle.batchWindowMs);
+        return registerMonitorLane(this.core, input);
     }
     registerWorkflow(input) {
-        assertOwnership(input, "registerWorkflow");
-        const id = input.runId;
-        if (this.handles.has(id))
-            throw new Error(`TaskRegistry: task id already registered: ${id}`);
-        const now = input.now ?? Date.now();
-        const originatingSessionId = input.originatingSessionId;
-        const handle = {
-            id,
-            type: "workflow",
-            status: "running",
-            ...(input.description !== undefined ? { description: input.description } : {}),
-            ...(input.owner !== undefined ? { owner: input.owner } : {}),
-            ...(input.scope !== undefined ? { scope: input.scope } : {}),
-            ...(input.toolUseId !== undefined ? { toolUseId: input.toolUseId } : {}),
-            createdAt: now,
-            updatedAt: now,
-            runId: id,
-            handle: input.handle,
-            ...(input.store !== undefined ? { store: input.store } : {}),
-            ...(originatingSessionId !== undefined ? { originatingSessionId, sessionScoped: true } : {}),
-            ...(input.onServedTerminal !== undefined ? { onServedTerminal: input.onServedTerminal } : {}),
-        };
-        this.handles.set(id, handle);
-        void input.handle.done.then((res) => {
-            handle.status = "completed";
-            const run = res?.run;
-            const r = run?.resultFull ?? run?.result;
-            if (typeof r === "string")
-                handle.result = r;
-            if (run?.completionId !== undefined)
-                handle.completionId = run.completionId;
-            handle.updatedAt = Date.now();
-        }, (err) => {
-            if (handle.status !== "cancelled")
-                handle.status = "failed";
-            handle.error = boundedRedactedSummary(err instanceof Error ? err.message : String(err), 500);
-            const rejectedRun = err !== null && (typeof err === "object" || typeof err === "function")
-                ? err.workflowRun
-                : undefined;
-            if (rejectedRun?.completionId !== undefined)
-                handle.completionId = rejectedRun.completionId;
-            handle.updatedAt = Date.now();
-        });
-        return id;
+        return registerWorkflowLane(this.core, input);
     }
     async pollTask(id, access, opts = {}) {
         const taskId = id.trim();
@@ -1939,38 +805,6 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
         }
         return noTask(taskId);
     }
-    serveDurableAgentRow(row) {
-        if (row.status === "parked") {
-            return {
-                content: delimitUntrusted(`TaskOutput ${row.handle}`, `status: parked
-The agent is durably suspended, waiting for an approval decision. It resumes when the pending approval is decided (durable approval inbox), or lands failed if the approval expires.`),
-                details: {
-                    task_id: row.handle,
-                    type: "background_agent",
-                    status: "parked",
-                    retrieval_status: "success",
-                    ...(row.seq !== undefined ? { seq: row.seq } : {}),
-                },
-            };
-        }
-        const body = `status: ${row.status}
-${row.error ? `error: ${row.error}
-` : ""}${row.finalOutput ? `--- result${row.resultIsPartial ? " (partial — produced before the task was stopped)" : ""} ---
-${clipTaskOutput(row.finalOutputFull ?? row.finalOutput)}` : "(no result text)"}`;
-        return {
-            content: delimitUntrusted(`TaskOutput ${row.handle}`, body),
-            details: {
-                task_id: row.handle,
-                type: "background_agent",
-                status: row.status,
-                retrieval_status: "success",
-                ...(row.status === "killed" && row.stoppedBy !== undefined ? { stoppedBy: row.stoppedBy } : {}),
-                ...(row.seq !== undefined ? { seq: row.seq } : {}),
-                ...(row.resultIsPartial ? { partial_result: true } : {}),
-                ...(row.completionId !== undefined ? { completionId: row.completionId } : {}),
-            },
-        };
-    }
     async stopTask(id, access, opts = {}) {
         const taskId = id.trim();
         const handle = this.resolveInternal(taskId, access);
@@ -2026,265 +860,24 @@ ${clipTaskOutput(row.finalOutputFull ?? row.finalOutput)}` : "(no result text)"}
                         retrieval_status: row.status === "parked" ? "not_ready" : "success",
                         ...(row.status === "running" ? { error: "not_local" } : {}),
                         ...(row.status === "parked" ? { error: "parked_pending_approval" } : {}),
-                    },
-                };
-            }
-        }
-        const byName = this.resolveBackgroundAgentByName(taskId, access, { preferRunning: true });
-        if (byName.status === "found")
-            return this.stopBackgroundAgent(byName.handle);
-        if (byName.status === "ambiguous") {
-            return {
-                content: byName.message,
-                details: { task_id: taskId, retrieval_status: "not_ready", error: "ambiguous" },
-                isError: true,
-            };
-        }
-        return noTaskForStop(taskId, {
-            ...(byName.suggestion !== undefined ? { suggestion: byName.suggestion } : {}),
-            runningAgents: this.runningBackgroundAgentLabels(access),
-        });
-    }
-    resolveBackgroundAgentByName(name, access, opts) {
-        const key = normalizeAgentName(name);
-        if (key === "")
-            return { status: "not_found" };
-        const latestOf = (pool) => {
-            let best;
-            for (const h of pool)
-                if (best === undefined || h.createdAt >= best.createdAt)
-                    best = h;
-            return best;
-        };
-        const named = [];
-        for (const h of this.handles.values()) {
-            if (h.type !== "background_agent" || h.name === undefined || !canAccess(h, access))
-                continue;
-            if (h.name === name || normalizeAgentName(h.name) === key)
-                named.push(h);
-        }
-        if (opts?.preferRunning === true) {
-            const namedRunning = named.filter((h) => h.status === "running");
-            if (namedRunning.length > 1) {
-                return {
-                    status: "ambiguous",
-                    message: `Multiple RUNNING background agents match "${name}": ${namedRunning.map((h) => `${h.id} (${h.name ?? h.description ?? "unnamed"})`).join(", ")}. Use the task ID.`,
-                };
-            }
-            if (namedRunning.length === 1)
-                return { status: "found", handle: namedRunning[0] };
-        }
-        const namedWinner = latestOf(named);
-        if (namedWinner !== undefined)
-            return { status: "found", handle: namedWinner };
-        const exact = [];
-        for (const h of this.handles.values()) {
-            if (h.type !== "background_agent" || !canAccess(h, access))
-                continue;
-            if (h.description === name)
-                exact.push(h);
-        }
-        const exactRunning = exact.filter((h) => h.status === "running");
-        const exactPool = exactRunning.length > 0 ? exactRunning : exact;
-        if (exactPool.length === 1)
-            return { status: "found", handle: exactPool[0] };
-        if (exactPool.length > 1) {
-            return {
-                status: "ambiguous",
-                message: `Multiple background agents match "${name}": ${exactPool.map((h) => (h.description ? `${h.id} (${h.description})` : h.id)).join(", ")}. Use the task ID.`,
-            };
-        }
-        const matches = [];
-        for (const h of this.handles.values()) {
-            if (h.type !== "background_agent" || !canAccess(h, access))
-                continue;
-            if (h.description !== undefined && normalizeAgentName(h.description) === key)
-                matches.push(h);
+                    },
+                };
+            }
         }
-        const running = matches.filter((h) => h.status === "running");
-        const pool = running.length > 0 ? running : matches;
-        if (pool.length === 1)
-            return { status: "found", handle: pool[0] };
-        if (pool.length > 1) {
+        const byName = this.resolveBackgroundAgentByName(taskId, access, { preferRunning: true });
+        if (byName.status === "found")
+            return this.stopBackgroundAgent(byName.handle);
+        if (byName.status === "ambiguous") {
             return {
-                status: "ambiguous",
-                message: `Multiple background agents match "${name}": ${pool.map((h) => (h.description ? `${h.id} (${h.description})` : h.id)).join(", ")}. Use the task ID.`,
+                content: byName.message,
+                details: { task_id: taskId, retrieval_status: "not_ready", error: "ambiguous" },
+                isError: true,
             };
         }
-        const byKey = new Map();
-        for (const h of this.handles.values()) {
-            if (h.type !== "background_agent" || h.status !== "running" || !canAccess(h, access))
-                continue;
-            for (const label of [h.name, h.description]) {
-                if (label === undefined)
-                    continue;
-                const k = normalizeAgentName(label);
-                if (k !== "" && !byKey.has(k))
-                    byKey.set(k, label);
-            }
-        }
-        const closest = closestName(key, byKey.keys());
-        return { status: "not_found", ...(closest !== undefined ? { suggestion: byKey.get(closest) } : {}) };
-    }
-    markRetainedContinuation(id) {
-        const handle = this.handles.get(id);
-        if (handle && handle.type === "background_agent")
-            handle.retainedContinuation = true;
-    }
-    reviveBackgroundAgent(id, access, abort) {
-        if (this.reapingHandles.has(id) || this.claimingHandles.has(id))
-            return { ok: false, reason: "not_found" };
-        const handle = this.handles.get(id);
-        if (!handle || handle.type !== "background_agent" || !canAccess(handle, access))
-            return { ok: false, reason: "not_found" };
-        if (handle.status === "running" || handle.status === "pending")
-            return { ok: false, reason: "still_running" };
-        if (handle.status === "parked")
-            return { ok: false, reason: "still_running" };
-        handle.status = "running";
-        handle.channelState = "attaching";
-        handle.notify = undefined;
-        if (abort !== undefined)
-            handle.abort = abort;
-        handle.result = undefined;
-        handle.resultFull = undefined;
-        handle.error = undefined;
-        handle.resultIsPartial = undefined;
-        handle.stopSource = undefined;
-        handle.completionId = undefined;
-        handle.reviveCycle = (handle.reviveCycle ?? 0) + 1;
-        handle.cycleSeq = (handle.cycleSeq ?? 1) + 1;
-        handle.updatedAt = Date.now();
-        this.durableAgentWrite(handle, { status: "running" }, ["settledAt", "stoppedBy", "finalOutput", "finalOutputFull", "error", "resultIsPartial", "completionId", "summary", "recentSteps", "editedFiles", "usage"]);
-        return { ok: true, cycle: handle.reviveCycle };
-    }
-    settleRevivedAgent(id, cycle, outcome) {
-        const handle = this.handles.get(id);
-        if (!handle || handle.type !== "background_agent")
-            return undefined;
-        if ((handle.reviveCycle ?? 0) !== cycle)
-            return undefined;
-        return this.settleBackgroundAgent(id, outcome);
-    }
-    unmarkRetainedContinuation(id) {
-        const handle = this.handles.get(id);
-        if (handle && handle.type === "background_agent")
-            handle.retainedContinuation = false;
-    }
-    attachAgentNotify(id, notify, cycle) {
-        const handle = this.handles.get(id);
-        if (!handle || handle.type !== "background_agent" || handle.status !== "running")
-            return;
-        if (cycle !== undefined && (handle.reviveCycle ?? 0) !== cycle)
-            return;
-        handle.notify = notify;
-        handle.channelState = "attaching";
-        const live = handle.preAttachQueue;
-        if (live !== undefined && live.length > 0) {
-            void (async () => {
-                while (handle.preAttachQueue === live && live.length > 0) {
-                    const [qPayload, qOpts, qResolve] = live[0];
-                    let result;
-                    try {
-                        const d = await notify(qPayload, qOpts);
-                        result =
-                            d === "parked" && handle.retainedContinuation !== true
-                                ? { ok: false, reason: "not_running" }
-                                : d === "parked"
-                                    ? { ok: true, disposition: "parked" }
-                                    : { ok: true, disposition: "queued" };
-                    }
-                    catch {
-                        result = { ok: false, reason: "not_running" };
-                    }
-                    if (handle.preAttachQueue !== live)
-                        return;
-                    live.shift();
-                    qResolve?.(result);
-                }
-                if (handle.preAttachQueue === live) {
-                    handle.preAttachQueue = undefined;
-                    handle.channelState = "attached";
-                }
-            })();
-        }
-        else {
-            handle.preAttachQueue = undefined;
-            handle.channelState = "attached";
-        }
-    }
-    async deliverToRunningAgent(id, access, notification, opts) {
-        const handle = this.handles.get(id);
-        if (!handle || handle.type !== "background_agent" || !canAccess(handle, access))
-            return { ok: false, reason: "not_found" };
-        if (handle.status !== "running")
-            return { ok: false, reason: "not_running" };
-        const bounded = (p, fallback, onTimeout) => new Promise((resolve) => {
-            const t = setTimeout(() => {
-                try {
-                    onTimeout?.();
-                }
-                catch {
-                }
-                resolve(fallback);
-            }, this.deliverConfirmTimeoutMs);
-            t.unref?.();
-            void p.then((v) => {
-                clearTimeout(t);
-                resolve(v);
-            }, () => {
-                clearTimeout(t);
-                resolve(fallback);
-            });
+        return noTaskForStop(taskId, {
+            ...(byName.suggestion !== undefined ? { suggestion: byName.suggestion } : {}),
+            runningAgents: this.runningBackgroundAgentLabels(access),
         });
-        if (handle.notify === undefined || handle.channelState === "attaching") {
-            if (handle.channelState !== "attaching")
-                return { ok: false, reason: "no_channel" };
-            const q = (handle.preAttachQueue ??= []);
-            if (q.length >= 8)
-                return { ok: false, reason: "no_channel" };
-            return bounded(new Promise((resolve) => {
-                q.push([notification, opts, resolve]);
-            }), { ok: true, disposition: "pending" });
-        }
-        let detachOnTimeout;
-        return await bounded(new Promise((resolve) => {
-            const inflight = (handle.inFlightDirect ??= new Set());
-            const settleOnce = (r) => {
-                if (!inflight.has(settleOnce))
-                    return;
-                inflight.delete(settleOnce);
-                resolve(r);
-            };
-            inflight.add(settleOnce);
-            detachOnTimeout = () => inflight.delete(settleOnce);
-            void (async () => {
-                let result;
-                try {
-                    const d = await handle.notify?.(notification, opts);
-                    if (d === "parked") {
-                        result = handle.retainedContinuation === true ? { ok: true, disposition: "parked" } : { ok: false, reason: "not_running" };
-                    }
-                    else {
-                        result = { ok: true, disposition: "queued" };
-                    }
-                }
-                catch {
-                    result = { ok: false, reason: "not_running" };
-                }
-                settleOnce(result);
-            })();
-        }), { ok: true, disposition: "pending" }, () => detachOnTimeout?.());
-    }
-    runningBackgroundAgentLabels(access) {
-        const out = [];
-        for (const h of this.handles.values()) {
-            if (h.type !== "background_agent" || h.status !== "running" || !canAccess(h, access))
-                continue;
-            const label = h.name ?? h.description;
-            out.push(label ? `${h.id} (${label})` : h.id);
-        }
-        return out;
     }
     deliverConfirmTimeoutMs = 10_000;
     lastGcAt = 0;
@@ -2501,70 +1094,8 @@ ${clipTaskOutput(row.finalOutputFull ?? row.finalOutput)}` : "(no result text)"}
             await sleepPollStep(deadline, signal);
         }
     }
-    fireServedTerminal(handle) {
-        const cb = handle.onServedTerminal;
-        if (!cb)
-            return;
-        handle.onServedTerminal = undefined;
-        try {
-            cb();
-        }
-        catch {
-        }
-    }
     async pollWorkflow(handle, access, deadline, signal) {
-        const store = handle.store;
-        if (store) {
-            for (;;) {
-                const run = await store.get(handle.runId);
-                if (!run || !canAccessWorkflowRun(run, access))
-                    break;
-                if (run.status !== "running" || deadline === undefined || Date.now() >= deadline || signal?.aborted) {
-                    const out = formatWorkflowRun(run);
-                    if (run.status === "running" && deadline !== undefined && Date.now() >= deadline)
-                        out.details.retrieval_status = "timeout";
-                    else if (run.status !== "running")
-                        this.fireServedTerminal(handle);
-                    return out;
-                }
-                await sleepPollStep(deadline, signal);
-            }
-        }
-        while (handle.status === "running" && deadline !== undefined && Date.now() < deadline && !signal?.aborted) {
-            await sleepPollStep(deadline, signal);
-        }
-        if (handle.status !== "running")
-            this.fireServedTerminal(handle);
-        return {
-            content: JSON.stringify({
-                task_id: handle.id,
-                runId: handle.id,
-                type: "workflow",
-                status: handle.status,
-                ...(handle.status === "completed" && handle.result !== undefined
-                    ? { result: delimitUntrusted("workflow result", handle.result) }
-                    : {}),
-                ...(handle.status === "failed" && handle.error !== undefined
-                    ? { error: delimitUntrusted("workflow error", handle.error) }
-                    : {}),
-                note: handle.status === "running"
-                    ? "still running — poll again shortly."
-                    : handle.status === "completed"
-                        ? handle.result !== undefined
-                            ? "completed — `result` above is the workflow's return value."
-                            : "completed — its result was delivered on the completion notification."
-                        : handle.status === "failed" && handle.error !== undefined
-                            ? "failed — see error."
-                            : "workflow reached a terminal state.",
-            }),
-            details: {
-                task_id: handle.id,
-                type: "workflow",
-                status: handle.status,
-                retrieval_status: handle.status === "running" && deadline !== undefined && Date.now() >= deadline ? "timeout" : "success",
-                ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
-            },
-        };
+        return pollWorkflowLane(handle, access, deadline, signal);
     }
     async stopBackgroundBash(handle) {
         const wasRunning = handle.status === "running";
@@ -2637,367 +1168,30 @@ ${clipTaskOutput(row.finalOutputFull ?? row.finalOutput)}` : "(no result text)"}
         };
     }
     async pollMonitor(handle, filter, deadline, signal) {
-        let rx;
-        if (filter !== undefined) {
-            try {
-                rx = new RegExp(filter);
-            }
-            catch {
-                return {
-                    content: `Error (TaskOutput): invalid filter regex: ${filter}`,
-                    details: { task_id: handle.id, type: "monitor", status: handle.status, retrieval_status: "not_ready" },
-                    isError: true,
-                };
-            }
-        }
-        while (handle.status === "running" && deadline !== undefined && Date.now() < deadline && !signal?.aborted) {
-            await sleepPollStep(deadline, signal);
-        }
-        const spool = handle.spool;
-        const shape = (text) => clipTaskOutput(rx ? text.split(/\r?\n/).filter((l) => rx.test(l)).join("\n") : text, handle.outputFile);
-        const running = handle.status === "running";
-        const retrieval = running && deadline !== undefined && Date.now() >= deadline ? "timeout" : "success";
-        const timedOutClause = spool.timedOut === true ? ` (timed out after ${spool.timeoutSec !== undefined ? `${spool.timeoutSec}s` : "its background time budget"})` : "";
-        const displayStatus = (spool.exitCode !== undefined ? `exited(code ${spool.exitCode})` : running ? "running" : handle.status) + timedOutClause;
-        const rolledNote = spool.rolledChars > 0 ? `[!] ${spool.rolledChars} earlier char(s) dropped from the spool (memory bound)\n` : "";
-        const droppedNote = (spool.droppedBytes ?? 0) > 0
-            ? `[!] ${spool.droppedBytes} earlier byte(s) permanently dropped before this window (8MB buffer evicted)\n`
-            : spool.dropUnknown === true
-                ? "[!] an unknown amount of earlier output was permanently dropped before this window (buffer evicted)\n"
-                : "";
-        const drainNote = spool.drainFailed === true ? "[!] the final output drain at stop failed — the tail of the output may be missing\n" : "";
-        const stdoutHeading = droppedNote !== "" || drainNote !== "" ? "stdout (re-readable spool — INCOMPLETE, see note above)" : "stdout (full, re-readable)";
-        const body = `status: ${displayStatus}\n${rolledNote}${droppedNote}${drainNote}--- ${stdoutHeading} ---\n${shape(spool.stdout) || "(none)"}\n` +
-            `--- stderr ---\n${shape(spool.stderr) || "(none)"}`;
-        return {
-            content: delimitUntrusted(`TaskOutput ${handle.id}`, body),
-            details: {
-                task_id: handle.id,
-                type: "monitor",
-                status: handle.status,
-                retrieval_status: retrieval,
-                ...(handle.status === "killed" && handle.stoppedBy !== undefined ? { stoppedBy: handle.stoppedBy } : {}),
-                ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
-                details: {
-                    status: running ? "running" : handle.status,
-                    exitCode: spool.exitCode,
-                    ...(spool.droppedBytes !== undefined ? { bytesDroppedBeforeCursor: spool.droppedBytes } : {}),
-                    ...(spool.timedOut === true ? { timedOut: true, ...(spool.timeoutSec !== undefined ? { timeoutSec: spool.timeoutSec } : {}) } : {}),
-                },
-            },
-        };
+        return pollMonitorLane(handle, filter, deadline, signal);
     }
     async stopMonitor(handle) {
-        const wasRunning = handle.status === "running";
-        if (handle.watcher !== undefined) {
-            handle.timers.clearInterval(handle.watcher);
-            handle.watcher = undefined;
-        }
-        if (wasRunning && handle.tickInFlight !== true) {
-            try {
-                const drained = await handle.env.pollBackground(handle.shellId);
-                if (drained.ok) {
-                    const lines = this.absorbMonitorPoll(handle, drained.value);
-                    const finalLines = handle.lineBuf !== "" ? [...lines, handle.lineBuf] : lines;
-                    handle.lineBuf = "";
-                    if (finalLines.length > 0 && handle.status === "running") {
-                        handle.seq += 1;
-                        handle.updatedAt = Date.now();
-                        this.emitMonitorEvent(handle, {
-                            task_id: handle.id,
-                            task_type: "monitor",
-                            ...(handle.toolUseId !== undefined ? { toolUseId: handle.toolUseId } : {}),
-                            status: "event",
-                            seq: handle.seq,
-                            lines: finalLines,
-                            summary: `${(handle.description ?? "monitor").slice(0, 200)} — ${finalLines.length} final output line(s) drained at stop${firstDropNote(handle.spool)}`,
-                            result: clipMonitorEvent(finalLines.join("\n")),
-                        });
-                    }
-                }
-                else {
-                    handle.spool.drainFailed = true;
-                }
-            }
-            catch {
-                handle.spool.drainFailed = true;
-            }
-        }
-        const drainNote = handle.spool.drainFailed === true ? " (the final output drain failed — TaskOutput may be missing the last window)" : "";
-        this.markStopSource(handle.id, "parent");
-        const r = await handle.env.killBackground(handle.shellId);
-        if (handle.status !== "running") {
-            return {
-                content: wasRunning ? `Terminated ${handle.id}.${drainNote}` : alreadyTerminalStopNote(handle.id, handle.status),
-                details: {
-                    task_id: handle.id,
-                    type: "monitor",
-                    status: handle.status,
-                    retrieval_status: "success",
-                    ...(handle.stoppedBy !== undefined ? { stoppedBy: handle.stoppedBy } : {}),
-                    ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
-                },
-            };
-        }
-        if (!r.ok) {
-            if (r.error.code === "not_found") {
-                if (handle.stoppedBy === undefined)
-                    handle.stoppedBy = handle.stopSource ?? "parent";
-                handle.status = "killed";
-                handle.updatedAt = Date.now();
-                mintCompletionId(handle);
-                this.pokeBgQuiescence(handle.owner);
-                return {
-                    content: `Terminated ${handle.id} (the process was already gone).${drainNote}`,
-                    details: {
-                        task_id: handle.id,
-                        type: "monitor",
-                        status: "killed",
-                        retrieval_status: "success",
-                        stoppedBy: handle.stoppedBy,
-                        ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
-                    },
-                };
-            }
-            if (handle.watcher === undefined)
-                this.startMonitorWatcher(handle.id);
-            const retrieval_status = r.error.code === "timeout" ? "timeout" : "not_ready";
-            return {
-                content: `Error (TaskStop): ${r.error.message} — the kill did not land; the process may still be running. The watch keeps running: events and the terminal notification still fire.`,
-                isError: true,
-                details: { task_id: handle.id, type: "monitor", status: handle.status, retrieval_status, error: r.error.code },
-            };
-        }
-        if (handle.status === "running") {
-            if (handle.stoppedBy === undefined)
-                handle.stoppedBy = handle.stopSource ?? "parent";
-            handle.status = "killed";
-            handle.updatedAt = Date.now();
-            mintCompletionId(handle);
-            this.pokeBgQuiescence(handle.owner);
-        }
-        return {
-            content: `Terminated ${handle.id}.${drainNote}`,
-            details: {
-                task_id: handle.id,
-                type: "monitor",
-                status: handle.status,
-                retrieval_status: "success",
-                ...(handle.stoppedBy !== undefined ? { stoppedBy: handle.stoppedBy } : {}),
-                ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
-            },
-        };
-    }
-    async pollBackgroundAgent(handle, deadline, signal) {
-        while (handle.status === "running" && deadline !== undefined && Date.now() < deadline && !signal?.aborted) {
-            await sleepPollStep(deadline, signal);
-        }
-        const running = handle.status === "running";
-        const retrieval = running && deadline !== undefined && Date.now() >= deadline ? "timeout" : "success";
-        if (handle.status === "parked") {
-            return {
-                content: delimitUntrusted(`TaskOutput ${handle.id}`, `status: parked
-The agent is durably suspended, waiting for an approval decision. It resumes when the pending approval is decided (durable approval inbox), or lands failed if the approval expires.`),
-                details: {
-                    task_id: handle.id,
-                    type: "background_agent",
-                    status: "parked",
-                    retrieval_status: "success",
-                    ...(handle.cycleSeq !== undefined ? { seq: handle.cycleSeq } : {}),
-                },
-            };
-        }
-        const body = running
-            ? `status: running
-The agent is still working — you will be notified when it completes.`
-            : `status: ${handle.status}
-${handle.error ? `error: ${handle.error}
-` : ""}${handle.result ? `--- result${handle.resultIsPartial ? " (partial — produced before the task was stopped)" : ""} ---
-${clipTaskOutput(handle.resultFull ?? handle.result, handle.outputFile)}` : "(no result text)"}`;
-        return {
-            content: delimitUntrusted(`TaskOutput ${handle.id}`, body),
-            details: {
-                task_id: handle.id,
-                type: "background_agent",
-                status: handle.status,
-                retrieval_status: retrieval,
-                ...(handle.cycleSeq !== undefined ? { seq: handle.cycleSeq } : {}),
-                ...(handle.status === "killed" && handle.stoppedBy !== undefined ? { stoppedBy: handle.stoppedBy } : {}),
-                ...(handle.resultIsPartial ? { partial_result: true } : {}),
-                ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
-            },
-        };
-    }
-    async stopBackgroundAgent(handle) {
-        const entryStatus = handle.status;
-        if (handle.status === "parked") {
-            const arbiter = handle.resolveParkedStop;
-            if (arbiter === undefined) {
-                return {
-                    content: `${handle.id} is parked on a pending approval — stop it by deciding (deny/expire) the pending approval in the durable approval inbox.`,
-                    details: { task_id: handle.id, type: "background_agent", status: "parked", retrieval_status: "not_ready", error: "parked_pending_approval" },
-                };
-            }
-            let stopWon = false;
-            let arbiterUnreachable = false;
-            try {
-                stopWon = await arbiter();
-            }
-            catch {
-                stopWon = false;
-                arbiterUnreachable = true;
-            }
-            if (stopWon && handle.status === "parked") {
-                this.markStopSource(handle.id, "parent");
-                handle.status = "killed";
-                handle.stoppedBy = handle.stopSource ?? "parent";
-                handle.updatedAt = Date.now();
-                mintCompletionId(handle);
-                handle.parkedCheckpointToken = undefined;
-                handle.resolveParkedStop = undefined;
-                this.pokeBgQuiescence(handle.owner);
-                {
-                    const lane = handle.durable;
-                    if (lane !== undefined) {
-                        try {
-                            const live = await lane.store.get(handle.id, lane.record.scope);
-                            if (live && (live.status === "parked" || live.status === "running")) {
-                                const term = structuredClone(live);
-                                term.status = "killed";
-                                if (handle.stoppedBy !== undefined)
-                                    term.stoppedBy = handle.stoppedBy;
-                                term.settledAt = Date.now();
-                                term.updatedAt = Date.now();
-                                delete term.parkedCheckpointToken;
-                                delete term.parkClaimId;
-                                delete term.parkedAt;
-                                await lane.store.update(handle.id, lane.record.scope, term, { rev: live.rev });
-                            }
-                        }
-                        catch {
-                        }
-                    }
-                }
-                this.durableAgentWrite(handle, {
-                    status: "killed",
-                    settledAt: Date.now(),
-                    ...(handle.stoppedBy !== undefined ? { stoppedBy: handle.stoppedBy } : {}),
-                    ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
-                }, ["parkedCheckpointToken", "parkClaimId"]);
-                return {
-                    content: `Terminated ${handle.id} (pending approval expired).`,
-                    details: {
-                        task_id: handle.id,
-                        type: "background_agent",
-                        status: "killed",
-                        retrieval_status: "success",
-                        ...(handle.cycleSeq !== undefined ? { seq: handle.cycleSeq } : {}),
-                        ...(handle.stoppedBy !== undefined ? { stoppedBy: handle.stoppedBy } : {}),
-                        ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
-                    },
-                };
-            }
-            if (arbiterUnreachable) {
-                return {
-                    content: `${handle.id} was not stopped: the approval arbitration store was unreachable — the row stays parked; retry the stop.`,
-                    details: { task_id: handle.id, type: "background_agent", status: handle.status, retrieval_status: "not_ready", error: "park_arbiter_unreachable" },
-                    isError: true,
-                };
-            }
-            return {
-                content: `${handle.id} was not stopped: its pending approval was already consumed (a resume won the arbitration).`,
-                details: { task_id: handle.id, type: "background_agent", status: handle.status, retrieval_status: "not_ready", error: "park_resume_won" },
-                isError: true,
-            };
-        }
-        if (handle.status === "running") {
-            this.markStopSource(handle.id, "parent");
-            handle.abort.abort();
-            handle.status = "killed";
-            handle.stoppedBy = handle.stopSource ?? "parent";
-            handle.updatedAt = Date.now();
-            mintCompletionId(handle);
-            handle.notify = undefined;
-            for (const [, , qResolve] of handle.preAttachQueue ?? [])
-                qResolve?.({ ok: false, reason: "not_running" });
-            handle.preAttachQueue = undefined;
-            for (const r of [...(handle.inFlightDirect ?? [])])
-                r({ ok: false, reason: "not_running" });
-            handle.inFlightDirect = undefined;
-            this.pokeBgQuiescence(handle.owner);
-            this.durableAgentWrite(handle, {
-                status: "killed",
-                settledAt: Date.now(),
-                ...(handle.stoppedBy !== undefined ? { stoppedBy: handle.stoppedBy } : {}),
-                ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
-            });
-        }
-        return {
-            content: entryStatus === "running" ? `Terminated ${handle.id}.` : alreadyTerminalStopNote(handle.id, handle.status),
-            details: {
-                task_id: handle.id,
-                type: "background_agent",
-                status: handle.status,
-                retrieval_status: "success",
-                ...(handle.cycleSeq !== undefined ? { seq: handle.cycleSeq } : {}),
-                ...(handle.status === "killed" && handle.stoppedBy !== undefined ? { stoppedBy: handle.stoppedBy } : {}),
-                ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
-            },
-        };
+        return stopMonitorLane(this.core, handle);
     }
     async stopWorkflow(handle) {
-        if (handle.status !== "running") {
-            return {
-                content: JSON.stringify({
-                    task_id: handle.id,
-                    runId: handle.id,
-                    type: "workflow",
-                    status: handle.status,
-                    stopped: false,
-                    note: `workflow already ${handle.status} — nothing to stop; poll TaskOutput for its final state.`,
-                }),
-                details: { task_id: handle.id, type: "workflow", status: handle.status, retrieval_status: "success" },
-            };
-        }
-        handle.status = "cancelled";
-        handle.updatedAt = Date.now();
-        handle.handle.cancel("TaskStop requested");
-        return {
-            content: JSON.stringify({
-                task_id: handle.id,
-                runId: handle.id,
-                type: "workflow",
-                status: "cancelled",
-                stopped: true,
-                note: "workflow cancellation requested; durable run status maps cancellation to failed when it finalizes.",
-            }),
-            details: { task_id: handle.id, type: "workflow", status: "cancelled", retrieval_status: "success" },
-        };
+        return stopWorkflowLane(handle);
     }
 }
 export const defaultTaskRegistry = new TaskRegistry();
 export function createTaskOutputTool(opts) {
+    const caps = { ...REGISTRY_TASK_TOOL_CAPS, notification: opts.notificationWired !== false };
     return defineTool({
-        name: "TaskOutput",
+        name: TASK_OUTPUT_TOOL_NAME,
         aliases: [...TASK_OUTPUT_ALIASES],
-        contract: { contractId: "core.task_output@1", implementationRevision: "1" },
-        description: "[Deprecated] — for background Bash tasks, prefer Read on the output file path; for agent tasks, use the Agent tool result directly. " +
-            "DEPRECATED: Background tasks return their output file path in the tool result, and you receive a <task-notification> with the same path when the task completes. " +
-            "Retrieve output or status for a background task by task_id. Supports background Bash tasks and workflow " +
-            "tasks returned by RunWorkflow. Returns only the caller's own task scope; unknown and out-of-scope ids are " +
-            "reported the same way. Legacy bash_id and runId arguments are accepted for compatibility.",
-        parameters: Type.Object({
-            task_id: Type.Optional(Type.String({ description: "The task_id returned by Bash(run_in_background) or RunWorkflow." })),
-            block: Type.Optional(Type.Boolean({ description: "Whether to wait for completion (default true — the call waits until the task finishes or `timeout`, saving re-poll turns). Pass false for an instantaneous snapshot." })),
-            timeout: Type.Optional(Type.Number({ description: "Optional timeout in milliseconds when block is true (default 30000, max 600000)." })),
-            filter: Type.Optional(Type.String({ description: "Optional regex filter for background Bash output (sema extension)." })),
-        }),
+        contract: TASK_OUTPUT_CONTRACT,
+        description: composeTaskOutputDescription(caps),
+        parameters: composeTaskOutputParams(caps),
         effect: "read",
         execute: async (rawArgs, ctx) => {
             const args = rawArgs;
-            const id = firstString(args.task_id, args.bash_id, args.runId);
+            const id = resolveTaskIdArg(args.task_id, args.bash_id, args.runId);
             if (!id)
-                return errorResult("Error (TaskOutput): Missing required parameter: task_id");
+                return errorResult(TASK_OUTPUT_MISSING_ID_MESSAGE);
             const requestedMs = typeof args.timeout === "number" ? args.timeout : undefined;
             let effectiveTimeoutMs = requestedMs;
             let waitClampNote = "";
@@ -3034,24 +1228,17 @@ export function createTaskOutputTool(opts) {
 }
 export function createTaskStopTool(opts) {
     return defineTool({
-        name: "TaskStop",
+        name: TASK_STOP_TOOL_NAME,
         aliases: [...TASK_STOP_ALIASES],
-        contract: { contractId: "core.task_stop@1", implementationRevision: "1" },
-        description: "- Stops a running background task by its ID\n" +
-            "- Takes a task_id parameter identifying the task to stop\n" +
-            "- To stop a background agent spawned with a name, pass that name as task_id\n" +
-            "- Returns a success or failure status\n" +
-            "- Use this tool when you need to terminate a long-running task",
-        parameters: Type.Object({
-            task_id: Type.Optional(Type.String({ description: "The ID of the background task to stop" })),
-            shell_id: Type.Optional(Type.String({ description: "Deprecated: use task_id instead" })),
-        }),
+        contract: TASK_STOP_CONTRACT,
+        description: composeTaskStopDescription(REGISTRY_TASK_TOOL_CAPS),
+        parameters: TASK_STOP_PARAMS,
         effect: "write",
         execute: async (rawArgs, ctx) => {
             const args = rawArgs;
-            const id = firstString(args.task_id, args.shell_id, args.runId);
+            const id = resolveTaskIdArg(args.task_id, args.shell_id, args.runId);
             if (!id)
-                return errorResult("Missing required parameter: task_id");
+                return errorResult(TASK_STOP_MISSING_ID_MESSAGE);
             const r = await opts.registry.stopTask(id, { owner: ctx.taskId ?? opts.owner, scope: ctx.principal ?? opts.scope, ...((ctx.sessionId ?? opts.sessionId) !== undefined ? { sessionId: ctx.sessionId ?? opts.sessionId } : {}) }, { workflowStore: opts.workflowStore, agentStore: opts.agentStore });
             const { type: taskType, ...rest } = r.details;
             return {