@xopcai/xopc 0.0.385 → 0.0.387

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

@@ -1,3 +1,5 @@
+import { parseResultReferenceId } from "../../../packages/gateway-contract/src/result-reference.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { TaskRepository, init_task_repository } from "../../tasks/task-repository.js";
 import { TaskRunRepository, init_task_run_repository } from "../../tasks/task-run-repository.js";
 import { init_request_repository, personalRequestForExecution } from "../../personal-agent/request-repository.js";
@@ -7,16 +9,37 @@ import { TaskReadModelProjector } from "../../tasks/task-read-model-projector.js
 import { TaskConversationRepository } from "../../tasks/task-conversation-repository.js";
 import { getEmbeddedExecutionSession } from "../embedded/execution-context.js";
 import { TaskCollaborationRepository } from "../../tasks/task-collaboration-repository.js";
+import { taskResearchEvidence } from "../../tasks/task-research-result.js";
+import { assertTaskHandoffAccess, assertTaskHandoffExecutorAccess, getTaskHandoff, materializeTaskHandoffFile, readTaskHandoffSource } from "../../tasks/task-handoff.js";
 import { createXopcUseTool } from "./xopc-use-tool.js";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/task-collaboration-tool.ts
+init_src();
 init_request_repository();
 init_session_repository();
 init_task_repository();
 init_task_run_repository();
 const Schema = Type.Object({
 	command: Type.Union([Type.Literal("get"), Type.Literal("post")]),
-	section: Type.Optional(Type.Union([Type.Literal("collaboration"), Type.Literal("task")])),
+	section: Type.Optional(Type.Union([
+		Type.Literal("collaboration"),
+		Type.Literal("task"),
+		Type.Literal("brief"),
+		Type.Literal("handoff"),
+		Type.Literal("source"),
+		Type.Literal("evidence")
+	])),
+	offset: Type.Optional(Type.Integer({ minimum: 0 })),
+	materialize: Type.Optional(Type.Boolean()),
+	sourceIndex: Type.Optional(Type.Integer({ minimum: 0 })),
+	toolCallId: Type.Optional(Type.String({ minLength: 1 })),
+	query: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 300
+	})),
+	revision: Type.Optional(Type.String()),
+	cursor: Type.Optional(Type.String()),
+	sectionId: Type.Optional(Type.String()),
 	kind: Type.Optional(Type.Union([
 		Type.Literal("progress"),
 		Type.Literal("question"),
@@ -67,7 +90,7 @@ function createTaskCollaborationTool(deps) {
 		name: "task_collaboration",
 		label: "Task collaboration",
 		parameters: Schema,
-		description: "Coordinate the current Task with its Personal owner. get with section task reads the complete brief, constraints and waits; default get reads complete ordered messages (afterSequence/limit) or one entryId. post progress for meaningful changes; post question then stop this turn until answered. Before continuing, post ack with causationId equal to each delivered answer/instruction ID and explain how the result will incorporate it. Confirmation is receipt and intent, not completed verification. Reuse the same Task and executor. Account authorization stays in the main connection UI; answers and instructions cannot change the selected connector/account or permit writes. Preserve idempotencyKey on retries.",
+		description: "Coordinate the current Task with its Personal owner. get section brief reads the full task body in 4000-character pages (offset/nextOffset); section handoff lists the host-captured original request and selected versioned sources, Read the CURRENT handoff first; source indices can change across work revisions. Only entries marked materializable support materialize=true, with an explicit sourceIndex. section source with materialize=true copies a selected pinned workspace file OR published result artifact into your Task input directory; use the returned executionInputRoot as cwd and readOnlyPath as input, never the owner workspace path. Result body text uses read; materialize requires an exact artifact source. The returned copies are read-only: write revised outputs elsewhere and publish those new files. It grants no wider root access. Otherwise section source reads one sourceIndex (query for result search, revision for pinned extracted text). section evidence lists real successful tool reads, or reads a toolCallId in 4000-character pages. Evidence excerpts must cite that original toolCallId. get with section task reads constraints and waits; default get reads complete ordered messages (afterSequence/limit) or one entryId. post progress for meaningful changes; post question then stop this turn until answered. Initial handoff and source/tool IDs require no ack. Before continuing, post ack only for a user/main_agent collaboration entry of kind answer or instruction, with causationId equal to that entry ID and explain how the result will incorporate it. Confirmation is receipt and intent, not completed verification. Reuse the same Task and executor. Account authorization stays in the main connection UI; answers and instructions cannot change the selected connector/account or permit writes. Preserve idempotencyKey on retries.",
 		mutatesWorkspace: true,
 		mutationScope: "external",
 		requiresExclusiveWorkspaceLock: false,
@@ -82,6 +105,98 @@ function createTaskCollaborationTool(deps) {
 				"failed"
 			].includes(request.state)) throw new Error("Personal request is no longer active");
 			if (input.command === "get") {
+				const page = (text) => {
+					const offset = input.offset ?? 0;
+					return {
+						text: text.slice(offset, offset + 4e3),
+						offset,
+						totalChars: text.length,
+						...offset + 4e3 < text.length ? { nextOffset: offset + 4e3 } : {}
+					};
+				};
+				const reply = (value) => ({
+					content: [{
+						type: "text",
+						text: JSON.stringify(value)
+					}],
+					details: {}
+				});
+				if (input.section === "brief") return reply(page(new TaskRepository().require(active.taskId).body ?? ""));
+				if (input.section === "handoff") {
+					const handoff = getTaskHandoff(active.taskId);
+					if (!handoff) return reply({ available: false });
+					assertTaskHandoffAccess(handoff);
+					return reply({
+						...handoff,
+						originalRequest: page(handoff.originalRequest ?? ""),
+						interpretation: void 0,
+						sources: handoff.sources.map(({ text: _text, ...source }, sourceIndex) => ({
+							...source,
+							sourceIndex,
+							materializable: source.kind === "file" && source.representation !== "directory" || source.kind === "result" && parseResultReferenceId(source.sourceId)?.sourceId !== "body",
+							sourceIndexScope: "current_handoff_only"
+						}))
+					});
+				}
+				if (input.section === "source") {
+					assertTaskHandoffExecutorAccess(active.taskId, active.agentId);
+					if (input.materialize) {
+						if (input.sourceIndex === void 0) throw new Error("Materialization requires sourceIndex from the CURRENT handoff manifest. Never reuse indices from earlier runs");
+						const config = deps.getConfig?.();
+						const workspace = deps.getWorkspace?.();
+						if (!config || !workspace) throw new Error("Execution workspace is unavailable");
+						return {
+							...reply(await materializeTaskHandoffFile(active.taskId, input.sourceIndex ?? 0, workspace, config)),
+							details: { taskSourceRead: {
+								taskId: active.taskId,
+								sourceIndex: input.sourceIndex ?? 0,
+								materialized: true
+							} }
+						};
+					}
+					const source = await readTaskHandoffSource(active.taskId, input.sourceIndex ?? 0, {
+						command: input.query ? "search" : "read",
+						offset: input.offset,
+						limit: 4e3,
+						query: input.query,
+						revision: input.revision,
+						cursor: input.cursor,
+						sectionId: input.sectionId
+					}, deps.getConfig?.());
+					const plain = "text" in source && typeof source.text === "string" ? [source.text] : "items" in source && Array.isArray(source.items) ? source.items.map((item) => item.text) : [];
+					return {
+						content: [...reply(source).content, ...plain.map((text) => ({
+							type: "text",
+							text
+						}))],
+						details: plain.length ? { taskSourceRead: {
+							taskId: active.taskId,
+							sourceIndex: input.sourceIndex ?? 0
+						} } : {}
+					};
+				}
+				if (input.section === "evidence") {
+					const { tools } = taskResearchEvidence(conversationId);
+					if (input.toolCallId) {
+						const tool = tools.find((item) => item.toolCallId === input.toolCallId);
+						if (!tool) throw new Error("Successful evidence read not found in this execution");
+						return reply({
+							toolCallId: tool.toolCallId,
+							toolName: tool.toolName,
+							...page(tool.body)
+						});
+					}
+					const offset = input.offset ?? 0;
+					return reply({
+						items: tools.slice(offset, offset + 10).map((tool) => ({
+							toolCallId: tool.toolCallId,
+							toolName: tool.toolName,
+							totalChars: tool.body.length,
+							observedAt: tool.observedAt
+						})),
+						...offset + 10 < tools.length ? { nextOffset: offset + 10 } : {}
+					});
+				}
 				if (input.section === "task") {
 					const model = new TaskReadModelProjector().project(new TaskRepository().require(active.taskId));
 					return {
@@ -90,6 +205,10 @@ function createTaskCollaborationTool(deps) {
 							text: JSON.stringify({
 								ok: true,
 								...model,
+								task: {
+									...model.task,
+									body: page(model.task.body ?? "")
+								},
 								waits: new TaskRunRepository().listActiveWaits(active.taskId)
 							})
 						}],

package/dist/src/agent/tools/task-evidence.d.ts

@@ -0,0 +1,3 @@
+import type { AgentTool } from '@earendil-works/pi-agent-core';
+/** Tool-call IDs are protocol metadata and may be invisible to the model; expose the host ID in Task reads. */
+export declare function withTaskEvidenceIdentity<T extends AgentTool>(tool: T): T;

package/dist/src/agent/tools/task-evidence.js

@@ -0,0 +1,71 @@
+import { suggestedEvidenceRanges } from "../../tasks/task-evidence-ranges.js";
+//#region src/agent/tools/task-evidence.ts
+/** Tool-call IDs are protocol metadata and may be invisible to the model; expose the host ID in Task reads. */
+function withTaskEvidenceIdentity(tool) {
+	if (!new Set([
+		"read_file",
+		"read_media",
+		"web_fetch",
+		"web_search",
+		"web_extract",
+		"exec_command",
+		"managed_job",
+		"xopc_tool_execute",
+		"publish_artifacts",
+		"session_status",
+		"task_collaboration"
+	]).has(tool.name)) return tool;
+	return {
+		...tool,
+		execute: async (...args) => {
+			const result = await tool.execute(args[0], args[1], args[2], args[3]);
+			const artifacts = tool.name === "publish_artifacts" ? result.details?.artifacts : void 0;
+			const receipt = artifacts ? [{
+				type: "text",
+				text: JSON.stringify({
+					publishedArtifacts: artifacts.map(({ artifactId, title, availability }) => ({
+						artifactId,
+						title,
+						availability
+					})),
+					guidance: "Use exact artifactId values in publish_task_result.finalArtifactIds to select final deliverables."
+				})
+			}] : [];
+			const execution = result.details;
+			const body = result.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+			const ranges = !result.isError && ![
+				"failed",
+				"blocked",
+				"running",
+				"timed_out",
+				"cancelled"
+			].includes(execution?.status ?? "") && (tool.name !== "managed_job" || execution?.status === "success" && execution.exitCode === 0) ? [{
+				type: "text",
+				text: JSON.stringify({ evidence: {
+					toolCallId: args[0],
+					excerptRanges: suggestedEvidenceRanges(body),
+					guidance: "Prefer toolCallId plus excerptRange in publish_task_result.sources; omit excerpt. The host copies exact observed output. For a yielded command cite the successful managed_job completion ID, not the earlier running exec_command. Never rerun completed work merely to obtain evidence. Never reconstruct quoted code, escapes or input commands. This identifies provenance; claim support still requires review."
+				} })
+			}] : [];
+			const quote = tool.name === "exec_command" && execution?.status === "success" && execution.exitCode === 0 ? [{
+				type: "text",
+				text: "Evidence quoting: copy a short contiguous passage from the output above. The input command is not output; never prepend it to an excerpt. Successful execution and exitCode=0 are host metadata, not extra lines to invent in a quote."
+			}] : [];
+			return {
+				...result,
+				content: [
+					...result.content,
+					...receipt,
+					...quote,
+					...ranges,
+					{
+						type: "text",
+						text: `Task source toolCallId: ${args[0]}`
+					}
+				]
+			};
+		}
+	};
+}
+//#endregion
+export { withTaskEvidenceIdentity };

package/dist/src/agent/tools/task-result-tool.d.ts

@@ -0,0 +1,2 @@
+import type { AgentTool } from '@earendil-works/pi-agent-core';
+export declare function createTaskResultTool(getConversationId: () => string | undefined): AgentTool;

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

@@ -0,0 +1,93 @@
+import { submitTaskResearchResult } from "../../tasks/task-research-result.js";
+import { Type } from "@sinclair/typebox";
+//#region src/agent/tools/task-result-tool.ts
+const id = Type.String({
+	minLength: 1,
+	maxLength: 120
+});
+const schema = Type.Object({
+	finalArtifactIds: Type.Optional(Type.Array(Type.String({ minLength: 1 }), {
+		maxItems: 50,
+		uniqueItems: true
+	})),
+	mode: Type.Optional(Type.Union([Type.Literal("replace"), Type.Literal("amend")])),
+	retireClaimIds: Type.Optional(Type.Array(id, { maxItems: 40 })),
+	sources: Type.Array(Type.Object({
+		id,
+		toolCallId: Type.Optional(Type.String()),
+		excerpt: Type.Optional(Type.String({
+			minLength: 1,
+			maxLength: 2e3
+		})),
+		excerptRange: Type.Optional(Type.Object({
+			start: Type.Integer({ minimum: 0 }),
+			end: Type.Integer({ minimum: 1 })
+		}, { additionalProperties: false })),
+		url: Type.Optional(Type.String())
+	}, {
+		additionalProperties: false,
+		oneOf: [{
+			required: ["excerpt"],
+			not: { required: ["excerptRange"] }
+		}, {
+			required: ["toolCallId", "excerptRange"],
+			not: { required: ["excerpt"] }
+		}]
+	}), {
+		minItems: 1,
+		maxItems: 40
+	}),
+	claims: Type.Array(Type.Object({
+		id,
+		statement: Type.String({
+			minLength: 1,
+			maxLength: 2e3
+		}),
+		kind: Type.Union([
+			Type.Literal("fact"),
+			Type.Literal("inference"),
+			Type.Literal("recommendation")
+		]),
+		sourceIds: Type.Array(id, {
+			minItems: 1,
+			maxItems: 8
+		})
+	}, { additionalProperties: false }), {
+		minItems: 1,
+		maxItems: 40
+	})
+}, { additionalProperties: false });
+function createTaskResultTool(getConversationId) {
+	return {
+		name: "publish_task_result",
+		label: "Publish research conclusions",
+		parameters: schema,
+		description: "For sources prefer toolCallId plus excerptRange {start,end} copied from evidence receipts, and OMIT excerpt. Ranges use Unicode character offsets, at most 1000 characters; the host extracts the original successful read exactly so code escapes and commands cannot corrupt quotes. Supply exactly one of excerptRange or a short exact excerpt. Never include the input command as output. When this execution published files, finalArtifactIds is required: explicitly select the exact artifact IDs from publication receipts for the final delivery. Exclude intermediate, failed, obsolete and unrelated files. [] explicitly selects a text-only final result. New submissions replace this final selection; no historical union. Submit Task research evidence for per-criterion review; publish required files first. Initial submission creates the ledger; subsequent submissions default to amend so earlier evidence is retained. Use explicit replace only for a complete replacement ledger. During repair retain stable source/claim IDs, update targeted claims and retire obsolete/wrong claim IDs with retireClaimIds. All retained claims are reviewed again. Reviewer support/note/checks fields are read-only; never send them back in sources or claims. Never drop valid calculation/input evidence merely to fix a file. Negative assertions such as \"never reran a script\" need an observable, scoped execution record; do not invent proof of absence or add an unnecessary absolute negative claim. Keep prohibitions as constraints, and retire unsupported optional claims while retaining required verified findings. Sources require short contiguous exact excerpts from successful read_file/read_media/web/exec/session_status results or publication receipts in this TaskRun. Never concatenate passages, invent call IDs, or cite an earlier review as factual evidence. Use task_collaboration get section evidence to list/read original toolCallIds. Your planned final reply is not evidence and should not become a claim about future delivery. On source_quote_mismatch follow the recovery instruction; never repeat unchanged sources. Prefer original inputs; the host reads published reports/scripts. URL is optional; actual web metadata is preserved. Claims reference source IDs and distinguish fact/inference/recommendation. Publication receipts prove availability, not prices. This binds provenance and runs model review, not independent fact certification. Resubmit changed evidence or adopted directions; do not endlessly repeat unchanged data when review is unavailable. Do not use outside a Task.",
+		supportsParallel: false,
+		mutationScope: "none",
+		idempotent: false,
+		async execute(toolCallId, input, signal) {
+			const conversationId = getConversationId();
+			if (!conversationId) throw new Error("Task conversation is required");
+			const research = await submitTaskResearchResult(conversationId, toolCallId, input, signal);
+			const readyForCompletion = research.checks.length > 0 && research.checks.every((check) => check.status === "passed") && (research.instructionChecks ?? []).every((check) => check.status === "passed") && research.claims.every((claim) => claim.support === "supported");
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						saved: true,
+						readyForCompletion,
+						...readyForCompletion ? {} : { nextAction: "The saved ledger is not fully verified. Before finishing, amend evidence for required unsupported findings; retire optional unsupported claims with retireClaimIds while preserving valid required evidence. Do not replay completed or uncertain operations just to change the ledger. If a required finding cannot be verified safely, retain an honest partial result." },
+						review: research.review,
+						claims: research.claims,
+						checks: research.checks,
+						instructionChecks: research.instructionChecks
+					})
+				}],
+				details: { research }
+			};
+		}
+	};
+}
+//#endregion
+export { createTaskResultTool };

package/dist/src/agent/tools/tool-media.js

@@ -1,5 +1,5 @@
-import { sniffImageMimeType } from "../image/generation/image-assets.js";
 import { MEDIA_ARTIFACT_MAX_BYTES, mimeTypeFromMediaPath, saveMediaBuffer } from "../../media/store.js";
+import { sniffImageMimeType } from "../image/generation/image-assets.js";
 import { basename } from "node:path";
 //#region src/agent/tools/tool-media.ts
 function hasImageMagic(buffer) {

package/dist/src/agent/tools/web.d.ts

@@ -1,4 +1,18 @@
-import type { AgentTool } from '@earendil-works/pi-agent-core';
+import type { AgentTool, AgentToolResult } from '@earendil-works/pi-agent-core';
 import type { Config } from '../../config/schema.js';
-export declare function createWebSearchTool(getConfig: () => Config | undefined): AgentTool;
+export interface WebSearchBatchTool extends AgentTool {
+    executeSearchBatch(requests: Array<{
+        id: string;
+        query: string;
+        count?: number;
+    }>, signal?: AbortSignal, authorize?: () => void): Promise<{
+        items: Array<{
+            id: string;
+            result: AgentToolResult<any>;
+        }>;
+        sourceRequests: number;
+    }>;
+}
+export declare function createWebSearchTool(getConfig: () => Config | undefined): WebSearchBatchTool;
+export declare function extractReadableText(html: string, pageUrl: string): Promise<string>;
 export declare function createWebFetchTool(getConfig: () => Config | undefined): AgentTool;

package/dist/src/agent/tools/web.js

@@ -1,3 +1,4 @@
+import { SearchError, classifySearchError, searchFailureInfo } from "./search/errors.js";
 import { SearchProviderRegistry } from "./search/registry.js";
 import { resolveWebSearchConfig } from "./search/resolve-config.js";
 import { fetchPublicText } from "./fetch-text.js";
@@ -10,52 +11,93 @@ const WebSearchSchema = Type.Object({
 function formatSearchResults(results) {
 	return results.map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.description ? `${r.description}` : ""}`).join("\n\n");
 }
+function searchToolResult(query, count, response) {
+	return {
+		content: [{
+			type: "text",
+			text: response.results.length ? formatSearchResults(response.results) : "No results found."
+		}],
+		details: {
+			results: response.results,
+			provider: response.provider,
+			query,
+			count,
+			cached: response.cached ?? false,
+			capturedAt: response.capturedAt
+		}
+	};
+}
+function searchToolError(error, signal) {
+	const failure = classifySearchError(error, signal);
+	return {
+		content: [{
+			type: "text",
+			text: `Search error (${failure.kind}): ${failure.message}`
+		}],
+		details: {
+			results: [],
+			error: failure.message,
+			failure: searchFailureInfo(failure),
+			status: failure.kind === "cancelled" ? "cancelled" : "failed"
+		}
+	};
+}
 function createWebSearchTool(getConfig) {
 	return {
 		name: "web_search",
-		description: "Search the web. Uses configured search APIs when set; otherwise falls back to a built-in HTML search (region-aware).",
+		description: "Search the web using authorized configured providers or the region-aware HTML fallback. Search failures retain permission, rate-limit and timeout reasons. Research reuses recent successful queries; permission refusals are not bypassed.",
 		parameters: WebSearchSchema,
 		label: "🔍 Web Search",
 		supportsParallel: true,
-		async execute(_toolCallId, params, signal) {
-			const p = params;
+		async execute(_id, params, signal) {
 			const cfg = resolveWebSearchConfig(getConfig()?.tools?.web);
 			const registry = new SearchProviderRegistry(cfg);
-			const count = p.count ?? cfg.maxResults ?? 5;
+			const count = Math.max(1, Math.min(20, Math.floor(params.count ?? cfg.maxResults ?? 5)));
 			try {
-				const { results, provider } = await registry.search(p.query, count, signal);
-				if (results.length === 0) return {
-					content: [{
-						type: "text",
-						text: "No results found."
-					}],
-					details: {
-						results: [],
-						provider
-					}
-				};
+				const response = await registry.search(params.query, count, signal);
+				const result = searchToolResult(params.query, count, response);
 				return {
-					content: [{
-						type: "text",
-						text: formatSearchResults(results)
-					}],
+					...result,
 					details: {
-						results,
-						provider
+						...result.details,
+						sourceRequests: registry.sourceRequests
 					}
 				};
 			} catch (error) {
+				const result = searchToolError(error, signal);
 				return {
-					content: [{
-						type: "text",
-						text: `Search error: ${error instanceof Error ? error.message : String(error)}`
-					}],
+					...result,
 					details: {
-						results: [],
-						error: error instanceof Error ? error.message : String(error)
+						...result.details,
+						sourceRequests: registry.sourceRequests
 					}
 				};
 			}
+		},
+		async executeSearchBatch(requests, signal, authorize = () => {}) {
+			const cfg = resolveWebSearchConfig(getConfig()?.tools?.web);
+			const registry = new SearchProviderRegistry(cfg);
+			const inputs = requests.map((request) => ({
+				...request,
+				count: Math.max(1, Math.min(20, Math.floor(request.count ?? cfg.maxResults ?? 5)))
+			}));
+			const responses = await registry.searchBatch(inputs, signal, authorize);
+			return {
+				sourceRequests: registry.sourceRequests,
+				items: responses.map((item) => {
+					const result = item.response ? searchToolResult(item.query, item.count, item.response) : searchToolError(new SearchError(item.error), signal);
+					return {
+						id: item.id,
+						result: {
+							...result,
+							details: {
+								...result.details,
+								fallback: item.fallback
+							}
+						}
+					};
+				})
+			};
 		}
 	};
 }
@@ -70,8 +112,11 @@ async function extractReadableText(html, pageUrl) {
 	const { parseHTML } = await import("linkedom");
 	const { Readability } = await import("@mozilla/readability");
 	const { document } = parseHTML(html);
+	const paragraphs = [...document.querySelector("main, [role=\"main\"]")?.querySelectorAll("p") ?? []].filter((element) => !element.closest("nav, aside, footer, header")).map((element) => element.textContent?.replace(/\s+/g, " ").trim() ?? "").filter((text) => text.length >= 40 && text.length <= 2e3);
 	Object.defineProperty(document, "documentURI", { value: pageUrl });
-	return new Readability(document).parse()?.textContent?.trim() ?? "";
+	const text = new Readability(document).parse()?.textContent?.trim() ?? "";
+	const normalized = text.replace(/\s+/g, " ");
+	return [...[...new Set(paragraphs)].filter((paragraph) => !normalized.includes(paragraph)), text].filter(Boolean).join("\n\n");
 }
 function createWebFetchTool(getConfig) {
 	return {
@@ -122,4 +167,4 @@ function createWebFetchTool(getConfig) {
 	};
 }
 //#endregion
-export { createWebFetchTool, createWebSearchTool };
+export { createWebFetchTool, createWebSearchTool, extractReadableText };

package/dist/src/agent/tools/xopc-use-tool.js

@@ -11,25 +11,26 @@ import { TaskRunRepository } from "../../tasks/task-run-repository.js";
 import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
 import { init_sqlite } from "../../storage/sqlite/index.js";
 import "../../activity/index.js";
-import { CapabilityError } from "../../capabilities/runtime/errors.js";
-import "../../capabilities/runtime/dispatcher.js";
 import { getDefaultAgentId, init_resolve_route } from "../../routing/resolve-route.js";
 import { resolveTaskLocale } from "../../tasks/task-language.js";
 import { TaskReadModelProjector } from "../../tasks/task-read-model-projector.js";
 import { TaskOriginRepository } from "../../tasks/task-origin-repository.js";
 import { TaskConversationRepository } from "../../tasks/task-conversation-repository.js";
+import { CapabilityError } from "../../capabilities/runtime/errors.js";
+import "../../capabilities/runtime/dispatcher.js";
 import { resolveProjectAgentId } from "../../projects/project-agent.js";
 import "../../projects/index.js";
+import { TaskCollaborationRepository } from "../../tasks/task-collaboration-repository.js";
+import { defineTaskContract } from "../../tasks/task-contract-definition.js";
 import { resolveResponseLanguageForSession } from "../prompt/response-language.js";
 import { TaskDeletionService } from "../../tasks/task-deletion-service.js";
 import { TaskDeleteOutputSchema } from "../../tasks/capabilities/management.js";
-import { TaskCollaborationRepository } from "../../tasks/task-collaboration-repository.js";
+import { parseTaskHandoffReferences } from "../../tasks/task-handoff.js";
 import { TaskApplicationService } from "../../tasks/task-application-service.js";
 import { AutomationCreateCapabilityInputSchema, AutomationUpdatePatchSchema } from "../../automations/capabilities/write.js";
 import { TaskMutationOutputSchema } from "../../tasks/capabilities/write.js";
 import { createProductDispatcher } from "../../capabilities/runtime/product.js";
 import { localAppCapabilities } from "../../local-apps/capabilities/runtime.js";
-import { defineTaskContract } from "../../tasks/task-contract-definition.js";
 import "../../tasks/index.js";
 import { randomUUID } from "node:crypto";
 import { Type } from "@sinclair/typebox";
@@ -1472,6 +1473,16 @@ async function handleTask(command, args, deps, dryRun, capabilities) {
 			explicitAgentId,
 			projectId
 		}) : explicitAgentId ?? (config ? getDefaultAgentId() : deps.getCurrentAgentId?.() ?? "main");
+		const sourceRefs = parseTaskHandoffReferences(args.sourceRefs);
+		if (!sourceRefs || sourceRefs.some((ref) => ![
+			"result",
+			"note",
+			"task",
+			"file"
+		].includes(ref.kind))) return {
+			ok: false,
+			error: "Invalid selected task sourceRefs"
+		};
 		const input = {
 			idempotencyKey: trimString(args.idempotencyKey) ?? randomUUID(),
 			title: trimString(args.title) ?? objective,
@@ -1488,14 +1499,24 @@ async function handleTask(command, args, deps, dryRun, capabilities) {
 				outputDestinations: []
 			},
 			dependencies: dependsOnTaskIds,
-			context: args.includeConversationContext === false ? [] : conversationId ? [{
+			context: [...args.includeConversationContext === false ? [] : conversationId ? [{
 				targetKind: "session",
 				targetId: conversationId,
 				role: "input",
 				pinned: false,
 				retrievalPolicy: {},
 				metadata: {}
-			}] : [],
+			}] : [], ...sourceRefs.map((ref) => ({
+				targetKind: "source",
+				targetId: `${ref.kind}:${ref.sourceId}`,
+				role: "input",
+				pinned: true,
+				retrievalPolicy: { currentAuthorizationRequired: true },
+				metadata: {
+					kind: "task_reference_request",
+					ref
+				}
+			}))],
 			authorityGrants: [],
 			activation: createMode === "allocate" ? {
 				mode: "allocate",

package/dist/src/agent/workspace-runtime/registry.js

@@ -1,5 +1,5 @@
-import { init_agent_scope, resolveAgentIdForWorkspacePath } from "../agent-scope.js";
 import { init_agent_session_key, normalizeAgentId } from "../../routing/agent-session-key.js";
+import { init_agent_scope, resolveAgentIdForWorkspacePath } from "../agent-scope.js";
 import { SkillManager } from "../skills/skill-manager.js";
 import { SystemPromptBuilder } from "../prompt/service-prompt-builder.js";
 import { UserContextRuntimeRegistry } from "../../user-context/runtime.js";

package/dist/src/agent-catalog/capabilities.js

@@ -1,10 +1,10 @@
 import { AgentEntrySchema, EffectiveAgentConfigSchema } from "../agent-config/schema.js";
 import { resolveEffectiveAgentConfig } from "../agent-config/resolver.js";
 import { init_agent_config } from "../agent-config/index.js";
-import { CapabilityError } from "../capabilities/runtime/errors.js";
-import { defineAtomicCapability, defineReadCapability } from "../capabilities/runtime/dispatcher.js";
 import { AgentCatalogRepository, init_repository } from "./repository.js";
 import { init_agent_scope, resolveAgentWorkspaceDir } from "../agent/agent-scope.js";
+import { CapabilityError } from "../capabilities/runtime/errors.js";
+import { defineAtomicCapability, defineReadCapability } from "../capabilities/runtime/dispatcher.js";
 import { AgentCatalogService } from "./service.js";
 import { z } from "zod";
 //#region src/agent-catalog/capabilities.ts

package/dist/src/automations/capabilities/drafts.js

@@ -3,10 +3,10 @@ import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { init_trust_policy, resolveAutomationSafetyForTrust } from "../../user-context/trust-policy.js";
 import { getUserTrustPolicy } from "../../storage/sqlite/user-trust-repository.js";
 import { init_sqlite } from "../../storage/sqlite/index.js";
+import { init_agent_scope, resolveDefaultAgentId } from "../../agent/agent-scope.js";
 import { CapabilityError } from "../../capabilities/runtime/errors.js";
 import { ExternalEffectNotAppliedError } from "../../capabilities/runtime/external-operations.js";
 import { defineExternalCapability, defineReadCapability } from "../../capabilities/runtime/dispatcher.js";
-import { init_agent_scope, resolveDefaultAgentId } from "../../agent/agent-scope.js";
 import { AutomationCreateCapabilityInputSchema } from "./write.js";
 import { simulateAutomation } from "../draft/automation-draft-validator.js";
 import { AutomationDraftService } from "../draft/automation-draft-service.js";