@xopcai/xopc 0.0.308 → 0.0.311

package/dist/packages/gateway-contract/src/proactive.js

@@ -1,7 +1,7 @@
 import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
 import { z } from "zod";
 //#region packages/gateway-contract/src/proactive.ts
-var ProactiveLevelSchema, ProactiveTimezoneSchema, ProactivePreferencesSchema, ProactivePreferencesUpdateSchema, ProactiveSubscriptionSettingsSchema, ProactiveSubscriptionCreateSchema, ProactiveSubscriptionUpdateSchema, ProactiveArtifactSchema, ProactiveTaskDraftSchema, ProactiveCardActionSchema;
+var ProactiveLevelSchema, ProactiveTimezoneSchema, ProactivePreferencesSchema, ProactiveSubscriptionSettingsSchema, ProactiveArtifactSchema, ProactiveTaskDraftSchema;
 var init_proactive = __esmMin((() => {
 	ProactiveLevelSchema = z.enum([
 		"quiet",
@@ -46,7 +46,7 @@ var init_proactive = __esmMin((() => {
 		notificationsMuted: z.boolean().default(false),
 		revision: z.number().int().nonnegative().default(0)
 	});
-	ProactivePreferencesUpdateSchema = z.object({
+	z.object({
 		level: ProactivePreferencesSchema.shape.level.removeDefault().optional(),
 		timezone: ProactivePreferencesSchema.shape.timezone.removeDefault().optional(),
 		quietStartHour: ProactivePreferencesSchema.shape.quietStartHour.removeDefault().optional(),
@@ -74,13 +74,13 @@ var init_proactive = __esmMin((() => {
 		scanIntervalMinutes: z.number().int().min(15).max(10080).nullable().default(null),
 		userInstructions: z.string().max(12e3).default("")
 	});
-	ProactiveSubscriptionCreateSchema = ProactiveSubscriptionSettingsSchema.extend({
+	ProactiveSubscriptionSettingsSchema.extend({
 		scenarioKey: z.string().min(1).max(100),
 		scopeKind: z.enum(["workspace", "project"]),
 		scopeId: z.string().min(1).max(200),
 		enabled: z.boolean().default(true)
 	}).strict();
-	ProactiveSubscriptionUpdateSchema = z.object({
+	z.object({
 		level: ProactiveSubscriptionSettingsSchema.shape.level.removeDefault().optional(),
 		delivery: ProactiveSubscriptionSettingsSchema.shape.delivery.removeDefault().optional(),
 		completedAt: ProactiveSubscriptionSettingsSchema.shape.completedAt.removeDefault().optional(),
@@ -102,7 +102,7 @@ var init_proactive = __esmMin((() => {
 		title: z.string().trim().min(1).max(160),
 		objective: z.string().trim().min(1).max(1200)
 	}).strict();
-	ProactiveCardActionSchema = z.object({
+	z.object({
 		actionId: z.enum([
 			"read",
 			"resolve",
@@ -133,4 +133,4 @@ var init_proactive = __esmMin((() => {
 }));
 //#endregion
 init_proactive();
-export { ProactiveArtifactSchema, ProactiveCardActionSchema, ProactiveLevelSchema, ProactivePreferencesSchema, ProactivePreferencesUpdateSchema, ProactiveSubscriptionCreateSchema, ProactiveSubscriptionSettingsSchema, ProactiveSubscriptionUpdateSchema, ProactiveTaskDraftSchema, ProactiveTimezoneSchema, init_proactive };
+export { ProactiveArtifactSchema, ProactiveLevelSchema, ProactivePreferencesSchema, ProactiveSubscriptionSettingsSchema, ProactiveTaskDraftSchema, ProactiveTimezoneSchema, init_proactive };

package/dist/packages/gateway-contract/src/project-monitoring.js

@@ -1,7 +1,7 @@
 import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
 import { z } from "zod";
 //#region packages/gateway-contract/src/project-monitoring.ts
-var MonitoringModeSchema, QuietHoursSchema, ProjectMonitoringPolicySchema, ProjectMonitoringUpdateSchema;
+var MonitoringModeSchema, QuietHoursSchema;
 var init_project_monitoring = __esmMin((() => {
 	MonitoringModeSchema = z.enum([
 		"observe",
@@ -13,7 +13,7 @@ var init_project_monitoring = __esmMin((() => {
 		endHour: z.number().int().min(0).max(23),
 		timezone: z.string().min(1)
 	});
-	ProjectMonitoringPolicySchema = z.object({
+	z.object({
 		projectId: z.string(),
 		mode: MonitoringModeSchema,
 		quietHours: QuietHoursSchema.optional(),
@@ -23,7 +23,7 @@ var init_project_monitoring = __esmMin((() => {
 		configured: z.boolean(),
 		updatedAt: z.number().optional()
 	});
-	ProjectMonitoringUpdateSchema = z.object({
+	z.object({
 		mode: MonitoringModeSchema.optional(),
 		quietHours: QuietHoursSchema.nullable().optional(),
 		allowedActions: z.array(z.string()).optional(),
@@ -33,4 +33,4 @@ var init_project_monitoring = __esmMin((() => {
 }));
 //#endregion
 init_project_monitoring();
-export { MonitoringModeSchema, ProjectMonitoringPolicySchema, ProjectMonitoringUpdateSchema, QuietHoursSchema, init_project_monitoring };
+export { MonitoringModeSchema, QuietHoursSchema, init_project_monitoring };

package/dist/packages/gateway-contract/src/project-operating.js

@@ -1,13 +1,11 @@
 import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
 import { TaskAttentionItemSchema, TaskOperationalStateSchema, TaskPhaseSchema, TaskResolutionSchema } from "./task-lifecycle.js";
 import { TaskDependencySummarySchema, TaskPrioritySchema, TaskRunReceiptSchema, init_tasks } from "./tasks.js";
-import { ProjectMonitoringPolicySchema, init_project_monitoring } from "./project-monitoring.js";
 import { z } from "zod";
 //#region packages/gateway-contract/src/project-operating.ts
 var ProjectSummarySchema, ProjectTaskDependencyEdgeSchema, ProjectTaskCardSchema;
 var init_project_operating = __esmMin((() => {
 	init_tasks();
-	init_project_monitoring();
 	ProjectSummarySchema = z.object({
 		id: z.string(),
 		name: z.string(),
@@ -91,8 +89,7 @@ var init_project_operating = __esmMin((() => {
 			]),
 			summary: z.string(),
 			recommendedAction: z.string().optional()
-		}),
-		monitoring: ProjectMonitoringPolicySchema
+		})
 	});
 }));
 //#endregion

package/dist/packages/gateway-contract/src/sessions.js

@@ -138,7 +138,12 @@ var init_sessions = __esmMin((() => {
 			offset: z.number(),
 			hasMore: z.boolean()
 		}),
-		inbox: sessionsListResponseSchema
+		inbox: sessionsListResponseSchema,
+		pinned: z.array(z.unknown()).default([]),
+		layouts: z.record(z.string(), z.object({
+			itemIds: z.array(z.string()),
+			revision: z.number().int().nonnegative()
+		})).default({})
 	}).passthrough();
 }));
 //#endregion

package/dist/src/agent/agent-manager.d.ts

@@ -1,9 +1,4 @@
-/**
- * Agent Manager - Manages Agent instances per session
- *
- * Each session gets its own Agent instance for true isolation
- * and concurrent processing across sessions.
- */
+import type { SceneAccess } from '../scenes/httpServices.js';
 import { Agent, type AgentMessage, type AgentEvent, type ThinkingLevel } from '@earendil-works/pi-agent-core';
 import type { AgentInstanceGateway } from './agent-instance-gateway.js';
 import { type Config } from '../config/schema.js';
@@ -95,6 +90,7 @@ export interface AgentManagerConfig {
     };
     /** Gateway: exposes AutomationService for the `automation` tool. */
     getAutomationService?: () => AutomationService | undefined;
+    getSceneAccess?: () => SceneAccess | undefined;
     getBrowserAutomationService?: () => import('../browser/automations/index.js').BrowserAutomationService | undefined;
     emitBrowserEvent?: (type: string, payload: unknown) => void;
     /** Gateway: exposes first-class xopc product objects for the `xopc_use` tool. */

package/dist/src/agent/agent-manager.js

@@ -4,7 +4,7 @@ import { init_logger } from "../utils/logger.js";
 import { isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
 import { consumeClarificationApproval } from "../storage/sqlite/clarification-wait-repository.js";
 import { getInteractionState } from "../storage/sqlite/interaction-state-repository.js";
-import { getSessionMetadata } from "../storage/sqlite/session-repository.js";
+import { getSessionMetadata } from "../storage/sqlite/session-read-repository.js";
 import "../storage/sqlite/index.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
 import { applyConfigOverrides } from "../config/runtime-overrides.js";
@@ -262,6 +262,7 @@ var AgentManager = class {
 			getSessionStore: this.config.getSessionStore,
 			gatewayClarify: this.config.gatewayClarify,
 			getAutomationService: this.config.getAutomationService,
+			getSceneAccess: this.config.getSceneAccess,
 			getBrowserAutomationService: this.config.getBrowserAutomationService,
 			emitBrowserEvent: this.config.emitBrowserEvent,
 			getNotesService: this.config.getNotesService,
@@ -967,6 +968,8 @@ var AgentManager = class {
 			conversationId,
 			disabledTools: profile.tools.denied,
 			getPrimaryModel: () => agent?.state.model ?? model,
+			getParentTools: () => agent?.state.tools ?? [],
+			createDelegationPolicy: () => this.createAgentTurnPolicy(conversationId),
 			getMemoryManager: () => rt.memoryManager,
 			getSkillManager: () => rt.skillManager
 		});
@@ -1009,11 +1012,12 @@ var AgentManager = class {
 		};
 	}
 	buildAgentTurnPolicy(conversationId, profile) {
+		const currentProfile = () => resolveEffectiveAgentProfileForSession(this.config.config, conversationId);
 		return createAgentTurnPolicy({
 			maxTurns: profile.config.runtime.maxTurns,
 			maxToolFailures: profile.config.runtime.maxToolFailuresPerTurn,
 			resolveToolLimit: (toolName, args) => {
-				const policy = this.resolveToolPolicy(profile, toolName, args);
+				const policy = this.resolveToolPolicy(currentProfile(), toolName, args);
 				const maxCalls = policy?.maxCallsPerTurn;
 				return policy && maxCalls ? {
 					id: policy.id,
@@ -1039,8 +1043,12 @@ var AgentManager = class {
 						reason: decision.reason ?? "Blocked by collaboration rule."
 					};
 				}
-				const policy = this.resolveToolPolicy(profile, toolName, args);
+				const policy = this.resolveToolPolicy(currentProfile(), toolName, args);
 				const detail = JSON.stringify(args ?? {});
+				if (policy?.mode === "deny") return {
+					block: true,
+					reason: `${policy.id} is denied by tool policy.`
+				};
 				if (policy?.mode === "ask") {
 					if (!await this.requestToolConfirmation(conversationId, policy?.id ?? toolName, detail)) return {
 						block: true,
@@ -1082,6 +1090,11 @@ var AgentManager = class {
 		});
 	}
 	resolveToolPolicy(profile, toolName, args) {
+		const gatewayPolicy = profile.config.tools[toolName];
+		if (gatewayPolicy && gatewayPolicy.mode !== "allow") return {
+			id: toolName,
+			...gatewayPolicy
+		};
 		if (toolName !== "xopc_tool_execute") {
 			const policy = profile.config.tools[toolName];
 			return policy ? {
@@ -1089,13 +1102,26 @@ var AgentManager = class {
 				...policy
 			} : void 0;
 		}
-		const parsed = parseExternalToolRef(typeof args?.toolRef === "string" ? args.toolRef : "", "mcp");
-		if (!parsed) return void 0;
+		const toolRef = typeof args?.toolRef === "string" ? args.toolRef : "";
+		const parsed = parseExternalToolRef(toolRef, "mcp");
+		if (!parsed) {
+			const externalPolicy = profile.config.tools[toolRef];
+			return externalPolicy ? {
+				id: toolRef,
+				...externalPolicy
+			} : gatewayPolicy ? {
+				id: toolName,
+				...gatewayPolicy
+			} : void 0;
+		}
 		const id = mcpToolPolicyId(parsed.namespace, parsed.toolName);
 		const policy = profile.config.tools[id];
 		return policy ? {
 			id,
 			...policy
+		} : gatewayPolicy ? {
+			id: toolName,
+			...gatewayPolicy
 		} : void 0;
 	}
 	async requestToolConfirmation(conversationId, toolName, detail) {

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

@@ -1,7 +1,7 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { finishContextExtractionRun } from "../../storage/sqlite/context-extraction-repository.js";
-import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
+import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
 import { loadCompactionSourceSnapshot } from "../../storage/sqlite/transcript-repository.js";
 import "../../storage/sqlite/index.js";
 import { extractProfileAgentId } from "../../config/agent-profile.js";

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/commands/command-registry.js

@@ -1,8 +1,8 @@
 import { resolveStateDir } from "../../config/paths-state.js";
 import { init_global_singleton, resolveGlobalSingleton } from "../../utils/global-singleton.js";
 import { init_paths } from "../../config/paths.js";
-import { DurableState } from "../../storage/sqlite/durable-state.js";
 import { spawnProcess } from "../../process/run-process.js";
+import { DurableState } from "../../storage/sqlite/durable-state.js";
 import { isolatedCommand, removeCommandContainer } from "./command-isolation.js";
 import { readWorkspaceRevision } from "../coding/workspace-revision.js";
 import { join } from "node:path";

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

@@ -1,5 +1,5 @@
 import { isXopcDatabaseOpen } from "../../storage/sqlite/connection.js";
-import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
+import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
 import "../../storage/sqlite/index.js";
 import { sanitizeForPromptLiteral } from "../prompt/sanitize-for-prompt.js";
 import { TaskRepository } from "../../tasks/task-repository.js";

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;