@agimon-ai/doompi-task 0.0.1-alpha.76 → 0.0.1-alpha.77

package/dist/extensions/mcp.mjs

@@ -0,0 +1,1836 @@
+import { defineMcpPlugin, defineMcpTool } from "@agimon-ai/doompi-core/mcp-facet";
+import { DOOM_DELEGATION_ACCEPTED_EVENT, DOOM_DELEGATION_FINISHED_EVENT, DOOM_DELEGATION_STARTED_EVENT, DOOM_DELEGATION_UPDATED_EVENT, InlineAgentSchema } from "@agimon-ai/doompi-core/delegation";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { SUBAGENT_CHILD_ENV, SUBAGENT_PARENT_SESSION_ENV } from "@agimon-ai/doompi-core/child-process";
+import { Check } from "typebox/value";
+import { Type } from "typebox";
+//#region src/services/config/index.ts
+const MAX_TASKS_ENV = "DOOM_TASK_MAX_TASKS";
+const DELEGATION_TIMEOUT_MS_ENV = "DOOM_TASK_DELEGATION_TIMEOUT_MS";
+/** Deliberately under the subagents auto-drain ceiling (30 min) so a headless
+* session still gets the failure and a model turn before draining gives up. */
+const DEFAULT_DELEGATION_TIMEOUT_MS = 12e5;
+/** Maximum number of non-deleted tasks retained on one board. */
+function getMaxTasks(env = process.env) {
+	const raw = Number(env[MAX_TASKS_ENV]);
+	return Number.isSafeInteger(raw) && raw > 0 ? raw : 15;
+}
+/** How long a delegated run may go without reporting a result. */
+function getDelegationTimeoutMs(env = process.env) {
+	const raw = Number(env[DELEGATION_TIMEOUT_MS_ENV]);
+	return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_DELEGATION_TIMEOUT_MS;
+}
+//#endregion
+//#region src/models/taskGraph.ts
+const COMPLETED_STATUS = "completed";
+const DELETED_STATUS$2 = "deleted";
+/** True when a non-empty list has no visible work left to finish. */
+function isTaskListComplete(taskList) {
+	const visible = taskList.filter((task) => task.status !== DELETED_STATUS$2);
+	return visible.length > 0 && visible.every((task) => task.status === COMPLETED_STATUS);
+}
+/**
+* Would merging `newBlockedBy` into `taskId`'s dependencies introduce a cycle?
+*
+* Takes the proposed additions explicitly so the reducer can ask the question
+* before mutating anything.
+*/
+function detectCycle(taskList, taskId, newBlockedBy) {
+	const edges = /* @__PURE__ */ new Map();
+	for (const task of taskList) if (task.id === taskId) edges.set(task.id, [.../* @__PURE__ */ new Set([...task.blockedBy ?? [], ...newBlockedBy])]);
+	else edges.set(task.id, task.blockedBy ? [...task.blockedBy] : []);
+	const visiting = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const hasCycleFrom = (node) => {
+		if (visiting.has(node)) return true;
+		if (visited.has(node)) return false;
+		visiting.add(node);
+		for (const next of edges.get(node) ?? []) if (hasCycleFrom(next)) return true;
+		visiting.delete(node);
+		visited.add(node);
+		return false;
+	};
+	for (const node of edges.keys()) if (hasCycleFrom(node)) return true;
+	return false;
+}
+/** Inverse adjacency: for each task, which tasks list it in their blockedBy. */
+function deriveBlocks(taskList) {
+	const blocks = /* @__PURE__ */ new Map();
+	for (const task of taskList) for (const dep of task.blockedBy ?? []) {
+		const dependents = blocks.get(dep) ?? [];
+		dependents.push(task.id);
+		blocks.set(dep, dependents);
+	}
+	return blocks;
+}
+/**
+* Blocking dependencies of a task that are not yet resolved.
+*
+* `completed` clears a dependency; `failed` deliberately does not, so a failed
+* delegation keeps its dependents blocked instead of silently releasing work
+* that was never actually finished.
+*/
+function unresolvedBlockers(taskList, task) {
+	return (task.blockedBy ?? []).filter((dep) => {
+		const blocker = taskList.find((candidate) => candidate.id === dep);
+		if (!blocker) return false;
+		return blocker.status !== COMPLETED_STATUS && blocker.status !== DELETED_STATUS$2;
+	});
+}
+function isBlocked(taskList, task) {
+	return unresolvedBlockers(taskList, task).length > 0;
+}
+//#endregion
+//#region src/types/telemetry.ts
+const TASK_EVENT = {
+	notificationFailed: "doom_task.notification_failed",
+	storeReadFailed: "doom_task.store_read_failed",
+	storeLockTimeout: "doom_task.store_lock_timeout",
+	storeLockBreakFailed: "doom_task.store_lock_break_failed",
+	storeWatchFailed: "doom_task.store_watch_failed",
+	storeListenerFailed: "doom_task.store_listener_failed",
+	storeCommitListenerFailed: "doom_task.store_commit_listener_failed",
+	storeSweepFailed: "doom_task.store_sweep_failed",
+	sessionStartFailed: "doom_task.session_start_failed",
+	sessionStartDegraded: "doom_task.session_start_degraded",
+	toolFailed: "doom_task.tool_failed",
+	delegationRequestFailed: "doom_task.delegation_request_failed",
+	delegationStartFailed: "doom_task.delegation_start_failed",
+	delegationResponseFailed: "doom_task.delegation_response_failed",
+	delegationSettleFailed: "doom_task.delegation_settle_failed",
+	delegationTimedOut: "doom_task.delegation_timed_out",
+	delegationOrphaned: "doom_task.delegation_orphaned",
+	delegationAssigned: "doom_task.delegation_assigned",
+	delegationCompleted: "doom_task.delegation_completed"
+};
+//#endregion
+//#region src/models/task.ts
+const DELETED_STATUS$1 = "deleted";
+function emptyDocument() {
+	return {
+		version: 1,
+		rev: 0,
+		nextId: 1,
+		tasks: []
+	};
+}
+/**
+* A delegation is "live" while the owning run may still produce a response.
+*
+* Takes the delegation shape rather than `Task` so the cockpit's `WebTask`,
+* which carries the state as a plain string, answers the question the same way
+* the store does.
+*/
+function isDelegationActive(task) {
+	const state = task.delegation?.state;
+	return state === "requested" || state === "running";
+}
+//#endregion
+//#region src/services/processLiveness/index.ts
+/**
+* Is a process still running?
+*
+* Signal 0 performs the permission and existence check without delivering a
+* signal. EPERM means the process exists but belongs to another user, which
+* still counts as alive.
+*/
+function isProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+//#endregion
+//#region src/services/reconcile/index.ts
+const ERR_ORPHANED_BY_RESTART = "Delegation orphaned by harness restart";
+const ERR_ORPHANED_BY_SESSION = "Delegation orphaned by session restart";
+/**
+* Recover tasks that no longer have anyone able to finish them.
+*
+* A subagent run dies with the harness that spawned it, but the store file
+* outlives both, so a crash leaves tasks stuck in `in_progress` forever. Two
+* kinds of delegation qualify as dead:
+*
+* - the owning pid is gone, so nothing is left to report a result;
+* - the owning pid is *this* process, yet the request is absent from the live
+*   set. Settling requires an in-memory record, so an in-process session
+*   restart (which clears that map without writing to the store) leaves rows
+*   nothing can ever resolve. Checking pid liveness alone misses these, because
+*   the pid is our own and very much alive.
+*
+* Delegations owned by a different, still-running pid belong to a parallel
+* session and are left untouched.
+*/
+function reconcileOrphanedDelegations(document, now = (/* @__PURE__ */ new Date()).toISOString(), isAlive = isProcessAlive, self) {
+	const orphaned = [];
+	const tasks = document.tasks.map((task) => {
+		if (!isDelegationActive(task)) return task;
+		const pid = task.delegation?.pid;
+		if (pid === void 0) return task;
+		const abandonedHere = self !== void 0 && pid === self.pid && !self.liveRequestIds.has(task.delegation.requestId);
+		if (!abandonedHere && isAlive(pid)) return task;
+		const recovered = {
+			...task,
+			status: "pending",
+			updatedAt: now,
+			delegation: {
+				...task.delegation,
+				state: "failed",
+				endedAt: now,
+				result: {
+					status: "failed",
+					error: abandonedHere ? ERR_ORPHANED_BY_SESSION : ERR_ORPHANED_BY_RESTART
+				}
+			}
+		};
+		orphaned.push(recovered);
+		return recovered;
+	});
+	if (orphaned.length === 0) return {
+		document,
+		orphaned
+	};
+	return {
+		document: {
+			...document,
+			tasks
+		},
+		orphaned
+	};
+}
+//#endregion
+//#region src/services/delegation/index.ts
+const NOTIFY_CUSTOM_TYPE = "doom-task-notify";
+const DEFAULT_STARTED_TIMEOUT_MS = 5e3;
+const DEFAULT_RUN_TIMEOUT_MS = 12e5;
+const DEFAULT_CANCEL_TIMEOUT_MS = 1e4;
+const MAX_RUN_TIMEOUT_GRACE_MS = 6e4;
+const MAX_STORED_OUTPUT = 4e3;
+/**
+* Cap on files rendered into a brief. Exported so the tool schema can state the
+* same number to the model rather than restating it and drifting.
+*/
+const MAX_BRIEF_NOTES = 1500;
+const COMPLETED_STATE = "completed";
+const FAILED_STATE = "failed";
+const CANCELLED_STATE = "cancelled";
+const TIMED_OUT_STATUS = "timed_out";
+const DELETED_STATUS = "deleted";
+const TASK_ID_ATTRIBUTE = "task.id";
+const REQUEST_ID_ATTRIBUTE = "delegation.request_id";
+const AGENT_ATTRIBUTE = "delegation.agent_name";
+const PID_ATTRIBUTE = "delegation.pid";
+const CONTEXT_PRESENT_ATTRIBUTE = "delegation.context_present";
+const CONTEXT_FILE_COUNT_ATTRIBUTE = "delegation.context_file_count";
+const CONTEXT_NOTES_LENGTH_ATTRIBUTE = "delegation.context_notes_length";
+const BRIEF_LENGTH_ATTRIBUTE = "delegation.brief_length";
+const TOOL_COUNT_ATTRIBUTE = "delegation.tool_count";
+const DURATION_MS_ATTRIBUTE = "delegation.duration_ms";
+const OUTCOME_ATTRIBUTE = "delegation.outcome";
+const ERR_NO_RUNTIME = "No subagent runtime responded. Delegation needs the subagents extension — relaunch doom-pi with agents enabled.";
+const ERR_CHILD_SESSION = "assign is only available in the main session. Update this task directly instead of re-delegating it.";
+const ERR_CANCEL_UNACKNOWLEDGED = "Subagent did not acknowledge the cancel request";
+function truncate(value, limit = MAX_STORED_OUTPUT) {
+	if (!value) return void 0;
+	return value.length <= limit ? value : `${value.slice(0, limit)}\n… (truncated)`;
+}
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** Normalize the parent context with host-owned path semantics. */
+function briefContext(options, cwd, platform) {
+	const files = /* @__PURE__ */ new Set();
+	for (const entry of options.relevantFiles ?? []) {
+		if (files.size >= 12) break;
+		const normalized = platform.formatBriefPath(entry.trim(), cwd);
+		if (normalized && normalized !== ".") files.add(normalized);
+	}
+	return {
+		files: [...files],
+		notes: truncate(options.priorFindings?.trim(), MAX_BRIEF_NOTES)
+	};
+}
+/**
+* Build the brief handed to the subagent.
+*
+* Doom Team owns the child tool surface and the parent owns the task record.
+* Keeping those responsibilities explicit prevents a child from attempting to
+* call a task tool that is not loaded in its runtime, while still giving it a
+* reliable path to ask the parent for a decision.
+*
+* The context pack is the parent's verified discovery handed over. The whole
+* block is omitted when nothing was supplied: this brief is the child's whole
+* starting context, so an empty section header is pure token cost.
+*/
+function buildBrief(task, instructions, context) {
+	const sections = [`Task #${task.id}: ${task.subject}`];
+	if (task.description) sections.push(task.description);
+	if (instructions) sections.push(instructions);
+	if (context.files.length > 0 || context.notes) {
+		const contextLines = ["Parent context — consume before repository discovery:"];
+		if (context.files.length > 0) contextLines.push(`- Parent-verified files (read these first with direct reads): ${context.files.join(", ")}`);
+		if (context.notes) contextLines.push(`- Established facts (do not re-derive unless direct evidence contradicts them): ${context.notes}`);
+		contextLines.push("This pack satisfies initial repository/context exploration. Do not begin with repository-wide listing, find, or grep. Expand only after consuming the pack and naming a concrete missing dependency or invalid path; search narrowly for that item and state why.");
+		sections.push(contextLines.join("\n"));
+	}
+	sections.push("Coordination: work directly without changing the task record; ask main through intercom only for blockers or decisions; report changed files and verification when done.");
+	return sections.join("\n\n");
+}
+/**
+* Owns the lifecycle of tasks delegated to subagents.
+*
+* Delegation rides Team's injected Cordis service rather than spawning
+* processes directly, so doom-task stays decoupled from the subagent runtime
+* and degrades to a clear error when that service is not loaded.
+*
+* Liveness rule: every entry in `pendingTasks` has a timer armed against it, so
+* a delegation always has a deadline no matter which phase it is in. Losing
+* that pairing is what previously left tasks running forever.
+*/
+var DelegationManager = class DelegationManager {
+	options;
+	progress = /* @__PURE__ */ new Map();
+	pendingTasks = /* @__PURE__ */ new Map();
+	settlingRequests = /* @__PURE__ */ new Set();
+	timers = /* @__PURE__ */ new Map();
+	subscriptions = [];
+	service;
+	constructor(options) {
+		this.options = options;
+	}
+	now() {
+		return this.options.now?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+	}
+	nowMs() {
+		return this.options.nowMs?.() ?? Date.now();
+	}
+	get runTimeoutMs() {
+		return this.options.runTimeoutMs ?? DEFAULT_RUN_TIMEOUT_MS;
+	}
+	report(event, error, attributes) {
+		this.options.report?.error(event, error, attributes);
+	}
+	/** True in a session that is itself a subagent child. */
+	get isChildSession() {
+		return Boolean(this.options.platform.environment.PI_SUBAGENT_CHILD);
+	}
+	/** Live progress for a task, for the overlay to render. */
+	progressFor(task) {
+		const requestId = task.delegation?.requestId;
+		return requestId ? this.progress.get(requestId) : void 0;
+	}
+	/** Displayed runtime duration, rebased from the latest child observation. */
+	static elapsedMs(progress, nowMs = Date.now()) {
+		const baseline = progress.durationMs ?? 0;
+		const observedAt = progress.durationObservedAt ?? nowMs;
+		return baseline + Math.max(0, nowMs - observedAt);
+	}
+	/** Rebind to the active Team service without stacking lifecycle listeners. */
+	bind(ctx, service) {
+		this.unbind();
+		this.service = service;
+		this.subscriptions.push(ctx.on(DOOM_DELEGATION_ACCEPTED_EVENT, (event) => {
+			this.handleAccepted(event);
+		}), ctx.on(DOOM_DELEGATION_STARTED_EVENT, (event) => {
+			this.handleStarted(event);
+		}), ctx.on(DOOM_DELEGATION_UPDATED_EVENT, (event) => {
+			this.handleUpdate(event);
+		}), ctx.on(DOOM_DELEGATION_FINISHED_EVENT, (event) => {
+			this.handleResponse(event).catch((error) => {
+				this.report(TASK_EVENT.delegationResponseFailed, error, { [REQUEST_ID_ATTRIBUTE]: event.requestId });
+			});
+		}));
+		return () => {
+			if (this.service === service) this.unbind();
+		};
+	}
+	/** Remove only the cross-package binding; task state and watchdogs remain live. */
+	unbind() {
+		for (const unsubscribe of this.subscriptions.splice(0)) unsubscribe();
+		this.service = void 0;
+	}
+	/** Items still in flight, surfaced so auto-stop will not kill the harness. */
+	listActiveWork() {
+		return [...this.pendingTasks.entries()].flatMap(([requestId, pending]) => pending.sessionId ? [{
+			id: `task-${pending.taskId}:${requestId}`,
+			sessionId: pending.sessionId
+		}] : []);
+	}
+	/**
+	* Return tasks nothing can finish to `pending`.
+	*
+	* The live request set is read inside the mutation so a delegation assigned
+	* while the lock was contended is not mistaken for a leftover.
+	*/
+	async reconcile(isCurrent = () => true) {
+		const { value } = await this.options.store.mutate((document) => {
+			if (!isCurrent()) return { value: [] };
+			const result = reconcileOrphanedDelegations(document, this.now(), void 0, {
+				pid: this.options.platform.processId,
+				liveRequestIds: new Set(this.pendingTasks.keys())
+			});
+			if (result.orphaned.length === 0) return { value: [] };
+			return {
+				document: result.document,
+				value: result.orphaned
+			};
+		});
+		if (!isCurrent()) return [];
+		for (const task of value) this.options.report?.warn(TASK_EVENT.delegationOrphaned, new Error(task.delegation?.result?.error ?? ""), {
+			[TASK_ID_ATTRIBUTE]: task.id,
+			...task.delegation?.agent ? { [AGENT_ATTRIBUTE]: task.delegation.agent } : {},
+			...task.delegation?.pid === void 0 ? {} : { [PID_ATTRIBUTE]: task.delegation.pid }
+		});
+		if (value.length > 0) this.options.onChange?.();
+		return value;
+	}
+	async assign(taskId, options) {
+		const agent = options.agent?.trim();
+		if (!agent) return {
+			ok: false,
+			message: "agent required for assign"
+		};
+		if (this.isChildSession) return {
+			ok: false,
+			message: ERR_CHILD_SESSION
+		};
+		if (options.signal?.aborted) return {
+			ok: false,
+			message: "delegation cancelled before it started"
+		};
+		const requestId = this.options.platform.createRequestId();
+		const startedAt = this.now();
+		const sessionId = this.options.getSessionId?.();
+		const context = briefContext(options, this.options.cwd, this.options.platform);
+		const { value: outcome } = await this.options.store.mutate((current) => {
+			const index = current.tasks.findIndex((task) => task.id === taskId);
+			if (index === -1) return { value: {
+				ok: false,
+				message: `#${taskId} not found`
+			} };
+			const task = current.tasks[index];
+			if (task.status === DELETED_STATUS) return { value: {
+				ok: false,
+				message: `#${taskId} is deleted`
+			} };
+			if (task.status === COMPLETED_STATE) return { value: {
+				ok: false,
+				message: `#${taskId} is already completed`
+			} };
+			if (isDelegationActive(task)) return { value: {
+				ok: false,
+				message: `#${taskId} is already delegated to ${task.delegation?.agent}`
+			} };
+			if (isBlocked(current.tasks, task)) return { value: {
+				ok: false,
+				message: `#${taskId} is blocked by ${(task.blockedBy ?? []).map((id) => `#${id}`).join(", ")}`
+			} };
+			const delegation = {
+				requestId,
+				agent,
+				state: "requested",
+				pid: this.options.platform.processId,
+				startedAt,
+				...sessionId ? { sessionId } : {},
+				...options.model ? { model: options.model } : {}
+			};
+			const tasks = [...current.tasks];
+			tasks[index] = {
+				...task,
+				owner: agent,
+				updatedAt: startedAt,
+				delegation
+			};
+			return {
+				document: {
+					...current,
+					tasks
+				},
+				value: {
+					ok: true,
+					message: "",
+					task: tasks[index]
+				}
+			};
+		});
+		if (!outcome.ok || !outcome.task) return {
+			ok: false,
+			message: outcome.message
+		};
+		const contextNotesLength = context.notes?.length ?? 0;
+		this.pendingTasks.set(requestId, {
+			taskId,
+			sessionId
+		});
+		this.progress.set(requestId, {
+			agent,
+			contextFileCount: context.files.length,
+			contextNotesLength
+		});
+		this.armStartedTimeout(requestId);
+		this.options.onChange?.();
+		const request = {
+			requestId,
+			taskId,
+			agent,
+			...options.inlineAgent ? { inlineAgent: options.inlineAgent } : {},
+			prompt: buildBrief(outcome.task, options.instructions, context),
+			...options.context ? { context: options.context } : {},
+			cwd: this.options.cwd,
+			artifacts: true,
+			timeoutMs: this.runTimeoutMs,
+			runMode: "detached",
+			teamTask: {
+				id: String(outcome.task.id),
+				subject: outcome.task.subject
+			},
+			...options.model ? { model: options.model } : {}
+		};
+		try {
+			const service = this.service;
+			if (!service) throw new Error(ERR_NO_RUNTIME);
+			service.request(request).catch((error) => {
+				this.report(TASK_EVENT.delegationRequestFailed, error, {
+					[TASK_ID_ATTRIBUTE]: taskId,
+					[REQUEST_ID_ATTRIBUTE]: requestId,
+					[AGENT_ATTRIBUTE]: agent
+				});
+				this.settleDetached(requestId, FAILED_STATE, {
+					status: FAILED_STATE,
+					error: `Delegation request failed: ${messageOf(error)}`
+				});
+			});
+		} catch (error) {
+			this.report(TASK_EVENT.delegationRequestFailed, error, {
+				[TASK_ID_ATTRIBUTE]: taskId,
+				[REQUEST_ID_ATTRIBUTE]: requestId,
+				[AGENT_ATTRIBUTE]: agent
+			});
+			const detail = messageOf(error);
+			await this.settle(requestId, FAILED_STATE, {
+				status: FAILED_STATE,
+				error: `Delegation request failed: ${detail}`
+			});
+			return {
+				ok: false,
+				message: `Could not dispatch #${taskId} to ${agent}: ${detail}`
+			};
+		}
+		this.options.report?.event(TASK_EVENT.delegationAssigned, {
+			[TASK_ID_ATTRIBUTE]: taskId,
+			[REQUEST_ID_ATTRIBUTE]: requestId,
+			[AGENT_ATTRIBUTE]: agent,
+			[CONTEXT_PRESENT_ATTRIBUTE]: context.files.length > 0 || contextNotesLength > 0,
+			[CONTEXT_FILE_COUNT_ATTRIBUTE]: context.files.length,
+			[CONTEXT_NOTES_LENGTH_ATTRIBUTE]: contextNotesLength,
+			[BRIEF_LENGTH_ATTRIBUTE]: request.prompt.length
+		});
+		return {
+			ok: true,
+			message: `Delegated #${taskId} to ${agent} in the background. It runs independently of this turn and will notify you when it finishes. Continue non-overlapping work, or end your turn.`
+		};
+	}
+	async cancel(taskId) {
+		const task = this.options.store.read().tasks.find((candidate) => candidate.id === taskId);
+		if (!task) return {
+			ok: false,
+			message: `#${taskId} not found`
+		};
+		if (!task.delegation || !isDelegationActive(task)) return {
+			ok: false,
+			message: `#${taskId} has no running delegation`
+		};
+		const { requestId } = task.delegation;
+		this.service?.cancel({ requestId });
+		this.armCancelTimeout(requestId);
+		return {
+			ok: true,
+			message: `Cancelling delegation for #${taskId} (${task.delegation.agent})`
+		};
+	}
+	/** Settle without awaiting, reporting rather than dropping a failure. */
+	settleDetached(requestId, state, result, event = TASK_EVENT.delegationSettleFailed) {
+		this.settle(requestId, state, result).catch((error) => {
+			this.report(event, error, { [REQUEST_ID_ATTRIBUTE]: requestId });
+		});
+	}
+	/**
+	* Fail a delegation that nobody acknowledged.
+	*
+	* Provider loss or a stalled Team runtime can still leave a dispatched
+	* request silent. Without this acknowledgement deadline the task would sit
+	* in `requested` forever.
+	*/
+	armStartedTimeout(requestId) {
+		this.armTimer(requestId, this.options.startedTimeoutMs ?? DEFAULT_STARTED_TIMEOUT_MS, () => {
+			this.settleDetached(requestId, FAILED_STATE, {
+				status: FAILED_STATE,
+				error: ERR_NO_RUNTIME
+			});
+		});
+	}
+	/**
+	* Bound a run that already started.
+	*
+	* The request carries the same budget, so in the normal case the runtime ends
+	* the run itself and reports a richer result. The grace period biases toward
+	* that answer; this timer only covers a runtime that goes silent, which is
+	* precisely the case where no response event will ever arrive.
+	*/
+	armRunTimeout(requestId) {
+		const grace = Math.min(MAX_RUN_TIMEOUT_GRACE_MS, this.runTimeoutMs);
+		this.armTimer(requestId, this.runTimeoutMs + grace, () => {
+			const taskId = this.pendingTasks.get(requestId)?.taskId;
+			const agent = this.progress.get(requestId)?.agent;
+			const error = /* @__PURE__ */ new Error(`Delegation produced no result within ${this.runTimeoutMs}ms`);
+			this.options.report?.warn(TASK_EVENT.delegationTimedOut, error, {
+				...taskId === void 0 ? {} : { [TASK_ID_ATTRIBUTE]: taskId },
+				[REQUEST_ID_ATTRIBUTE]: requestId,
+				...agent ? { [AGENT_ATTRIBUTE]: agent } : {}
+			});
+			this.service?.cancel({
+				requestId,
+				reason: error.message
+			});
+			this.settleDetached(requestId, FAILED_STATE, {
+				status: TIMED_OUT_STATUS,
+				error: error.message
+			});
+		});
+	}
+	/**
+	* Guarantee a cancel reaches a terminal state.
+	*
+	* Calling the service is a request, not an outcome: a runtime that has
+	* already forgotten the request answers nothing at all. The window still
+	* favours a real response, which carries the run's partial output.
+	*/
+	armCancelTimeout(requestId) {
+		if (!this.pendingTasks.has(requestId)) return;
+		this.armTimer(requestId, this.options.cancelTimeoutMs ?? DEFAULT_CANCEL_TIMEOUT_MS, () => {
+			this.settleDetached(requestId, CANCELLED_STATE, {
+				status: CANCELLED_STATE,
+				error: ERR_CANCEL_UNACKNOWLEDGED
+			});
+		});
+	}
+	armTimer(requestId, delayMs, onFire) {
+		this.clearTimer(requestId);
+		const timer = setTimeout(onFire, delayMs);
+		timer.unref?.();
+		this.timers.set(requestId, timer);
+	}
+	clearTimer(requestId) {
+		const timer = this.timers.get(requestId);
+		if (timer) clearTimeout(timer);
+		this.timers.delete(requestId);
+	}
+	/** Runtime acknowledgement moves the request off the short extension-presence watchdog while launch is in flight. */
+	handleAccepted(event) {
+		if (!this.pendingTasks.has(event.requestId)) return;
+		this.armRunTimeout(event.requestId);
+	}
+	handleStarted(event) {
+		const { runId } = event;
+		const taskId = this.pendingTasks.get(event.requestId)?.taskId;
+		if (taskId === void 0) return;
+		this.armRunTimeout(event.requestId);
+		const existing = this.progress.get(event.requestId);
+		if (existing) this.progress.set(event.requestId, {
+			...existing,
+			durationMs: existing.durationMs ?? 0,
+			durationObservedAt: existing.durationObservedAt ?? this.nowMs()
+		});
+		this.options.store.mutate((document) => this.patchDelegation(document, event.requestId, (task, delegation) => ({
+			...task,
+			status: task.status === COMPLETED_STATE ? task.status : "in_progress",
+			delegation: {
+				...delegation,
+				state: "running",
+				startedAt: delegation.startedAt ?? this.now(),
+				...runId ? { runId } : {}
+			}
+		}))).then(() => this.options.onChange?.()).catch((error) => {
+			this.report(TASK_EVENT.delegationStartFailed, error, {
+				[TASK_ID_ATTRIBUTE]: taskId,
+				[REQUEST_ID_ATTRIBUTE]: event.requestId
+			});
+		});
+	}
+	handleUpdate(event) {
+		const existing = this.progress.get(event.requestId);
+		if (!existing) return;
+		const observedAt = this.nowMs();
+		const currentElapsed = DelegationManager.elapsedMs(existing, observedAt);
+		const hasDuration = event.durationMs !== void 0;
+		this.progress.set(event.requestId, {
+			...existing,
+			currentTool: event.currentTool ?? existing.currentTool,
+			toolCount: event.toolCount === void 0 ? existing.toolCount : Math.max(existing.toolCount ?? 0, event.toolCount),
+			tokens: event.tokens === void 0 ? existing.tokens : Math.max(existing.tokens ?? 0, event.tokens),
+			durationMs: hasDuration ? Math.max(currentElapsed, event.durationMs) : existing.durationMs,
+			durationObservedAt: hasDuration ? observedAt : existing.durationObservedAt
+		});
+		this.options.onChange?.();
+	}
+	async handleResponse(event) {
+		if (!this.pendingTasks.has(event.requestId)) return;
+		const state = event.status === COMPLETED_STATE && !event.error ? COMPLETED_STATE : event.status === CANCELLED_STATE ? CANCELLED_STATE : FAILED_STATE;
+		await this.settle(event.requestId, state, {
+			status: event.status,
+			error: event.error,
+			output: truncate(event.output),
+			outputPath: event.outputPath,
+			sessionFile: event.sessionFile,
+			durationMs: event.durationMs,
+			toolCount: event.toolCount
+		});
+	}
+	/**
+	* Apply the terminal state of a delegation and tell the model about it.
+	*
+	* A cancelled run returns the task to `pending` (the work is still wanted,
+	* just not by that agent); a failure marks it `failed` so it stays visible
+	* rather than silently rejoining the backlog.
+	*
+	* The request is claimed in `settlingRequests` while it remains published as
+	* active work. It is removed only after the terminal state and model notification
+	* have been handed off, so an auto-stop observer cannot end the session between
+	* receiving the result and delivering it to the model.
+	*/
+	async settle(requestId, state, result) {
+		const pending = this.pendingTasks.get(requestId);
+		if (!pending || this.settlingRequests.has(requestId)) return;
+		this.settlingRequests.add(requestId);
+		this.clearTimer(requestId);
+		const { taskId } = pending;
+		const progress = this.progress.get(requestId);
+		try {
+			const endedAt = this.now();
+			let task;
+			try {
+				const { value } = await this.options.store.mutate((document) => this.patchDelegation(document, requestId, (current, delegation) => ({
+					...current,
+					status: state === COMPLETED_STATE ? COMPLETED_STATE : state === CANCELLED_STATE ? "pending" : FAILED_STATE,
+					updatedAt: endedAt,
+					delegation: {
+						...delegation,
+						state,
+						endedAt,
+						...result ? { result } : {}
+					}
+				})));
+				task = value;
+			} catch (error) {
+				this.report(TASK_EVENT.delegationSettleFailed, error, {
+					[TASK_ID_ATTRIBUTE]: taskId,
+					[REQUEST_ID_ATTRIBUTE]: requestId
+				});
+			}
+			const agent = task?.delegation?.agent ?? progress?.agent ?? "subagent";
+			const subject = task?.subject ?? `#${taskId}`;
+			this.options.report?.event(TASK_EVENT.delegationCompleted, {
+				[TASK_ID_ATTRIBUTE]: taskId,
+				[REQUEST_ID_ATTRIBUTE]: requestId,
+				[AGENT_ATTRIBUTE]: agent,
+				[OUTCOME_ATTRIBUTE]: state,
+				[CONTEXT_PRESENT_ATTRIBUTE]: (progress?.contextFileCount ?? 0) > 0 || (progress?.contextNotesLength ?? 0) > 0,
+				[CONTEXT_FILE_COUNT_ATTRIBUTE]: progress?.contextFileCount ?? 0,
+				[CONTEXT_NOTES_LENGTH_ATTRIBUTE]: progress?.contextNotesLength ?? 0,
+				...result?.toolCount === void 0 ? {} : { [TOOL_COUNT_ATTRIBUTE]: result.toolCount },
+				...result?.durationMs === void 0 ? {} : { [DURATION_MS_ATTRIBUTE]: result.durationMs }
+			});
+			const listComplete = state === COMPLETED_STATE && task !== void 0 && isTaskListComplete(this.options.store.snapshot.tasks);
+			this.notifyModel(state, taskId, subject, agent, result, listComplete);
+		} finally {
+			this.pendingTasks.delete(requestId);
+			this.progress.delete(requestId);
+			this.settlingRequests.delete(requestId);
+			this.options.onChange?.();
+		}
+	}
+	notifyModel(state, taskId, subject, agent, result, listComplete) {
+		const notify = this.options.notify;
+		if (!notify) return;
+		const lines = [state === COMPLETED_STATE ? `Subagent ${agent} completed task #${taskId}: ${subject}` : state === CANCELLED_STATE ? `Subagent ${agent} was cancelled on task #${taskId}: ${subject} (returned to pending)` : `Subagent ${agent} failed task #${taskId}: ${subject}`];
+		if (listComplete) lines.push("", "All tasks are completed. Review the full task list once more, then close it with task {\"action\":\"clear\"}.");
+		if (result?.error) lines.push(`Error: ${result.error}`);
+		if (result?.output) lines.push("", result.output);
+		if (result?.outputPath) lines.push("", `Full output: ${result.outputPath}`);
+		try {
+			notify({
+				customType: NOTIFY_CUSTOM_TYPE,
+				content: lines.join("\n"),
+				display: true
+			}, {
+				triggerTurn: true,
+				deliverAs: "steer"
+			});
+		} catch (error) {
+			this.options.onNotifyError(error, taskId);
+		}
+	}
+	/**
+	* Rewrite the task carrying `requestId`, returning the updated task as the mutation value.
+	*
+	* Terminal delegations are left alone. The document here is the freshest one,
+	* read under the store lock, which is the only place the check is meaningful:
+	* a `started` event can land after a cancel already settled the run, and
+	* without this guard its write would resurrect a delegation that nothing is
+	* tracking any more.
+	*/
+	patchDelegation(document, requestId, patch) {
+		const index = document.tasks.findIndex((task) => task.delegation?.requestId === requestId);
+		if (index === -1) return { value: void 0 };
+		const task = document.tasks[index];
+		if (!isDelegationActive(task)) return { value: task };
+		const updated = patch(task, task.delegation);
+		if (updated === task) return { value: task };
+		const tasks = [...document.tasks];
+		tasks[index] = updated;
+		return {
+			document: {
+				...document,
+				tasks
+			},
+			value: updated
+		};
+	}
+	dispose() {
+		this.unbind();
+		this.reset();
+	}
+	/** Clear one Pi session's transient delegation state without losing service injection. */
+	reset() {
+		const changed = this.pendingTasks.size > 0 || this.progress.size > 0;
+		for (const timer of this.timers.values()) clearTimeout(timer);
+		this.timers.clear();
+		this.pendingTasks.clear();
+		this.settlingRequests.clear();
+		this.progress.clear();
+		if (changed) this.options.onChange?.();
+	}
+};
+//#endregion
+//#region src/services/delegationPlatform/index.ts
+function formatBriefPath(entry, cwd) {
+	if (!path.isAbsolute(entry)) return path.normalize(entry);
+	const relative = path.relative(cwd, entry);
+	return relative && !relative.startsWith("..") ? relative : entry;
+}
+/** Supply Node-owned process and path facilities to the host-neutral manager. */
+function createNodeDelegationPlatform(environment = process.env) {
+	return {
+		environment,
+		processId: process.pid,
+		createRequestId: randomUUID,
+		formatBriefPath
+	};
+}
+//#endregion
+//#region src/services/paths/index.ts
+const STORE_PATH_ENV = "DOOM_TASK_STORE";
+const STORE_DIR_NAME = "doom-task";
+const STORE_FILE_NAME = "tasks.json";
+const DEFAULT_CONFIG_DIR_NAME = ".pi";
+const AGENT_DIR_NAME = "agent";
+const PI_CODING_AGENT_DIR_ENV = "PI_CODING_AGENT_DIR";
+const HOME_ALIAS = "~";
+const HOME_ALIAS_PREFIX = "~/";
+function resolveAgentDirectory(env) {
+	const configured = env[PI_CODING_AGENT_DIR_ENV]?.trim();
+	if (configured === HOME_ALIAS) return os.homedir();
+	if (configured?.startsWith(HOME_ALIAS_PREFIX)) return path.join(os.homedir(), configured.slice(2));
+	return configured ? path.resolve(configured) : path.join(os.homedir(), DEFAULT_CONFIG_DIR_NAME, AGENT_DIR_NAME);
+}
+/** Resolve the tree root without relying on extension startup order. */
+function resolveSessionKey(rootSessionId, env = process.env) {
+	if (!env[SUBAGENT_CHILD_ENV]) return rootSessionId;
+	const parentSessionId = env[SUBAGENT_PARENT_SESSION_ENV]?.trim();
+	if (!parentSessionId) throw new Error(`${SUBAGENT_PARENT_SESSION_ENV} is required in a subagent child`);
+	return parentSessionId;
+}
+/** Resolve one root session tree to a task document under the Pi agent directory. */
+function resolveStorePath(_cwd = process.cwd(), env = process.env, sessionKey = "standalone") {
+	const override = env[STORE_PATH_ENV]?.trim();
+	if (override) return path.resolve(override);
+	const trimmedSessionKey = sessionKey.trim();
+	if (!trimmedSessionKey) throw new Error("doom-task session id cannot be blank");
+	return path.join(resolveAgentDirectory(env), STORE_DIR_NAME, trimmedSessionKey, STORE_FILE_NAME);
+}
+function lockPathFor(storePath) {
+	return `${storePath}.lock`;
+}
+function tempPathFor(storePath, pid = process.pid) {
+	return `${storePath}.tmp.${pid}`;
+}
+//#endregion
+//#region src/services/invariants/index.ts
+/**
+* Collapse a malformed snapshot to one row per task id.
+*
+* Normal writes replace tasks in place, but older or externally edited stores
+* can contain both a stale and a current copy. Prefer the copy with the newest
+* ISO update timestamp; equal or missing timestamps use the later array entry.
+* The winning row keeps the id's original position so repair does not reorder
+* an otherwise stable task list.
+*/
+function canonicalizeTasks(tasks) {
+	const canonical = [];
+	const indexById = /* @__PURE__ */ new Map();
+	for (const task of tasks) {
+		const existingIndex = indexById.get(task.id);
+		if (existingIndex === void 0) {
+			indexById.set(task.id, canonical.length);
+			canonical.push(task);
+			continue;
+		}
+		const existing = canonical[existingIndex];
+		if (!existing.updatedAt || !task.updatedAt || task.updatedAt >= existing.updatedAt) canonical[existingIndex] = task;
+	}
+	return canonical;
+}
+/**
+* Allowed forward transitions per source status.
+*
+* `failed` is recoverable (a delegation can be retried) so it may return to
+* pending or in_progress. `completed` is one-way to `deleted`; `deleted` is a
+* terminal tombstone.
+*/
+const VALID_TRANSITIONS = {
+	pending: /* @__PURE__ */ new Set([
+		"in_progress",
+		"completed",
+		"failed",
+		"deleted"
+	]),
+	in_progress: /* @__PURE__ */ new Set([
+		"pending",
+		"completed",
+		"failed",
+		"deleted"
+	]),
+	failed: /* @__PURE__ */ new Set([
+		"pending",
+		"in_progress",
+		"completed",
+		"deleted"
+	]),
+	completed: /* @__PURE__ */ new Set(["deleted"]),
+	deleted: /* @__PURE__ */ new Set()
+};
+function isTransitionValid(from, to) {
+	if (from === to) return true;
+	return VALID_TRANSITIONS[from].has(to);
+}
+//#endregion
+//#region src/services/taskStore/index.ts
+const LOCK_TIMEOUT_MS = 2e3;
+const LOCK_STALE_MS = 1e4;
+const LOCK_RETRY_BASE_MS = 10;
+const LOCK_RETRY_MAX_MS = 60;
+const UTF8_ENCODING = "utf8";
+const MISSING_FILE_CODE = "ENOENT";
+const LOCK_EXISTS_CODE = "EEXIST";
+const STORE_PATH_ATTRIBUTE = "store.path";
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Coerce arbitrary parsed JSON into a valid document.
+*
+* A corrupt or truncated store must not take the session down: the worst
+* acceptable outcome is starting from an empty list, never a crash on startup.
+*/
+function normalizeDocument(parsed) {
+	if (!parsed || typeof parsed !== "object") return emptyDocument();
+	const candidate = parsed;
+	if (!Array.isArray(candidate.tasks)) return emptyDocument();
+	const tasks = canonicalizeTasks(candidate.tasks.filter((task) => Boolean(task) && typeof task === "object" && typeof task.id === "number"));
+	const maxId = tasks.reduce((max, task) => Math.max(max, task.id), 0);
+	return {
+		version: typeof candidate.version === "number" ? candidate.version : 1,
+		rev: typeof candidate.rev === "number" ? candidate.rev : 0,
+		nextId: typeof candidate.nextId === "number" && candidate.nextId > maxId ? candidate.nextId : maxId + 1,
+		tasks
+	};
+}
+/**
+* File-backed task store shared by one root session and its delegated children.
+*
+* Durability model: the JSON file is the source of truth. Mutations are
+* read-modify-write under an advisory lock so concurrent delegated processes
+* cannot clobber each other, and writes land via temp-file rename so a
+* crash mid-write can never leave a partial document behind.
+*/
+var TaskStore = class {
+	storePath;
+	cwd;
+	env;
+	cached = emptyDocument();
+	listeners = /* @__PURE__ */ new Set();
+	lockTimeoutMs;
+	report;
+	onCommitted;
+	constructor(options = {}) {
+		this.cwd = options.cwd ?? process.cwd();
+		this.env = options.env ?? process.env;
+		this.storePath = options.storePath ?? resolveStorePath(this.cwd, this.env);
+		this.lockTimeoutMs = options.lockTimeoutMs ?? LOCK_TIMEOUT_MS;
+		this.report = options.report;
+		this.onCommitted = options.onCommitted;
+	}
+	/** Bind a default store to the current session tree before reading it. */
+	configureSession(sessionKey) {
+		if (this.env["DOOM_TASK_STORE"]?.trim()) return;
+		this.storePath = resolveStorePath(this.cwd, this.env, sessionKey);
+		this.cached = emptyDocument();
+	}
+	/** Last document read from disk, without hitting the filesystem. */
+	get snapshot() {
+		return this.cached;
+	}
+	read() {
+		try {
+			const raw = fs.readFileSync(this.storePath, UTF8_ENCODING);
+			this.cached = normalizeDocument(JSON.parse(raw));
+		} catch (error) {
+			if (error.code !== MISSING_FILE_CODE) this.report?.error(TASK_EVENT.storeReadFailed, error, { [STORE_PATH_ATTRIBUTE]: this.storePath });
+			this.cached = emptyDocument();
+		}
+		return this.cached;
+	}
+	async readAsync(shouldApply = () => true) {
+		const storePath = this.storePath;
+		const document = await this.readDocumentAsync(storePath);
+		if (!shouldApply()) return document;
+		this.cached = document;
+		return document;
+	}
+	async readDocumentAsync(storePath = this.storePath) {
+		try {
+			const raw = await fs.promises.readFile(storePath, UTF8_ENCODING);
+			return normalizeDocument(JSON.parse(raw));
+		} catch (error) {
+			if (error.code !== MISSING_FILE_CODE) this.report?.error(TASK_EVENT.storeReadFailed, error, { [STORE_PATH_ATTRIBUTE]: storePath });
+			return emptyDocument();
+		}
+	}
+	/**
+	* Apply a mutation under the store lock.
+	*
+	* `mutate` receives the freshest on-disk document and returns either the next
+	* document to commit or `undefined` for a read-only action (list/get), which
+	* skips the write entirely so queries never bump `rev`.
+	*/
+	async mutate(mutate) {
+		const release = await this.acquireLock();
+		const outcome = (() => {
+			try {
+				const current = this.read();
+				const mutation = mutate(current);
+				if (!mutation.document) return { result: {
+					document: current,
+					value: mutation.value
+				} };
+				const committed = this.write(mutation.document);
+				return {
+					result: {
+						document: committed,
+						value: mutation.value
+					},
+					notification: {
+						previous: current,
+						committed
+					}
+				};
+			} finally {
+				release();
+			}
+		})();
+		if (outcome.notification) this.notifyCommitted(outcome.notification.previous, outcome.notification.committed);
+		return outcome.result;
+	}
+	notifyCommitted(previous, committed) {
+		try {
+			this.onCommitted?.(previous, committed);
+		} catch (error) {
+			this.report?.error(TASK_EVENT.storeCommitListenerFailed, error, { [STORE_PATH_ATTRIBUTE]: this.storePath });
+		}
+		for (const listener of this.listeners) try {
+			listener(committed);
+		} catch (error) {
+			this.report?.error(TASK_EVENT.storeListenerFailed, error, { [STORE_PATH_ATTRIBUTE]: this.storePath });
+		}
+	}
+	write(document) {
+		const next = {
+			...document,
+			version: 1,
+			rev: document.rev + 1
+		};
+		fs.mkdirSync(path.dirname(this.storePath), { recursive: true });
+		const temp = tempPathFor(this.storePath);
+		fs.writeFileSync(temp, `${JSON.stringify(next, void 0, 2)}\n`, UTF8_ENCODING);
+		fs.renameSync(temp, this.storePath);
+		this.cached = next;
+		return next;
+	}
+	async acquireLock() {
+		const lockPath = lockPathFor(this.storePath);
+		fs.mkdirSync(path.dirname(this.storePath), { recursive: true });
+		const deadline = Date.now() + this.lockTimeoutMs;
+		for (;;) try {
+			const handle = fs.openSync(lockPath, "wx");
+			fs.writeSync(handle, JSON.stringify({
+				pid: process.pid,
+				time: Date.now()
+			}));
+			fs.closeSync(handle);
+			return () => fs.rmSync(lockPath, { force: true });
+		} catch (error) {
+			if (error.code !== LOCK_EXISTS_CODE) throw error;
+			if (Date.now() >= deadline) {
+				this.report?.warn(TASK_EVENT.storeLockTimeout, /* @__PURE__ */ new Error(`Task store lock still held after ${this.lockTimeoutMs}ms; proceeding without it`), { [STORE_PATH_ATTRIBUTE]: this.storePath });
+				return () => {};
+			}
+			this.breakStaleLock(lockPath);
+			await sleep(LOCK_RETRY_BASE_MS + Math.random() * LOCK_RETRY_MAX_MS);
+		}
+	}
+	/** Remove a lock left behind by a dead process or one held implausibly long. */
+	breakStaleLock(lockPath) {
+		try {
+			const holder = JSON.parse(fs.readFileSync(lockPath, UTF8_ENCODING));
+			const expired = typeof holder.time === "number" && Date.now() - holder.time > LOCK_STALE_MS;
+			const dead = typeof holder.pid === "number" && !isProcessAlive(holder.pid);
+			if (!expired && !dead) return false;
+			fs.unlinkSync(lockPath);
+			return true;
+		} catch (error) {
+			if (error.code !== MISSING_FILE_CODE) this.report?.warn(TASK_EVENT.storeLockBreakFailed, error, { [STORE_PATH_ATTRIBUTE]: lockPath });
+			return false;
+		}
+	}
+	/**
+	* Listen for commits made through this store instance.
+	*
+	* Live cross-process updates use the owning session's direct event bus. This
+	* listener remains for local terminal views and never watches the filesystem.
+	*/
+	onExternalChange(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	dispose() {
+		this.listeners.clear();
+	}
+};
+//#endregion
+//#region src/schemas/task.ts
+const TASK_ACTIONS = [
+	"upsert",
+	"list",
+	"get",
+	"delete",
+	"clear",
+	"assign",
+	"cancel"
+];
+const TASK_STATUSES = [
+	"pending",
+	"in_progress",
+	"completed",
+	"failed",
+	"deleted"
+];
+const TASK_CONTEXTS = ["fresh", "fork"];
+/**
+* A dependency target: an existing task id, or the `ref` of a task created
+* earlier in the same call.
+*/
+const DepTokenSchema = Type.Union([Type.Integer(), Type.String()]);
+/**
+* One entry of an upsert. `additionalProperties: false` is load-bearing: pi
+* validates tool arguments against this schema before `execute` runs, so a
+* stray `{"action":"update"}` inside an entry is rejected at the boundary.
+*/
+const TaskItemSchema = Type.Object({
+	id: Type.Optional(Type.Integer({ description: "Existing task id to change. Omit to create. An unknown id fails only that entry; it never creates." })),
+	ref: Type.Optional(Type.String({ description: "Temporary name for a task created by this entry, so a LATER entry in this array can list it in blockedBy. Must start with a letter; never stored." })),
+	subject: Type.Optional(Type.String({ description: "Short imperative subject. Required when the entry has no id; on an entry with an id it renames." })),
+	description: Type.Optional(Type.String({ description: "Long-form detail; becomes the brief handed to the subagent on assign." })),
+	activeForm: Type.Optional(Type.String({ description: "Present-continuous label shown while in_progress (e.g. 'writing tests')" })),
+	status: Type.Optional(Type.String({
+		enum: [...TASK_STATUSES],
+		description: "New entries default to pending and cannot start deleted; on an entry with an id the transition must be legal."
+	})),
+	blockedBy: Type.Optional(Type.Array(DepTokenSchema, { description: "Dependencies for a NEW entry: task ids, or refs of tasks created EARLIER in this array. On an entry with an id use addBlockedBy / removeBlockedBy instead." })),
+	addBlockedBy: Type.Optional(Type.Array(DepTokenSchema, { description: "Dependencies to add (ids or earlier refs). Additive; do not resend the full array." })),
+	removeBlockedBy: Type.Optional(Type.Array(DepTokenSchema, { description: "Dependencies to remove. Additive; do not resend the full array." })),
+	owner: Type.Optional(Type.String({ description: "Owner label; assign sets it to the subagent name." })),
+	metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: "Merged into the task; a null value deletes that key." }))
+}, { additionalProperties: false });
+/** One task-to-agent handoff in a native assignment batch. */
+const TaskAssignmentSchema = Type.Object({
+	id: Type.Integer({ description: "Pending, unblocked task id to delegate" }),
+	agent: Type.String({ description: "Exact discovered subagent name" }),
+	inlineAgent: Type.Optional(InlineAgentSchema),
+	instructions: Type.Optional(Type.String({ description: "Extra instructions appended to this delegated brief" })),
+	relevantFiles: Type.Optional(Type.Array(Type.String(), { description: `Files already read or located, relative to the working directory; at most 12 are used.` })),
+	priorFindings: Type.Optional(Type.String({ description: "Established facts this child should consume rather than re-derive" })),
+	model: Type.Optional(Type.String({ description: "Model override for this delegated run" })),
+	context: Type.Optional(Type.String({
+		enum: [...TASK_CONTEXTS],
+		description: "Starting context for this child: 'fresh' or 'fork'"
+	}))
+}, { additionalProperties: false });
+/**
+* Tool parameters. Every `description` doubles as LLM-facing prompt copy, so
+* wording changes here change model behaviour.
+*/
+const TaskParamsSchema = Type.Object({
+	action: Type.String({ enum: [...TASK_ACTIONS] }),
+	tasks: Type.Optional(Type.Array(TaskItemSchema, {
+		minItems: 1,
+		description: "upsert only. An entry with an id changes that task, an entry without an id creates one. Entries apply in array order, so a later entry can depend on an earlier one by ref."
+	})),
+	assignments: Type.Optional(Type.Array(TaskAssignmentSchema, {
+		minItems: 1,
+		description: "Required for assign, one entry per task, including when there is only one."
+	})),
+	id: Type.Optional(Type.Integer({ description: "Task id, for get, delete and cancel. Not accepted by upsert or assign: those carry ids inside tasks[] and assignments[] entries." })),
+	status: Type.Optional(Type.String({
+		enum: [...TASK_STATUSES],
+		description: "list only: return just the tasks in this status. To SET a status, upsert the task by id."
+	})),
+	includeDeleted: Type.Optional(Type.Boolean({ description: "list only: also return deleted tombstones. Default false." }))
+});
+//#endregion
+//#region src/services/reducer/index.ts
+/** Default board capacity when a caller does not provide a configured limit. */
+const DEFAULT_REDUCER_MAX_TASKS = 15;
+/**
+* A ref must start with a letter, which makes it structurally unconfusable with
+* a stringified id. That is why resolving a dependency token is just a `typeof`
+* check with no coercion heuristics.
+*/
+const REF_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,31}$/;
+/**
+* Does this op represent state that must reach disk?
+*
+* The exhaustive switch is the point: a future `Op` variant cannot be added
+* without declaring its persistence intent, so nothing silently starts or stops
+* bumping `rev`.
+*/
+function isCommittingOp(op) {
+	switch (op.kind) {
+		case "error":
+		case "list":
+		case "get": return false;
+		case "upsert": return op.items.some((item) => item.kind === "created" || item.kind === "updated");
+		case "delete":
+		case "clear": return true;
+	}
+}
+function errorResult(document, message) {
+	return {
+		document,
+		op: {
+			kind: "error",
+			message
+		}
+	};
+}
+function sameNumberList(a, b) {
+	const x = a ?? [];
+	const y = b ?? [];
+	return x.length === y.length && x.every((value, index) => value === y[index]);
+}
+function sameRecord(a, b) {
+	return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+}
+/**
+* Did this update change anything? A no-effect update (status re-set to its
+* current value, fields re-sent unchanged) reports "No change" rather than
+* "Updated #N" — without the distinction a model can loop re-issuing the same
+* call believing it never landed.
+*/
+function taskChanged(before, after) {
+	return before.subject !== after.subject || before.status !== after.status || before.description !== after.description || before.activeForm !== after.activeForm || before.owner !== after.owner || !sameNumberList(before.blockedBy, after.blockedBy) || !sameRecord(before.metadata, after.metadata);
+}
+function withTasks(document, tasks, nextId = document.nextId) {
+	return {
+		...document,
+		tasks,
+		nextId
+	};
+}
+/** Merge incoming metadata over a base; a `null` value deletes its key. */
+function mergeMetadata(base, incoming) {
+	const merged = { ...base };
+	for (const [key, value] of Object.entries(incoming)) if (value === null) delete merged[key];
+	else merged[key] = value;
+	return Object.keys(merged).length ? merged : void 0;
+}
+/** Copy the optional scalar fields an item may set onto a task, in place. */
+function assignScalars(target, item) {
+	if (item.subject !== void 0) target.subject = item.subject;
+	if (item.description !== void 0) target.description = item.description;
+	if (item.activeForm !== void 0) target.activeForm = item.activeForm;
+	if (item.owner !== void 0) target.owner = item.owner;
+	if (item.metadata !== void 0) {
+		const merged = mergeMetadata(target.metadata, item.metadata);
+		if (merged === void 0) delete target.metadata;
+		else target.metadata = merged;
+	}
+}
+function resolveDep(context, field, token) {
+	if (typeof token === "number") return {
+		ok: true,
+		id: token
+	};
+	if (!REF_PATTERN.test(token)) return {
+		ok: false,
+		message: `${field}: "${token}" is not a valid ref; pass an existing task id as a number`
+	};
+	const id = context.refIds.get(token);
+	if (id !== void 0) return {
+		ok: true,
+		id
+	};
+	const failedAt = context.failedRefs.get(token);
+	if (failedAt !== void 0) return {
+		ok: false,
+		message: `${field}: ref "${token}" refers to item[${failedAt}], which failed`
+	};
+	return {
+		ok: false,
+		message: `${field}: unknown ref "${token}" — a ref must be declared by an earlier entry in the same call`
+	};
+}
+function fail(message) {
+	return {
+		ok: false,
+		message
+	};
+}
+/** Structural checks that apply to every entry, whichever kind it is. */
+function checkShape(context, item) {
+	if (item.ref !== void 0) {
+		if (item.id !== void 0) return "ref is only valid when creating a task; drop the id, or drop the ref";
+		if (!REF_PATTERN.test(item.ref)) return `ref "${item.ref}" is invalid: a ref must start with a letter and contain only letters, digits, - or _`;
+		if (context.refIds.get(item.ref) !== void 0 || context.failedRefs.has(item.ref)) return `duplicate ref "${item.ref}": it was already declared by an earlier entry`;
+	}
+}
+function applyCreateItem(context, item, index, now) {
+	if (item.subject === void 0) return fail("subject is required when the entry has no id");
+	if (!item.subject.trim()) return fail("subject must not be blank");
+	if (item.addBlockedBy !== void 0 || item.removeBlockedBy !== void 0) return fail("addBlockedBy / removeBlockedBy are only for an entry with an id; a new task uses blockedBy");
+	if (item.status === "deleted") return fail("cannot create a task with status deleted; create it, then use action delete");
+	if (context.tasks.filter((task) => task.status !== "deleted").length >= context.maxTasks) return fail(`task limit of ${context.maxTasks} reached; delete completed tasks first before creating new tasks`);
+	const blockedBy = [];
+	for (const token of item.blockedBy ?? []) {
+		const resolved = resolveDep(context, "blockedBy", token);
+		if (!resolved.ok) return fail(resolved.message);
+		const dep = context.tasks.find((task) => task.id === resolved.id);
+		if (!dep) return fail(`blockedBy: #${resolved.id} not found`);
+		if (dep.status === "deleted") return fail(`blockedBy: #${resolved.id} is deleted`);
+		if (!blockedBy.includes(resolved.id)) blockedBy.push(resolved.id);
+	}
+	const created = {
+		id: context.nextId,
+		subject: item.subject,
+		status: item.status ?? "pending",
+		createdAt: now,
+		updatedAt: now
+	};
+	assignScalars(created, item);
+	if (blockedBy.length) created.blockedBy = blockedBy;
+	context.nextId += 1;
+	context.tasks.push(created);
+	if (item.ref) context.refIds.set(item.ref, created.id);
+	return {
+		ok: true,
+		outcome: {
+			index,
+			kind: "created",
+			id: created.id,
+			subject: created.subject,
+			status: created.status,
+			...item.ref ? { ref: item.ref } : {},
+			...blockedBy.length ? { blockedBy } : {}
+		}
+	};
+}
+function applyUpdateItem(context, item, index, now) {
+	const id = item.id;
+	const at = context.tasks.findIndex((task) => task.id === id);
+	if (at === -1) return fail(`#${id} not found`);
+	if (item.blockedBy !== void 0) return fail("blockedBy is only for a new entry; use addBlockedBy / removeBlockedBy on an entry that has an id");
+	if (!(item.subject !== void 0 || item.description !== void 0 || item.activeForm !== void 0 || item.status !== void 0 || item.owner !== void 0 || item.metadata !== void 0 || Boolean(item.addBlockedBy?.length) || Boolean(item.removeBlockedBy?.length))) return fail("nothing to change: provide at least one of subject, description, activeForm, status, owner, metadata, addBlockedBy, or removeBlockedBy");
+	const current = context.tasks[at];
+	if (item.subject !== void 0 && !item.subject.trim()) return fail("subject must not be blank");
+	let newStatus = current.status;
+	if (item.status !== void 0) {
+		if (!isTransitionValid(current.status, item.status)) return fail(`illegal transition ${current.status} -> ${item.status}`);
+		newStatus = item.status;
+	}
+	let newBlockedBy = current.blockedBy ? [...current.blockedBy] : [];
+	for (const token of item.removeBlockedBy ?? []) {
+		const resolved = resolveDep(context, "removeBlockedBy", token);
+		if (!resolved.ok) return fail(resolved.message);
+		newBlockedBy = newBlockedBy.filter((dep) => dep !== resolved.id);
+	}
+	for (const token of item.addBlockedBy ?? []) {
+		const resolved = resolveDep(context, "addBlockedBy", token);
+		if (!resolved.ok) return fail(resolved.message);
+		if (resolved.id === id) return fail(`cannot block #${id} on itself`);
+		const dep = context.tasks.find((task) => task.id === resolved.id);
+		if (!dep) return fail(`addBlockedBy: #${resolved.id} not found`);
+		if (dep.status === "deleted") return fail(`addBlockedBy: #${resolved.id} is deleted`);
+		if (!newBlockedBy.includes(resolved.id)) newBlockedBy.push(resolved.id);
+	}
+	const updated = {
+		...current,
+		status: newStatus
+	};
+	assignScalars(updated, item);
+	if (newBlockedBy.length) updated.blockedBy = newBlockedBy;
+	else delete updated.blockedBy;
+	const candidate = [...context.tasks];
+	candidate[at] = updated;
+	if (item.addBlockedBy?.length && detectCycle(candidate, id, newBlockedBy)) return fail("addBlockedBy would create a cycle in the blockedBy graph");
+	const changed = taskChanged(current, updated);
+	if (changed) updated.updatedAt = now;
+	context.tasks = candidate;
+	return {
+		ok: true,
+		outcome: changed ? {
+			index,
+			kind: "updated",
+			id,
+			fromStatus: current.status,
+			toStatus: newStatus
+		} : {
+			index,
+			kind: "unchanged",
+			id,
+			status: newStatus
+		}
+	};
+}
+/**
+* Apply every entry in request order, threading the document.
+*
+* Each entry lands completely or not at all: a create whose dependencies fail
+* is not kept dependency-free, because handing back an unblocked task the
+* caller asked to be blocked is a lie it may immediately act on.
+*/
+function applyUpsert(document, items, now, maxTasks) {
+	const context = {
+		tasks: [...document.tasks],
+		nextId: document.nextId,
+		maxTasks,
+		refIds: /* @__PURE__ */ new Map(),
+		failedRefs: /* @__PURE__ */ new Map()
+	};
+	const outcomes = [];
+	let applied = 0;
+	for (const [index, item] of items.entries()) {
+		const shapeError = checkShape(context, item);
+		const result = shapeError ? fail(shapeError) : item.id === void 0 ? applyCreateItem(context, item, index, now) : applyUpdateItem(context, item, index, now);
+		if (result.ok) {
+			outcomes.push(result.outcome);
+			applied += 1;
+			continue;
+		}
+		if (item.ref && REF_PATTERN.test(item.ref) && !context.refIds.has(item.ref)) context.failedRefs.set(item.ref, index);
+		outcomes.push({
+			index,
+			kind: "failed",
+			message: result.message,
+			...item.id === void 0 ? {} : { id: item.id },
+			...item.ref ? { ref: item.ref } : {}
+		});
+	}
+	return {
+		document: applied > 0 ? withTasks(document, context.tasks, context.nextId) : document,
+		op: {
+			kind: "upsert",
+			items: outcomes,
+			applied,
+			failed: outcomes.length - applied
+		}
+	};
+}
+/**
+* Pure reducer: (document, action, params) -> (document, op).
+*
+* All validation is in-line: structural guards plus state-aware checks
+* (transition legality, dangling or deleted blockedBy, self-block, cycles,
+* in-flight delegations). The caller owns persistence and formatting.
+*/
+function applyTaskMutation(document, action, params, now = (/* @__PURE__ */ new Date()).toISOString(), maxTasks = DEFAULT_REDUCER_MAX_TASKS) {
+	switch (action) {
+		case "upsert": {
+			const items = params.tasks;
+			if (!Array.isArray(items) || items.length === 0) return errorResult(document, "upsert requires a non-empty tasks array, e.g. {\"action\":\"upsert\",\"tasks\":[{\"subject\":\"Write tests\"}]}");
+			if (items.length > 100) return errorResult(document, `upsert accepts at most 100 entries per call (received ${items.length})`);
+			return applyUpsert(document, items, now, maxTasks);
+		}
+		case "list": return {
+			document,
+			op: {
+				kind: "list",
+				includeDeleted: params.includeDeleted === true,
+				...params.status !== void 0 ? { statusFilter: params.status } : {}
+			}
+		};
+		case "get": {
+			if (params.id === void 0) return errorResult(document, "id required for get");
+			const task = document.tasks.find((candidate) => candidate.id === params.id);
+			if (!task) return errorResult(document, `#${params.id} not found`);
+			return {
+				document,
+				op: {
+					kind: "get",
+					task
+				}
+			};
+		}
+		case "delete": {
+			if (params.id === void 0) return errorResult(document, "id required for delete");
+			const index = document.tasks.findIndex((task) => task.id === params.id);
+			if (index === -1) return errorResult(document, `#${params.id} not found`);
+			const current = document.tasks[index];
+			if (current.status === "deleted") return errorResult(document, `#${current.id} is already deleted`);
+			if (isDelegationActive(current)) return errorResult(document, `#${current.id} has a running delegation — cancel it before deleting`);
+			const tasks = [...document.tasks];
+			tasks[index] = {
+				...current,
+				status: DELETED_STATUS$1,
+				updatedAt: now
+			};
+			return {
+				document: withTasks(document, tasks),
+				op: {
+					kind: "delete",
+					id: current.id,
+					subject: current.subject
+				}
+			};
+		}
+		case "clear": {
+			const active = document.tasks.filter(isDelegationActive);
+			if (active.length > 0) return errorResult(document, `cannot clear while delegations are running (${active.map((task) => `#${task.id}`).join(", ")}) — cancel them first`);
+			const count = document.tasks.length;
+			return {
+				document: withTasks(document, [], 1),
+				op: {
+					kind: "clear",
+					count
+				}
+			};
+		}
+	}
+}
+//#endregion
+//#region src/services/taskResult/index.ts
+const MSG_ALL_COMPLETE_CLEAR = "All tasks are completed. Review the full task list once more, then close it with task {\"action\":\"clear\"}.";
+/**
+* Steering for a mixed batch. Unlike a batch of spawned subagents, a failed
+* entry here had no side effect at all, so retrying the failures is the safe
+* move and the model must be told so or it will do nothing. The hazard is the
+* other half: resending an applied create would make a second task.
+*/
+const MSG_UPSERT_PARTIAL = "The applied entries are committed. Resend only the failed entries, corrected — a failed entry changed nothing, so a corrected retry is safe. Do not resend an entry that already applied: an entry without an id creates a second task.";
+const MSG_ASSIGN_PARTIAL = "Successful assignments are already running. Retry only the failed entries after correcting their task state or arguments; do not resend successful entries.";
+/** LLM-facing report for a native assignment batch. */
+function formatAssignmentResults(items) {
+	if (items.length === 1) return items[0].message;
+	const succeeded = items.filter((item) => item.ok).length;
+	const failed = items.length - succeeded;
+	const lines = [`Assigned ${succeeded}/${items.length} tasks${failed > 0 ? `; ${failed} failed` : ""}.`, ...items.map((item) => item.ok ? `- [${item.index}] Delegated #${item.id} to ${item.agent}` : `- [${item.index}] Failed #${item.id} → ${item.agent}: ${item.message}`)];
+	if (failed > 0 && succeeded > 0) lines.push("", MSG_ASSIGN_PARTIAL);
+	if (failed === 0) lines.push("", "All assignments are running independently in the background. Continue non-overlapping work, or end your turn.");
+	return lines.join("\n");
+}
+/** `[status] #id subject (activeForm) [agent] ⛓ #dep` — the `list` line format. */
+function formatListLine(task) {
+	const block = task.blockedBy?.length ? ` ⛓ ${task.blockedBy.map((id) => `#${id}`).join(",")}` : "";
+	const form = task.status === "in_progress" && task.activeForm ? ` (${task.activeForm})` : "";
+	const delegated = task.delegation && task.delegation.state !== "cancelled" ? ` [${task.delegation.agent}]` : "";
+	return `[${task.status}] #${task.id} ${task.subject}${form}${delegated}${block}`;
+}
+function formatDelegationLines(task) {
+	const delegation = task.delegation;
+	if (!delegation) return [];
+	const lines = [`  delegated to: ${delegation.agent} (${delegation.state})`];
+	if (delegation.model) lines.push(`  model: ${delegation.model}`);
+	if (delegation.result?.error) lines.push(`  error: ${delegation.result.error}`);
+	if (delegation.result?.outputPath) lines.push(`  output file: ${delegation.result.outputPath}`);
+	if (delegation.result?.output) lines.push(`  output: ${delegation.result.output}`);
+	return lines;
+}
+function formatGetLines(task, document) {
+	const blocks = deriveBlocks(document.tasks).get(task.id) ?? [];
+	const lines = [`#${task.id} [${task.status}] ${task.subject}`];
+	if (task.description) lines.push(`  description: ${task.description}`);
+	if (task.activeForm) lines.push(`  activeForm: ${task.activeForm}`);
+	if (task.blockedBy?.length) lines.push(`  blockedBy: ${task.blockedBy.map((id) => `#${id}`).join(", ")}`);
+	if (blocks.length) lines.push(`  blocks: ${blocks.map((id) => `#${id}`).join(", ")}`);
+	if (task.owner) lines.push(`  owner: ${task.owner}`);
+	lines.push(...formatDelegationLines(task));
+	return lines.join("\n");
+}
+/** One entry's outcome. Batch lines prefix this with `- [n] `. */
+function formatUpsertItem(item) {
+	switch (item.kind) {
+		case "created": {
+			const ref = item.ref ? ` (ref "${item.ref}")` : "";
+			const deps = item.blockedBy?.length ? ` — blocked by ${item.blockedBy.map((id) => `#${id}`).join(", ")}` : "";
+			return `Created #${item.id}${ref}: ${item.subject} (${item.status})${deps}`;
+		}
+		case "updated": {
+			const transition = item.fromStatus === item.toStatus ? "" : ` (${item.fromStatus} -> ${item.toStatus})`;
+			return `Updated #${item.id}${transition}`;
+		}
+		case "unchanged": return `No change: #${item.id} already matches the requested values (status: ${item.status})`;
+		case "failed": return `Failed${item.id === void 0 ? "" : ` #${item.id}`}: ${item.message}`;
+	}
+}
+/**
+* Pure formatter: `(op, document) -> string`. The switch is closed over `Op`,
+* so a new reducer variant fails to compile until it is handled here.
+*/
+function formatContent(op, document) {
+	switch (op.kind) {
+		case "upsert": {
+			const lines = op.items.length === 1 ? [formatUpsertItem(op.items[0])] : [
+				`Upsert applied ${op.applied}/${op.items.length} entries${op.failed > 0 ? `; ${op.failed} failed` : ""}.`,
+				...op.items.map((item) => `- [${item.index}] ${formatUpsertItem(item)}`),
+				...op.failed > 0 ? ["", MSG_UPSERT_PARTIAL] : []
+			];
+			if (op.applied > 0 && isTaskListComplete(document.tasks)) lines.push(MSG_ALL_COMPLETE_CLEAR);
+			return lines.join("\n");
+		}
+		case "delete": return `Deleted #${op.id}: ${op.subject}`;
+		case "clear": return `Closed task list (cleared ${op.count} tasks)`;
+		case "list": {
+			let view = document.tasks;
+			if (!op.includeDeleted) view = view.filter((task) => task.status !== "deleted");
+			if (op.statusFilter) view = view.filter((task) => task.status === op.statusFilter);
+			return view.length === 0 ? "No tasks" : view.map(formatListLine).join("\n");
+		}
+		case "get": return formatGetLines(op.task, document);
+		case "error": return `Error: ${op.message}`;
+	}
+}
+/** Build the LLM-facing envelope. `details` carries the post-mutation snapshot. */
+function buildToolResult(action, params, document, op) {
+	return {
+		content: [{
+			type: "text",
+			text: formatContent(op, document)
+		}],
+		details: {
+			action,
+			params,
+			tasks: document.tasks,
+			nextId: document.nextId,
+			rev: document.rev,
+			...op.kind === "error" ? { error: op.message } : {},
+			...op.kind === "upsert" ? { upsert: {
+				applied: op.items.flatMap((item) => item.kind === "failed" ? [] : [item.id]),
+				failed: op.failed
+			} } : {}
+		}
+	};
+}
+/** Envelope for a native assignment batch, including ids used by the consolidated TUI result. */
+function buildAssignmentResult(params, document, text, assignment) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {
+			action: "assign",
+			params,
+			tasks: document.tasks,
+			nextId: document.nextId,
+			rev: document.rev,
+			assignment
+		}
+	};
+}
+/** Envelope for delegation actions, which do not flow through the reducer. */
+function buildTextResult(action, params, document, text, error) {
+	return {
+		content: [{
+			type: "text",
+			text: error ? `Error: ${error}` : text
+		}],
+		details: {
+			action,
+			params,
+			tasks: document.tasks,
+			nextId: document.nextId,
+			rev: document.rev,
+			...error ? { error } : {}
+		}
+	};
+}
+//#endregion
+//#region src/services/taskTool/index.ts
+function output(value) {
+	if (typeof value === "object" && value !== null && "content" in value) return value;
+	return {
+		content: [{
+			type: "text",
+			text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+		}],
+		details: value
+	};
+}
+function failure(error) {
+	return {
+		content: [{
+			type: "text",
+			text: error instanceof Error ? error.message : String(error)
+		}],
+		isError: true
+	};
+}
+async function reducerAction(store, action, params, maxTasks) {
+	const { document, value } = await store.mutate((current) => {
+		const result = applyTaskMutation(current, action, params, void 0, maxTasks);
+		return {
+			...isCommittingOp(result.op) ? { document: result.document } : {},
+			value: result
+		};
+	});
+	if (value.op.kind === "error") throw new Error(value.op.message);
+	return buildToolResult(action, params, document, value.op);
+}
+async function assignmentBatch(manager, assignments, signal) {
+	const result = [];
+	for (const [index, assignment] of assignments.entries()) try {
+		const outcome = await manager.assign(assignment.id, {
+			agent: assignment.agent,
+			inlineAgent: assignment.inlineAgent,
+			instructions: assignment.instructions,
+			relevantFiles: assignment.relevantFiles,
+			priorFindings: assignment.priorFindings,
+			model: assignment.model,
+			...assignment.context === "fork" || assignment.context === "fresh" ? { context: assignment.context } : {},
+			signal
+		});
+		result.push({
+			index,
+			id: assignment.id,
+			agent: assignment.agent,
+			...outcome
+		});
+	} catch (error) {
+		result.push({
+			index,
+			id: assignment.id,
+			agent: assignment.agent,
+			ok: false,
+			message: String(error)
+		});
+	}
+	return result;
+}
+function createHeadlessTaskTool(store, manager, maxTasks) {
+	return {
+		name: "task",
+		label: "Task",
+		description: "Maintain a persistent task graph and delegate ready tasks to background agents.",
+		parameters: TaskParamsSchema,
+		promptSnippet: "Track complex work persistently and delegate ready tasks",
+		executionMode: "serial",
+		async execute(_toolCallId, rawParams, signal, onUpdate) {
+			if (!Check(TaskParamsSchema, rawParams)) return failure("Invalid task parameters.");
+			const params = rawParams;
+			try {
+				if (params.action === "assign") {
+					if (!params.assignments?.length) throw new Error("assign requires a non-empty assignments[] array");
+					onUpdate?.(output(`Delegating ${params.assignments.length} task${params.assignments.length === 1 ? "" : "s"}...`));
+					const items = await assignmentBatch(manager, params.assignments, signal);
+					const assigned = items.filter((item) => item.ok).map((item) => item.id);
+					const text = formatAssignmentResults(items);
+					if (assigned.length === 0) throw new Error(text);
+					return buildAssignmentResult(params, store.snapshot, text, {
+						assigned,
+						failed: items.length - assigned.length
+					});
+				}
+				if (params.action === "cancel") {
+					const outcome = await manager.cancel(params.id ?? NaN);
+					if (!outcome.ok) throw new Error(outcome.message);
+					return buildTextResult("cancel", params, store.snapshot, outcome.message);
+				}
+				return reducerAction(store, params.action, params, maxTasks);
+			} catch (error) {
+				return failure(error);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/task.mcp.ts
+var task_mcp_default = defineMcpTool(({ execution }) => {
+	const store = new TaskStore({
+		cwd: execution.cwd,
+		env: execution.environment
+	});
+	store.configureSession(resolveSessionKey(execution.sessionId, execution.environment));
+	const manager = new DelegationManager({
+		store,
+		cwd: execution.cwd,
+		platform: createNodeDelegationPlatform(execution.environment),
+		getSessionId: () => execution.sessionId,
+		runTimeoutMs: getDelegationTimeoutMs(execution.environment),
+		onNotifyError: (error) => void execution.client.notify({
+			body: String(error),
+			level: "warning"
+		})
+	});
+	const tool = createHeadlessTaskTool(store, manager, getMaxTasks(execution.environment));
+	let initialized;
+	return {
+		...tool,
+		async execute(...args) {
+			initialized ??= store.readAsync().then(async () => {
+				await manager.reconcile();
+			});
+			await initialized;
+			return tool.execute(...args);
+		}
+	};
+});
+//#endregion
+//#region generated/mcp.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+const via = (identity, value) => ({
+	...identity,
+	...value
+});
+const mcp = defineMcpPlugin({
+	name: "@agimon-ai/doompi-task",
+	session: (context) => ({ get tools() {
+		return [via({ name: "task" }, at(task_mcp_default, context))];
+	} })
+});
+//#endregion
+export { mcp as default, mcp };
+
+//# sourceMappingURL=mcp.mjs.map