@agimon-ai/doompi-task 0.0.1-alpha.9 → 0.0.1-alpha.90

package/dist/delegation-3hMdTFXF.cjs

@@ -0,0 +1,661 @@
+require("./delegation-LDpHP2CC.cjs");
+const require_taskGraph = require("./taskGraph-BskRslrr.cjs");
+const require_telemetry = require("./telemetry-I4md7Xzz.cjs");
+const require_task = require("./task-CXF9VULl.cjs");
+const require_reconcile = require("./reconcile-cRL0NjDr.cjs");
+let _agimon_ai_doompi_core_delegation = require("@agimon-ai/doompi-core/delegation");
+//#region src/services/delegation/index.ts
+const NOTIFY_CUSTOM_TYPE = "doom-task-notify";
+const BACKGROUND_WORK_PROVIDER = "doom-task";
+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(require_telemetry.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 = require_reconcile.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(require_telemetry.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 (require_task.isDelegationActive(task)) return { value: {
+				ok: false,
+				message: `#${taskId} is already delegated to ${task.delegation?.agent}`
+			} };
+			if (require_taskGraph.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(require_telemetry.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(require_telemetry.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(require_telemetry.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 || !require_task.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 = require_telemetry.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(require_telemetry.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(require_telemetry.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(require_telemetry.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(require_telemetry.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 && require_taskGraph.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 (!require_task.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
+Object.defineProperty(exports, "BACKGROUND_WORK_PROVIDER", {
+	enumerable: true,
+	get: function() {
+		return BACKGROUND_WORK_PROVIDER;
+	}
+});
+Object.defineProperty(exports, "DelegationManager", {
+	enumerable: true,
+	get: function() {
+		return DelegationManager;
+	}
+});
+Object.defineProperty(exports, "ERR_CANCEL_UNACKNOWLEDGED", {
+	enumerable: true,
+	get: function() {
+		return ERR_CANCEL_UNACKNOWLEDGED;
+	}
+});
+Object.defineProperty(exports, "ERR_CHILD_SESSION", {
+	enumerable: true,
+	get: function() {
+		return ERR_CHILD_SESSION;
+	}
+});
+Object.defineProperty(exports, "ERR_NO_RUNTIME", {
+	enumerable: true,
+	get: function() {
+		return ERR_NO_RUNTIME;
+	}
+});
+Object.defineProperty(exports, "NOTIFY_CUSTOM_TYPE", {
+	enumerable: true,
+	get: function() {
+		return NOTIFY_CUSTOM_TYPE;
+	}
+});
+
+//# sourceMappingURL=delegation-3hMdTFXF.cjs.map