@agimon-ai/po-task 0.0.0-alpha.7 → 0.0.0-alpha.71

package/dist/extensions/server.cjs

@@ -2,27 +2,28 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_paths = require("../paths-P-XvOUuH.cjs");
+const require_paths = require("../paths-CWVDY8Yd.cjs");
 const require_config = require("../config-BC-bztyx.cjs");
 const require_taskGraph = require("../taskGraph-BskRslrr.cjs");
 const require_telemetry = require("../telemetry-x3JxCA5K.cjs");
-const require_delegation = require("../delegation-frvEXhIz.cjs");
+const require_delegation = require("../delegation-BJtAUTVg.cjs");
 const require_taskResult = require("../taskResult-D2G7b4w-.cjs");
 const require_task = require("../task-UvW877Ez.cjs");
 const require_reducer = require("../reducer-BV0YIZ2o.cjs");
-const require_taskStore = require("../taskStore-C4vcUOzA.cjs");
-const require_logSinkTelemetry = require("../logSinkTelemetry-BGb8WQBz.cjs");
+const require_taskStore = require("../taskStore-B-BbY2Ci.cjs");
+const require_logSinkTelemetry = require("../logSinkTelemetry-DhzIQMsV.cjs");
 let _agimon_ai_po_core_delegation = require("@agimon-ai/po-core/delegation");
 let node_path = require("node:path");
 node_path = require_paths.__toESM(node_path, 1);
-let _agimon_ai_po_core_serverFacet = require("@agimon-ai/po-core/serverFacet");
+let _agimon_ai_po_core_serverPlugin = require("@agimon-ai/po-core/serverPlugin");
 let _agimon_ai_po_core_extensionFile = require("@agimon-ai/po-core/extensionFile");
 let _agimon_ai_po_core_backgroundWork = require("@agimon-ai/po-core/backgroundWork");
+let _agimon_ai_po_core_codemode = require("@agimon-ai/po-core/codemode");
 let _agimon_ai_po_core_contextContributions = require("@agimon-ai/po-core/contextContributions");
 let _agimon_ai_po_core_readiness = require("@agimon-ai/po-core/readiness");
 let node_crypto = require("node:crypto");
-let _agimon_ai_po_core_hubChannel = require("@agimon-ai/po-core/hubChannel");
 let typebox_value = require("typebox/value");
+let _agimon_ai_po_core_hubChannel = require("@agimon-ai/po-core/hubChannel");
 //#region src/services/contextContribution/index.ts
 const TASK_CONTEXT_CONTRIBUTION_SOURCE = "@agimon-ai/po-task";
 const TASK_CONTEXT_CONTRIBUTION_ID = "active-tasks";
@@ -82,6 +83,315 @@ function createNodeDelegationPlatform(environment = process.env) {
 	};
 }
 //#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 = require_reducer.applyTaskMutation(current, action, params, void 0, maxTasks);
+		return {
+			...require_reducer.isCommittingOp(result.op) ? { document: result.document } : {},
+			value: result
+		};
+	});
+	if (value.op.kind === "error") throw new Error(value.op.message);
+	return require_taskResult.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;
+}
+/** One task action against the session store, shared by the `task` tool and the `tasks` code-mode namespace. */
+async function runTaskAction(store, manager, maxTasks, rawParams, signal, onUpdate) {
+	if (!(0, typebox_value.Check)(require_task.TaskParamsSchema, rawParams)) {
+		const [first] = (0, typebox_value.Errors)(require_task.TaskParamsSchema, rawParams);
+		return failure(`Invalid task parameters${first ? `: ${first.instancePath || "/"} ${first.message}` : ""}.`);
+	}
+	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 = require_taskResult.formatAssignmentResults(items);
+			if (assigned.length === 0) throw new Error(text);
+			return require_taskResult.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 require_taskResult.buildTextResult("cancel", params, store.snapshot, outcome.message);
+		}
+		return reducerAction(store, params.action, params, maxTasks);
+	} catch (error) {
+		return failure(error);
+	}
+}
+function createHeadlessTaskTool(store, manager, maxTasks) {
+	return {
+		name: "task",
+		label: "Task",
+		description: "Maintain a persistent task graph and delegate ready tasks to background agents.",
+		parameters: require_task.TaskParamsSchema,
+		promptSnippet: "Track complex work persistently and delegate ready tasks",
+		executionMode: "serial",
+		execute: (_toolCallId, rawParams, signal, onUpdate) => runTaskAction(store, manager, maxTasks, rawParams, signal, onUpdate)
+	};
+}
+//#endregion
+//#region src/services/taskNamespace/index.ts
+const DECLARATIONS = `type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'deleted';
+
+type DelegationState = 'requested' | 'running' | 'completed' | 'failed' | 'cancelled';
+
+interface DelegationResult {
+  status: string;
+  output?: string;
+  outputPath?: string;
+  sessionFile?: string;
+  error?: string;
+  durationMs?: number;
+  toolCount?: number;
+}
+
+interface TaskDelegation {
+  requestId: string;
+  agent: string;
+  identity?: string;
+  state: DelegationState;
+  sessionId?: string;
+  pid?: number;
+  runId?: string;
+  model?: string;
+  startedAt?: string;
+  endedAt?: string;
+  result?: DelegationResult;
+}
+
+interface Task {
+  id: number;
+  subject: string;
+  description?: string;
+  activeForm?: string;
+  status: TaskStatus;
+  blockedBy?: number[];
+  owner?: string;
+  metadata?: Record<string, unknown>;
+  createdAt?: string;
+  updatedAt?: string;
+  delegation?: TaskDelegation;
+}
+
+interface TaskDocument {
+  version: number;
+  rev: number;
+  nextId: number;
+  tasks: Task[];
+}
+interface TaskItem {
+  /** Existing task id to change. Omit to create; an unknown id fails only that entry. */
+  id?: number;
+  /** Temporary name so a LATER entry in the same call can list it in blockedBy. Never stored. */
+  ref?: string;
+  /** Short and imperative. Required when creating. */
+  subject?: string;
+  /** The durable brief handed to a subagent on assign. */
+  description?: string;
+  /** Present-continuous label shown while in_progress, such as 'writing tests'. */
+  activeForm?: string;
+  status?: TaskStatus;
+  /** For a NEW entry: task ids or earlier refs. */
+  blockedBy?: (number | string)[];
+  /** For an entry with an id: dependencies to add or remove. */
+  addBlockedBy?: (number | string)[];
+  removeBlockedBy?: (number | string)[];
+  owner?: string;
+  /** Merged into the task; a null value deletes that key. */
+  metadata?: Record<string, unknown>;
+}
+
+interface TaskAssignment {
+  /** A pending, unblocked task. */
+  id: number;
+  /** Exact name from subagent({ action: 'agents' }). */
+  agent: string;
+  instructions?: string;
+  /** Only files you actually read or located. */
+  relevantFiles?: string[];
+  /** Only verified facts, not directives. */
+  priorFindings?: string;
+  model?: string;
+  context?: 'fresh' | 'fork';
+}
+
+/** What a write returns: the text the task tool would print, and the graph after the write. */
+interface TaskWrite {
+  message: string;
+  document: TaskDocument;
+  /** upsert only: ids that landed and how many entries failed. Nothing landing throws; a partial failure does not. */
+  applied?: number[];
+  failed?: number;
+}
+declare const tasks: {
+  /** The whole task graph, tombstones included. Filter it in the script. */
+  snapshot(): Promise<TaskDocument>;
+  /**
+   * Create or change tasks, applied in array order. Never mark a task completed while tests fail or the
+   * work is partial: use failed, or keep it in_progress and add a task for the blocker in the same call.
+   * Status flow is pending, in_progress, completed. failed is recoverable and deleted is a tombstone.
+   */
+  upsert(tasks: TaskItem[]): Promise<TaskWrite>;
+  /** Tombstone one task. Refused while it has a running delegation. */
+  delete(id: number): Promise<TaskWrite>;
+  /** Remove every task. Refused while a delegation is running. */
+  clear(): Promise<TaskWrite>;
+  /** Hand ready tasks to background subagents. Batch independent tasks in one call. */
+  assign(assignments: TaskAssignment[]): Promise<TaskWrite>;
+  /** Cancel a task's running delegation. */
+  cancel(id: number): Promise<TaskWrite>;
+};`;
+/** The owning session's task graph: `snapshot` reads without locking, the rest write through the same store as the `task` tool. */
+function createTaskNamespace(options) {
+	return {
+		name: "tasks",
+		summary: "The session task graph: tasks.snapshot() reads it, tasks.upsert/delete/clear change it, tasks.assign/cancel hand tasks to background subagents. Use it to track multi-step work.",
+		declarations: DECLARATIONS,
+		bind(run) {
+			if (run.sessionId !== options.sessionId) throw new Error("Tasks namespace belongs to another session.");
+			let disposed = false;
+			run.onDispose(() => {
+				disposed = true;
+			});
+			const assertAvailable = () => {
+				run.signal.throwIfAborted();
+				if (disposed) throw new Error("Tasks namespace run is disposed.");
+				options.assertAvailable();
+			};
+			const members = Object.create(null);
+			members.snapshot = async () => {
+				assertAvailable();
+				const storePath = options.store.storePath;
+				const errors = [];
+				const document = await options.store.readAsync(() => false, (error) => errors.push(error));
+				assertAvailable();
+				if (options.store.storePath !== storePath) throw new Error("Task store path changed during snapshot.");
+				if (errors.length > 0) throw new Error("Task snapshot read failed.", { cause: errors[0] });
+				return JSON.parse(JSON.stringify(document));
+			};
+			const write = async (params) => {
+				assertAvailable();
+				const started = Date.now();
+				const result = await runTaskAction(options.store, options.manager, options.maxTasks, params, run.signal);
+				assertAvailable();
+				const message = result.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n");
+				const upsert = result.details?.upsert;
+				const failure = result.isError || upsert && upsert.applied.length === 0 && upsert.failed > 0 ? message : void 0;
+				run.record?.({
+					name: `tasks.${String(params.action)}`,
+					tool: "task",
+					args: params,
+					ok: failure === void 0,
+					ms: Date.now() - started,
+					...failure === void 0 ? {} : { error: failure },
+					result: {
+						content: result.content,
+						details: result.details
+					}
+				});
+				if (failure !== void 0) throw new Error(failure);
+				return {
+					message,
+					document: JSON.parse(JSON.stringify(options.store.snapshot)),
+					...upsert ? {
+						applied: upsert.applied,
+						failed: upsert.failed
+					} : {}
+				};
+			};
+			members.upsert = (tasks) => write({
+				action: "upsert",
+				tasks: entriesWithIds(tasks)
+			});
+			members.list = members.snapshot;
+			members.delete = (id) => write({
+				action: "delete",
+				id: taskId(id)
+			});
+			members.clear = () => write({ action: "clear" });
+			members.assign = (assignments) => write({
+				action: "assign",
+				assignments: entriesWithIds(assignments)
+			});
+			members.cancel = (id) => write({
+				action: "cancel",
+				id: taskId(id)
+			});
+			return members;
+		}
+	};
+}
+/** `'3'` becomes `3`, as the `task` tool's argument coercion does; anything else is left for validation to reject. */
+function taskId(value) {
+	return typeof value === "string" && /^\d+$/.test(value) ? Number(value) : value;
+}
+/** One entry becomes a list, and each entry's id goes through `taskId`. The caller's objects are not changed. */
+function entriesWithIds(value) {
+	const entries = value !== null && typeof value === "object" && !Array.isArray(value) ? [value] : value;
+	if (!Array.isArray(entries)) return entries;
+	return entries.map((entry) => entry !== null && typeof entry === "object" && "id" in entry ? {
+		...entry,
+		id: taskId(entry.id)
+	} : entry);
+}
+//#endregion
 //#region src/types/webTasks.ts
 /** Browser-safe task view published by the cockpit hub channel. */
 const TASKS_CHANNEL_TYPE = "task_graph";
@@ -95,7 +405,7 @@ function headlineOf(content) {
 const root = (0, _agimon_ai_po_core_extensionFile.defineRoot)(({ host: serverHost, agent: host, signal: pluginSignal }) => {
 	if (!host) throw new Error("Task session requires the headless host.");
 	const execution = host.context;
-	if (serverHost.context.directEvents === void 0) throw new Error("Task headless facet requires the session direct event bus.");
+	if (serverHost.context.directEvents === void 0) throw new Error("Task server plugin requires the session direct event bus.");
 	const directEvents = serverHost.context.directEvents;
 	const reporter = require_logSinkTelemetry.createTaskErrorReporter({
 		cwd: execution.cwd,
@@ -180,6 +490,25 @@ const root = (0, _agimon_ai_po_core_extensionFile.defineRoot)(({ host: serverHos
 		},
 		services: [(serviceContextOwner) => {
 			serviceContext = serviceContextOwner;
+			const namespace = createTaskNamespace({
+				store,
+				manager,
+				maxTasks,
+				sessionId: execution.sessionId,
+				assertAvailable: () => {
+					if (!active || disposed || pluginSignal?.aborted) throw new Error("Task session is unavailable.");
+				}
+			});
+			serviceContextOwner.inject([_agimon_ai_po_core_codemode.PO_CODEMODE_SERVICE], (context) => {
+				const codemode = (0, _agimon_ai_po_core_codemode.readPoCodemode)(context);
+				if (!codemode) return void 0;
+				const registration = codemode.register(SOURCE, namespace);
+				const restriction = host.registerToolRestriction({ excludedTools: ["task"] });
+				return () => {
+					restriction.dispose();
+					registration.dispose();
+				};
+			});
 			serviceContextOwner.inject([_agimon_ai_po_core_contextContributions.PO_CONTEXT_CONTRIBUTIONS_SERVICE], (context) => {
 				const registration = (0, _agimon_ai_po_core_contextContributions.requirePoContextContributions)(context).register(createTaskContextContribution(() => active && !disposed ? store.snapshot.tasks : []));
 				return () => registration.dispose();
@@ -226,9 +555,9 @@ const root = (0, _agimon_ai_po_core_extensionFile.defineRoot)(({ host: serverHos
 						if (!isCurrent()) return { value: void 0 };
 						store.configureSession(require_paths.resolveSessionKey(activityContext.sessionId, activityContext.environment));
 						manager.setCwd(activityContext.cwd);
-						const cleanup = await require_paths.removeLegacyStoreDirectoryAsync(store.storePath, activityContext.cwd);
+						const cleanup = await require_paths.removeLegacyStoreDirectory(store.storePath, activityContext.cwd);
 						if (!isCurrent()) return { value: void 0 };
-						const sweep = require_paths.hasStorePathOverride(activityContext.environment) ? { errors: [] } : await require_paths.sweepStoreFilesAsync(store.storePath, require_config.getStoreTtlMs(activityContext.environment));
+						const sweep = require_paths.hasStorePathOverride(activityContext.environment) ? { errors: [] } : await require_paths.sweepStoreFiles(store.storePath, require_config.getStoreTtlMs(activityContext.environment));
 						for (const error of [...cleanup.errors, ...sweep.errors]) {
 							diagnostics.push(error);
 							report.warn(require_telemetry.TASK_EVENT.storeSweepFailed, new Error(error));
@@ -282,12 +611,14 @@ const root = (0, _agimon_ai_po_core_extensionFile.defineRoot)(({ host: serverHos
 			generation += 1;
 			startupAbort.abort();
 			await Promise.allSettled([startup]);
-			unwatch?.();
-			background?.dispose();
-			manager.dispose();
-			store.dispose();
-			await ownedReadiness.dispose();
-			await reporter.shutdown();
+			await (0, _agimon_ai_po_core_extensionFile.runCleanups)([
+				() => unwatch?.(),
+				() => background?.dispose(),
+				() => manager.dispose(),
+				() => store.dispose(),
+				() => ownedReadiness.dispose(),
+				() => reporter.shutdown()
+			], "Task cleanup failed.");
 		}
 	};
 });
@@ -315,6 +646,7 @@ function present(document) {
 			if (task.updatedAt) view.updatedAt = task.updatedAt;
 			if (task.delegation) view.delegation = {
 				...task.delegation.agent === void 0 ? {} : { agent: task.delegation.agent },
+				...task.delegation.identity === void 0 ? {} : { identity: task.delegation.identity },
 				...task.delegation.state === void 0 ? {} : { state: task.delegation.state }
 			};
 			return [view];
@@ -328,8 +660,9 @@ function createTasksChannel(options = {}) {
 		frameType: TASKS_CHANNEL_TYPE,
 		start(host) {
 			const stores = /* @__PURE__ */ new Map();
-			const open = (scope) => {
-				if (stores.has(scope.sessionId)) return;
+			let closed = false;
+			const open = async (scope) => {
+				if (closed || stores.has(scope.sessionId)) return;
 				let store = options.storeFor?.(scope);
 				if (store === void 0) {
 					if (scope.environment === void 0) throw new Error(`Task channel requires an admitted environment for session '${scope.sessionId}'.`);
@@ -339,12 +672,21 @@ function createTasksChannel(options = {}) {
 						storePath: require_paths.resolveStorePath(scope.cwd, scope.environment, require_paths.resolveSessionKey(scope.sessionId, scope.environment))
 					});
 				}
-				store.read();
 				const source = {
 					store,
-					unsubscribe: () => void 0
+					unsubscribe: () => void 0,
+					ready: false,
+					latest: void 0
 				};
 				stores.set(scope.sessionId, source);
+				try {
+					await store.readAsync();
+				} catch (error) {
+					if (stores.get(scope.sessionId) === source) close(scope.sessionId);
+					throw error;
+				}
+				if (closed || stores.get(scope.sessionId) !== source) return;
+				source.ready = true;
 				source.unsubscribe = host.directEvents.subscribe(TASKS_CHANNEL_TYPE, scope.sessionId, (payload) => {
 					if (!isTaskDocument(payload)) return;
 					const current = stores.get(scope.sessionId);
@@ -352,6 +694,12 @@ function createTasksChannel(options = {}) {
 					current.latest = payload;
 					host.publish(scope.sessionId, present(payload));
 				}, { replayLatest: true });
+				if (!source.latest && store.snapshot.tasks.length > 0) host.publish(scope.sessionId, present(store.snapshot));
+			};
+			const requestOpen = (scope) => {
+				open(scope).catch((error) => {
+					host.onNotice(`Could not open task store for session '${scope.sessionId}': ${String(error)}`);
+				});
 			};
 			const close = (sessionId) => {
 				const source = stores.get(sessionId);
@@ -360,12 +708,11 @@ function createTasksChannel(options = {}) {
 				source.store.dispose();
 				stores.delete(sessionId);
 			};
-			for (const scope of host.sessions()) open(scope);
+			for (const scope of host.sessions()) requestOpen(scope);
 			return {
 				homeFor(scope) {
-					open(scope);
 					const source = stores.get(scope.sessionId);
-					const document = source?.latest ?? source?.store.snapshot;
+					const document = source?.ready ? source.latest ?? source.store.snapshot : void 0;
 					if (!document) return {
 						coverage: "unavailable",
 						entities: []
@@ -416,14 +763,15 @@ function createTasksChannel(options = {}) {
 					};
 				},
 				payloadFor(scope) {
-					open(scope);
+					requestOpen(scope);
 					const source = stores.get(scope.sessionId);
-					const document = source?.latest ?? source?.store.snapshot;
+					const document = source?.ready ? source.latest ?? source.store.snapshot : void 0;
 					return document === void 0 ? void 0 : present(document);
 				},
-				sessionAdded: open,
+				sessionAdded: requestOpen,
 				sessionRemoved: close,
 				close() {
+					closed = true;
 					for (const sessionId of stores.keys()) close(sessionId);
 				}
 			};
@@ -434,105 +782,6 @@ function createTasksChannel(options = {}) {
 //#region src/extensions/(backend)/channel/task-graph.server.ts
 var task_graph_server_default = (0, _agimon_ai_po_core_extensionFile.defineChannel)(createTasksChannel);
 //#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 = require_reducer.applyTaskMutation(current, action, params, void 0, maxTasks);
-		return {
-			...require_reducer.isCommittingOp(result.op) ? { document: result.document } : {},
-			value: result
-		};
-	});
-	if (value.op.kind === "error") throw new Error(value.op.message);
-	return require_taskResult.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: require_task.TaskParamsSchema,
-		promptSnippet: "Track complex work persistently and delegate ready tasks",
-		executionMode: "serial",
-		async execute(_toolCallId, rawParams, signal, onUpdate) {
-			if (!(0, typebox_value.Check)(require_task.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 = require_taskResult.formatAssignmentResults(items);
-					if (assigned.length === 0) throw new Error(text);
-					return require_taskResult.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 require_taskResult.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)/command/_lib/tasks.server.ts
 var tasks_server_default$1 = (context) => ({
 	name: require_task.COMMAND_NAME,
@@ -550,12 +799,22 @@ var tasks_server_default$1 = (context) => ({
 //#region src/extensions/workspaces/sessions/(backend)/command/tasks.server.ts
 var tasks_server_default = (0, _agimon_ai_po_core_extensionFile.defineServerCommand)(tasks_server_default$1);
 //#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/codemode-how-to-task.server.ts
+var codemode_how_to_task_server_default = (0, _agimon_ai_po_core_extensionFile.defineResource)({
+	name: "codemode-how-to-task",
+	description: "Track work as a task list with the tasks namespace, so the plan and its progress survive compaction, and hand tasks to background subagents. Use at the start of any request with three or more steps, when the person gives a list of things to do, or before delegating work.",
+	kind: "skill",
+	pinned: true,
+	path: (0, _agimon_ai_po_core_serverPlugin.packageResourcePath)(require("url").pathToFileURL(__filename).href, "src/prompts/codemode-how-to-task/SKILL.md"),
+	read: () => (0, _agimon_ai_po_core_serverPlugin.readPackageResource)(require("url").pathToFileURL(__filename).href, "src/prompts/codemode-how-to-task/SKILL.md")
+});
+//#endregion
 //#region src/extensions/workspaces/sessions/(backend)/resource/_lib/task-board.server.ts
 var task_board_server_default$1 = (context) => ({
 	name: "po/task-board",
 	kind: "context",
 	/**
-	* The same bounded projection the Pi facet renders: open work only, one line each.
+	* The same bounded projection the Pi extension renders: open work only, one line each.
 	* Dumping the whole TaskDocument put every completed task plus the store's own
 	* version/rev/nextId bookkeeping in the prompt, and an idle board still cost a
 	* paragraph. '' is dropped by the prompt composer.
@@ -577,21 +836,24 @@ var task_server_default = (0, _agimon_ai_po_core_extensionFile.defineServerTool)
 //#endregion
 //#region generated/server.ts
 const at = (value, context) => typeof value === "function" ? value(context) : value;
+/* v8 ignore next -- generated normalization branch */
+const defined = (values) => values.filter((value) => value !== void 0);
 const via = (identity, value) => value === void 0 ? void 0 : {
 	...identity,
 	...value
 };
-const facet = (0, _agimon_ai_po_core_serverFacet.defineServerPlugin)({
+const serverPlugin = (0, _agimon_ai_po_core_serverPlugin.defineServerPlugin)({
 	name: "@agimon-ai/po-task",
-	providerOverrides: (0, _agimon_ai_po_core_serverFacet.composeServerProviderOverrides)(root_server_default),
-	global: () => ({ get channels() {
-		return [() => via({ frameType: "task_graph" }, task_graph_server_default())];
+	providerOverrides: (0, _agimon_ai_po_core_serverPlugin.composeServerProviderOverrides)(root_server_default),
+	injects: (0, _agimon_ai_po_core_extensionFile.composeRootInjects)({ session: [root_server_default] }),
+	global: (context) => ({ get channels() {
+		return [() => via({ frameType: "task_graph" }, at(task_graph_server_default, context))];
 	} }),
-	workspace: () => ({ get channels() {
-		return [() => via({ frameType: "task_graph" }, task_graph_server_default())];
+	workspace: (context) => ({ get channels() {
+		return defined([context.hosted("global") ? void 0 : () => via({ frameType: "task_graph" }, at(task_graph_server_default, context))]);
 	} }),
 	session: async (context) => {
-		const scopeSession = await root_server_default(context);
+		const scopeSession = await context.scopeRoot("session", root_server_default, context);
 		const contextSession = {
 			...context,
 			root: scopeSession.value
@@ -599,13 +861,13 @@ const facet = (0, _agimon_ai_po_core_serverFacet.defineServerPlugin)({
 		return {
 			...(0, _agimon_ai_po_core_extensionFile.composeRootHooks)(scopeSession),
 			get channels() {
-				return [() => via({ frameType: "task_graph" }, task_graph_server_default())];
+				return defined([context.hosted("global") ? void 0 : () => via({ frameType: "task_graph" }, at(task_graph_server_default, context))]);
 			},
 			get commands() {
 				return [via({ name: "tasks" }, at(tasks_server_default, contextSession))];
 			},
 			get resources() {
-				return [at(task_board_server_default, contextSession)];
+				return [at(codemode_how_to_task_server_default, contextSession), at(task_board_server_default, contextSession)];
 			},
 			get tools() {
 				return [via({ name: "task" }, at(task_server_default, contextSession))];
@@ -618,7 +880,7 @@ const facet = (0, _agimon_ai_po_core_serverFacet.defineServerPlugin)({
 	}
 });
 //#endregion
-exports.default = facet;
-exports.facet = facet;
+exports.default = serverPlugin;
+exports.serverPlugin = serverPlugin;
 
 //# sourceMappingURL=server.cjs.map