@xopcai/xopc 0.0.243 → 0.0.245

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

@@ -1,161 +1,73 @@
-import { DEFAULT_MAX_BYTES, formatSize, truncateHead, truncateLine } from "./truncate.js";
+import { evaluateFilePolicy } from "../sandbox/exec-policy.js";
 import { resolveToCwd } from "../../utils/helpers.js";
-import path from "path";
-import { existsSync, readFileSync, statSync } from "fs";
+import { repositorySearch } from "./repository-search.js";
 import { Type } from "@sinclair/typebox";
-import { globSync } from "glob";
 //#region src/agent/tools/grep.ts
 const grepSchema = Type.Object({
-	pattern: Type.String({ description: "Search pattern (regex or literal string)" }),
-	path: Type.Optional(Type.String({ description: "Directory or file to search (default: current directory)" })),
-	glob: Type.Optional(Type.String({ description: "Filter files by glob pattern, e.g. '*.ts'" })),
-	ignoreCase: Type.Optional(Type.Boolean({ description: "Case-insensitive search (default: false)" })),
-	literal: Type.Optional(Type.Boolean({ description: "Treat pattern as literal string instead of regex (default: false)" })),
-	context: Type.Optional(Type.Number({ description: "Number of lines to show before and after each match (default: 0)" })),
-	limit: Type.Optional(Type.Number({ description: "Maximum number of matches to return (default: 100)" }))
+	pattern: Type.String({ description: "Ripgrep regex, or literal text when literal=true" }),
+	path: Type.Optional(Type.String()),
+	glob: Type.Optional(Type.String()),
+	ignoreCase: Type.Optional(Type.Boolean()),
+	literal: Type.Optional(Type.Boolean()),
+	context: Type.Optional(Type.Integer({
+		minimum: 0,
+		maximum: 20
+	})),
+	limit: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 1e3
+	}))
 });
-const DEFAULT_LIMIT = 100;
-/**
-* Simple grep implementation using Node.js regex
-*/
-function simpleGrep(content, pattern, options) {
-	const matches = [];
-	const lines = content.split("\n");
-	const regexPattern = options.literal ? pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : pattern;
-	const flags = options.ignoreCase ? "i" : "";
-	const regex = new RegExp(regexPattern, flags);
-	for (let i = 0; i < lines.length; i++) if (regex.test(lines[i])) matches.push({
-		lineNumber: i + 1,
-		line: lines[i]
-	});
-	return matches;
-}
-/**
-* Grep tool - Search file contents for a pattern
-*/
 function createGrepTool(cwd) {
 	return {
 		name: "grep",
-		label: "🔍 grep",
-		description: "Search file contents for a pattern (regex or literal).",
+		label: "Search",
 		parameters: grepSchema,
+		description: "Search with ripgrep, respecting .gitignore and skipping binary files. Returns path:line content. Use a narrow path or glob; output is bounded.",
 		supportsParallel: true,
 		idempotent: true,
-		execute: async (_toolCallId, params, signal) => {
-			try {
-				const p = params;
-				const searchPath = resolveToCwd(p.path || ".", cwd);
-				if (!existsSync(searchPath)) return {
-					content: [{
-						type: "text",
-						text: `Error: Path not found: ${searchPath}`
-					}],
-					details: {}
-				};
-				const isDirectory = statSync(searchPath).isDirectory();
-				const context = p.context || 0;
-				const effectiveLimit = p.limit || DEFAULT_LIMIT;
-				const files = [];
-				if (isDirectory) {
-					const filePaths = globSync(p.glob || "**/*", {
-						cwd: searchPath,
-						dot: true,
-						ignore: ["**/node_modules/**", "**/.git/**"]
-					});
-					files.push(...filePaths.map((f) => path.join(searchPath, f)));
-				} else files.push(searchPath);
-				const matches = [];
-				let matchCount = 0;
-				let linesTruncated = false;
-				for (const filePath of files) {
-					if (signal?.aborted) return {
-						content: [{
-							type: "text",
-							text: "Operation aborted"
-						}],
-						details: {}
-					};
-					try {
-						if (!existsSync(filePath)) continue;
-						const fileMatches = simpleGrep(readFileSync(filePath, "utf-8"), p.pattern, {
-							ignoreCase: p.ignoreCase || false,
-							literal: p.literal || false
-						});
-						for (const match of fileMatches) {
-							if (matchCount >= effectiveLimit) break;
-							matches.push({
-								file: filePath,
-								...match
-							});
-							matchCount++;
-						}
-					} catch {}
-					if (matchCount >= effectiveLimit) break;
-				}
-				if (matches.length === 0) return {
-					content: [{
-						type: "text",
-						text: "No matches found"
-					}],
-					details: {}
-				};
-				const outputLines = [];
-				const basePath = isDirectory ? searchPath : path.dirname(searchPath);
-				for (const match of matches) {
-					const relativePath = path.relative(basePath, match.file);
-					const { text: truncatedLine, wasTruncated } = truncateLine(match.line);
-					if (wasTruncated) linesTruncated = true;
-					if (context > 0) try {
-						const allLines = readFileSync(match.file, "utf-8").split("\n");
-						const start = Math.max(1, match.lineNumber - context);
-						const end = Math.min(allLines.length, match.lineNumber + context);
-						for (let i = start; i <= end; i++) {
-							const { text: truncatedContextLine } = truncateLine(allLines[i - 1] || "");
-							if (i === match.lineNumber) outputLines.push(`${relativePath}:${i}: ${truncatedContextLine}`);
-							else outputLines.push(`${relativePath}-${i}- ${truncatedContextLine}`);
-						}
-					} catch {
-						outputLines.push(`${relativePath}:${match.lineNumber}: ${truncatedLine}`);
-					}
-					else outputLines.push(`${relativePath}:${match.lineNumber}: ${truncatedLine}`);
-				}
-				const truncation = truncateHead(outputLines.join("\n"), { maxLines: Number.MAX_SAFE_INTEGER });
-				let output = truncation.content;
-				const details = {};
-				const notices = [];
-				if (matches.length >= effectiveLimit) {
-					notices.push(`${effectiveLimit} matches limit reached`);
-					details.matchLimitReached = effectiveLimit;
-				}
-				if (truncation.truncated) {
-					notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
-					details.truncation = truncation;
-				}
-				if (linesTruncated) {
-					notices.push(`Some lines truncated to 500 chars`);
-					details.linesTruncated = true;
-				}
-				if (notices.length > 0) output += `\n\n[${notices.join(". ")}]`;
-				return {
-					content: [{
-						type: "text",
-						text: output
-					}],
-					details: Object.keys(details).length > 0 ? details : void 0
-				};
-			} catch (error) {
-				return {
-					content: [{
-						type: "text",
-						text: `Error during grep: ${error instanceof Error ? error.message : String(error)}`
-					}],
-					details: {}
-				};
-			}
+		async execute(_id, params, signal) {
+			const path = resolveToCwd(params.path || ".", cwd);
+			const policy = evaluateFilePolicy({
+				operation: "read",
+				path,
+				workspaceRoot: cwd
+			});
+			if (!policy.allowed) throw new Error(policy.reason);
+			const limit = Math.min(1e3, Math.max(1, params.limit ?? 100));
+			const result = await repositorySearch(cwd, [
+				"--line-number",
+				"--with-filename",
+				"--color",
+				"never",
+				"--max-columns",
+				"300",
+				"--max-columns-preview",
+				"--max-count",
+				String(limit),
+				"--context",
+				String(params.context ?? 0),
+				...params.ignoreCase ? ["--ignore-case"] : [],
+				...params.literal ? ["--fixed-strings"] : [],
+				...params.glob ? ["--glob", params.glob] : [],
+				"-e",
+				params.pattern,
+				"--",
+				path
+			], signal);
+			const lines = result.output.trimEnd().split("\n");
+			const outputLimit = limit * (1 + 2 * (params.context ?? 0));
+			const truncated = result.truncated || lines.length > outputLimit;
+			return {
+				content: [{
+					type: "text",
+					text: (result.output ? lines.slice(0, outputLimit).join("\n") : "No matches found") + (truncated ? "\n[Results truncated; narrow the path or pattern.]" : "")
+				}],
+				details: { truncated }
+			};
 		}
 	};
 }
-/** Default grep tool using process.cwd() */
 const grepTool = createGrepTool(process.cwd());
 //#endregion
 export { createGrepTool, grepTool };

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

@@ -25,7 +25,6 @@ export { createClarifyTool, type ClarifyRequestPayload, type GatewayClarifyReque
 export { BrowserManager, assertBrowserUrlAllowed } from '../../browser/index.js';
 export { createDelegateTool, DEFAULT_DELEGATE_TOOLS, DELEGATE_BLOCKED_TOOLS, } from './delegate-tool.js';
 export { createWorkflowTool, type WorkflowToolDeps, type WorkflowToolInput } from './workflow-tool.js';
-export { createExecuteCodeTool, buildSandboxToolMap, SANDBOX_ALLOWED_TOOLS, } from './execute-code-tool.js';
 export { createAutomationTool, type AutomationToolDeps } from './automation-tool.js';
 export { createBrowserRecipeTool } from './browser-recipe-tool.js';
 export { createXopcUseTool, type XopcUseToolDeps, type XopcUseToolInput } from './xopc-use-tool.js';

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

@@ -27,9 +27,9 @@ import { createClarifyTool } from "./clarify-tool.js";
 import { BrowserManager } from "../../browser/manager.js";
 import { assertBrowserUrlAllowed } from "../../browser/url-policy.js";
 import "../../browser/index.js";
+import { resolveImageModelConfigForTool } from "../image/tool-model-config.js";
 import { DEFAULT_DELEGATE_TOOLS, DELEGATE_BLOCKED_TOOLS, createDelegateTool } from "./delegate-tool.js";
 import { createWorkflowTool } from "./workflow-tool.js";
-import { SANDBOX_ALLOWED_TOOLS, buildSandboxToolMap, createExecuteCodeTool } from "./execute-code-tool.js";
 import { createAutomationTool } from "./automation-tool.js";
 import { createBrowserRecipeTool } from "./browser-recipe-tool.js";
 import { createXopcUseTool } from "./xopc-use-tool.js";
@@ -40,7 +40,6 @@ import { createSkillInstallTool } from "./skill-install-tool.js";
 import { createToolManualTool } from "./tool-manual-tool.js";
 import { createDesktopPetTool } from "./desktop-pet-tool.js";
 import { createManagedJobTool } from "./managed-job-tool.js";
-import { resolveImageModelConfigForTool } from "../image/tool-model-config.js";
 import { createImageTool } from "./image-tool.js";
 import { createImageGenerateTool, resolveImageGenerationModelConfigForTool } from "./image-generate-tool.js";
-export { BrowserManager, DEFAULT_DELEGATE_TOOLS, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, DEFAULT_TOOL_METADATA, DEFAULT_WEB_EXTRACT_MAX_LENGTH, DELEGATE_BLOCKED_TOOLS, GREP_MAX_LINE_LENGTH, MAX_RAW_HTML_CHARS_FOR_WEB_EXTRACT, SANDBOX_ALLOWED_TOOLS, TodoStore, ToolConcurrencyController, assertBrowserUrlAllowed, buildSandboxToolMap, createApplyPatchTool, createAutomationTool, createBrowserRecipeTool, createClarifyTool, createCreateShareTool, createDelegateTool, createDesktopPetTool, createDreamingTool, createExecCommandTool, createExecuteCodeTool, createFindTool, createGrepTool, createImageGenerateTool, createImageTool, createListDirTool, createManagedJobTool, createMemoryGetTool, createMemorySearchTool, createMessageTool, createPublishArtifactsTool, createReadFileTool, createReadMediaTool, createSendMediaTool, createSessionRecallTool, createSessionSearchTool, createSessionStatusTool, createSkillInstallTool, createSkillManageTool, createSkillViewTool, createSkillsListTool, createSkillsMarketplaceSearchTool, createTodoTool, createToolManualTool, createUpdatePlanTool, createWebExtractTool, createWebFetchTool, createWebSearchTool, createWorkflowTool, createWriteFileTool, createXopcUseTool, findTool, formatSize, fuzzyFindText, generateDiffString, getToolMetadata, grepTool, isShareToolAvailable, listDirTool, normalizeForFuzzyMatch, normalizeToLF, resolveImageGenerationModelConfigForTool, resolveImageModelConfigForTool, resolveToolLockMode, restoreLineEndings, stripBom, stripHtmlBoilerplate, truncateHead, truncateLine, truncateTail, writeFileTool };
+export { BrowserManager, DEFAULT_DELEGATE_TOOLS, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, DEFAULT_TOOL_METADATA, DEFAULT_WEB_EXTRACT_MAX_LENGTH, DELEGATE_BLOCKED_TOOLS, GREP_MAX_LINE_LENGTH, MAX_RAW_HTML_CHARS_FOR_WEB_EXTRACT, TodoStore, ToolConcurrencyController, assertBrowserUrlAllowed, createApplyPatchTool, createAutomationTool, createBrowserRecipeTool, createClarifyTool, createCreateShareTool, createDelegateTool, createDesktopPetTool, createDreamingTool, createExecCommandTool, createFindTool, createGrepTool, createImageGenerateTool, createImageTool, createListDirTool, createManagedJobTool, createMemoryGetTool, createMemorySearchTool, createMessageTool, createPublishArtifactsTool, createReadFileTool, createReadMediaTool, createSendMediaTool, createSessionRecallTool, createSessionSearchTool, createSessionStatusTool, createSkillInstallTool, createSkillManageTool, createSkillViewTool, createSkillsListTool, createSkillsMarketplaceSearchTool, createTodoTool, createToolManualTool, createUpdatePlanTool, createWebExtractTool, createWebFetchTool, createWebSearchTool, createWorkflowTool, createWriteFileTool, createXopcUseTool, findTool, formatSize, fuzzyFindText, generateDiffString, getToolMetadata, grepTool, isShareToolAvailable, listDirTool, normalizeForFuzzyMatch, normalizeToLF, resolveImageGenerationModelConfigForTool, resolveImageModelConfigForTool, resolveToolLockMode, restoreLineEndings, stripBom, stripHtmlBoilerplate, truncateHead, truncateLine, truncateTail, writeFileTool };

package/dist/src/agent/tools/language-diagnostics.d.ts

@@ -0,0 +1,11 @@
+import type { AgentTool } from '@earendil-works/pi-agent-core';
+import { type CreateExecCommandToolOptions } from './exec-command.js';
+export interface LanguageDiagnostic {
+    file: string;
+    line: number;
+    column: number;
+    code: string;
+    message: string;
+}
+export declare function parseTypeScriptDiagnostics(output: string): LanguageDiagnostic[];
+export declare function createLanguageDiagnosticsTool(workspace: string, options?: CreateExecCommandToolOptions): AgentTool;

package/dist/src/agent/tools/language-diagnostics.js

@@ -0,0 +1,62 @@
+import { createExecCommandTool } from "./exec-command.js";
+import { relative, resolve, sep } from "node:path";
+import { access } from "node:fs/promises";
+import { Type } from "@sinclair/typebox";
+//#region src/agent/tools/language-diagnostics.ts
+function parseTypeScriptDiagnostics(output) {
+	return [...output.matchAll(/^(.+)\((\d+),(\d+)\): error (TS\d+): (.+)$/gm)].slice(0, 200).map((match) => ({
+		file: match[1],
+		line: Number(match[2]),
+		column: Number(match[3]),
+		code: match[4],
+		message: match[5]
+	}));
+}
+function quote(value) {
+	if (process.platform === "win32") {
+		if (/[%!"\r\n]/.test(value)) throw new Error("Unsupported character in diagnostic path");
+		return `"${value}"`;
+	}
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function createLanguageDiagnosticsTool(workspace, options) {
+	const exec = createExecCommandTool(workspace, options);
+	return {
+		name: "language_diagnostics",
+		label: "TypeScript diagnostics",
+		description: "Run the repository-installed TypeScript compiler without emitting code. Returns compiler exit status, bounded file/line diagnostics, and a durable command log. Supports tsconfig projects; other languages use their normal check command.",
+		parameters: Type.Object({ project: Type.Optional(Type.String({ description: "tsconfig path relative to the workspace; defaults to tsconfig.json" })) }),
+		supportsParallel: false,
+		idempotent: false,
+		async execute(id, input, signal, onUpdate) {
+			const project = resolve(workspace, input.project ?? "tsconfig.json");
+			const projectRelative = relative(workspace, project);
+			if (projectRelative === ".." || projectRelative.startsWith(`..${sep}`)) throw new Error("Project must be inside the workspace");
+			await access(project);
+			let compiler;
+			try {
+				compiler = resolve(workspace, "node_modules/typescript/lib/tsc.js");
+				await access(compiler);
+			} catch {
+				throw new Error("This workspace has no installed TypeScript compiler. Install its declared dependencies first.");
+			}
+			const isolated = options?.getCommandIsolation?.()?.mode === "docker";
+			const compilerPath = isolated ? relative(workspace, compiler).split(sep).join("/") : compiler;
+			if (isolated && compilerPath.startsWith("../")) throw new Error("Container diagnostics require TypeScript installed inside the workspace.");
+			const result = await exec.execute(id, {
+				cmd: `${quote(isolated ? "node" : process.execPath)} ${quote(compilerPath)} --project ${quote(projectRelative)} --noEmit --pretty false`,
+				timeoutMs: 12e4
+			}, signal, onUpdate);
+			return {
+				...result,
+				details: {
+					...result.details,
+					diagnosticEngine: "typescript",
+					diagnostics: parseTypeScriptDiagnostics(String(result.details.aggregatedOutput ?? ""))
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { createLanguageDiagnosticsTool, parseTypeScriptDiagnostics };

package/dist/src/agent/tools/managed-job-tool.d.ts

@@ -1,2 +1,3 @@
 import type { AgentTool } from '@earendil-works/pi-agent-core';
-export declare function createManagedJobTool(workspace: string, getSessionKey: () => string | undefined, getSkillPassthroughEnvVarNames?: () => string[], prepareEnv?: (baseEnv: Record<string, string>, cwd: string) => Promise<Record<string, string>>): AgentTool;
+import type { CommandIsolation } from '../commands/command-isolation.js';
+export declare function createManagedJobTool(workspace: string, getSessionKey: () => string | undefined, getSkillPassthroughEnvVarNames?: () => string[], prepareEnv?: (baseEnv: Record<string, string>, cwd: string) => Promise<Record<string, string>>, getCommandIsolation?: () => CommandIsolation | undefined): AgentTool;

package/dist/src/agent/tools/managed-job-tool.js

@@ -1,106 +1,12 @@
-import { resolveGlobalSingleton } from "../../utils/global-singleton.js";
+import { commandRegistry, commandTimeout } from "../commands/command-registry.js";
 import { evaluateExecPolicy } from "../sandbox/exec-policy.js";
 import { resolve } from "node:path";
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/managed-job-tool.ts
-const MANAGED_JOB_REGISTRY_KEY = Symbol.for("xopc.managedJobRegistry");
-const DEFAULT_MAX_RUNTIME_MS = 60 * 6e4;
-const MAX_RUNTIME_MS = 1440 * 6e4;
-const MAX_CAPTURE_CHARS = 2e5;
-var ManagedJobRegistry = class {
-	jobs = /* @__PURE__ */ new Map();
-	start(owner, command, cwd, env, maxRuntimeMs) {
-		this.prune();
-		const id = randomUUID();
-		const child = spawn(command, [], {
-			shell: true,
-			cwd,
-			env,
-			detached: process.platform !== "win32"
-		});
-		const job = {
-			id,
-			owner,
-			command,
-			cwd,
-			status: "running",
-			process: child,
-			pid: child.pid,
-			createdAtMs: Date.now(),
-			stdout: "",
-			stderr: "",
-			timeout: setTimeout(() => this.stop(job, "timed_out"), maxRuntimeMs)
-		};
-		job.timeout.unref?.();
-		const append = (stream, value) => {
-			const next = `${job[stream]}${String(value)}`;
-			job[stream] = next.length > MAX_CAPTURE_CHARS ? next.slice(-MAX_CAPTURE_CHARS) : next;
-		};
-		child.stdout?.on("data", (value) => append("stdout", value));
-		child.stderr?.on("data", (value) => append("stderr", value));
-		child.on("error", (error) => append("stderr", `\n${error.message}`));
-		child.on("close", (exitCode) => {
-			if (job.status === "running") job.status = exitCode === 0 ? "succeeded" : "failed";
-			job.exitCode = exitCode;
-			job.endedAtMs = Date.now();
-			clearTimeout(job.timeout);
-		});
-		this.jobs.set(id, job);
-		return this.view(job);
-	}
-	get(owner, id) {
-		const job = this.jobs.get(id);
-		return job?.owner === owner ? this.view(job) : void 0;
-	}
-	list(owner) {
-		return [...this.jobs.values()].filter((job) => job.owner === owner).toSorted((a, b) => b.createdAtMs - a.createdAtMs).slice(0, 50).map((job) => this.view(job));
-	}
-	cancel(owner, id) {
-		const job = this.jobs.get(id);
-		if (!job || job.owner !== owner) return void 0;
-		if (job.status === "running") this.stop(job, "cancelled");
-		return this.view(job);
-	}
-	stop(job, status) {
-		if (job.status !== "running") return;
-		job.status = status;
-		job.endedAtMs = Date.now();
-		clearTimeout(job.timeout);
-		if (job.pid && process.platform !== "win32") try {
-			process.kill(-job.pid, "SIGTERM");
-			return;
-		} catch {}
-		job.process.kill("SIGTERM");
-	}
-	view(job) {
-		const outputLength = job.stdout.length + job.stderr.length;
-		return {
-			id: job.id,
-			command: job.command,
-			cwd: job.cwd,
-			status: job.status,
-			pid: job.pid,
-			createdAtMs: job.createdAtMs,
-			endedAtMs: job.endedAtMs,
-			exitCode: job.exitCode,
-			stdout: job.stdout,
-			stderr: job.stderr,
-			durationMs: (job.endedAtMs ?? Date.now()) - job.createdAtMs,
-			outputTruncated: outputLength >= MAX_CAPTURE_CHARS
-		};
-	}
-	prune() {
-		if (this.jobs.size < 500) return;
-		const removable = [...this.jobs.values()].filter((job) => job.status !== "running").toSorted((a, b) => a.createdAtMs - b.createdAtMs).slice(0, Math.max(1, this.jobs.size - 400));
-		for (const job of removable) this.jobs.delete(job.id);
-	}
-};
 const ManagedJobSchema = Type.Union([
 	Type.Object({
 		action: Type.Literal("start"),
-		command: Type.String(),
+		command: Type.String({ minLength: 1 }),
 		cwd: Type.Optional(Type.String()),
 		maxRuntimeMs: Type.Optional(Type.Number())
 	}),
@@ -108,52 +14,86 @@ const ManagedJobSchema = Type.Union([
 		action: Type.Literal("status"),
 		jobId: Type.String()
 	}),
+	Type.Object({
+		action: Type.Literal("wait"),
+		jobId: Type.String(),
+		waitMs: Type.Optional(Type.Number({
+			minimum: 0,
+			maximum: 6e4
+		}))
+	}),
+	Type.Object({
+		action: Type.Literal("stdin"),
+		jobId: Type.String(),
+		chars: Type.String({ maxLength: 65536 }),
+		end: Type.Optional(Type.Boolean())
+	}),
 	Type.Object({ action: Type.Literal("list") }),
 	Type.Object({
 		action: Type.Literal("cancel"),
 		jobId: Type.String()
 	})
 ], { type: "object" });
-function registry() {
-	return resolveGlobalSingleton(MANAGED_JOB_REGISTRY_KEY, () => new ManagedJobRegistry());
-}
 function result(value) {
 	return {
 		content: [{
 			type: "text",
 			text: JSON.stringify(value, null, 2)
 		}],
-		details: {}
+		details: Array.isArray(value) ? { jobs: value } : value
 	};
 }
-function createManagedJobTool(workspace, getSessionKey, getSkillPassthroughEnvVarNames, prepareEnv) {
+function createManagedJobTool(workspace, getSessionKey, getSkillPassthroughEnvVarNames, prepareEnv, getCommandIsolation) {
 	return {
 		name: "managed_job",
 		label: "Managed Job",
-		description: "Start and manage commands expected to outlive a single tool call. Start returns a jobId immediately; use status/list/cancel to observe or stop it.",
+		description: "Manage shell jobs, including jobs yielded by exec_command. Start returns an id; wait returns on completion or after at most 60s; stdin writes pipe input (not a terminal); status/list/cancel inspect or stop jobs. Completed output and logs survive restart. Interrupted jobs require inspection before restart.",
 		parameters: ManagedJobSchema,
 		supportsParallel: true,
 		idempotent: false,
-		async execute(_toolCallId, input) {
-			const owner = getSessionKey() ?? "default";
-			if (input.action === "list") return result(registry().list(owner));
-			if (input.action === "status") return result(registry().get(owner, input.jobId) ?? { error: "Managed job not found" });
-			if (input.action === "cancel") return result(registry().cancel(owner, input.jobId) ?? { error: "Managed job not found" });
-			const command = String(input.command ?? "").trim();
-			if (!command) return result({ error: "command is required" });
+		async execute(_toolCallId, input, signal) {
+			const owner = getSessionKey() ?? workspace;
+			const registry = commandRegistry();
+			if (input.action === "list") return result(registry.list(owner));
+			if (input.action !== "start") {
+				if (input.action === "stdin" && !registry.write(owner, input.jobId, input.chars, input.end)) return result({
+					status: "failed",
+					error: "Job is unavailable or stdin is closed"
+				});
+				return result((input.action === "wait" ? await registry.wait(owner, input.jobId, input.waitMs, signal) : input.action === "cancel" ? await registry.cancel(owner, input.jobId) : registry.get(owner, input.jobId)) ?? {
+					status: "failed",
+					error: "Managed job not found"
+				});
+			}
+			const command = input.command.trim();
+			if (!command) return result({
+				status: "failed",
+				error: "command is required"
+			});
 			const policy = evaluateExecPolicy({
 				command,
-				cwd: input.cwd?.trim() ? resolve(workspace, input.cwd.trim()) : workspace,
+				cwd: resolve(workspace, input.cwd?.trim() || "."),
 				allowedEnvVars: getSkillPassthroughEnvVarNames?.() ?? []
 			});
-			if (!policy.allowed) return result({ error: `Sandbox blocked command: ${policy.reason}` });
-			const rawMax = Number(input.maxRuntimeMs ?? DEFAULT_MAX_RUNTIME_MS);
-			const maxRuntimeMs = Math.min(MAX_RUNTIME_MS, Math.max(1e3, Number.isFinite(rawMax) ? rawMax : DEFAULT_MAX_RUNTIME_MS));
-			const runtimeEnv = prepareEnv ? await prepareEnv(policy.sanitizedEnv, policy.effectiveCwd) : policy.sanitizedEnv;
-			return result(registry().start(owner, command, policy.effectiveCwd, {
-				...runtimeEnv,
-				COLUMNS: "200"
-			}, maxRuntimeMs));
+			if (!policy.allowed) return result({
+				status: "blocked",
+				error: `Command blocked: ${policy.reason}`
+			});
+			const env = prepareEnv ? await prepareEnv(policy.sanitizedEnv, policy.effectiveCwd) : policy.sanitizedEnv;
+			return result(await registry.start({
+				owner,
+				command,
+				cwd: policy.effectiveCwd,
+				env: {
+					...env,
+					COLUMNS: "200"
+				},
+				workspace,
+				isolation: getCommandIsolation?.(),
+				timeoutMs: commandTimeout(input.maxRuntimeMs, policy.timeoutMs),
+				snapshot: true,
+				signal
+			}));
 		}
 	};
 }

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

@@ -8,7 +8,15 @@ const MAX_FILE_SIZE = 10 * 1024 * 1024;
 const DEFAULT_MAX_LINES = 500;
 const ReadFileSchema = Type.Object({
 	path: Type.String({ description: "File path to read" }),
-	limit: Type.Optional(Type.Number({ description: "Max lines (default: 500)" }))
+	offset: Type.Optional(Type.Integer({
+		minimum: 1,
+		description: "First line to read, one-based (default: 1)"
+	})),
+	limit: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 2e3,
+		description: "Max lines (default: 500)"
+	}))
 });
 function createReadFileTool(workspace, options) {
 	return {
@@ -31,7 +39,7 @@ async function executeReadFile(workspace, profileMarkdownRoot, params) {
 				type: "text",
 				text: `🚫 ${safety.message}`
 			}],
-			details: {}
+			details: { status: "failed" }
 		};
 		let normalized = resolvePathUnderWorkspace(params.path, workspace);
 		let stats;
@@ -53,21 +61,30 @@ async function executeReadFile(workspace, profileMarkdownRoot, params) {
 				type: "text",
 				text: `🚫 File too large: ${formatSize(stats.size)}`
 			}],
-			details: {}
+			details: { status: "failed" }
 		};
-		const truncation = truncateHead(await readFile(normalized, "utf-8"), {
+		const content = await readFile(normalized, "utf-8");
+		const offset = Math.max(1, params.offset ?? 1);
+		const lines = content.split("\n");
+		if (offset > lines.length) throw new Error(`Offset ${offset} exceeds ${lines.length} lines`);
+		const truncation = truncateHead(lines.slice(offset - 1).join("\n"), {
 			maxLines: params.limit || DEFAULT_MAX_LINES,
 			maxBytes: DEFAULT_MAX_BYTES
 		});
 		let outputText = truncation.content;
 		if (truncation.truncated) if (truncation.firstLineExceedsLimit) outputText = `(Line exceeds ${formatSize(DEFAULT_MAX_BYTES)})`;
-		else outputText += `\n\n[${truncation.outputLines}/${truncation.totalLines} lines]`;
+		else outputText += `\n\n[Lines ${offset}-${offset + truncation.outputLines - 1} of ${lines.length}; continue with offset=${offset + truncation.outputLines}]`;
 		return {
 			content: [{
 				type: "text",
 				text: outputText
 			}],
-			details: {}
+			details: {
+				path: normalized,
+				offset,
+				totalLines: lines.length,
+				truncated: truncation.truncated
+			}
 		};
 	} catch (error) {
 		return {
@@ -75,7 +92,7 @@ async function executeReadFile(workspace, profileMarkdownRoot, params) {
 				type: "text",
 				text: `Error: ${error instanceof Error ? error.message : String(error)}`
 			}],
-			details: {}
+			details: { status: "failed" }
 		};
 	}
 }

package/dist/src/agent/tools/repository-search.d.ts

@@ -0,0 +1,5 @@
+/** Bounded native search; unavailable tools and invalid regexes are explicit failures. */
+export declare function repositorySearch(cwd: string, args: string[], signal?: AbortSignal): Promise<{
+    output: string;
+    truncated: boolean;
+}>;