@xopcai/xopc 0.0.382 → 0.0.384

package/dist/src/agent/tools/personal-task-tool.js

@@ -1,29 +1,83 @@
-import { resolveEffectiveAgentConfig } from "../../agent-config/resolver.js";
-import { init_agent_config } from "../../agent-config/index.js";
-import { AgentCatalogRepository, init_repository } from "../../agent-catalog/repository.js";
-import { resolveEffectiveAgentConfigForAgent } from "../../config/agent-profile.js";
+import { normalizeSpecialistRequirements } from "../../../packages/gateway-contract/src/specialists.js";
+import { appendProductDeliveryText } from "../../../packages/gateway-contract/src/product-delivery.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
+import { getSessionInputState, init_session_input_repository } from "../../storage/sqlite/session-input-repository.js";
+import { TaskRepository, init_task_repository } from "../../tasks/task-repository.js";
+import { getPersonalRequest, init_request_repository } from "../../personal-agent/request-repository.js";
+import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
+import { init_sqlite } from "../../storage/sqlite/index.js";
 import { isPersonalConversation } from "../../personal-agent/repository.js";
-import { getAvailablePersonalAgentTools, personalAgentModelAvailability } from "../../personal-agent/specialist-capabilities.js";
+import { TaskAllocationRepository } from "../../tasks/task-allocation-repository.js";
 import { TaskOriginRepository } from "../../tasks/task-origin-repository.js";
+import { boundedPersonalResult } from "./personal-result-budget.js";
+import { TaskApplicationService } from "../../tasks/task-application-service.js";
 import { createXopcUseTool } from "./xopc-use-tool.js";
+import { getAvailablePersonalAgentTools, personalAgentModelAvailability } from "../../personal-agent/specialist-capabilities.js";
+import { assessSpecialist, matchSpecialists } from "../../agent-matching/service.js";
+import { AgentSelectionRepository, selectionRequestHash } from "../../agent-matching/selection-repository.js";
+import { assertSpecialistEligible, createSelectedTask } from "../../agent-matching/delegation-service.js";
 import { PERSONAL_WORKER_RESULT_GUIDANCE } from "../../personal-agent/communication.js";
+import { cancelPersonalTask } from "../../personal-agent/task-cancel.js";
 import { randomUUID } from "node:crypto";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/personal-task-tool.ts
-init_repository();
-init_agent_config();
+init_src();
+init_sqlite();
+init_session_input_repository();
+init_request_repository();
+init_task_repository();
 const PersonalTaskSchema = Type.Object({
 	command: Type.Union([
+		Type.Literal("retry_allocation"),
+		Type.Literal("submit"),
 		Type.Literal("agents"),
+		Type.Literal("match"),
+		Type.Literal("selection"),
 		Type.Literal("create"),
 		Type.Literal("list"),
 		Type.Literal("get"),
 		Type.Literal("instruct"),
-		Type.Literal("answer")
+		Type.Literal("answer"),
+		Type.Literal("cancel")
 	]),
+	requirements: Type.Optional(Type.Object({
+		version: Type.Optional(Type.Literal(1)),
+		summary: Type.String({ maxLength: 300 }),
+		domain: Type.Optional(Type.String()),
+		taskType: Type.Optional(Type.String()),
+		inputKinds: Type.Optional(Type.Array(Type.String())),
+		outputKinds: Type.Optional(Type.Array(Type.String())),
+		requiredTools: Type.Optional(Type.Array(Type.String())),
+		requiredSkills: Type.Optional(Type.Array(Type.String())),
+		requestedAgentId: Type.Optional(Type.String({
+			minLength: 1,
+			description: "Only an executor explicitly named by the human user. Omit this field when the background router should choose; never infer it from the specialist directory."
+		}))
+	})),
+	selectionReason: Type.Optional(Type.String({ maxLength: 500 })),
+	selectionSource: Type.Optional(Type.Union([
+		Type.Literal("snapshot"),
+		Type.Literal("match"),
+		Type.Literal("explicit")
+	])),
+	previousSelectionId: Type.Optional(Type.String()),
+	matchId: Type.Optional(Type.String()),
+	requestId: Type.Optional(Type.String()),
+	cursor: Type.Optional(Type.String()),
+	offset: Type.Optional(Type.Integer({ minimum: 0 })),
+	limit: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 20
+	})),
 	title: Type.Optional(Type.String({ description: "Short task title, ideally under 60 characters. Do not put the full instructions here." })),
-	objective: Type.Optional(Type.String({ description: "One-sentence outcome for a new delegated Task." })),
-	description: Type.Optional(Type.String({ description: "Full task brief in Markdown: background, specific requests, source material, and delivery expectations." })),
+	objective: Type.Optional(Type.String({
+		minLength: 1,
+		description: "One-sentence outcome for a new delegated Task."
+	})),
+	description: Type.Optional(Type.String({
+		minLength: 1,
+		description: "Complete Markdown brief preserving the user request, input references, and delivery expectations. Optional structured fields need not repeat it."
+	})),
 	agentId: Type.Optional(Type.String({ description: "Specialist Agent ID. Never use your own ID." })),
 	taskId: Type.Optional(Type.String()),
 	instruction: Type.Optional(Type.String({ description: "The user’s new direction for this delegated Task." })),
@@ -33,22 +87,62 @@ const PersonalTaskSchema = Type.Object({
 	constraints: Type.Optional(Type.Array(Type.String())),
 	requiredSkills: Type.Optional(Type.Array(Type.String({
 		minLength: 1,
-		description: "Canonical Skill names explicitly requested by the user. Verify through agents before creation."
+		description: "Only Skill names explicitly requested by the user. Forward them to the background router for validation; omit otherwise."
 	}))),
 	requiredTools: Type.Optional(Type.Array(Type.String({ description: "Tool names needed for this Task. Use names returned by agents; omit when matching by role or expertise." }))),
 	idempotencyKey: Type.Optional(Type.String())
 });
-var PersonalSkillUnavailableError = class extends Error {};
-function resolveRequiredSkills(deps, agentId, requested) {
-	if (requested.length === 0) return [];
-	if (!deps.getAgentSkillAvailability) throw new Error("Specialist Skill availability cannot be verified");
-	const skills = deps.getAgentSkillAvailability(agentId).skills;
-	return [...new Set(requested.map((name) => name.trim().toLowerCase()))].map((name) => {
-		const skill = skills.find((item) => item.name.toLowerCase() === name);
-		if (!skill?.availableForCurrentAgent) throw new PersonalSkillUnavailableError(`Agent ${agentId} cannot use required Skill ${name}: ${skill?.unavailableReason ?? "not-installed"}. Do not substitute the requested Skill without the user’s direction.`);
-		return skill.name;
-	});
-}
+const PersonalTaskModelSchema = Type.Object({
+	...Type.Omit(PersonalTaskSchema, [
+		"agentId",
+		"selectionReason",
+		"selectionSource",
+		"previousSelectionId",
+		"matchId",
+		"cursor",
+		"requiredTools"
+	]).properties,
+	requirements: Type.Optional(Type.Omit(PersonalTaskSchema.properties.requirements, ["requiredTools", "requiredSkills"], { additionalProperties: false })),
+	command: Type.Union([
+		"submit",
+		"list",
+		"get",
+		"instruct",
+		"answer",
+		"retry_allocation",
+		"selection",
+		"cancel"
+	].map((command) => Type.Literal(command)))
+}, {
+	additionalProperties: false,
+	anyOf: [
+		{
+			properties: { command: { const: "submit" } },
+			required: ["objective", "description"]
+		},
+		{ properties: { command: { enum: ["list", "selection"] } } },
+		{
+			properties: { command: { enum: [
+				"get",
+				"retry_allocation",
+				"cancel"
+			] } },
+			required: ["taskId"]
+		},
+		{
+			properties: { command: { const: "instruct" } },
+			required: ["taskId", "instruction"]
+		},
+		{
+			properties: { command: { const: "answer" } },
+			required: [
+				"taskId",
+				"instruction",
+				"questionId"
+			]
+		}
+	]
+});
 const MAX_PERSONAL_TASK_TITLE = 60;
 function buildPersonalTaskBrief(input) {
 	const fullObjective = input.objective.trim();
@@ -66,69 +160,203 @@ function buildPersonalTaskBrief(input) {
 /** A narrow Task surface for the fast personal conversation. */
 function createPersonalTaskTool(deps) {
 	const productTool = createXopcUseTool(deps);
+	const matches = /* @__PURE__ */ new Map();
 	return {
 		name: "personal_task",
 		label: "Personal Task",
-		description: "Find specialist Agents by role, availableTools, and model.available; delegate work, inspect Tasks, send instructions, or answer worker questions. Choose an Agent whose model.available is true. Before saying you cannot do a request, inspect another Agent. If a candidate fails, retry alternatives within the user’s authorization only when the user has not required a particular Agent or Skill. For explicitly requested Skills, use requiredSkills in agents and create; creation validates availability and includes them in the worker brief. agents can filter by requiredTools or requiredSkills; if none match, inspect unfiltered Agents. Return to the user quickly after creation.",
-		parameters: PersonalTaskSchema,
+		description: "Submit objective and a concise complete description, then return after local persistence. Preserve the user request and source references without inventing an execution plan or extra requirements. Omit optional structured fields when they merely repeat the description. Describe required capabilities in the brief; the background Task Router selects one executor and checks its tools. Do not read input files, select Agents or invent tool names before submit. Set requirements.requestedAgentId only for an executor explicitly named by the user, using their ID or display name; preserve explicitly requested requiredSkills. get/list inspect existing Tasks with limit/offset; cancel stops a Task on explicit user instruction and reports execution stop confirmation; instruct/answer send context; retry_allocation retries selection before execution; selection explains assignment. Status and results return automatically. Preserve idempotencyKey on uncertain retries. Report only confirmed states.",
+		parameters: PersonalTaskModelSchema,
 		mutatesWorkspace: true,
 		mutationScope: "external",
 		requiresExclusiveWorkspaceLock: false,
 		finalGuardRelevant: true,
-		async execute(toolCallId, input, signal) {
+		async execute(toolCallId, modelInput, signal) {
+			const input = modelInput;
 			const conversationId = deps.getCurrentConversationId?.();
 			const ownAgentId = deps.getCurrentAgentId?.();
 			if (!conversationId || !ownAgentId || !isPersonalConversation(conversationId)) throw new Error("Personal conversation context is unavailable");
-			if (input.command === "agents") {
-				const requiredTools = input.requiredTools ?? [];
-				if (input.requiredSkills?.length && !deps.getAgentSkillAvailability) throw new Error("Specialist Skill availability cannot be verified");
-				const catalog = new AgentCatalogRepository().snapshot();
-				const agents = catalog.agents.filter((agent) => agent.enabled !== false && agent.id !== ownAgentId && !agent.id.startsWith("personal-")).map((agent) => {
-					const config = resolveEffectiveAgentConfig({
-						defaults: catalog.defaults,
-						agent
-					}).config;
-					const availableTools = getAvailablePersonalAgentTools(config, deps);
-					let requiredSkills;
-					try {
-						requiredSkills = resolveRequiredSkills(deps, agent.id, input.requiredSkills ?? []);
-					} catch (error) {
-						if (error instanceof PersonalSkillUnavailableError) return null;
-						throw error;
+			const requirements = normalizeSpecialistRequirements({
+				...input.requirements,
+				requestedAgentId: input.requirements?.requestedAgentId?.trim() || void 0,
+				version: 1,
+				summary: input.requirements?.summary ?? (input.objective?.trim() || "Specialist discovery").slice(0, 300),
+				requiredTools: [...input.requirements?.requiredTools ?? [], ...input.requiredTools ?? []],
+				requiredSkills: [...input.requirements?.requiredSkills ?? [], ...input.requiredSkills ?? []]
+			});
+			const context = {
+				ownAgentId,
+				getConfig: deps.getConfig,
+				getAgentSkillAvailability: deps.getAgentSkillAvailability,
+				getAgentToolAvailability: deps.getAgentToolAvailability,
+				legacyToolPolicyOnly: !input.requirements
+			};
+			if (input.command === "match" || input.command === "agents") {
+				if (input.command === "agents" && requirements.requiredSkills?.length && !deps.getAgentSkillAvailability) throw new Error("Specialist Skill availability cannot be verified");
+				const result = matchSpecialists(requirements, context, {
+					cursor: input.cursor,
+					limit: input.command === "agents" ? 50 : 10
+				});
+				if (input.command === "agents") {
+					let cursor = result.nextCursor;
+					while (cursor) {
+						const page = matchSpecialists(requirements, context, {
+							cursor,
+							limit: 50
+						});
+						result.candidates.push(...page.candidates);
+						cursor = page.nextCursor;
 					}
-					return {
-						...requiredSkills.length ? { verifiedSkills: requiredSkills } : {},
-						id: agent.id,
-						name: agent.profile?.name ?? agent.id,
-						description: agent.profile?.description ?? "",
-						availableTools,
-						model: personalAgentModelAvailability(config)
-					};
-				}).filter((agent) => agent !== null && requiredTools.every((tool) => agent.availableTools.includes(tool)));
+				}
+				const matchId = input.command === "match" ? randomUUID() : void 0;
+				if (matchId) {
+					if (matches.size >= 20) matches.delete(matches.keys().next().value);
+					matches.set(matchId, {
+						conversationId,
+						requirements,
+						result
+					});
+				}
+				const payload = input.command === "agents" ? result.candidates.filter((agent) => !agent.checks.some((check) => check.condition === "identity" && check.state === "blocked") && (requirements.requiredTools ?? []).every((tool) => agent.availableTools.includes(tool)) && (requirements.requiredSkills?.length ?? 0) === agent.verifiedSkills.length) : {
+					...result,
+					matchId
+				};
 				return {
 					content: [{
 						type: "text",
-						text: JSON.stringify(agents)
+						text: JSON.stringify(payload)
 					}],
 					details: {}
 				};
 			}
+			if (input.command === "selection") {
+				if (!(input.taskId ? new TaskOriginRepository().owns(input.taskId, conversationId) : input.requestId ? getPersonalRequest(input.requestId)?.conversationId === conversationId : true)) throw new Error("Task or Request does not belong to this personal conversation");
+				const offset = input.offset ?? 0;
+				const limit = input.limit ?? 10;
+				const rows = new AgentSelectionRepository().list(conversationId, {
+					taskId: input.taskId,
+					requestId: input.requestId,
+					offset,
+					limit: limit + 1
+				});
+				const items = rows.slice(0, limit).map(({ candidates: _candidates, assessment, ...record }) => ({
+					...record,
+					executor: {
+						id: assessment.id,
+						name: assessment.name
+					}
+				}));
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(boundedPersonalResult({
+							items,
+							offset,
+							...rows.length > limit ? { nextOffset: offset + items.length } : {}
+						}))
+					}],
+					details: {}
+				};
+			}
+			let selectedProductTool = productTool;
+			let pendingSelection;
 			let command = input.command;
 			let args = {};
-			if (command === "create") {
+			if (command === "submit") {
+				const objective = input.objective?.trim();
+				if (!objective || !input.description?.trim()) throw new Error("objective and a complete description are required");
+				if (input.agentId) throw new Error("Use requirements.requestedAgentId for an explicitly requested executor");
+				const brief = buildPersonalTaskBrief({
+					title: input.title,
+					objective,
+					description: input.description
+				});
+				const inputId = getSessionInputState(conversationId).activeInputId;
+				const submissionKey = input.idempotencyKey?.trim() || selectionRequestHash({
+					sourceInput: inputId ?? toolCallId,
+					brief,
+					requirements,
+					expectedOutputs: input.expectedOutputs,
+					acceptanceCriteria: input.acceptanceCriteria,
+					constraints: input.constraints
+				});
+				command = "create";
+				args = {
+					...brief,
+					createMode: "allocate",
+					requirements,
+					includeConversationContext: false,
+					expectedOutputs: input.expectedOutputs ?? [],
+					acceptanceCriteria: input.acceptanceCriteria ?? [],
+					constraints: input.constraints ?? [],
+					idempotencyKey: `personal-submit:${conversationId}:${selectionRequestHash(submissionKey)}`
+				};
+				if (requirements.requiredSkills?.length) args.body = `${brief.body}\n\nRequired Skills: ${requirements.requiredSkills.join(", ")}. Read and follow these Skills before execution.`;
+			} else if (command === "create") {
 				const objective = input.objective?.trim();
 				const agentId = input.agentId?.trim();
 				if (!objective || !agentId) throw new Error("objective and specialist agentId are required");
 				if (agentId === ownAgentId || agentId.startsWith("personal-")) throw new Error("Delegate to a specialist Agent, not a personal Agent");
-				const specialist = new AgentCatalogRepository().get(agentId);
-				if (!specialist || specialist.enabled === false || specialist.provisioningState !== "ready") throw new Error(`Specialist Agent is unavailable: ${agentId}`);
-				const config = resolveEffectiveAgentConfigForAgent(agentId).config;
-				const model = personalAgentModelAvailability(config);
-				if (!model.available) throw new Error(`Agent ${agentId} cannot start: ${model.reason}. Find another available Agent.`);
-				const availableTools = getAvailablePersonalAgentTools(config, deps);
-				const missingTools = (input.requiredTools ?? []).filter((tool) => !availableTools.includes(tool));
-				if (missingTools.length > 0) throw new Error(`Agent ${agentId} lacks required tools: ${missingTools.join(", ")}. Find another Agent or approach.`);
-				const requiredSkills = resolveRequiredSkills(deps, agentId, input.requiredSkills ?? []);
+				const key = input.idempotencyKey?.trim() || randomUUID();
+				const { requiredTools: _tools, requiredSkills: _skills, requirements: _requirements, ...requestInput } = input;
+				const requestHash = selectionRequestHash({
+					...requestInput,
+					idempotencyKey: key,
+					requirements
+				});
+				const previous = new AgentSelectionRepository().find(conversationId, key);
+				if (previous && previous.requestHash !== requestHash) throw new Error("Idempotency key was reused with different input");
+				if (previous?.status === "rejected") assertSpecialistEligible(previous.assessment);
+				const matched = input.matchId ? matches.get(input.matchId) : void 0;
+				if (!previous && input.matchId && (!matched || matched.conversationId !== conversationId)) throw new Error("Matching snapshot expired; match again");
+				if (!previous && matched && (selectionRequestHash(matched.requirements) !== selectionRequestHash(requirements) || !matched.result.candidates.some((candidate) => candidate.id === agentId))) throw new Error("Selection must preserve matched requirements and select a displayed candidate");
+				let assessment = previous?.assessment;
+				if (!assessment) {
+					assessment = assessSpecialist(agentId, requirements, context);
+					if (assessment.eligibility !== "eligible" && getSessionMetadata(conversationId)) new AgentSelectionRepository().create({
+						conversationId,
+						key,
+						requestHash,
+						requirements,
+						assessment,
+						source: input.selectionSource ?? "legacy",
+						reason: input.selectionReason,
+						previousSelectionId: input.previousSelectionId,
+						status: "rejected"
+					});
+					assertSpecialistEligible(assessment);
+				}
+				const requiredSkills = assessment.verifiedSkills;
+				if (!previous) pendingSelection = {
+					conversationId,
+					key,
+					requestHash,
+					requirements,
+					assessment,
+					source: requirements.requestedAgentId ? "explicit" : matched ? "match" : input.selectionSource === "match" ? "snapshot" : input.selectionSource ?? "legacy",
+					reason: input.selectionReason,
+					previousSelectionId: input.previousSelectionId,
+					status: "start_failed"
+				};
+				selectedProductTool = createXopcUseTool({
+					...deps,
+					createTask: (taskInput, actor) => createSelectedTask(taskInput, actor, {
+						conversationId,
+						requirements,
+						context,
+						requestHash,
+						candidates: matched?.result.candidates.map(({ id, revision, eligibility, checks, matched: tags, missing }) => ({
+							id,
+							revision,
+							eligibility,
+							checks,
+							matched: tags,
+							missing
+						})),
+						reason: input.selectionReason,
+						source: requirements.requestedAgentId ? "explicit" : matched ? "match" : input.selectionSource === "match" ? "snapshot" : input.selectionSource ?? (input.requirements ? "snapshot" : "legacy"),
+						previousSelectionId: input.previousSelectionId
+					})
+				});
 				const brief = buildPersonalTaskBrief({
 					title: input.title,
 					objective,
@@ -143,16 +371,37 @@ function createPersonalTaskTool(deps) {
 					expectedOutputs: input.expectedOutputs ?? [],
 					acceptanceCriteria: input.acceptanceCriteria ?? [],
 					constraints: input.constraints ?? [],
-					idempotencyKey: input.idempotencyKey?.trim() || randomUUID()
+					idempotencyKey: key
 				};
 			} else if (command === "list") {
 				command = "delegated_tasks";
-				args = { limit: 20 };
+				args = {
+					limit: input.limit ?? 10,
+					offset: input.offset ?? 0
+				};
 			} else {
 				const taskId = input.taskId?.trim();
 				if (!taskId) throw new Error("taskId is required");
 				if (!new TaskOriginRepository().owns(taskId, conversationId)) throw new Error("Task does not belong to this personal conversation");
-				if (command === "instruct" || command === "answer") {
+				if (command === "cancel") {
+					const result = await cancelPersonalTask(taskId, conversationId, input.idempotencyKey ?? toolCallId);
+					deps.dispatchTaskRuns?.();
+					return {
+						content: [{
+							type: "text",
+							text: JSON.stringify(result)
+						}],
+						details: {}
+					};
+				}
+				if (command === "retry_allocation") {
+					command = "command";
+					args = {
+						taskId,
+						type: "retry_allocation",
+						expectedVersion: new TaskRepository().require(taskId).version
+					};
+				} else if (command === "instruct" || command === "answer") {
 					const body = input.instruction?.trim();
 					if (!body) throw new Error("instruction is required");
 					if (command === "answer" && !input.questionId?.trim()) throw new Error("questionId is required");
@@ -165,14 +414,90 @@ function createPersonalTaskTool(deps) {
 					};
 				} else args = { taskId };
 			}
-			return {
-				content: (await productTool.execute(toolCallId, {
+			try {
+				const result = await selectedProductTool.execute(toolCallId, {
 					mode: "task",
 					command,
 					args
-				}, signal, void 0)).content,
-				details: {}
-			};
+				}, signal, void 0);
+				if ((input.command === "answer" || input.command === "instruct") && input.taskId && result.details.result && result.details.result.ok !== false) {
+					const allocation = new TaskAllocationRepository().get(input.taskId);
+					if (allocation && ["blocked", "failed"].includes(allocation.status)) {
+						new TaskApplicationService().execute({
+							taskId: input.taskId,
+							expectedVersion: new TaskRepository().require(input.taskId).version,
+							idempotencyKey: `allocation-answer:${toolCallId}`,
+							command: { type: "retry_allocation" },
+							actor: {
+								kind: "agent",
+								id: ownAgentId
+							}
+						});
+						deps.dispatchTaskRuns?.();
+					}
+				}
+				const payload = result.details.result;
+				if (payload?.ok === true && input.command === "submit") {
+					const task = payload.task;
+					const confirmation = {
+						ok: true,
+						task: {
+							id: task.id,
+							title: task.title,
+							phase: task.phase,
+							version: task.version
+						},
+						operationalState: payload.operationalState,
+						allocation: payload.allocation,
+						runId: payload.runId
+					};
+					return {
+						content: [{
+							type: "text",
+							text: appendProductDeliveryText(JSON.stringify(confirmation, null, 2), result.details.delivery)
+						}],
+						details: {}
+					};
+				}
+				if (payload && input.command === "get") return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(boundedPersonalResult({
+							ok: payload.ok,
+							task: payload.task,
+							allocation: new TaskAllocationRepository().summary(input.taskId),
+							operationalState: payload.operationalState,
+							attention: payload.attention,
+							allowedCommands: payload.allowedCommands
+						}))
+					}],
+					details: {}
+				};
+				if (payload && input.command === "list") return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(boundedPersonalResult({
+							...payload,
+							offset: input.offset ?? 0
+						}))
+					}],
+					details: {}
+				};
+				return {
+					content: result.content,
+					details: {}
+				};
+			} catch (error) {
+				if (pendingSelection && !new AgentSelectionRepository().find(conversationId, pendingSelection.key)) {
+					const repository = new AgentSelectionRepository();
+					const record = repository.create(pendingSelection);
+					repository.link(record.id, {
+						status: "start_failed",
+						reasonCode: "creation_exception"
+					});
+				}
+				throw error;
+			}
 		}
 	};
 }

package/dist/src/agent/tools/xopc-use-tool.d.ts

@@ -8,6 +8,7 @@ import type { NotesService } from '../../notes/index.js';
 import { type ProjectService } from '../../projects/index.js';
 import type { LocalAppService } from '../../local-apps/index.js';
 import type { ChatPreviewService } from '../../chat-previews/index.js';
+import { TaskApplicationService } from '../../tasks/task-application-service.js';
 declare const XopcUseToolSchema: import("@sinclair/typebox").TObject<{
     mode: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"context">, import("@sinclair/typebox").TLiteral<"scene">, import("@sinclair/typebox").TLiteral<"project">, import("@sinclair/typebox").TLiteral<"automation">, import("@sinclair/typebox").TLiteral<"note">, import("@sinclair/typebox").TLiteral<"task">, import("@sinclair/typebox").TLiteral<"task_run">, import("@sinclair/typebox").TLiteral<"local_app">, import("@sinclair/typebox").TLiteral<"chat_preview">, import("@sinclair/typebox").TLiteral<"agent">, import("@sinclair/typebox").TLiteral<"settings">]>;
     command: import("@sinclair/typebox").TString;
@@ -35,6 +36,7 @@ export interface XopcUseToolDeps {
     getLocalAppService?: () => LocalAppService | undefined;
     getChatPreviewService?: () => ChatPreviewService | undefined;
     dispatchTaskEvents?: () => void;
+    createTask?: TaskApplicationService['create'];
     dispatchTaskRuns?: () => void;
     onAgentCatalogMutate?: () => void;
 }