@agimon-ai/po-task 0.0.0-alpha.4 → 0.0.0-alpha.41

package/dist/extensions/server.mjs

@@ -1,23 +1,24 @@
 import { f as getDelegationTimeoutMs, h as getStoreTtlMs, p as getMaxTasks } from "../config-BTadoGeF.mjs";
 import { r as isBlocked } from "../taskGraph-BOQvT0-M.mjs";
 import { t as TASK_EVENT } from "../telemetry-gEGWTaMI.mjs";
-import { n as DelegationManager, t as BACKGROUND_WORK_PROVIDER } from "../delegation-Dsqf7fUM.mjs";
+import { n as DelegationManager, t as BACKGROUND_WORK_PROVIDER } from "../delegation-CLcleXHi.mjs";
 import { a as buildAssignmentResult, c as formatAssignmentResults, o as buildTextResult, s as buildToolResult } from "../taskResult-edBAAKSH.mjs";
 import { g as COMMAND_NAME, m as TaskParamsSchema } from "../task-DO0TwZ0z.mjs";
 import { a as removeLegacyStoreDirectoryAsync, c as resolveSessionKey, d as sweepStoreFilesAsync, l as resolveStorePath, n as hasStorePathOverride } from "../paths-DajceJig.mjs";
 import { a as isCommittingOp, r as applyTaskMutation } from "../reducer-BEfJFM5L.mjs";
 import { t as TaskStore } from "../taskStore-BAi54FKL.mjs";
-import { n as toFailureReporter, t as createTaskErrorReporter } from "../logSinkTelemetry-BhbKdn-x.mjs";
+import { n as toFailureReporter, t as createTaskErrorReporter } from "../logSinkTelemetry-3GMazFYa.mjs";
 import { PO_DELEGATION_SERVICE, readPoDelegationService } from "@agimon-ai/po-core/delegation";
 import path from "node:path";
-import { composeServerProviderOverrides, defineServerPlugin } from "@agimon-ai/po-core/serverFacet";
-import { composeRootHooks, defineChannel, defineResource, defineRoot, defineServerCommand, defineServerTool } from "@agimon-ai/po-core/extensionFile";
+import { composeServerProviderOverrides, defineServerPlugin, packageResourcePath, readPackageResource } from "@agimon-ai/po-core/serverPlugin";
+import { composeRootHooks, composeRootInjects, defineChannel, defineResource, defineRoot, defineServerCommand, defineServerTool, runCleanups } from "@agimon-ai/po-core/extensionFile";
 import { PO_BACKGROUND_WORK_SERVICE, readPoBackgroundWorkService } from "@agimon-ai/po-core/backgroundWork";
+import { PO_CODEMODE_SERVICE, readPoCodemode } from "@agimon-ai/po-core/codemode";
 import { PO_CONTEXT_CONTRIBUTIONS_SERVICE, requirePoContextContributions } from "@agimon-ai/po-core/contextContributions";
 import { createPoReadinessCoordinator, readPoReadinessCoordinator } from "@agimon-ai/po-core/readiness";
 import { createHash, randomUUID } from "node:crypto";
-import { HOME_ENTITY_LIMIT } from "@agimon-ai/po-core/hubChannel";
 import { Check } from "typebox/value";
+import { HOME_ENTITY_LIMIT } from "@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";
@@ -77,6 +78,298 @@ 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 = 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;
+}
+/** 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 (!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);
+	}
+}
+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",
+		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
+			});
+			members.delete = (id) => write({
+				action: "delete",
+				id
+			});
+			members.clear = () => write({ action: "clear" });
+			members.assign = (assignments) => write({
+				action: "assign",
+				assignments
+			});
+			members.cancel = (id) => write({
+				action: "cancel",
+				id
+			});
+			return members;
+		}
+	};
+}
+//#endregion
 //#region src/types/webTasks.ts
 /** Browser-safe task view published by the cockpit hub channel. */
 const TASKS_CHANNEL_TYPE = "task_graph";
@@ -90,7 +383,7 @@ function headlineOf(content) {
 const root = 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 = createTaskErrorReporter({
 		cwd: execution.cwd,
@@ -175,6 +468,25 @@ const root = defineRoot(({ host: serverHost, agent: host, signal: pluginSignal }
 		},
 		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([PO_CODEMODE_SERVICE], (context) => {
+				const 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([PO_CONTEXT_CONTRIBUTIONS_SERVICE], (context) => {
 				const registration = requirePoContextContributions(context).register(createTaskContextContribution(() => active && !disposed ? store.snapshot.tasks : []));
 				return () => registration.dispose();
@@ -277,12 +589,14 @@ const root = defineRoot(({ host: serverHost, agent: host, signal: pluginSignal }
 			generation += 1;
 			startupAbort.abort();
 			await Promise.allSettled([startup]);
-			unwatch?.();
-			background?.dispose();
-			manager.dispose();
-			store.dispose();
-			await ownedReadiness.dispose();
-			await reporter.shutdown();
+			await runCleanups([
+				() => unwatch?.(),
+				() => background?.dispose(),
+				() => manager.dispose(),
+				() => store.dispose(),
+				() => ownedReadiness.dispose(),
+				() => reporter.shutdown()
+			], "Task cleanup failed.");
 		}
 	};
 });
@@ -310,6 +624,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];
@@ -429,105 +744,6 @@ function createTasksChannel(options = {}) {
 //#region src/extensions/(backend)/channel/task-graph.server.ts
 var task_graph_server_default = 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 = applyTaskMutation(current, action, params, void 0, maxTasks);
-		return {
-			...isCommittingOp(result.op) ? { document: result.document } : {},
-			value: result
-		};
-	});
-	if (value.op.kind === "error") throw new Error(value.op.message);
-	return buildToolResult(action, params, document, value.op);
-}
-async function assignmentBatch(manager, assignments, signal) {
-	const result = [];
-	for (const [index, assignment] of assignments.entries()) try {
-		const outcome = await manager.assign(assignment.id, {
-			agent: assignment.agent,
-			inlineAgent: assignment.inlineAgent,
-			instructions: assignment.instructions,
-			relevantFiles: assignment.relevantFiles,
-			priorFindings: assignment.priorFindings,
-			model: assignment.model,
-			...assignment.context === "fork" || assignment.context === "fresh" ? { context: assignment.context } : {},
-			signal
-		});
-		result.push({
-			index,
-			id: assignment.id,
-			agent: assignment.agent,
-			...outcome
-		});
-	} catch (error) {
-		result.push({
-			index,
-			id: assignment.id,
-			agent: assignment.agent,
-			ok: false,
-			message: String(error)
-		});
-	}
-	return result;
-}
-function createHeadlessTaskTool(store, manager, maxTasks) {
-	return {
-		name: "task",
-		label: "Task",
-		description: "Maintain a persistent task graph and delegate ready tasks to background agents.",
-		parameters: TaskParamsSchema,
-		promptSnippet: "Track complex work persistently and delegate ready tasks",
-		executionMode: "serial",
-		async execute(_toolCallId, rawParams, signal, onUpdate) {
-			if (!Check(TaskParamsSchema, rawParams)) return failure("Invalid task parameters.");
-			const params = rawParams;
-			try {
-				if ((params.action === "assign" || 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)/command/_lib/tasks.server.ts
 var tasks_server_default$1 = (context) => ({
 	name: COMMAND_NAME,
@@ -545,12 +761,22 @@ var tasks_server_default$1 = (context) => ({
 //#region src/extensions/workspaces/sessions/(backend)/command/tasks.server.ts
 var tasks_server_default = 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 = defineResource({
+	name: "codemode-how-to-task",
+	description: "Keep a plan that survives compaction and delegate parts of it to background subagents. Use for any multi-step plan, todo list, or delegation.",
+	kind: "skill",
+	pinned: true,
+	path: packageResourcePath(import.meta.url, "src/prompts/codemode-how-to-task/SKILL.md"),
+	read: () => readPackageResource(import.meta.url, "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.
@@ -572,21 +798,24 @@ var task_server_default = defineServerTool(task_server_default$1);
 //#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 = defineServerPlugin({
+const serverPlugin = defineServerPlugin({
 	name: "@agimon-ai/po-task",
 	providerOverrides: composeServerProviderOverrides(root_server_default),
-	global: () => ({ get channels() {
-		return [() => via({ frameType: "task_graph" }, task_graph_server_default())];
+	injects: 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
@@ -594,13 +823,13 @@ const facet = defineServerPlugin({
 		return {
 			...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))];
@@ -613,6 +842,6 @@ const facet = defineServerPlugin({
 	}
 });
 //#endregion
-export { facet as default, facet };
+export { serverPlugin as default, serverPlugin };
 
 //# sourceMappingURL=server.mjs.map