@agimon-ai/doompi-task 0.0.1-alpha.120 → 0.0.1-alpha.122

package/dist/extensions/mcp.cjs

@@ -26,843 +26,114 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#endregion
 let _agimon_ai_doompi_core_mcpFacet = require("@agimon-ai/doompi-core/mcpFacet");
 let _agimon_ai_doompi_core_delegation = require("@agimon-ai/doompi-core/delegation");
-let node_crypto = require("node:crypto");
-let node_path = require("node:path");
-node_path = __toESM(node_path, 1);
+let typebox = require("typebox");
 let node_fs = require("node:fs");
 node_fs = __toESM(node_fs, 1);
 let node_os = require("node:os");
 node_os = __toESM(node_os, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
 let _agimon_ai_doompi_core_childProcess = require("@agimon-ai/doompi-core/childProcess");
 let typebox_value = require("typebox/value");
-let typebox = require("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;
-	}
-	setCwd(cwd) {
-		this.options.cwd = cwd;
-	}
-	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(_agimon_ai_doompi_core_delegation.DOOM_DELEGATION_ACCEPTED_EVENT, (event) => {
-			this.handleAccepted(event);
-		}), ctx.on(_agimon_ai_doompi_core_delegation.DOOM_DELEGATION_STARTED_EVENT, (event) => {
-			this.handleStarted(event);
-		}), ctx.on(_agimon_ai_doompi_core_delegation.DOOM_DELEGATION_UPDATED_EVENT, (event) => {
-			this.handleUpdate(event);
-		}), ctx.on(_agimon_ai_doompi_core_delegation.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?.();
-	}
-};
+//#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 = typebox.Type.Union([typebox.Type.Integer(), typebox.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 = typebox.Type.Object({
+	id: typebox.Type.Optional(typebox.Type.Integer({ description: "Existing task id to change. Omit to create. An unknown id fails only that entry; it never creates." })),
+	ref: typebox.Type.Optional(typebox.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: typebox.Type.Optional(typebox.Type.String({ description: "Short imperative subject. Required when the entry has no id; on an entry with an id it renames." })),
+	description: typebox.Type.Optional(typebox.Type.String({ description: "Long-form detail; becomes the brief handed to the subagent on assign." })),
+	activeForm: typebox.Type.Optional(typebox.Type.String({ description: "Present-continuous label shown while in_progress (e.g. 'writing tests')" })),
+	status: typebox.Type.Optional(typebox.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: typebox.Type.Optional(typebox.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: typebox.Type.Optional(typebox.Type.Array(DepTokenSchema, { description: "Dependencies to add (ids or earlier refs). Additive; do not resend the full array." })),
+	removeBlockedBy: typebox.Type.Optional(typebox.Type.Array(DepTokenSchema, { description: "Dependencies to remove. Additive; do not resend the full array." })),
+	owner: typebox.Type.Optional(typebox.Type.String({ description: "Owner label; assign sets it to the subagent name." })),
+	metadata: typebox.Type.Optional(typebox.Type.Record(typebox.Type.String(), typebox.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 = typebox.Type.Object({
+	id: typebox.Type.Integer({ description: "Pending, unblocked task id to delegate" }),
+	agent: typebox.Type.String({ description: "Exact discovered subagent name" }),
+	inlineAgent: typebox.Type.Optional(_agimon_ai_doompi_core_delegation.InlineAgentSchema),
+	instructions: typebox.Type.Optional(typebox.Type.String({ description: "Extra instructions appended to this delegated brief" })),
+	relevantFiles: typebox.Type.Optional(typebox.Type.Array(typebox.Type.String(), { description: `Files already read or located, relative to the working directory; at most 12 are used.` })),
+	priorFindings: typebox.Type.Optional(typebox.Type.String({ description: "Established facts this child should consume rather than re-derive" })),
+	model: typebox.Type.Optional(typebox.Type.String({ description: "Model override for this delegated run" })),
+	context: typebox.Type.Optional(typebox.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 = typebox.Type.Object({
+	action: typebox.Type.String({ enum: [...TASK_ACTIONS] }),
+	tasks: typebox.Type.Optional(typebox.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: typebox.Type.Optional(typebox.Type.Array(TaskAssignmentSchema, {
+		minItems: 1,
+		description: "Required for assign, one entry per task, including when there is only one."
+	})),
+	id: typebox.Type.Optional(typebox.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: typebox.Type.Optional(typebox.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: typebox.Type.Optional(typebox.Type.Boolean({ description: "list only: also return deleted tombstones. Default false." }))
+});
+/** Remote MCP connections track tasks only; delegation stays with the local agent. */
+const REMOTE_TASK_ACTIONS = [
+	"upsert",
+	"list",
+	"get",
+	"delete",
+	"clear"
+];
+const { assignments: _assignments, ...remoteTaskProperties } = TaskParamsSchema.properties;
+const RemoteTaskParamsSchema = typebox.Type.Object({
+	...remoteTaskProperties,
+	action: typebox.Type.String({ enum: [...REMOTE_TASK_ACTIONS] })
+});
 //#endregion
-//#region src/services/delegationPlatform/index.ts
-function formatBriefPath(entry, cwd) {
-	if (!node_path.default.isAbsolute(entry)) return node_path.default.normalize(entry);
-	const relative = node_path.default.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: node_crypto.randomUUID,
-		formatBriefPath
-	};
+//#region src/services/config/index.ts
+const MAX_TASKS_ENV = "DOOM_TASK_MAX_TASKS";
+/** 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;
 }
 //#endregion
 //#region src/services/paths/index.ts
@@ -902,6 +173,51 @@ function tempPathFor(storePath, pid = process.pid) {
 	return `${storePath}.tmp.${pid}`;
 }
 //#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/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/services/invariants/index.ts
 /**
 * Collapse a malformed snapshot to one row per task id.
@@ -961,6 +277,23 @@ function isTransitionValid(from, to) {
 	return VALID_TRANSITIONS[from].has(to);
 }
 //#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/taskStore/index.ts
 const LOCK_TIMEOUT_MS = 2e3;
 const LOCK_STALE_MS = 1e4;
@@ -1164,85 +497,48 @@ var TaskStore = class {
 	}
 };
 //#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 = typebox.Type.Union([typebox.Type.Integer(), typebox.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 = typebox.Type.Object({
-	id: typebox.Type.Optional(typebox.Type.Integer({ description: "Existing task id to change. Omit to create. An unknown id fails only that entry; it never creates." })),
-	ref: typebox.Type.Optional(typebox.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: typebox.Type.Optional(typebox.Type.String({ description: "Short imperative subject. Required when the entry has no id; on an entry with an id it renames." })),
-	description: typebox.Type.Optional(typebox.Type.String({ description: "Long-form detail; becomes the brief handed to the subagent on assign." })),
-	activeForm: typebox.Type.Optional(typebox.Type.String({ description: "Present-continuous label shown while in_progress (e.g. 'writing tests')" })),
-	status: typebox.Type.Optional(typebox.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: typebox.Type.Optional(typebox.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: typebox.Type.Optional(typebox.Type.Array(DepTokenSchema, { description: "Dependencies to add (ids or earlier refs). Additive; do not resend the full array." })),
-	removeBlockedBy: typebox.Type.Optional(typebox.Type.Array(DepTokenSchema, { description: "Dependencies to remove. Additive; do not resend the full array." })),
-	owner: typebox.Type.Optional(typebox.Type.String({ description: "Owner label; assign sets it to the subagent name." })),
-	metadata: typebox.Type.Optional(typebox.Type.Record(typebox.Type.String(), typebox.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 = typebox.Type.Object({
-	id: typebox.Type.Integer({ description: "Pending, unblocked task id to delegate" }),
-	agent: typebox.Type.String({ description: "Exact discovered subagent name" }),
-	inlineAgent: typebox.Type.Optional(_agimon_ai_doompi_core_delegation.InlineAgentSchema),
-	instructions: typebox.Type.Optional(typebox.Type.String({ description: "Extra instructions appended to this delegated brief" })),
-	relevantFiles: typebox.Type.Optional(typebox.Type.Array(typebox.Type.String(), { description: `Files already read or located, relative to the working directory; at most 12 are used.` })),
-	priorFindings: typebox.Type.Optional(typebox.Type.String({ description: "Established facts this child should consume rather than re-derive" })),
-	model: typebox.Type.Optional(typebox.Type.String({ description: "Model override for this delegated run" })),
-	context: typebox.Type.Optional(typebox.Type.String({
-		enum: [...TASK_CONTEXTS],
-		description: "Starting context for this child: 'fresh' or 'fork'"
-	}))
-}, { additionalProperties: false });
+//#region src/models/taskGraph.ts
+const COMPLETED_STATUS = "completed";
+const DELETED_STATUS = "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);
+	return visible.length > 0 && visible.every((task) => task.status === COMPLETED_STATUS);
+}
 /**
-* Tool parameters. Every `description` doubles as LLM-facing prompt copy, so
-* wording changes here change model behaviour.
+* 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.
 */
-const TaskParamsSchema = typebox.Type.Object({
-	action: typebox.Type.String({ enum: [...TASK_ACTIONS] }),
-	tasks: typebox.Type.Optional(typebox.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: typebox.Type.Optional(typebox.Type.Array(TaskAssignmentSchema, {
-		minItems: 1,
-		description: "Required for assign, one entry per task, including when there is only one."
-	})),
-	id: typebox.Type.Optional(typebox.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: typebox.Type.Optional(typebox.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: typebox.Type.Optional(typebox.Type.Boolean({ description: "list only: also return deleted tombstones. Default false." }))
-});
+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;
+}
 //#endregion
 //#region src/services/reducer/index.ts
 /** Default board capacity when a caller does not provide a configured limit. */
@@ -1793,6 +1089,7 @@ function createHeadlessTaskTool(store, manager, maxTasks) {
 			if (!(0, typebox_value.Check)(TaskParamsSchema, rawParams)) return failure("Invalid task parameters.");
 			const params = rawParams;
 			try {
+				if ((params.action === "assign" || params.action === "cancel") && !manager) throw new Error("Delegation is not available on this connection.");
 				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"}...`));
@@ -1825,25 +1122,14 @@ var task_mcp_default = (0, _agimon_ai_doompi_core_mcpFacet.defineMcpTool)(({ exe
 		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));
+	const tool = createHeadlessTaskTool(store, void 0, getMaxTasks(execution.environment));
 	let initialized;
 	return {
 		...tool,
+		parameters: RemoteTaskParamsSchema,
+		description: "Track multi-step work in the DoomPi session as a persistent task list (todo, plan, task graph). Delegating to background agents is not available here.",
 		async execute(...args) {
-			initialized ??= store.readAsync().then(async () => {
-				await manager.reconcile();
-			});
+			initialized ??= store.readAsync().then(() => void 0);
 			await initialized;
 			return tool.execute(...args);
 		}