@xopcai/xopc 0.0.307 → 0.0.309

package/dist/src/agent/background-review/prompts.js

@@ -40,7 +40,9 @@ Rules:
 - Set selfContained=false and list unresolvedReferences for unresolved pronouns or references.
 - Omit temporary reactions and one-off task instructions.
 - Never include passwords, credentials, regulated identifiers, or speculative diagnoses.
-- In transcript mode, use system_inferred unless a quoted user message is itself an explicit memory command.
+- Use user_explicit only for a fact or preference the user directly states, user_observed for repeated behavior, and system_inferred for synthesis. No separate remember command is required for an ordinary direct statement.
+- A project-specific choice stays scoped to that project. Do not generalize it into a global preference.
+- Existing memory, assistant output, repeated summaries, and lack of objection are not new supporting evidence.
 - If evidence is insufficient, return candidates=[] and explain abstentionReason.
 ${targets}`;
 }

package/dist/src/agent/child-agent-factory.d.ts

@@ -30,6 +30,7 @@ export interface DelegateChildProgressHooks {
     }) => void;
 }
 export interface DelegateChildHandleOptions {
+    authorizeToolCall?: import('./orchestration/agent-turn-policy.js').AgentTurnPolicyOptions['authorizeToolCall'];
     workspace: string;
     goal: string;
     context?: string;

package/dist/src/agent/child-agent-factory.js

@@ -29,14 +29,20 @@ function createDelegateChildHandle(options) {
 				agentId: options.agentId,
 				getConfig: options.getConfig,
 				toolExecutorConfig: options.toolExecutorConfig,
-				browserConversationId: options.requesterConversationId ?? conversationId
+				browserConversationId: options.requesterConversationId ?? options.conversationId
 			}).filter((tool) => allow.has(tool.name));
 			const limit = Math.min(60, Math.max(1, Math.floor(options.maxIterations)));
 			let toolIterations = 0, exhausted = false, tokens = 0;
+			let terminationReason;
 			const policy = createAgentTurnPolicy({
 				maxTurns: limit + 1,
 				maxToolFailures: 5,
-				authorizeToolCall: async () => {
+				authorizeToolCall: async (context, signal) => {
+					const { toolCall } = context;
+					if (!allow.has(toolCall.name)) return {
+						block: true,
+						reason: "Tool is outside the delegated capability set."
+					};
 					if (toolIterations >= limit || tokens >= 1e5) {
 						exhausted = true;
 						return {
@@ -45,7 +51,15 @@ function createDelegateChildHandle(options) {
 							reason: "Sub-agent budget exhausted."
 						};
 					}
-					toolIterations++;
+					if (toolCall.name !== "data_batch") toolIterations++;
+					const decision = await options.authorizeToolCall?.(context, signal);
+					if (decision?.block) {
+						if (decision.terminate) {
+							exhausted = true;
+							terminationReason = decision.reason;
+						}
+						return decision;
+					}
 				}
 			});
 			const baseStop = policy.shouldStopAfterTurn;
@@ -118,7 +132,7 @@ function createDelegateChildHandle(options) {
 				const proof = verification?.type === "custom" ? verification.data : void 0;
 				const unverified = options.verifyChanges && proof?.changed && (!proof.evidence.some((item) => item.kind === "check" && item.status === "passed") || proof.evidence.some((item) => item.status !== "passed"));
 				return {
-					summary: result.lastAssistantText || result.errorMessage || (exhausted ? "Sub-agent budget exhausted." : "(no final response)"),
+					summary: [result.lastAssistantText || result.errorMessage, terminationReason].filter(Boolean).join("\n\n") || (exhausted ? "Sub-agent budget exhausted." : "(no final response)"),
 					toolIterations,
 					messages: await runtime.loadMessages(),
 					status: controller.signal.aborted ? "cancelled" : !result.ok ? "failed" : exhausted || unverified ? "partial" : "success",

package/dist/src/agent/coding/repository-instructions.d.ts

@@ -8,5 +8,9 @@ export declare class RepositoryInstructions {
     private constructor();
     static open(workspace: string): Promise<RepositoryInstructions>;
     forTool(name: string, input: unknown): Promise<string>;
+    forDataResult(content: Array<{
+        type: string;
+        text?: string;
+    }>): Promise<string>;
     load(path: string, directory: boolean): Promise<string>;
 }

package/dist/src/agent/coding/repository-instructions.js

@@ -1,4 +1,6 @@
-import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { validateDataBatch } from "../data-acquisition/schema.js";
+import { isDataBatchResult } from "../data-acquisition/render.js";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { readFile, realpath, stat } from "node:fs/promises";
@@ -35,6 +37,22 @@ var RepositoryInstructions = class RepositoryInstructions {
 		return new RepositoryInstructions(root, canonicalWorkspace);
 	}
 	async forTool(name, input) {
+		if (name === "data_batch") {
+			validateDataBatch(input);
+			const sections = [];
+			for (const operation of input.operations) {
+				const paths = operation.kind === "file_read" || operation.kind === "git_read" ? [operation.path] : operation.kind === "file_search" ? operation.paths : operation.kind === "git_recent" ? operation.paths ?? ["."] : [];
+				for (const path of paths) {
+					let directory = false;
+					try {
+						directory = (await stat(resolve(this.workspace, path))).isDirectory();
+					} catch {}
+					const section = await this.load(path, directory);
+					if (section && !sections.includes(section)) sections.push(section);
+				}
+			}
+			return sections.join("\n\n");
+		}
 		const args = input && typeof input === "object" ? input : {};
 		if (name === "apply_patch") {
 			const paths = [...String(args.patch ?? "").matchAll(/^\*\*\* (?:Add File|Update File|Delete File|Move to): (.+)$/gm)].map((match) => match[1].trim());
@@ -44,8 +62,34 @@ var RepositoryInstructions = class RepositoryInstructions {
 		if (name === "exec_command" || name === "managed_job" && args.action === "start") return this.load(typeof args.cwd === "string" ? args.cwd : ".", true);
 		return "";
 	}
+	async forDataResult(content) {
+		const sections = /* @__PURE__ */ new Set();
+		for (const block of content) {
+			if (block.type !== "text" || !block.text) continue;
+			let result;
+			try {
+				result = JSON.parse(block.text);
+			} catch {
+				continue;
+			}
+			if (!isDataBatchResult(result)) continue;
+			for (const fragment of result.fragments) {
+				if (fragment.source.kind !== "file") continue;
+				const section = await this.load(fragment.source.resource, false);
+				if (section) sections.add(section);
+			}
+		}
+		return [...sections].join("\n\n");
+	}
 	async load(path, directory) {
-		const target = resolve(this.workspace, path);
+		let target = resolve(this.workspace, path);
+		try {
+			target = await realpath(target);
+		} catch {
+			try {
+				target = resolve(await realpath(dirname(target)), basename(target));
+			} catch {}
+		}
 		if (!inside(this.root, target)) return "";
 		const leaf = directory ? target : dirname(target);
 		const directories = [];

package/dist/src/agent/context/execution-context.js

@@ -5,7 +5,7 @@ import "../../knowledge-memory/index.js";
 import { retrievalLexicalSimilarity } from "../../retrieval/textFeatures.js";
 import { calculateExecutionValue } from "../../user-model/importance.js";
 import { listUserAssertions } from "../../user-model/repository.js";
-import { isWorkingAssumption } from "../../user-model/usage-policy.js";
+import { canUseAssertion } from "../../user-model/usage-policy.js";
 import { getExecutionContextFeedbackScores } from "./audit.js";
 import { buildUserContextBlock } from "../memory/context-fence.js";
 import { randomUUID } from "node:crypto";
@@ -63,7 +63,7 @@ function rankAssertion(assertion, query, asOf, feedbackScore) {
 	].filter(Boolean);
 	return {
 		assertion,
-		usage: assertion.status === "active" ? "confirmed" : "working_assumption",
+		usage: assertion.authority === "user_explicit" ? "confirmed" : "working_assumption",
 		score: assertion.status === "candidate" ? score - .05 : score,
 		reasons
 	};
@@ -125,7 +125,7 @@ function buildExecutionContext(request) {
 	const rankedAssertions = includeUserModel ? listUserAssertions({
 		statuses: ["active", "candidate"],
 		limit: 1e3
-	}).filter((item) => scopeVisible(getAssertionScope(item.slotId), request)).filter((item) => applicabilityVisible(item.applicability, request)).filter((item) => (item.validFrom === void 0 || item.validFrom <= asOf) && (item.validTo === void 0 || item.validTo >= asOf)).filter((item) => item.authority !== "external_untrusted").filter((item) => item.sensitivity !== "secret" && item.sensitivity !== "regulated" && item.disclosurePolicy !== "ask_before_reference").filter((item) => item.status === "active" || isWorkingAssumption(item)).map((item) => rankAssertion(item, request.query, asOf, feedbackScores.get(`assertion:${item.id}`) ?? 0)).filter((item) => item.score >= .12 || item.reasons.includes("high_consequence")).sort((left, right) => right.score - left.score) : [];
+	}).filter((item) => scopeVisible(getAssertionScope(item.slotId), request)).filter((item) => applicabilityVisible(item.applicability, request)).filter((item) => canUseAssertion(item, asOf)).map((item) => rankAssertion(item, request.query, asOf, feedbackScores.get(`assertion:${item.id}`) ?? 0)).filter((item) => item.score >= .12 || item.reasons.includes("high_consequence")).sort((left, right) => right.score - left.score) : [];
 	const assertions = [...rankedAssertions.filter((item) => item.usage === "confirmed"), ...rankedAssertions.filter((item) => item.usage === "working_assumption")].slice(0, assertionLimit);
 	const maxKnowledge = Math.max(0, Math.min(100, request.maxKnowledge ?? 12));
 	const knowledge = request.includeKnowledge === false || maxKnowledge === 0 ? [] : searchKnowledgeItems({
@@ -165,7 +165,7 @@ function renderExecutionContext(context) {
 	const confirmedAssertions = context.assertions.filter((item) => item.usage === "confirmed");
 	const workingAssumptions = context.assertions.filter((item) => item.usage === "working_assumption");
 	if (confirmedAssertions.length) sections.push(`Confirmed user context:\n${confirmedAssertions.map((item) => `- ${item.assertion.statement}`).join("\n")}`);
-	if (workingAssumptions.length) sections.push(`Working assumptions (may be wrong; adapt quietly, never present them as confirmed facts, and accept corrections immediately):\n${workingAssumptions.map((item) => `- ${item.assertion.statement} (confidence ${item.assertion.confidence.toFixed(2)})`).join("\n")}`);
+	if (workingAssumptions.length) sections.push(`Working assumptions (may be wrong; never authorize actions; current user instructions take precedence; adapt quietly, never present them as confirmed facts, and accept corrections immediately):\n${workingAssumptions.map((item) => `- ${item.assertion.statement} (confidence ${item.assertion.confidence.toFixed(2)})`).join("\n")}`);
 	const confirmedGoals = context.goals.filter((goal) => goal.usage === "confirmed");
 	const assumedGoals = context.goals.filter((goal) => goal.usage === "working_assumption");
 	if (confirmedGoals.length) sections.push(`Confirmed goals:\n${confirmedGoals.map((goal) => `- ${goal.title}: ${goal.desiredOutcome}`).join("\n")}`);

package/dist/src/agent/data-acquisition/git.d.ts

@@ -0,0 +1,17 @@
+export type GitDataOperation = {
+    kind: 'git_recent';
+    paths?: string[];
+    since?: string;
+    until?: string;
+} | {
+    kind: 'git_read';
+    path: string;
+    commit: string;
+};
+export declare function readGitData(workspace: string, operation: GitDataOperation, signal: AbortSignal, onRequest: () => void): Promise<{
+    text: string;
+    resource: string;
+    revision: string;
+    exhausted: boolean;
+    reason: string;
+}>;

package/dist/src/agent/data-acquisition/git.js

@@ -0,0 +1,100 @@
+import { runProcess } from "../../process/run-process.js";
+import { evaluateExecPolicy } from "../sandbox/exec-policy.js";
+import { checkedFilePath } from "../sandbox/fileAccess.js";
+import { dataScheduler } from "./scheduler.js";
+import { relative, resolve, sep } from "node:path";
+//#region src/agent/data-acquisition/git.ts
+async function readGitData(workspace, operation, signal, onRequest) {
+	const cwd = checkedFilePath(workspace, workspace, "read");
+	const policy = evaluateExecPolicy({
+		command: "git log",
+		cwd,
+		workspaceRoot: workspace
+	});
+	if (!policy.allowed) throw new Error(`Sandbox: ${policy.reason}`);
+	const env = Object.fromEntries(Object.entries(policy.sanitizedEnv).filter(([key]) => !key.startsWith("GIT_")));
+	env.GIT_CONFIG_NOSYSTEM = "1";
+	env.GIT_CONFIG_GLOBAL = process.platform === "win32" ? "NUL" : "/dev/null";
+	env.GIT_OPTIONAL_LOCKS = "0";
+	const run = async (args) => dataScheduler.run(cwd, signal, async () => {
+		onRequest();
+		const result = await runProcess({
+			program: "git",
+			args: [
+				"--no-pager",
+				"--literal-pathspecs",
+				"-c",
+				"core.fsmonitor=false",
+				"-c",
+				"core.hooksPath=/dev/null",
+				...args
+			],
+			cwd,
+			env,
+			signal,
+			timeoutMs: 5e3,
+			maxOutputBytes: 64 * 1024,
+			terminationPolicy: "tree"
+		});
+		signal.throwIfAborted();
+		if (result.exitCode !== 0 || result.timedOut) throw new Error(result.stderr || "Git data is unavailable");
+		return result;
+	});
+	if (operation.kind === "git_read") {
+		const target = checkedFilePath(workspace, resolve(workspace, operation.path), "read");
+		const path = relative((await run(["rev-parse", "--show-toplevel"])).stdout.trim(), target).split(sep).join("/");
+		if (path.startsWith("../") || path === "..") throw new Error("Git file must be inside the repository");
+		const result = await run([
+			"show",
+			"--no-ext-diff",
+			"--no-textconv",
+			`${operation.commit}:${path}`
+		]);
+		if (result.stdout.includes("\0")) throw new Error("Git object is binary; use a format-specific tool");
+		return {
+			text: result.stdout,
+			resource: target,
+			revision: operation.commit,
+			exhausted: !result.outputTruncated,
+			reason: result.outputTruncated ? "output_budget" : void 0
+		};
+	}
+	const paths = (operation.paths ?? ["."]).map((path) => checkedFilePath(workspace, resolve(workspace, path), "read"));
+	for (const value of [operation.since, operation.until]) if (value && !Number.isFinite(Date.parse(value))) throw new Error("Invalid Git date");
+	const head = (await run([
+		"rev-parse",
+		"--verify",
+		"HEAD"
+	])).stdout.trim();
+	const shallow = (await run(["rev-parse", "--is-shallow-repository"])).stdout.trim() === "true";
+	const recent = await run([
+		"log",
+		"--no-ext-diff",
+		"--no-textconv",
+		"--format=%H %cI %s",
+		"-21",
+		...operation.since ? [`--since=${operation.since}`] : [],
+		...operation.until ? [`--until=${operation.until}`] : [],
+		"HEAD",
+		"--",
+		...paths
+	]);
+	const rows = recent.stdout.trim().split("\n").filter(Boolean);
+	const dirty = (await run([
+		"status",
+		"--porcelain",
+		"--untracked-files=normal",
+		"--",
+		...paths
+	])).stdout.length > 0;
+	const omitted = recent.outputTruncated || rows.length > 20;
+	return {
+		text: `HEAD: ${head}\nDirty worktree: ${dirty}\nShallow history: ${shallow}\n${rows.slice(0, 20).join("\n")}`,
+		resource: cwd,
+		revision: head,
+		exhausted: !omitted && !shallow,
+		reason: omitted ? "output_budget" : shallow ? "shallow_history" : void 0
+	};
+}
+//#endregion
+export { readGitData };

package/dist/src/agent/data-acquisition/render.d.ts

@@ -0,0 +1,7 @@
+import { type DataBatchResult } from './types.js';
+/** Keep a valid envelope and explicit omissions even under a second context reduction. */
+export declare function renderDataBatch(input: DataBatchResult, maxChars?: number): {
+    text: string;
+    result: DataBatchResult;
+};
+export declare function isDataBatchResult(value: unknown): value is DataBatchResult;

package/dist/src/agent/data-acquisition/render.js

@@ -0,0 +1,79 @@
+import { DATA_MAX_CHARS } from "./types.js";
+//#region src/agent/data-acquisition/render.ts
+/** Keep a valid envelope and explicit omissions even under a second context reduction. */
+function renderDataBatch(input, maxChars = DATA_MAX_CHARS) {
+	const result = structuredClone(input);
+	const omitted = /* @__PURE__ */ new Set();
+	const encode = () => JSON.stringify(result);
+	const mark = () => {
+		for (const operation of result.operations) {
+			operation.fragmentIds = operation.fragmentIds.filter((id) => result.fragments.some((fragment) => fragment.id === id));
+			if (omitted.has(operation.id)) {
+				operation.outputOmitted = true;
+				if (operation.status === "ok") operation.status = "partial";
+				operation.reason ??= "output_budget";
+				if (operation.kind === "file_read") {
+					const original = input.fragments.find((fragment) => fragment.operationIds.includes(operation.id));
+					const kept = result.fragments.find((fragment) => fragment.operationIds.includes(operation.id));
+					if (original?.startLine !== void 0) operation.next = {
+						path: original.source.resource,
+						startLine: kept?.endLine !== void 0 ? kept.endLine + 1 : original.startLine,
+						maxLines: operation.next?.maxLines ?? 120
+					};
+				}
+			}
+		}
+	};
+	let text = encode();
+	while (text.length > maxChars || Buffer.byteLength(text) > 32768) {
+		const nonempty = result.fragments.filter((fragment) => fragment.text.length > 0);
+		if (nonempty.length) {
+			for (const fragment of nonempty) {
+				fragment.operationIds.forEach((id) => omitted.add(id));
+				const lines = fragment.text.split("\n");
+				if (lines.length > 1) {
+					fragment.text = lines.slice(0, Math.floor(lines.length / 2)).join("\n");
+					if (fragment.startLine !== void 0) fragment.endLine = fragment.startLine + fragment.text.split("\n").length - 1;
+				} else fragment.text = "";
+			}
+			result.fragments = result.fragments.filter((fragment) => fragment.text.length > 0);
+		} else {
+			for (const operation of result.operations) {
+				operation.scope = "";
+				operation.reason = operation.reason?.slice(0, 80);
+				delete operation.next;
+			}
+			mark();
+			for (const operation of result.operations) delete operation.next;
+			text = encode();
+			if (text.length <= maxChars && Buffer.byteLength(text) <= 32768) break;
+			text = JSON.stringify({
+				status: "partial",
+				reason: "output_budget",
+				operations: result.operations.map((op) => ({
+					id: op.id,
+					status: op.status
+				}))
+			});
+			if (text.length > maxChars) text = "{\"status\":\"partial\"}";
+			if (text.length > maxChars) text = "";
+			return {
+				text,
+				result
+			};
+		}
+		mark();
+		text = encode();
+	}
+	return {
+		text,
+		result
+	};
+}
+function isDataBatchResult(value) {
+	if (!value || typeof value !== "object") return false;
+	const item = value;
+	return item.schemaVersion === 1 && Array.isArray(item.operations) && item.operations.length <= 8 && item.operations.every((op) => op && typeof op.id === "string" && Array.isArray(op.fragmentIds) && typeof op.scope === "string") && Array.isArray(item.fragments) && item.fragments.length <= 256 && item.fragments.every((fragment) => fragment && typeof fragment.text === "string" && Array.isArray(fragment.operationIds) && fragment.source && typeof fragment.source.kind === "string" && typeof fragment.source.resource === "string");
+}
+//#endregion
+export { isDataBatchResult, renderDataBatch };

package/dist/src/agent/data-acquisition/scheduler.d.ts

@@ -0,0 +1,12 @@
+/** Shared limits across batches and callers; queued cancellation never consumes a permit. */
+export declare class DataScheduler {
+    private readonly totalLimit;
+    private readonly resourceLimit;
+    private readonly running;
+    private readonly queue;
+    private active;
+    constructor(totalLimit?: number, resourceLimit?: number);
+    run<T>(key: string, signal: AbortSignal | undefined, task: () => Promise<T>): Promise<T>;
+    private drain;
+}
+export declare const dataScheduler: DataScheduler;

package/dist/src/agent/data-acquisition/scheduler.js

@@ -0,0 +1,53 @@
+//#region src/agent/data-acquisition/scheduler.ts
+/** Shared limits across batches and callers; queued cancellation never consumes a permit. */
+var DataScheduler = class {
+	running = /* @__PURE__ */ new Map();
+	queue = [];
+	active = 0;
+	constructor(totalLimit = 8, resourceLimit = 4) {
+		this.totalLimit = totalLimit;
+		this.resourceLimit = resourceLimit;
+	}
+	run(key, signal, task) {
+		signal?.throwIfAborted();
+		return new Promise((resolve, reject) => {
+			const item = {
+				key,
+				signal,
+				abort: () => {
+					const index = this.queue.indexOf(item);
+					if (index !== -1) this.queue.splice(index, 1);
+					reject(signal?.reason ?? /* @__PURE__ */ new Error("Data operation cancelled"));
+				},
+				start: () => {
+					signal?.removeEventListener("abort", item.abort);
+					this.active++;
+					this.running.set(key, (this.running.get(key) ?? 0) + 1);
+					Promise.resolve().then(() => {
+						signal?.throwIfAborted();
+						return task();
+					}).then(resolve, reject).finally(() => {
+						this.active--;
+						const count = (this.running.get(key) ?? 1) - 1;
+						if (count) this.running.set(key, count);
+						else this.running.delete(key);
+						this.drain();
+					});
+				}
+			};
+			signal?.addEventListener("abort", item.abort, { once: true });
+			this.queue.push(item);
+			this.drain();
+		});
+	}
+	drain() {
+		while (this.active < this.totalLimit) {
+			const index = this.queue.findIndex((item) => (this.running.get(item.key) ?? 0) < this.resourceLimit);
+			if (index === -1) return;
+			this.queue.splice(index, 1)[0].start();
+		}
+	}
+};
+const dataScheduler = new DataScheduler();
+//#endregion
+export { DataScheduler, dataScheduler };

package/dist/src/agent/data-acquisition/schema.d.ts

@@ -0,0 +1,75 @@
+import { type Static } from '@sinclair/typebox';
+export declare const DataBatchSchema: import("@sinclair/typebox").TObject<{
+    operations: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"file_read">;
+        path: import("@sinclair/typebox").TString;
+        startLine: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        maxLines: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"file_search">;
+        paths: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        patterns: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        literal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        ignoreCase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        glob: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        contextLines: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"git_recent">;
+        paths: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+        since: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        until: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"git_read">;
+        path: import("@sinclair/typebox").TString;
+        commit: import("@sinclair/typebox").TString;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"knowledge_search">;
+        query: import("@sinclair/typebox").TString;
+        maxResults: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"knowledge_get">;
+        knowledgeId: import("@sinclair/typebox").TString;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"web_search">;
+        query: import("@sinclair/typebox").TString;
+        count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"web_fetch">;
+        url: import("@sinclair/typebox").TString;
+        maxChars: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"external_read">;
+        toolRef: import("@sinclair/typebox").TString;
+        revision: import("@sinclair/typebox").TString;
+        arguments: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>;
+    }>]>>;
+}>;
+export type DataBatchArgs = Static<typeof DataBatchSchema>;
+export type DataOperation = DataBatchArgs['operations'][number];
+export declare const DATA_OPERATION_TOOLS: {
+    readonly file_read: "read_file";
+    readonly file_search: "grep";
+    readonly git_recent: "exec_command";
+    readonly git_read: "exec_command";
+    readonly knowledge_search: "knowledge_search";
+    readonly knowledge_get: "knowledge_get";
+    readonly web_search: "web_search";
+    readonly web_fetch: "web_fetch";
+    readonly external_read: "xopc_tool_execute";
+};
+export declare function nativeDataArgs(op: DataOperation): Record<string, unknown>;
+/** Expose each underlying access to existing approval, hook and call-limit policies. */
+export declare function dataOperationCalls(args: unknown): Array<{
+    name: string;
+    args: Record<string, unknown>;
+}>;
+export declare function validateDataBatch(args: unknown): asserts args is DataBatchArgs;