@xopcai/xopc 0.0.244 → 0.0.245

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;
+}>;

package/dist/src/agent/tools/repository-search.js

@@ -0,0 +1,56 @@
+import { resolveRipgrepBinary } from "../../infra/ripgrep.js";
+import { spawn } from "node:child_process";
+//#region src/agent/tools/repository-search.ts
+/** Bounded native search; unavailable tools and invalid regexes are explicit failures. */
+async function repositorySearch(cwd, args, signal) {
+	signal?.throwIfAborted();
+	const binary = await resolveRipgrepBinary();
+	return new Promise((resolve, reject) => {
+		const child = spawn(binary, [
+			"--no-config",
+			"--hidden",
+			"--glob",
+			"!.git",
+			"--glob",
+			"!node_modules",
+			...args
+		], { cwd });
+		const chunks = [];
+		let bytes = 0, truncated = false, stderr = "";
+		const timer = setTimeout(() => child.kill("SIGKILL"), 1e4);
+		const abort = () => child.kill("SIGKILL");
+		signal?.addEventListener("abort", abort, { once: true });
+		child.stdout.on("data", (chunk) => {
+			const remaining = Math.max(0, 5e4 - bytes);
+			chunks.push(chunk.subarray(0, remaining));
+			bytes += chunk.length;
+			if (bytes > 5e4) {
+				truncated = true;
+				child.kill("SIGKILL");
+			}
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr = (stderr + String(chunk)).slice(-4e3);
+		});
+		child.on("error", reject);
+		child.on("close", (code) => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", abort);
+			if (signal?.aborted) {
+				reject(signal.reason ?? /* @__PURE__ */ new Error("Search aborted"));
+				return;
+			}
+			if (code !== 0 && code !== 1 && !truncated) {
+				reject(new Error(stderr || "Search did not complete; check ripgrep installation or narrow the search."));
+				return;
+			}
+			resolve({
+				output: Buffer.concat(chunks).toString("utf8"),
+				truncated
+			});
+		});
+		if (signal?.aborted) abort();
+	});
+}
+//#endregion
+export { repositorySearch };

package/dist/src/agent/tools/review-workspace.d.ts

@@ -0,0 +1,2 @@
+import type { AgentTool } from '@earendil-works/pi-agent-core';
+export declare function createReviewWorkspaceTool(workspace: string): AgentTool;

package/dist/src/agent/tools/review-workspace.js

@@ -0,0 +1,103 @@
+import { readWorkspaceRevision } from "../coding/workspace-revision.js";
+import { resolve } from "node:path";
+import { execFile } from "node:child_process";
+import { lstat, readFile, readlink, realpath } from "node:fs/promises";
+import { promisify } from "node:util";
+import { Type } from "@sinclair/typebox";
+//#region src/agent/tools/review-workspace.ts
+const exec$1 = promisify(execFile);
+function createReviewWorkspaceTool(workspace) {
+	return {
+		name: "review_workspace",
+		label: "Review workspace",
+		parameters: Type.Object({}),
+		description: "Inspect the complete Git workspace diff against HEAD, including untracked text files. Includes pre-existing changes. A truncated view is explicitly incomplete; inspect large files separately. Does not modify Git state.",
+		supportsParallel: true,
+		idempotent: true,
+		async execute(_id, _args, signal) {
+			let cwd = workspace;
+			const git = async (args) => (await exec$1("git", [
+				"-c",
+				"core.fsmonitor=false",
+				...args
+			], {
+				cwd,
+				signal,
+				timeout: 1e4,
+				maxBuffer: 8 * 1024 * 1024
+			})).stdout;
+			cwd = await realpath((await git(["rev-parse", "--show-toplevel"])).trim());
+			const startRevision = await readWorkspaceRevision(cwd);
+			const head = await git([
+				"rev-parse",
+				"--verify",
+				"HEAD"
+			]).catch(() => "");
+			const [diff, names] = await Promise.all([head ? git([
+				"diff",
+				"--no-ext-diff",
+				"--no-textconv",
+				"--binary",
+				"HEAD",
+				"--"
+			]) : Promise.all([git([
+				"diff",
+				"--no-ext-diff",
+				"--no-textconv",
+				"--binary",
+				"--cached",
+				"--"
+			]), git([
+				"diff",
+				"--no-ext-diff",
+				"--no-textconv",
+				"--binary",
+				"--"
+			])]).then((parts) => parts.join("\n")), git([
+				"ls-files",
+				"--others",
+				"--exclude-standard",
+				"-z"
+			])]);
+			let text = diff.slice(0, 2e5), complete = diff.length <= 2e5;
+			for (const path of names.split("\0").filter(Boolean)) {
+				signal?.throwIfAborted();
+				if (text.length >= 2e5) {
+					complete = false;
+					break;
+				}
+				const file = resolve(cwd, path), info = await lstat(file);
+				text += `\nUntracked file: ${path}\n`;
+				if (info.isSymbolicLink()) text += `Symlink to ${await readlink(file)}\n`;
+				else if (info.isFile() && info.size <= 5e4) {
+					const content = await readFile(file);
+					if (content.includes(0)) {
+						text += "(binary file; inspect separately)\n";
+						complete = false;
+					} else text += content.toString("utf8");
+				} else {
+					text += "(large file; inspect separately)\n";
+					complete = false;
+				}
+			}
+			complete &&= text.length <= 2e5;
+			const endRevision = await readWorkspaceRevision(cwd);
+			return {
+				content: [{
+					type: "text",
+					text: `Workspace changes against HEAD (including pre-existing changes):\n${text.slice(0, 2e5) || "(clean)"}${complete ? "" : "\n[Incomplete view]"}`
+				}],
+				details: {
+					status: "success",
+					command: "review_workspace",
+					complete,
+					exitCode: 0,
+					startRevision,
+					endRevision
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { createReviewWorkspaceTool };

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

@@ -33,7 +33,7 @@ function createWriteFileTool(workspace, options) {
 						type: "text",
 						text: `🚫 ${safety.message}`
 					}],
-					details: {}
+					details: { status: "failed" }
 				};
 				const writesProfileFile = Boolean(options?.profileMarkdownRoot && isBareProfileMarkdownFileName(p.path));
 				const workspaceRoot = writesProfileFile ? options.profileMarkdownRoot : workspace;
@@ -47,7 +47,7 @@ function createWriteFileTool(workspace, options) {
 						type: "text",
 						text: `🚫 Sandbox: ${pathPolicy.reason}`
 					}],
-					details: {}
+					details: { status: "failed" }
 				};
 				const contentBytes = Buffer.byteLength(p.content, "utf-8");
 				if (contentBytes > MAX_FILE_SIZE) return {
@@ -55,7 +55,7 @@ function createWriteFileTool(workspace, options) {
 						type: "text",
 						text: `🚫 File too large: ${contentBytes} bytes`
 					}],
-					details: {}
+					details: { status: "failed" }
 				};
 				const target = writesProfileFile ? resolveProfileMarkdownPathIfBareName(p.path, options.profileMarkdownRoot) : resolvePathUnderWorkspace(p.path, workspace);
 				await mkdir(dirname(target), { recursive: true });
@@ -88,7 +88,7 @@ function createWriteFileTool(workspace, options) {
 						type: "text",
 						text: `Error: ${error instanceof Error ? error.message : String(error)}`
 					}],
-					details: {}
+					details: { status: "failed" }
 				};
 			}
 		}

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

@@ -1,7 +1,7 @@
-import { extractToolCallsFromAssistant, extractToolResultId, sanitizeToolCallId, sanitizeToolCallIdsForCloudCodeAssist } from "./tool-call-id.js";
-import { makeMissingToolResult, repairToolUseResultPairing, sanitizeToolCallInputs, sanitizeToolUseResultPairing, stripToolResultDetails } from "./session-transcript-repair.js";
 import { resolveTranscriptPolicy } from "./transcript-policy.js";
 import { dropThinkingBlocks } from "./thinking.js";
+import { extractToolCallsFromAssistant, extractToolResultId, sanitizeToolCallId, sanitizeToolCallIdsForCloudCodeAssist } from "./tool-call-id.js";
+import { makeMissingToolResult, repairToolUseResultPairing, sanitizeToolCallInputs, sanitizeToolUseResultPairing, stripToolResultDetails } from "./session-transcript-repair.js";
 import { applySessionTranscriptHygiene, applySessionTranscriptHygieneForPersistence, applySessionTranscriptHygieneWithPolicy, resolvePolicyForModel, tryApplySessionTranscriptHygiene, tryApplySessionTranscriptHygieneForPersistence } from "./transcript-hygiene.js";
 import { stripToolMessages } from "./strip-tool-messages.js";
 export { applySessionTranscriptHygiene, applySessionTranscriptHygieneForPersistence, applySessionTranscriptHygieneWithPolicy, dropThinkingBlocks, extractToolCallsFromAssistant, extractToolResultId, makeMissingToolResult, repairToolUseResultPairing, resolvePolicyForModel, resolveTranscriptPolicy, sanitizeToolCallId, sanitizeToolCallIdsForCloudCodeAssist, sanitizeToolCallInputs, sanitizeToolUseResultPairing, stripToolMessages, stripToolResultDetails, tryApplySessionTranscriptHygiene, tryApplySessionTranscriptHygieneForPersistence };

package/dist/src/agent/transcript/transcript-hygiene.js

@@ -1,9 +1,9 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { sanitizeToolCallIdsForCloudCodeAssist } from "./tool-call-id.js";
-import { sanitizeToolCallInputs, sanitizeToolUseResultPairing, stripToolResultDetails } from "./session-transcript-repair.js";
 import { resolveTranscriptPolicy } from "./transcript-policy.js";
 import { dropThinkingBlocks } from "./thinking.js";
+import { sanitizeToolCallIdsForCloudCodeAssist } from "./tool-call-id.js";
+import { sanitizeToolCallInputs, sanitizeToolUseResultPairing, stripToolResultDetails } from "./session-transcript-repair.js";
 //#region src/agent/transcript/transcript-hygiene.ts
 init_logger();
 const log = createLogger("transcript-hygiene");

package/dist/src/agent/workflow/subagent-runner.d.ts

@@ -10,8 +10,6 @@
  *   without ever calling `structured_output`, we treat it as failure (`null`).
  * - Failures and aborts resolve to `null`. The workflow runtime continues — this
  *   matches the pi-dynamic-workflows contract and keeps fan-out pipelines robust.
- * - We do NOT mutate `createDelegateChildHandle` — we just leverage its
- *   `buildChildTools` injection point.
  */
 import type { AgentTool } from '@earendil-works/pi-agent-core';
 import type { Api, Model } from '@earendil-works/pi-ai';

package/dist/src/agent/workflow/subagent-runner.js

@@ -1,8 +1,8 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { createSqliteTranscriptRuntime } from "../embedded/transcript-runtime.js";
 import { createDelegateChildHandle } from "../child-agent-factory.js";
 import { DEFAULT_DELEGATE_TOOLS, DELEGATE_BLOCKED_TOOLS } from "../tools/delegate-tool.js";
-import { emitSessionTranscriptUpdate } from "../../session/transcript-events.js";
 import { STRUCTURED_OUTPUT_TOOL_NAME, createStructuredOutputTool } from "./structured-output-tool.js";
 //#region src/agent/workflow/subagent-runner.ts
 init_logger();
@@ -27,24 +27,6 @@ var DelegateSubagentRunner = class {
 		}
 		const fullPrompt = buildPrompt(prompt, opts, wantStructured);
 		const streamMode = resolveSubagentStreamMode(this.deps.getConfig);
-		let transcriptPersistQueue = Promise.resolve();
-		const persistTranscriptSnapshot = opts.sessionKey && this.deps.sessionStore ? (messages) => {
-			const store = this.deps.sessionStore;
-			const key = opts.sessionKey;
-			if (!store || !key) return;
-			const snapshot = cloneAgentMessages(messages);
-			transcriptPersistQueue = transcriptPersistQueue.then(async () => {
-				await store.saveMessages(key, snapshot);
-				emitSessionTranscriptUpdate({ sessionKey: key });
-			}).catch((err) => {
-				const msg = err instanceof Error ? err.message : String(err);
-				log.warn({
-					err,
-					sessionKey: key,
-					errorMessage: msg
-				}, `Failed to persist workflow subagent transcript snapshot: ${msg}`);
-			});
-		} : void 0;
 		const childOptions = {
 			workspace: this.deps.workspace,
 			goal: fullPrompt,
@@ -72,20 +54,22 @@ var DelegateSubagentRunner = class {
 				onProgress: (event) => {
 					opts.onProgress?.(mapChildProgressEvent(event));
 				}
-			} : void 0,
-			onTranscriptSnapshot: persistTranscriptSnapshot
+			} : void 0
 		};
-		if (opts.sessionKey && opts.sessionMetadata && this.deps.sessionStore) await this.preparePersistentSubagentSession(opts.sessionKey, opts.sessionMetadata);
+		if (opts.sessionKey && opts.sessionMetadata && this.deps.sessionStore) {
+			await this.preparePersistentSubagentSession(opts.sessionKey, opts.sessionMetadata);
+			childOptions.sessionKey = opts.sessionKey;
+			childOptions.transcriptRuntime = await createSqliteTranscriptRuntime({
+				sessionKey: opts.sessionKey,
+				sessionStore: this.deps.sessionStore
+			});
+		}
 		const handle = createDelegateChildHandle(childOptions);
 		const onAbort = () => handle.abort();
 		opts.signal?.addEventListener("abort", onAbort, { once: true });
 		try {
-			const { summary, messages } = await handle.run();
-			await transcriptPersistQueue;
-			if (opts.sessionKey && this.deps.sessionStore) {
-				await this.deps.sessionStore.saveMessages(opts.sessionKey, messages);
-				emitSessionTranscriptUpdate({ sessionKey: opts.sessionKey });
-			}
+			const { summary, status } = await handle.run();
+			if (status !== "success") return null;
 			if (opts.signal?.aborted) return null;
 			if (wantStructured) {
 				if (!capture.called) {
@@ -144,9 +128,6 @@ var DelegateSubagentRunner = class {
 		});
 	}
 };
-function cloneAgentMessages(messages) {
-	return messages.map((message) => structuredClone(message));
-}
 function resolveAllowedToolNames(requested, wantStructured) {
 	const filtered = (requested && requested.length > 0 ? requested : [...DEFAULT_DELEGATE_TOOLS]).map((s) => String(s).trim()).filter((s) => s.length > 0).filter((s) => !DELEGATE_BLOCKED_TOOLS.has(s));
 	if (wantStructured && !filtered.includes("structured_output")) filtered.push(STRUCTURED_OUTPUT_TOOL_NAME);