@xopcai/xopc 0.0.244 → 0.0.245

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

@@ -1,9 +1,12 @@
+import { readWorkspaceRevision } from "../coding/workspace-revision.js";
 import { EXTERNAL_TOOL_NAMES } from "../external-tools/gateway-tools.js";
 import "../external-tools/index.js";
 import { createDelegateChildHandle } from "../child-agent-factory.js";
+import { runGit } from "../../execution-environments/git.js";
+import { LocalWorktreeManager } from "../../execution-environments/local-worktree-manager.js";
+import { SessionEnvironmentService } from "../../execution-environments/session-environment-service.js";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/delegate-tool.ts
-const DEFAULT_MAX_ITERATIONS = 30;
 const DEFAULT_DELEGATE_TOOLS = [
 	"exec_command",
 	"read_file",
@@ -36,160 +39,135 @@ const DELEGATE_BLOCKED_TOOLS = new Set([
 	EXTERNAL_TOOL_NAMES.execute,
 	"managed_job"
 ]);
+const INSPECTION_TOOLS = new Set([
+	"read_file",
+	"grep",
+	"find",
+	"list_dir",
+	"review_workspace"
+]);
 const DelegateTaskSchema = Type.Object({
-	goal: Type.String({ description: "Clear description of what the sub-agent should accomplish" }),
-	context: Type.Optional(Type.String({ description: "Additional context the sub-agent needs (file paths, constraints, etc.)" })),
-	toolset: Type.Optional(Type.Array(Type.String(), { description: "Tool names the sub-agent may use. Defaults to exec_command, read_file, write_file, apply_patch, grep, find, list_dir, web_search, web_fetch. Dangerous or interactive tools are always removed." })),
-	maxIterations: Type.Optional(Type.Number({
-		description: "Maximum tool executions in the sub-agent (default: 30)",
-		default: DEFAULT_MAX_ITERATIONS
+	goal: Type.String({ minLength: 1 }),
+	context: Type.Optional(Type.String()),
+	mode: Type.Optional(Type.Union([
+		Type.Literal("inspect"),
+		Type.Literal("review"),
+		Type.Literal("implement")
+	])),
+	toolset: Type.Optional(Type.Array(Type.String())),
+	maxIterations: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 60
 	}))
 });
+function delegateToolNames(mode, requested) {
+	const available = mode === "implement" ? new Set([
+		...DEFAULT_DELEGATE_TOOLS,
+		"review_workspace",
+		"language_diagnostics"
+	]) : INSPECTION_TOOLS;
+	return [...new Set(requested ?? [...available])].filter((name) => available.has(name) && !DELEGATE_BLOCKED_TOOLS.has(name));
+}
 function createDelegateTool(deps) {
 	return {
 		name: "delegate_task",
-		label: "🤖 Delegate",
-		description: "Spawn a sub-agent for an isolated subtask with a fresh conversation (no parent transcript).\n\nThe sub-agent returns a text summary only — tool traces stay out of your context.\n\nWHEN TO USE:\n- Independent work (research, multi-file exploration) where you only need the task\n- Avoiding context bloat from long intermediate tool output\n\nWHEN NOT TO USE:\n- Tasks that need this chat history or user clarification\n- Single trivial steps\n\nSub-agents cannot use clarify, messaging, memory tools, todo, or nested delegate_task.",
+		label: "Delegate task",
 		parameters: DelegateTaskSchema,
-		async execute(_toolCallId, params, signal) {
-			const p = params;
-			const maxIterations = p.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-			if (!Number.isFinite(maxIterations) || maxIterations < 1 || maxIterations > 200) return {
-				content: [{
-					type: "text",
-					text: "Invalid maxIterations (use 1–200)."
-				}],
-				details: {
-					summary: "",
-					iterations: 0
-				}
-			};
-			const requested = p.toolset ?? [...DEFAULT_DELEGATE_TOOLS];
-			const allowedNames = [...new Set(requested.map((t) => String(t).trim()).filter(Boolean).filter((t) => !DELEGATE_BLOCKED_TOOLS.has(t)))];
-			if (allowedNames.length === 0) return {
-				content: [{
-					type: "text",
-					text: "No allowed tools remain after applying the delegation blocklist. Expand `toolset` with safe tools."
-				}],
-				details: {
-					summary: "",
-					iterations: 0
-				}
-			};
-			let model;
-			try {
-				model = deps.getSubagentModel();
-			} catch (e) {
-				return {
-					content: [{
-						type: "text",
-						text: `delegate_task: ${e instanceof Error ? e.message : String(e)}`
-					}],
-					details: {
-						summary: "",
-						iterations: 0
-					}
-				};
+		description: "Run one bounded leaf worker with a fresh context. inspect/review receive only read tools; review reports findings against a workspace revision. implement requires an attached project and clean Git workspace, creates a separate managed worktree, and returns its patch for parent review. Child changes are never merged automatically. No nested delegation, external messages or background jobs. Up to 60 tool calls, 100k tokens and five minutes per child.",
+		supportsParallel: false,
+		idempotent: false,
+		async execute(_id, input, signal) {
+			signal?.throwIfAborted();
+			const mode = input.mode ?? "inspect";
+			const tools = delegateToolNames(mode, input.toolset);
+			if (!tools.length) throw new Error("No permitted tools in the requested toolset");
+			const parentSessionKey = deps.getCurrentContext?.()?.sessionKey;
+			const model = deps.getSubagentModel();
+			let workspace = deps.workspace, environmentId;
+			if (mode === "implement") {
+				if (!parentSessionKey) throw new Error("Implementation delegation requires a project session");
+				const parent = new SessionEnvironmentService().get(parentSessionKey);
+				if (!parent?.projectId) throw new Error("Attach this session to a project before implementation delegation");
+				const environment = await new LocalWorktreeManager().provisionManagedWorktree({
+					projectId: parent.projectId,
+					repositoryPath: workspace
+				});
+				workspace = environment.rootPath;
+				environmentId = environment.id;
 			}
-			const ctx = deps.getCurrentContext?.() ?? null;
-			const parentSessionKey = ctx?.sessionKey;
-			const childOptions = {
-				workspace: deps.workspace,
-				goal: p.goal,
-				context: p.context,
+			const revision = await readWorkspaceRevision(workspace);
+			const child = createDelegateChildHandle({
+				workspace,
+				goal: mode === "review" ? `Independently review the actual changes. Inspect review_workspace and relevant source/tests. Report actionable defects with file and line evidence, severity and a concrete failure example. If there are no findings, state the checks and remaining uncertainty. Do not treat the parent's completion claim as evidence.\n\n${input.goal}` : input.goal,
+				context: input.context,
 				requesterSessionKey: parentSessionKey,
-				allowedToolNames: allowedNames,
-				maxIterations,
+				allowedToolNames: tools,
+				maxIterations: input.maxIterations ?? 30,
 				model,
 				bus: deps.bus,
 				getConfig: deps.getConfig,
 				toolExecutorConfig: deps.toolExecutorConfig,
-				buildChildTools: deps.buildChildTools
-			};
-			let childSessionKey;
-			try {
-				if (deps.hookRunner && parentSessionKey) {
-					const { parseSessionKey, buildSessionKey } = await import("../../routing/session-key.js");
-					const parsed = parseSessionKey(parentSessionKey);
-					if (parsed) childSessionKey = buildSessionKey({
-						agentId: "subagent",
-						source: parsed.agentId,
-						accountId: parsed.accountId,
-						peerKind: parsed.peerKind,
-						peerId: parsed.peerId,
-						threadId: parsed.threadId,
-						scopeId: parsed.scopeId
-					});
-					if (childSessionKey) {
-						const r = await deps.hookRunner.runHooksWithResult("subagent_spawning", {
-							childSessionKey,
-							requester: {
-								channel: ctx?.channel,
-								accountId: ctx?.accountId,
-								to: ctx?.to,
-								threadId: ctx?.threadId
-							},
-							threadRequested: true,
-							agentId: "subagent",
-							label: "delegate_task"
-						}, {
-							sessionKey: parentSessionKey,
-							agentId: ctx?.channel
-						});
-						if (r && r.status === "error") return {
-							content: [{
-								type: "text",
-								text: `delegate_task: ${String(r.error || "subagent spawn blocked")}`
-							}],
-							details: {
-								summary: "",
-								iterations: 0
-							}
-						};
-					}
-				}
-			} catch {}
-			const child = createDelegateChildHandle(childOptions);
-			if (signal) signal.addEventListener("abort", () => child.abort(), { once: true });
+				buildChildTools: deps.buildChildTools,
+				verifyChanges: mode === "implement"
+			});
+			const abort = () => child.abort();
+			signal?.addEventListener("abort", abort, { once: true });
+			if (signal?.aborted) abort();
 			try {
-				const { summary, toolIterations } = await child.run();
-				try {
-					if (deps.hookRunner && childSessionKey) await deps.hookRunner.runHooks("subagent_ended", {
-						targetSessionKey: childSessionKey,
-						accountId: ctx?.accountId
-					}, { sessionKey: parentSessionKey });
-				} catch {}
+				const result = await child.run();
+				const currentRevision = await readWorkspaceRevision(workspace);
+				const stale = mode !== "implement" && (!revision || revision !== currentRevision);
+				const patch = mode === "implement" ? await runGit(workspace, [
+					"diff",
+					"--no-ext-diff",
+					"--no-textconv",
+					"--binary",
+					"HEAD"
+				]).catch(() => "") : void 0;
 				return {
 					content: [{
 						type: "text",
-						text: `Sub-agent completed:\n\n${summary}`
+						text: [
+							result.summary,
+							stale ? "Workspace changed or could not be fingerprinted; review findings require revalidation." : "",
+							environmentId ? `Changes retained in ${workspace} (environment ${environmentId}). Review and integrate from this workspace, then verify the parent workspace again.` : "",
+							patch ? `Patch preview:\n${patch.slice(0, 3e4)}` : ""
+						].filter(Boolean).join("\n\n")
 					}],
 					details: {
-						summary,
-						iterations: toolIterations
+						status: stale && result.status === "success" ? "partial" : result.status,
+						mode,
+						summary: result.summary,
+						iterations: result.toolIterations,
+						revision: currentRevision,
+						reviewedRevision: revision,
+						...result.verification ? { childVerification: result.verification } : {},
+						...environmentId ? {
+							environmentId,
+							workspace,
+							patchTruncated: (patch?.length ?? 0) > 3e4
+						} : {}
 					}
 				};
 			} catch (error) {
-				child.abort();
-				try {
-					if (deps.hookRunner && childSessionKey) await deps.hookRunner.runHooks("subagent_ended", {
-						targetSessionKey: childSessionKey,
-						accountId: ctx?.accountId
-					}, { sessionKey: parentSessionKey });
-				} catch {}
 				return {
 					content: [{
 						type: "text",
-						text: `Sub-agent failed: ${error instanceof Error ? error.message : String(error)}`
+						text: `Delegation failed: ${String(error)}${environmentId ? `; work retained in ${workspace} (${environmentId})` : ""}`
 					}],
 					details: {
-						summary: "",
-						iterations: 0
+						status: signal?.aborted ? "cancelled" : "failed",
+						...environmentId ? {
+							environmentId,
+							workspace
+						} : {}
 					}
 				};
+			} finally {
+				signal?.removeEventListener("abort", abort);
 			}
 		}
 	};
 }
 //#endregion
-export { DEFAULT_DELEGATE_TOOLS, DELEGATE_BLOCKED_TOOLS, createDelegateTool };
+export { DEFAULT_DELEGATE_TOOLS, DELEGATE_BLOCKED_TOOLS, INSPECTION_TOOLS, createDelegateTool, delegateToolNames };

package/dist/src/agent/tools/exec-command.d.ts

@@ -1,9 +1,14 @@
 import type { AgentTool } from '@earendil-works/pi-agent-core';
 import type { TurnOutcomeDeliverable } from '@xopcai/gateway-contract';
+import type { CommandIsolation } from '../commands/command-isolation.js';
+import { type CommandStatus } from '../commands/command-registry.js';
 export interface ExecCommandDetails {
     command: string;
     cwd: string;
-    status: 'success' | 'failed' | 'timed_out' | 'blocked';
+    status: CommandStatus | 'blocked';
+    id?: string;
+    logPath?: string;
+    logTruncated?: boolean;
     exitCode: number | null;
     durationMs: number;
     timedOut: boolean;
@@ -27,6 +32,8 @@ export interface ExecCommandUpdateDetails {
 }
 export interface CreateExecCommandToolOptions {
     /** Env var names allowed through prepareSafeToolEnv even if they match secret heuristics. */
+    getCommandIsolation?: () => CommandIsolation | undefined;
+    getSessionKey?: () => string | undefined;
     getSkillPassthroughEnvVarNames?: () => string[];
     prepareEnv?: (baseEnv: Record<string, string>, cwd: string) => Promise<Record<string, string>>;
 }

package/dist/src/agent/tools/exec-command.js

@@ -1,76 +1,32 @@
+import { commandRegistry, commandTimeout } from "../commands/command-registry.js";
 import { formatSize, truncateTail } from "./truncate.js";
 import { evaluateExecPolicy } from "../sandbox/exec-policy.js";
 import { publishArtifactPaths } from "./publish-artifacts.js";
 import { resolve } from "node:path";
-import { spawn } from "node:child_process";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/exec-command.ts
-const MAX_COMMAND_TIMEOUT_MS = 14400 * 1e3;
-const DEFAULT_TIMEOUT_MS = 1800 * 1e3;
 const DEFAULT_MAX_OUTPUT_CHARS = 5e4;
-const STREAM_DELTA_MAX_CHARS = 16e3;
 const ExecCommandSchema = Type.Object({
 	cmd: Type.String({ description: "Shell command to execute." }),
 	cwd: Type.Optional(Type.String({ description: "Working directory. Relative paths are resolved under the agent workspace." })),
 	timeoutMs: Type.Optional(Type.Number({ description: "Command timeout in milliseconds. Defaults to 1800000 (30m) and is capped at 14400000 (4h)." })),
 	maxOutputChars: Type.Optional(Type.Number({ description: "Maximum characters returned to the model. UI streaming still receives output deltas." })),
+	yieldTimeMs: Type.Optional(Type.Number({
+		minimum: 0,
+		maximum: 6e4,
+		description: "Return a running job after this wait; manage it with managed_job. Omit to wait for completion. Cannot be combined with outputs."
+	})),
 	outputs: Type.Optional(Type.Array(Type.String({ minLength: 1 }), {
 		maxItems: 50,
 		description: "Final user-facing files created by this command. Relative paths resolve under the effective cwd and are persisted as chat deliverables after a successful command."
 	}))
 });
-function clampTimeoutMs(raw) {
-	return Math.min(MAX_COMMAND_TIMEOUT_MS, Math.max(1e3, Math.floor(typeof raw === "number" && Number.isFinite(raw) ? raw : DEFAULT_TIMEOUT_MS)));
-}
 function clampMaxOutputChars(raw) {
 	return Math.max(1e3, Math.min(5e5, Math.floor(typeof raw === "number" && Number.isFinite(raw) ? raw : DEFAULT_MAX_OUTPUT_CHARS)));
 }
-function commandStatus(exitCode, timedOut) {
-	if (timedOut) return "timed_out";
-	if (exitCode === 0) return "success";
-	return "failed";
-}
-function appendBoundedTail(current, chunk, maxChars) {
-	const combined = current + chunk;
-	if (combined.length <= maxChars) return {
-		value: combined,
-		truncated: false
-	};
-	return {
-		value: combined.slice(-maxChars),
-		truncated: true
-	};
-}
-function terminateProcessTree(proc) {
-	if (!proc.pid) return;
-	if (process.platform === "win32") {
-		const killer = spawn("taskkill", [
-			"/pid",
-			String(proc.pid),
-			"/t",
-			"/f"
-		], {
-			stdio: "ignore",
-			windowsHide: true
-		});
-		killer.once("error", () => {
-			try {
-				proc.kill("SIGKILL");
-			} catch {}
-		});
-		killer.unref();
-		return;
-	}
-	try {
-		process.kill(-proc.pid, "SIGKILL");
-		return;
-	} catch {}
-	try {
-		proc.kill("SIGKILL");
-	} catch {}
-}
 function commandFailureHint(details) {
-	if (details.status === "success") return void 0;
+	if (details.status === "success" || details.status === "running") return void 0;
+	if (details.status === "cancelled") return "The command was cancelled. Inspect its partial output before deciding whether to restart.";
 	if (details.status === "timed_out") return "The command timed out. Re-run a narrower command, increase timeoutMs if the long run is expected, or inspect partial output before retrying.";
 	if (details.exitCode !== 0 && details.stderr.trim()) return "The command failed. Inspect stderr first, fix the underlying issue, then re-run the narrowest relevant verification command.";
 	if (details.exitCode !== 0 && details.stdout.trim()) return "The command failed. Inspect stdout for the failure location, then re-run the narrowest relevant verification command.";
@@ -80,7 +36,7 @@ function formatOutputForModel(details, maxOutputChars) {
 	let prefix = "";
 	if (details.timedOut) prefix += `Command timed out after ${Math.round(details.durationMs / 1e3)}s\n`;
 	if (details.exitCode !== 0 && details.exitCode != null) prefix += `Command exited with code ${details.exitCode}\n`;
-	if (details.captureTruncated) prefix += `Earlier command output was discarded after ${formatSize(details.totalOutputBytes)}; showing the latest captured output.\n`;
+	if (details.captureTruncated) prefix += `Earlier command output was discarded from model context after ${formatSize(details.totalOutputBytes)}; showing the latest captured output.\n`;
 	const truncation = truncateTail(details.aggregatedOutput, { maxBytes: Math.min(maxOutputChars, DEFAULT_MAX_OUTPUT_CHARS) });
 	let text = `${prefix}${truncation.content}`.trimEnd();
 	if (!text) text = "(no output)";
@@ -109,7 +65,8 @@ function createExecCommandTool(workspaceCwd, options) {
 		idempotent: false,
 		finalGuardRelevant: true,
 		async execute(toolCallId, params, signal, onUpdate) {
-			const command = (params.cmd ?? params.command ?? "").trim();
+			const command = (params.cmd ?? "").trim();
+			if (params.yieldTimeMs !== void 0 && params.outputs?.length) throw new Error("yieldTimeMs cannot be combined with outputs; publish files after the job completes.");
 			if (!command) return {
 				content: [{
 					type: "text",
@@ -163,127 +120,78 @@ function createExecCommandTool(workspaceCwd, options) {
 					}
 				};
 			}
-			const timeoutMs = Math.min(clampTimeoutMs(params.timeoutMs), policy.timeoutMs);
+			const timeoutMs = commandTimeout(params.timeoutMs, policy.timeoutMs);
 			const maxOutputChars = clampMaxOutputChars(params.maxOutputChars);
-			const startTime = Date.now();
 			const runtimeEnv = options?.prepareEnv ? await options.prepareEnv(policy.sanitizedEnv, policy.effectiveCwd) : policy.sanitizedEnv;
-			let stdout = "";
-			let stderr = "";
-			let aggregatedOutput = "";
-			let totalOutputBytes = 0;
-			let captureTruncated = false;
-			let timedOut = false;
-			let settled = false;
-			return new Promise((resolveTool) => {
-				const proc = spawn(command, [], {
-					shell: true,
-					detached: process.platform !== "win32",
-					cwd: policy.effectiveCwd,
-					env: {
-						...runtimeEnv,
-						COLUMNS: "200"
-					}
-				});
-				const publishDelta = (stream, raw) => {
-					const text = raw.toString();
-					if (!text) return;
-					totalOutputBytes += Buffer.byteLength(text);
-					if (stream === "stdout") {
-						const next = appendBoundedTail(stdout, text, maxOutputChars);
-						stdout = next.value;
-						captureTruncated ||= next.truncated;
-					} else {
-						const next = appendBoundedTail(stderr, text, maxOutputChars);
-						stderr = next.value;
-						captureTruncated ||= next.truncated;
-					}
-					const nextAggregate = appendBoundedTail(aggregatedOutput, text, maxOutputChars);
-					aggregatedOutput = nextAggregate.value;
-					captureTruncated ||= nextAggregate.truncated;
-					const delta = text.length > STREAM_DELTA_MAX_CHARS ? `${text.slice(0, STREAM_DELTA_MAX_CHARS)}\n[stream delta truncated]` : text;
-					onUpdate?.({
-						content: [],
-						details: {
-							kind: "command_output_delta",
-							command,
-							cwd: policy.effectiveCwd,
-							stream,
-							delta
-						}
-					});
-				};
-				const finish = async (exitCode, errorText) => {
-					if (settled) return;
-					settled = true;
-					clearTimeout(timeout);
-					signal?.removeEventListener("abort", abort);
-					if (errorText) {
-						totalOutputBytes += Buffer.byteLength(errorText);
-						const nextStderr = appendBoundedTail(stderr, errorText, maxOutputChars);
-						stderr = nextStderr.value;
-						const nextAggregate = appendBoundedTail(aggregatedOutput, errorText, maxOutputChars);
-						aggregatedOutput = nextAggregate.value;
-						captureTruncated ||= nextStderr.truncated || nextAggregate.truncated;
-					}
-					const durationMs = Date.now() - startTime;
-					const baseDetails = {
+			const owner = options?.getSessionKey?.() ?? workspaceCwd;
+			const registry = commandRegistry();
+			let commandResult = await registry.start({
+				workspace: workspaceCwd,
+				isolation: options?.getCommandIsolation?.(),
+				owner,
+				command,
+				cwd: policy.effectiveCwd,
+				env: {
+					...runtimeEnv,
+					COLUMNS: "200"
+				},
+				timeoutMs,
+				maxOutputChars,
+				signal,
+				snapshot: true,
+				onOutput: (stream, delta) => onUpdate?.({
+					content: [],
+					details: {
+						kind: "command_output_delta",
 						command,
 						cwd: policy.effectiveCwd,
-						status: commandStatus(exitCode, timedOut),
-						exitCode,
-						durationMs,
-						timedOut,
-						truncated: false,
-						outputBytes: Buffer.byteLength(aggregatedOutput),
-						totalOutputBytes,
-						captureTruncated,
-						stdout,
-						stderr,
-						aggregatedOutput
-					};
-					baseDetails.failureHint = commandFailureHint(baseDetails);
-					const formatted = formatOutputForModel(baseDetails, maxOutputChars);
-					const details = {
-						...baseDetails,
-						truncated: formatted.truncated,
-						truncatedBy: formatted.truncatedBy,
-						outputBytes: formatted.outputBytes
-					};
-					let resultText = formatted.text;
-					if (details.status === "success" && params.outputs?.length) {
-						details.artifacts = await publishArtifactPaths({
-							paths: params.outputs,
-							baseDir: policy.effectiveCwd,
-							workspaceRoot: workspaceCwd,
-							toolCallId
-						});
-						const published = details.artifacts.filter((item) => item.availability === "available").length;
-						const failed = details.artifacts.length - published;
-						resultText += `\n\nArtifacts: ${published} published${failed > 0 ? `, ${failed} failed` : ""}.`;
+						stream,
+						delta
 					}
-					resolveTool({
-						content: [{
-							type: "text",
-							text: resultText
-						}],
-						details
-					});
-				};
-				const abort = () => {
-					timedOut = true;
-					terminateProcessTree(proc);
-				};
-				const timeout = setTimeout(() => {
-					timedOut = true;
-					terminateProcessTree(proc);
-				}, timeoutMs);
-				if (signal?.aborted) abort();
-				else signal?.addEventListener("abort", abort, { once: true });
-				proc.stdout?.on("data", (data) => publishDelta("stdout", data));
-				proc.stderr?.on("data", (data) => publishDelta("stderr", data));
-				proc.on("error", (err) => void finish(null, `Error: ${err.message}`));
-				proc.on("close", (code) => void finish(code));
+				})
 			});
+			try {
+				do
+					commandResult = await registry.wait(owner, commandResult.id, params.yieldTimeMs ?? 6e4, signal);
+				while (params.yieldTimeMs === void 0 && commandResult.status === "running");
+			} catch (error) {
+				if (!signal?.aborted) throw error;
+				commandResult = await registry.cancel(owner, commandResult.id);
+			}
+			const baseDetails = {
+				...commandResult,
+				truncated: false,
+				outputBytes: Buffer.byteLength(commandResult.aggregatedOutput)
+			};
+			baseDetails.failureHint = commandFailureHint(baseDetails);
+			const formatted = formatOutputForModel(baseDetails, maxOutputChars);
+			const details = {
+				...baseDetails,
+				truncated: formatted.truncated,
+				truncatedBy: formatted.truncatedBy,
+				outputBytes: formatted.outputBytes
+			};
+			let resultText = formatted.text;
+			if (details.status === "running") resultText += `\n\nCommand is running (jobId: ${details.id}). Use managed_job wait/status/stdin/cancel.`;
+			if (details.logPath) resultText += `\n\nLog: ${details.logPath}${details.logTruncated ? " (truncated)" : ""}`;
+			if (details.status === "success" && params.outputs?.length) {
+				details.artifacts = await publishArtifactPaths({
+					paths: params.outputs,
+					baseDir: policy.effectiveCwd,
+					workspaceRoot: workspaceCwd,
+					toolCallId
+				});
+				const published = details.artifacts.filter((item) => item.availability === "available").length;
+				const failed = details.artifacts.length - published;
+				resultText += `\n\nArtifacts: ${published} published${failed > 0 ? `, ${failed} failed` : ""}.`;
+			}
+			return {
+				content: [{
+					type: "text",
+					text: resultText
+				}],
+				details
+			};
 		}
 	};
 }

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

@@ -1,5 +1,6 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { commandTimeout } from "../commands/command-registry.js";
 import { DEFAULT_TOOL_EXECUTION_TIMEOUT_MS, TimeoutError, executeWithTimeout } from "../lifecycle/timeout-wrapper.js";
 import { withRetry } from "../../infra/retry.js";
 import { ToolConcurrencyController, resolveToolLockMode } from "./concurrency.js";
@@ -41,8 +42,14 @@ async function executeToolWithProtection(tool, toolCallId, params, signal, onUpd
 		const onParentAbort = () => controller.abort(signal?.reason);
 		if (signal?.aborted) onParentAbort();
 		else signal?.addEventListener("abort", onParentAbort, { once: true });
-		const execute = () => tool.execute(toolCallId, params, controller.signal, onUpdate);
-		return (fullConfig.enableTimeout ? executeWithTimeout(execute, {
+		const policyDeadline = fullConfig.resolveTimeoutMs?.(toolName);
+		const commandDeadlineField = toolName === "exec_command" ? "timeoutMs" : toolName === "managed_job" && params.action === "start" ? "maxRuntimeMs" : void 0;
+		const executionParams = commandDeadlineField && policyDeadline ? {
+			...params,
+			[commandDeadlineField]: Math.min(commandTimeout(params[commandDeadlineField]), policyDeadline)
+		} : params;
+		const execute = () => tool.execute(toolCallId, executionParams, controller.signal, onUpdate);
+		return (fullConfig.enableTimeout && toolName !== "exec_command" ? executeWithTimeout(execute, {
 			toolName,
 			timeoutMs: resolveTimeoutMs(tool, fullConfig),
 			description: `Executing ${toolName}`,