@agimon-ai/po-task 0.0.0-alpha.0

package/dist/extensions/mcp.cjs

@@ -0,0 +1,1144 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _agimon_ai_po_core_mcpFacet = require("@agimon-ai/po-core/mcpFacet");
+let _agimon_ai_po_core_delegation = require("@agimon-ai/po-core/delegation");
+let typebox = require("typebox");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let _agimon_ai_po_core_childProcess = require("@agimon-ai/po-core/childProcess");
+let _agimon_ai_po_core_piSettings = require("@agimon-ai/po-core/piSettings");
+let typebox_value = require("typebox/value");
+//#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_po_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/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
+const STORE_PATH_ENV = "DOOM_TASK_STORE";
+const STORE_DIR_NAME = "doom-task";
+const STORE_FILE_NAME = "tasks.json";
+/** Resolve the tree root without relying on extension startup order. */
+function resolveSessionKey(rootSessionId, env = process.env) {
+	if (!env[_agimon_ai_po_core_childProcess.SUBAGENT_CHILD_ENV]) return rootSessionId;
+	const parentSessionId = env[_agimon_ai_po_core_childProcess.SUBAGENT_PARENT_SESSION_ENV]?.trim();
+	if (!parentSessionId) throw new Error(`${_agimon_ai_po_core_childProcess.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 node_path.default.resolve(override);
+	const trimmedSessionKey = sessionKey.trim();
+	if (!trimmedSessionKey) throw new Error("doom-task session id cannot be blank");
+	return node_path.default.join((0, _agimon_ai_po_core_piSettings.piAgentDirectory)(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/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",
+	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.
+*
+* 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/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;
+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;
+	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;
+	}
+	/** 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 = node_fs.default.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, onReadError) {
+		const storePath = this.storePath;
+		const document = await this.readDocumentAsync(storePath, onReadError);
+		if (!shouldApply()) return document;
+		this.cached = document;
+		return document;
+	}
+	async readDocumentAsync(storePath = this.storePath, onReadError) {
+		try {
+			const raw = await node_fs.default.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 });
+				try {
+					onReadError?.(error);
+				} catch {}
+			}
+			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: committed
+				};
+			} finally {
+				release();
+			}
+		})();
+		if (outcome.notification) this.notifyCommitted(outcome.notification);
+		return outcome.result;
+	}
+	notifyCommitted(committed) {
+		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
+		};
+		node_fs.default.mkdirSync(node_path.default.dirname(this.storePath), { recursive: true });
+		const temp = tempPathFor(this.storePath);
+		node_fs.default.writeFileSync(temp, `${JSON.stringify(next, void 0, 2)}\n`, UTF8_ENCODING);
+		node_fs.default.renameSync(temp, this.storePath);
+		this.cached = next;
+		return next;
+	}
+	async acquireLock() {
+		const lockPath = lockPathFor(this.storePath);
+		node_fs.default.mkdirSync(node_path.default.dirname(this.storePath), { recursive: true });
+		const deadline = Date.now() + this.lockTimeoutMs;
+		for (;;) try {
+			const handle = node_fs.default.openSync(lockPath, "wx");
+			node_fs.default.writeSync(handle, JSON.stringify({
+				pid: process.pid,
+				time: Date.now()
+			}));
+			node_fs.default.closeSync(handle);
+			return () => node_fs.default.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(node_fs.default.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;
+			node_fs.default.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 publishes local commits to that bus and never watches the filesystem.
+	*/
+	onExternalChange(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	dispose() {
+		this.listeners.clear();
+	}
+};
+//#endregion
+//#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);
+}
+/**
+* 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;
+}
+//#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 (!(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"}...`));
+					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 = (0, _agimon_ai_po_core_mcpFacet.defineMcpTool)(({ execution }) => {
+	const store = new TaskStore({
+		cwd: execution.cwd,
+		env: execution.environment
+	});
+	store.configureSession(resolveSessionKey(execution.sessionId, execution.environment));
+	const tool = createHeadlessTaskTool(store, void 0, getMaxTasks(execution.environment));
+	let initialized;
+	return {
+		...tool,
+		parameters: RemoteTaskParamsSchema,
+		description: "Track multi-step work in the Po 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(() => void 0);
+			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) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const withWidget = (key, value) => value === void 0 ? value : {
+	...value,
+	_meta: {
+		...value._meta,
+		["po/widget"]: key
+	}
+};
+const mcp = (0, _agimon_ai_po_core_mcpFacet.defineMcpPlugin)({
+	name: "@agimon-ai/po-task",
+	session: (context) => ({ get tools() {
+		return [withWidget("@agimon-ai/po-task/task", via({ name: "task" }, at(task_mcp_default, context)))];
+	} })
+});
+//#endregion
+exports.default = mcp;
+exports.mcp = mcp;
+
+//# sourceMappingURL=mcp.cjs.map