@dimi-agent/cli 0.6.7 → 0.6.8

package/dist/main.mjs

@@ -34346,7 +34346,7 @@ var init_telemetry$2 = __esmMin((() => {
 	};
 	ITelemetryService = createDecorator("agentTelemetryService");
 }));
-var init_events$7 = __esmMin((() => {}));
+var init_events$8 = __esmMin((() => {}));
 //#endregion
 //#region ../../packages/agent-core-v2/src/app/telemetry/telemetryService.ts
 var TelemetryService, TelemetryContextView;
@@ -99307,6 +99307,11 @@ function loadNative() {
 function coldRebuild(recordsJson) {
 	return loadNative().coldRebuild(recordsJson);
 }
+/** Release an agent's scoped subagent registry (tasks + steering queues).
+*  Call when the owning agent scope is disposed. */
+function dropTaskRegistry(registryId) {
+	loadNative().dropTaskRegistry(registryId);
+}
 /** `RustHostProcess.spawn` — the M2 exec spawn socket. */
 async function rustHostProcessSpawn(command, args, options) {
 	return loadNative().RustHostProcess.spawn(command, [...args], options);
@@ -99337,7 +99342,7 @@ function rustHostEnvironmentProbe() {
 function rustTerminalSpawn(options) {
 	return loadNative().RustTerminal.spawn(options);
 }
-var nodeRequire$4, binding, PLATFORM_SUBPACKAGE, RustAgentTranscript, RustFileSystem;
+var nodeRequire$4, binding, PLATFORM_SUBPACKAGE, RustAgentTranscript, RustFileSystem, RustTurnSession;
 var init_src$7 = __esmMin((() => {
 	nodeRequire$4 = createRequire(import.meta.url);
 	PLATFORM_SUBPACKAGE = `@dimi-agent/dimi-native-${process.platform}-${process.arch}`;
@@ -99397,6 +99402,89 @@ var init_src$7 = __esmMin((() => {
 			return loadNative().RustFileSystem.realpath(path);
 		}
 	};
+	RustTurnSession = class {
+		#inner;
+		constructor(inputJson, policyJson, scriptedSegmentsJson, registryId) {
+			const NativeClass = loadNative().RustTurnSession;
+			this.#inner = new NativeClass(inputJson, policyJson, scriptedSegmentsJson ?? null, registryId);
+		}
+		/** Release the agent-scoped subagent registry (tasks + steering queues).
+		*  Call when the owning agent scope is disposed. */
+		static dropTaskRegistry(registryId) {
+			dropTaskRegistry(registryId);
+		}
+		/** Register the per-event callback: every engine event emitted by `run()` /
+		*  `resume()` is pushed through it as a JSON string, in emission order, as
+		*  it happens. Register before the first `run()`. */
+		setOnEvent(callback) {
+			this.#inner.setOnEvent(callback);
+		}
+		async run() {
+			return this.#inner.run();
+		}
+		async resume(decisionJson) {
+			return this.#inner.resume(decisionJson);
+		}
+		/** Record a session-scope approval (P1-6): the engine's policy is re-read
+		*  on every run/resume, so a pattern approved for the session mid-turn is
+		*  honored by the SAME turn's remaining batch. */
+		addSessionApproval(pattern) {
+			this.#inner.addSessionApproval(pattern);
+		}
+		/** Register the native-tool PreToolUse gate (A2 review): every registry
+		*  tool call is announced through `callback` (`{requestId, toolName,
+		*  arguments}` JSON); answer with `completeToolGate(requestId,
+		*  {decision:'allow'|'block', reason?})`. A block short-circuits the call. */
+		setToolGate(callback) {
+			this.#inner.setToolGate(callback);
+		}
+		/** Answer a pending gate request (see `setToolGate`). */
+		completeToolGate(requestId, verdictJson) {
+			this.#inner.completeToolGate(requestId, verdictJson);
+		}
+		/** Register a TS-side tool; `completeToolCall` finishes each call. The
+		*  definition (description + JSON parameters schema) is advertised to the
+		*  model from the next request on. */
+		registerExternalTool(name, description, parametersJson, callback) {
+			this.#inner.registerExternalTool(name, description, parametersJson, callback);
+		}
+		/** Advertise the LLM-facing definition (description + JSON parameters
+		*  schema) of a Rust-native tool (Agent / AgentOutput / WaitFor) registered
+		*  executor-first at construction. The executor stays the same; only the
+		*  def is updated, so the engine's request `tools` field carries it from
+		*  the next request on. */
+		registerNativeToolDef(name, description, parametersJson) {
+			this.#inner.registerNativeToolDef(name, description, parametersJson);
+		}
+		/** Steer the running turn (drained into its next LLM request). Returns
+		*  `false` when the turn has already finished — the caller must start a
+		*  new turn instead (the steer is never dropped). */
+		steer(message) {
+			return this.#inner.steer(message);
+		}
+		/** Steer a background subagent spawned by the `Agent` tool. */
+		steerSubagent(agentId, message) {
+			this.#inner.steerSubagent(agentId, message);
+		}
+		/** Cancel the running turn (engine stops at the next boundary). */
+		cancel() {
+			this.#inner.cancel();
+		}
+		/** Cancel a background task (TaskStop parity): the engine kills the
+		*  subagent nested turn / backgrounded bash command and settles "killed",
+		*  carrying the stop reason on the wire. */
+		cancelTask(taskId, reason) {
+			this.#inner.cancelTask(taskId, reason);
+		}
+		/** Close the session (agent dispose): task events stop forwarding, the
+		*  in-flight turn is cancelled. Background workers observe the close. */
+		close() {
+			this.#inner.close();
+		}
+		completeToolCall(requestId, resultJson) {
+			this.#inner.completeToolCall(requestId, resultJson);
+		}
+	};
 }));
 //#endregion
 //#region ../../packages/agent-core-v2/src/os/backends/rust-local/rustHostEnvironmentService.ts
@@ -121936,7 +122024,7 @@ function emptyOutputSnapshot() {
 function agentTaskNotificationChildren(output) {
 	if (output.fullOutputAvailable && output.outputPath !== void 0) return [renderOutputFileBlock(output.outputPath, output.outputSizeBytes)];
 	if (output.preview.length === 0) return void 0;
-	return [renderOutputPreviewBlock(output)];
+	return [renderOutputPreviewBlock$1(output)];
 }
 function renderOutputFileBlock(outputPath, outputSizeBytes) {
 	return [
@@ -121945,7 +122033,7 @@ function renderOutputFileBlock(outputPath, outputSizeBytes) {
 		"</output-file>"
 	].join("\n");
 }
-function renderOutputPreviewBlock(output) {
+function renderOutputPreviewBlock$1(output) {
 	return [
 		`<output-preview bytes="${String(output.previewBytes)}" total_bytes="${String(output.outputSizeBytes)}" truncated="${String(output.truncated)}">`,
 		output.truncated ? `Showing the last ${String(output.previewBytes)} bytes. No persisted full output is available.` : "No persisted full output is available; this preview is the currently buffered task output.",
@@ -122027,7 +122115,7 @@ function errorMessage$7(error) {
 	if (error instanceof Error) return error.message;
 	return String(error);
 }
-var TaskNotificationDeliveryModel, MAX_OUTPUT_BYTES, TERMINAL_OUTPUT_TAIL_BYTES, MAX_TASK_OUTPUT_BYTES, SIGTERM_GRACE_MS, TASK_ID_ALPHABET, SESSION_CLOSED_REASON, NOTIFICATION_FALLBACK_PREVIEW_BYTES, ACTIVE_BACKGROUND_TASK_INJECTION_VARIANT, ACTIVE_BACKGROUND_TASK_GUIDANCE, TaskNotificationStepRequest, taskGhostsKey, taskScheduledNotificationKeysKey, taskDeliveredNotificationKeysKey, taskActiveTaskReminderPendingKey, AgentTaskService;
+var TaskNotificationDeliveryModel, MAX_OUTPUT_BYTES, TERMINAL_OUTPUT_TAIL_BYTES, MAX_TASK_OUTPUT_BYTES, TASK_ID_ALPHABET, SESSION_CLOSED_REASON, NOTIFICATION_FALLBACK_PREVIEW_BYTES, ACTIVE_BACKGROUND_TASK_INJECTION_VARIANT, ACTIVE_BACKGROUND_TASK_GUIDANCE, TaskNotificationStepRequest, taskGhostsKey, taskScheduledNotificationKeysKey, taskDeliveredNotificationKeysKey, taskActiveTaskReminderPendingKey, AgentTaskService;
 var init_taskService = __esmMin((() => {
 	init_dist$5();
 	init_scope();
@@ -122075,7 +122163,6 @@ var init_taskService = __esmMin((() => {
 	MAX_OUTPUT_BYTES = 1024 * 1024;
 	TERMINAL_OUTPUT_TAIL_BYTES = 4 * 1024;
 	MAX_TASK_OUTPUT_BYTES = 16 * 1024 * 1024;
-	SIGTERM_GRACE_MS = 5e3;
 	TASK_ID_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
 	SESSION_CLOSED_REASON = "Session closed";
 	NOTIFICATION_FALLBACK_PREVIEW_BYTES = 3e3;
@@ -122274,7 +122361,7 @@ var init_taskService = __esmMin((() => {
 			};
 			this.assertCanRegister(detached);
 			const entry = {
-				taskId: generateTaskId(task.idPrefix),
+				taskId: options.taskId ?? generateTaskId(task.idPrefix),
 				task,
 				handle: void 0,
 				outputChunks: [],
@@ -122584,7 +122671,7 @@ var init_taskService = __esmMin((() => {
 			entry.stopReason = options.stopReason;
 			if (entry.handle) entry.handle.cancel();
 			else entry.abortController.abort(options.abortReason);
-			const graceMs = resolveAgentTaskConfig(this.config)?.killGracePeriodMs ?? SIGTERM_GRACE_MS;
+			const graceMs = resolveAgentTaskConfig(this.config)?.killGracePeriodMs ?? 5e3;
 			let graceTimer;
 			const graceful = await Promise.race([entry.lifecyclePromise.then(() => true, () => true), new Promise((resolve) => {
 				graceTimer = setTimeout(() => {
@@ -123262,6 +123349,258 @@ var init_waitForTool = __esmMin((() => {
 	});
 }));
 //#endregion
+//#region ../../packages/agent-core-v2/src/agent/tools/agent-output/agent-output.ts
+var AgentOutputInputSchema, AGENT_NOT_FOUND_MESSAGE, IAgentOutputTool;
+var init_agent_output$1 = __esmMin((() => {
+	init_zod$1();
+	init_instantiation();
+	AgentOutputInputSchema = object({
+		agent_id: string$2().describe("Agent ID of the subagent to inspect (returned by the Agent tool)."),
+		tail_lines: number$2().int().min(1).max(500).optional().describe("How many of the most recent renderable records to show. Defaults to 60. The output is a transcript-style view of the subagent's latest activity.")
+	});
+	AGENT_NOT_FOUND_MESSAGE = "Agent instance not found.";
+	IAgentOutputTool = createDecorator("agentOutputTool");
+}));
+//#endregion
+//#region ../../packages/agent-core-v2/src/agent/contextSize/contextSize.ts
+var IAgentContextSizeService;
+var init_contextSize = __esmMin((() => {
+	init_instantiation();
+	IAgentContextSizeService = createDecorator("agentContextSizeService");
+}));
+//#endregion
+//#region ../../packages/agent-core-v2/src/agent/tools/agent-output/agent-output.md?raw
+var agent_output_default;
+var init_agent_output = __esmMin((() => {
+	agent_output_default = "Read the recent rendered output of a subagent — the same transcript-style view a human sees in the TUI: its latest assistant text, thinking, tool calls, and task progress, in time order.\n\nSubagents run fully asynchronously. Use this tool to check on one:\n\n- While you still have other work, do that work instead — the subagent's result (and completion notification) arrives on its own.\n- When you have nothing else to do and want to see what the subagent is doing, call this tool with the `agent_id` returned by the Agent tool.\n- If it is still working and you want to park until it progresses, call `WaitFor` with a reasonable `timeout_seconds` instead of polling this tool in a loop; the wait wakes you on the completion notification or the timeout, then check again with this tool.\n\nPass `tail_lines` to control how much of the recent activity to show (default 60). The `agent_id` is the Agent tool's `agent_id` parameter value (e.g. \"agent-6\"), NOT the `task_id` from its output.\n";
+}));
+//#endregion
+//#region ../../packages/agent-core-v2/src/agent/tools/agent-output/agentOutputTool.ts
+/**
+* `tools` domain (L7) — `AgentOutputTool` implementation (the `AgentOutput`
+* tool).
+*
+* Returns a transcript-style view of a subagent's recent activity by reading
+* the tail of its `wire.jsonl` journal (`<sessionDir>/agents/<agentId>/`):
+* assistant text, thinking, tool calls, and task progress in time order —
+* the same surface a human sees in the TUI. Subagents run fully
+* asynchronously, so this is the primary progress-check tool for the calling
+* agent (park with `WaitFor` instead of polling when there is nothing else
+* to do).
+*
+* Registered via the module-level `registerAgentToolService(IAgentOutputTool,
+* AgentOutputTool)` at the bottom of this file — the same "import = register"
+* pattern used by every agent tool. Bound at Agent scope.
+*/
+function toRenderable(line) {
+	const trimmed = line.trim();
+	if (trimmed.length === 0) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(trimmed);
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const record = parsed;
+	const timeMs = typeof record.time === "number" ? normalizeTimestampMs$1(record.time) : void 0;
+	const turnStep = turnStepLabel(record.event);
+	switch (record.type) {
+		case "turn.prompt": return {
+			timeMs: timeMs ?? 0,
+			turnStep: "",
+			lines: [`user: ${clip(textOfPrompt(record.input), PROMPT_MAX_CHARS)}`]
+		};
+		case "context.append_loop_event": {
+			const event = record.event;
+			const eventType = event?.type;
+			if (eventType === "content.part" && typeof event?.part?.type === "string") {
+				const partType = event.part.type;
+				const text = partType === "think" ? typeof event.part.think === "string" ? event.part.think : "" : typeof event.part.text === "string" ? event.part.text : "";
+				return {
+					timeMs: timeMs ?? 0,
+					turnStep,
+					lines: [`${partType === "think" ? "think" : "assistant"}: ${clip(text, LINE_MAX_CHARS)}`]
+				};
+			}
+			if (eventType === "tool.call" && typeof event?.name === "string") return {
+				timeMs: timeMs ?? 0,
+				turnStep,
+				lines: [`tool: ${event.name}${argsLabel(event.args)}`]
+			};
+			if (eventType === "tool.result") {
+				const done = event?.isError === true ? "error" : "done";
+				return {
+					timeMs: timeMs ?? 0,
+					turnStep,
+					lines: [`  → ${done}`]
+				};
+			}
+			return;
+		}
+		case "task.started":
+		case "task.terminated": {
+			const info = record.info;
+			if (info === void 0) return void 0;
+			const description = typeof info.description === "string" ? info.description : "";
+			const taskId = typeof info.taskId === "string" ? info.taskId : "";
+			const status = typeof info.status === "string" ? info.status : "";
+			const label = record.type === "task.started" ? `task: ${clip(description, LINE_MAX_CHARS)} (running, ${taskId})` : `task: ${clip(description, LINE_MAX_CHARS)} (${status}, ${taskId})`;
+			return {
+				timeMs: timeMs ?? 0,
+				turnStep: "",
+				lines: [label]
+			};
+		}
+		default: return;
+	}
+}
+function turnStepLabel(event) {
+	if (event === void 0) return "";
+	const turn = typeof event.turnId === "string" ? event.turnId : void 0;
+	const step = typeof event.step === "number" ? event.step : void 0;
+	if (turn === void 0 && step === void 0) return "";
+	return `[turn ${turn ?? "?"} step ${step ?? "?"}] `;
+}
+function argsLabel(args) {
+	if (typeof args !== "object" || args === null) return "";
+	return `(${clip(JSON.stringify(args), ARGS_MAX_CHARS)})`;
+}
+function textOfPrompt(input) {
+	if (!Array.isArray(input)) return "";
+	return input.flatMap((part) => typeof part === "object" && part !== null && part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("").replaceAll(/\s+/g, " ").trim();
+}
+function clip(text, max) {
+	const collapsed = text.replaceAll(/\s+/g, " ").trim();
+	if (collapsed.length <= max) return collapsed;
+	return `${collapsed.slice(0, max)}…`;
+}
+function normalizeTimestampMs$1(value) {
+	return value > 0xe8d4a51000 ? Math.floor(value) : Math.floor(value * 1e3);
+}
+function formatTime(timeMs) {
+	if (timeMs <= 0) return "";
+	const date = new Date(timeMs);
+	const pad = (n) => String(n).padStart(2, "0");
+	return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+function formatTokens$2(size) {
+	if (size < 1024) return `${String(size)} tokens`;
+	return `${(size / 1024).toFixed(1)}k tokens`;
+}
+function isMissingPath$3(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+var WIRE_FILENAME$1, TAIL_READ_BYTES, LINE_MAX_CHARS, ARGS_MAX_CHARS, PROMPT_MAX_CHARS, AgentOutputTool;
+var init_agentOutputTool = __esmMin((() => {
+	init_dist$5();
+	init_input_schema();
+	init_rule_match();
+	init_toolContribution();
+	init_contextSize();
+	init_loop();
+	init_profile();
+	init_agentLifecycle();
+	init_sessionContext();
+	init_agent_output$1();
+	init_agent_output();
+	init_decorateParam();
+	init_decorate();
+	WIRE_FILENAME$1 = "wire.jsonl";
+	TAIL_READ_BYTES = 256 * 1024;
+	LINE_MAX_CHARS = 240;
+	ARGS_MAX_CHARS = 120;
+	PROMPT_MAX_CHARS = 300;
+	AgentOutputTool = class AgentOutputTool {
+		lifecycle;
+		session;
+		name = "AgentOutput";
+		description = agent_output_default;
+		parameters = toInputJsonSchema(AgentOutputInputSchema);
+		constructor(lifecycle, session) {
+			this.lifecycle = lifecycle;
+			this.session = session;
+		}
+		resolveExecution(args) {
+			return {
+				description: `Reading output of agent ${args.agent_id}`,
+				taskMode: "control",
+				approvalRule: this.name,
+				matchesRule: (ruleArgs) => matchesGlobRuleSubject(ruleArgs, args.agent_id),
+				execute: () => this.execute(args)
+			};
+		}
+		async execute(args) {
+			const target = this.lifecycle.get(args.agent_id);
+			if (target === void 0) return {
+				isError: true,
+				output: `${AGENT_NOT_FOUND_MESSAGE} agent_id=${args.agent_id}`
+			};
+			const records = await this.readRecentRecords(args.agent_id, args.tail_lines ?? 60);
+			const profileName = target.accessor.get(IAgentProfileService).data().profileName ?? "agent";
+			const status = target.accessor.get(IAgentLoopService).status();
+			const contextSize = target.accessor.get(IAgentContextSizeService)?.get().size ?? 0;
+			const lines = [[
+				`agent_id: ${args.agent_id}`,
+				`type: ${profileName}`,
+				`status: ${status.state}${status.activeTurnId !== void 0 ? ` · turn ${String(status.activeTurnId)}` : ""}`,
+				`context: ${formatTokens$2(contextSize)}`
+			].join(" · "), ""];
+			if (records.length === 0) lines.push("(no activity recorded yet)");
+			else for (const record of records) {
+				const stamp = formatTime(record.timeMs);
+				for (const line of record.lines) lines.push(`${stamp} ${record.turnStep}${line}`);
+			}
+			return {
+				output: lines.join("\n"),
+				isError: false
+			};
+		}
+		async readRecentRecords(agentId, tailLines) {
+			const path = join$5(this.session.sessionDir, "agents", agentId, WIRE_FILENAME$1);
+			let file;
+			try {
+				file = await open(path, "r");
+			} catch (error) {
+				if (isMissingPath$3(error)) return [];
+				throw error;
+			}
+			let input;
+			try {
+				const size = (await file.stat()).size;
+				const start = Math.max(0, size - TAIL_READ_BYTES);
+				input = size === 0 ? Readable.from([]) : file.createReadStream({
+					encoding: "utf8",
+					autoClose: false,
+					start,
+					end: size - 1
+				});
+				const lines = createInterface({
+					input,
+					crlfDelay: Infinity
+				});
+				const rendered = [];
+				for await (const line of lines) {
+					const record = toRenderable(line);
+					if (record === void 0) continue;
+					rendered.push(record);
+					if (rendered.length > tailLines) rendered.shift();
+				}
+				return rendered;
+			} finally {
+				input?.destroy();
+				if (input !== void 0) await finished(input, { cleanup: true }).catch(() => {});
+				await file.close();
+			}
+		}
+	};
+	AgentOutputTool = __decorate$1([__decorateParam(0, IAgentLifecycleService), __decorateParam(1, ISessionContext)], AgentOutputTool);
+	registerAgentToolService(IAgentOutputTool, AgentOutputTool, {
+		name: "AgentOutput",
+		domain: "subagent"
+	});
+}));
+//#endregion
 //#region ../../packages/agent-core-v2/src/agent/tools/all-done/all-done.md?raw
 var all_done_default;
 var init_all_done = __esmMin((() => {
@@ -139289,13 +139628,6 @@ var init_subagent_task = __esmMin((() => {
 	};
 }));
 //#endregion
-//#region ../../packages/agent-core-v2/src/agent/contextSize/contextSize.ts
-var IAgentContextSizeService;
-var init_contextSize = __esmMin((() => {
-	init_instantiation();
-	IAgentContextSizeService = createDecorator("agentContextSizeService");
-}));
-//#endregion
 //#region ../../packages/agent-core-v2/src/session/subagent/mirrorAgentRun.ts
 function emitAgentRunSpawned(requester, targetAgentId, meta) {
 	requester.accessor.get(IEventBus)?.publish({
@@ -208545,7 +208877,7 @@ function turnPromptText(input) {
 	const text = input.filter((part) => part.type === "text").map((part) => part.text).join("");
 	return text.length > 0 ? text : void 0;
 }
-function isDisplayablePromptOrigin(origin) {
+function isDisplayablePromptOrigin$1(origin) {
 	if (origin.kind === "user") return true;
 	return (origin.kind === "skill_activation" || origin.kind === "plugin_command") && origin.trigger === "user-slash";
 }
@@ -209007,7 +209339,7 @@ var init_loopService = __esmMin((() => {
 				type: "turn.started",
 				turnId: job.turn.id,
 				origin,
-				prompt: isDisplayablePromptOrigin(origin) ? turnPromptText(job.seed.input) : void 0
+				prompt: isDisplayablePromptOrigin$1(origin) ? turnPromptText(job.seed.input) : void 0
 			});
 			this.runTurn(job.turn, job.ready).then(job.result.resolve, job.result.reject);
 		}
@@ -213601,6 +213933,1504 @@ var init_rpc$2 = __esmMin((() => {
 	createDecorator("agentSessionRPCService");
 }));
 //#endregion
+//#region ../../packages/agent-core-v2/src/agent/loop/engineTaskAdapter.ts
+/** Extract a human-readable stop reason from an AbortSignal's abort reason:
+*  TaskStop aborts with the normalized reason string; `stopByUser` aborts
+*  with a `UserCancellationError` (its `.message` is the user-facing reason);
+*  anything else (undefined / session close) yields no reason — the engine
+*  falls back to "Stopped by TaskStop". An empty reason (e.g. an Error with
+*  an empty message) counts as "no reason" too, so the wire settle carries
+*  the documented fallback instead of an empty `error` string. */
+function abortReasonString(reason) {
+	if (typeof reason === "string") return reason === "" ? void 0 : reason;
+	if (reason instanceof Error) return reason.message === "" ? void 0 : reason.message;
+}
+var EngineTaskAdapter;
+var init_engineTaskAdapter = __esmMin((() => {
+	EngineTaskAdapter = class {
+		options;
+		idPrefix;
+		kind;
+		description;
+		sink;
+		pendingOutput = "";
+		pendingSettlement;
+		pendingExitCode;
+		exitCode;
+		settleResolve;
+		settled;
+		removeAbortListener;
+		/** UTF-8 bytes already pushed to the sink (or buffered pre-start). The
+		*  engine guarantees its `task.output` deltas concatenate byte-for-byte to
+		*  the settle's full output — the bash poller seeds a backgrounded command
+		*  with its pre-timeout foreground output as the FIRST delta, and the
+		*  subagent worker streams the nested turn's assistant deltas verbatim —
+		*  so `complete` appends only the not-yet-streamed tail. */
+		streamedBytes = 0;
+		constructor(options) {
+			this.options = options;
+			this.idPrefix = options.kind === "agent" ? "agent" : "bash";
+			this.kind = options.kind;
+			this.description = options.description;
+			this.settled = new Promise((resolve) => {
+				this.settleResolve = resolve;
+			});
+		}
+		async start(sink) {
+			this.sink = sink;
+			const requestStop = () => {
+				this.options.forceStop(abortReasonString(sink.signal.reason));
+			};
+			if (sink.signal.aborted) requestStop();
+			else {
+				sink.signal.addEventListener("abort", requestStop, { once: true });
+				this.removeAbortListener = () => {
+					sink.signal.removeEventListener("abort", requestStop);
+				};
+			}
+			this.flush();
+			await this.settled;
+		}
+		async forceStop() {
+			this.options.forceStop();
+		}
+		/** Runner-side live output (engine `task.output` events): stream the delta
+		*  straight into the service sink so TaskOutput shows partial output while
+		*  the task runs. Deltas racing `start()` (settle/stream before the
+		*  service invoked start) are buffered and flushed with the settle. */
+		appendOutput(delta) {
+			this.streamedBytes += Buffer.byteLength(delta, "utf-8");
+			if (this.sink !== void 0) this.sink.appendOutput(delta);
+			else this.pendingOutput += delta;
+		}
+		/** Runner-side settle: record the final output/exit code and settle the
+		*  registry entry (the runner dispatches the wire `task.terminated` and
+		*  delivers the notification itself — the service's `recorded: false`
+		*  entry only drives TaskList/TaskStop). The settle output is the engine's
+		*  full accumulated output; the deltas streamed during the run already
+		*  landed in the sink, so only the not-yet-streamed tail is appended (the
+		*  concatenated deltas equal the settle output byte-for-byte). */
+		complete(output, settlement, exitCode) {
+			this.pendingSettlement = settlement;
+			this.pendingExitCode = exitCode ?? null;
+			const fullBytes = Buffer.byteLength(output, "utf-8");
+			const streamed = this.streamedBytes;
+			if (streamed < fullBytes) {
+				const tail = Buffer.from(output, "utf-8").subarray(streamed).toString("utf-8");
+				if (this.sink !== void 0) this.sink.appendOutput(tail);
+				else this.pendingOutput += tail;
+			}
+			this.flush();
+		}
+		toInfo(base) {
+			if (this.kind === "agent") return {
+				...base,
+				kind: "agent",
+				agentId: this.options.agentId ?? "",
+				subagentType: this.options.subagentType ?? this.options.description,
+				detached: true
+			};
+			return {
+				...base,
+				kind: "process",
+				command: this.description,
+				pid: this.options.pid ?? 0,
+				exitCode: this.exitCode ?? null,
+				detached: true
+			};
+		}
+		flush() {
+			const sink = this.sink;
+			const settlement = this.pendingSettlement;
+			if (sink === void 0 || settlement === void 0) return;
+			this.exitCode = this.pendingExitCode ?? null;
+			if (this.pendingOutput.length > 0) sink.appendOutput(this.pendingOutput);
+			this.pendingOutput = "";
+			this.pendingSettlement = void 0;
+			this.removeAbortListener?.();
+			this.removeAbortListener = void 0;
+			sink.settle(settlement);
+			this.settleResolve?.();
+		}
+	};
+}));
+//#endregion
+//#region ../../packages/agent-core-v2/src/agent/toolResultTruncation/toolResultTruncation.ts
+var IAgentToolResultTruncationService;
+var init_toolResultTruncation = __esmMin((() => {
+	init_instantiation();
+	IAgentToolResultTruncationService = createDecorator("agentToolResultTruncationService");
+}));
+//#endregion
+//#region ../../packages/agent-core-v2/src/agent/loop/rustEngineTurnRunner.ts
+/**
+* `rustEngineTurnRunner` — the default turn runner: one turn through the Rust
+* engine (`RustTurnSession` napi socket) instead of the TS loop.
+*
+* Enabled by default; the CLI `--legacy` flag sets `DIMI_LEGACY=1` to keep
+* the TS loop. The runner:
+*  1. records `turn.prompt` (turn clock) and appends the user message;
+*  2. assembles the LLM messages from the context (context assembly stays
+*     on the TS side until slice 3);
+*  3. runs `RustTurnSession` (aimux-backed LLM in production, scripted
+*     segments under test);
+*  4. streams the engine events onto the event bus as they happen (the
+*     bridge pushes each event through a per-event callback while the turn
+*     is in flight) — the transcript projection layer (`coreEventMap`)
+*     folds them into wire ops exactly as it does for the TS loop — and
+*     mirrors them into the context (`step.begin` / `content.part` /
+*     `tool.call` / `tool.result` / `step.end` + the assistant message) so
+*     the next turn's history is intact.
+*
+* Slice-1 scope: single turn, no queue/cancellation/undo (those land with
+* later slices). The runner is a parallel path — `loopService` is untouched.
+*/
+function wrapSystemReminder(text) {
+	const trimmed = text.trim();
+	if (trimmed.startsWith("<system-reminder>") && trimmed.endsWith("</system-reminder>")) return trimmed;
+	return `<system-reminder>\n${trimmed}\n</system-reminder>`;
+}
+/**
+* The Rust engine is the default runtime; the CLI `--legacy` flag sets
+* `DIMI_LEGACY=1` to keep the TS loop (and the node-local OS backends).
+*/
+function rustEngineEnabled() {
+	return process.env["DIMI_LEGACY"] !== "1";
+}
+/** Render an engine event/tool value as text (strings pass through). */
+function toText(value) {
+	return typeof value === "string" ? value : JSON.stringify(value) ?? "";
+}
+/**
+* Serialize a TS `PromptOrigin` into the wire `TurnOrigin` JSON shape the
+* engine deserializes (`{ kind: 'user' }` / `{ kind: 'task', taskId }` /
+* … — see `dimi-wire` `model.rs`). Unknown kinds fall back to a plain user
+* origin (the wire default).
+*/
+function toEngineTurnOrigin(origin) {
+	switch (origin.kind) {
+		case "task": return {
+			kind: "task",
+			taskId: origin.taskId
+		};
+		case "cron_job": return {
+			kind: "cron",
+			taskId: origin.jobId
+		};
+		case "cron_missed": return { kind: "cron" };
+		case "hook_result": return { kind: "hook" };
+		case "compaction_summary": return { kind: "compaction" };
+		default: return { kind: "user" };
+	}
+}
+/**
+* TS `isDisplayablePromptOrigin` parity: only user-origin (and user-slash
+* skill/plugin) turns expose their prompt on `turn.started`; task/cron/hook
+* steering text must never leak into the transcript.
+*/
+function isDisplayablePromptOrigin(origin) {
+	if (origin.kind === "user") return true;
+	return (origin.kind === "skill_activation" || origin.kind === "plugin_command") && origin.trigger === "user-slash";
+}
+/**
+* Build a DimiErrorPayload-shaped error from the engine's `{ message, code }`
+* payload (TS `toDimiErrorPayload` parity): always carries `name` (the error
+* class name, mapped from the code when the engine omitted it), `retryable`
+* (mapped from the code per the TS registry) and `message`.
+*/
+function buildErrorPayload(rawError) {
+	const error = { ...rawError };
+	if (error["name"] === void 0 || error["name"] === null) error["name"] = error["code"] === "PROVIDER_FILTERED" ? "ProviderFilteredError" : "Error";
+	if (error["retryable"] === void 0) error["retryable"] = typeof error["code"] === "string" && RETRYABLE_ERROR_CODES.has(error["code"]);
+	return error;
+}
+/** Optional numeric engine field (pid / exitCode). */
+function toOptionalNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/** Mirrors the task domain's `buildAgentTaskNotificationBody` (minus the
+*  output-file block — the engine carries the tail inline). */
+function buildTaskNotificationBody(task) {
+	const baseLine = task.status === "timed_out" ? `${task.description} timed out.` : task.status === "killed" && task.error !== void 0 ? `${task.description} was stopped. Reason: ${task.error}` : task.status === "failed" && task.error !== void 0 ? `${task.description} failed. Reason: ${task.error}` : `${task.description} ${task.status}.`;
+	if (task.kind !== "agent" || task.status === "completed") return baseLine;
+	return `${baseLine}${[
+		"",
+		`To recover or continue this subagent, call Agent(resume="${task.agentId}", prompt="Pick up where you left off; redo the last tool call if its result was never observed.").`,
+		`Use agent_id ("${task.agentId}"), NOT source_id / task_id ("${task.taskId}") — the two look alike but only agent_id is accepted by the resume parameter.`,
+		"Add run_in_background=true to keep it backgrounded, or omit it to take the result inline in the current turn.",
+		"The subagent retains its full prior context across the restart, but any in-flight tool call lost its result and may need to be redone."
+	].join("\n")}`;
+}
+/** Mirrors the task domain's `renderOutputPreviewBlock` (tail inline): the
+*  engine's accumulated output is the "currently buffered" output, so the
+*  preview is the last `NOTIFICATION_OUTPUT_PREVIEW_BYTES` bytes with the
+*  same heading / `truncated` / `bytes` semantics the TS service renders. */
+function renderOutputPreviewBlock(output) {
+	const fullBytes = Buffer.byteLength(output, "utf-8");
+	const previewBytes = Math.min(NOTIFICATION_OUTPUT_PREVIEW_BYTES, fullBytes);
+	const truncated = fullBytes > previewBytes;
+	const preview = previewBytes > 0 ? Buffer.from(output, "utf-8").subarray(fullBytes - previewBytes).toString("utf-8") : "";
+	return [
+		`<output-preview bytes="${String(previewBytes)}" total_bytes="${String(fullBytes)}" truncated="${String(truncated)}">`,
+		truncated ? `Showing the last ${String(previewBytes)} bytes. No persisted full output is available.` : "No persisted full output is available; this preview is the currently buffered task output.",
+		escapeXml$1(preview),
+		"</output-preview>"
+	].join("\n");
+}
+/** Resolve once the signal aborts (used to race an approval wait). */
+function abortOnSignal(signal) {
+	return new Promise((resolve) => {
+		if (signal.aborted) {
+			resolve();
+			return;
+		}
+		signal.addEventListener("abort", () => {
+			resolve();
+		}, { once: true });
+	});
+}
+var WAIT_FOR_NATIVE_DESCRIPTION, ENGINE_NATIVE_TOOLS, WAIT_FOR_NATIVE_PARAMETERS, IRustEngineTurnRunner, RETRYABLE_ERROR_CODES, TERMINAL_OUTPUT_TAIL_CHARS, NOTIFICATION_OUTPUT_PREVIEW_BYTES, RustEngineTurnRunner;
+var init_rustEngineTurnRunner = __esmMin((() => {
+	init_src$7();
+	init_xml_escape();
+	init_contextMemory();
+	init_permissionMode();
+	init_toolRegistry();
+	init_toolPolicy();
+	init_permissionRules();
+	init_engineTaskAdapter();
+	init_notificationXml();
+	init_taskOps();
+	init_task$5();
+	init_configSection$12();
+	init_turnOps();
+	init_eventBus();
+	init_config$5();
+	init_log();
+	init_canonical_args();
+	init_errors$11();
+	init_externalHooksRunner();
+	init_toolResultTruncation();
+	init_approval$4();
+	init_usage();
+	init_profile();
+	init_scopeContext();
+	init_catalog$1();
+	init_providerRuntime();
+	init_sessionContext();
+	init_sessionMetadata();
+	init_usage$1();
+	init_wire();
+	init_compactionHandoff();
+	init_compactionOps();
+	init_completion();
+	init_decorateParam();
+	init_decorate();
+	init_instantiation();
+	init_scope();
+	WAIT_FOR_NATIVE_DESCRIPTION = [
+		"Wait for a background subagent task to finish (or time out).",
+		"Pass the `agent_id` of a subagent launched by the Agent tool (from its launch output).",
+		"The call blocks until that subagent completes, fails, or the timeout expires, then returns its final status and output.",
+		"This waits on a specific subagent task, NOT on the user: user-wait (waking on user notifications) is not implemented.",
+		"Prefer AgentOutput for a quick status check; use WaitFor when the turn should pause until the subagent finishes."
+	].join(" ");
+	ENGINE_NATIVE_TOOLS = new Set([
+		"Bash",
+		"Agent",
+		"AgentOutput",
+		"WaitFor"
+	]);
+	WAIT_FOR_NATIVE_PARAMETERS = {
+		type: "object",
+		properties: {
+			agent_id: {
+				type: "string",
+				description: "Agent id of the running subagent task to wait for, as returned by the Agent tool launch output."
+			},
+			timeout_seconds: {
+				type: "integer",
+				minimum: 1,
+				maximum: 1800,
+				description: "How long to wait for the subagent before giving up. Defaults to 60; maximum 1800."
+			}
+		},
+		required: ["agent_id"],
+		additionalProperties: false
+	};
+	IRustEngineTurnRunner = createDecorator("rustEngineTurnRunner");
+	RETRYABLE_ERROR_CODES = new Set([
+		"provider.rate_limit",
+		"provider.connection_error",
+		"provider.overloaded",
+		"context.overflow"
+	]);
+	TERMINAL_OUTPUT_TAIL_CHARS = 4 * 1024;
+	NOTIFICATION_OUTPUT_PREVIEW_BYTES = 3e3;
+	RustEngineTurnRunner = class RustEngineTurnRunner {
+		context;
+		eventBus;
+		wire;
+		config;
+		modeService;
+		rulesService;
+		toolRegistry;
+		usageService;
+		profile;
+		scopeContext;
+		sessionContext;
+		sessionMetadata;
+		tasks;
+		modelCatalog;
+		providerRuntime;
+		instantiation;
+		toolPolicy;
+		log;
+		/** The in-flight Rust session, while a turn is running (steer/cancel target). */
+		activeSession;
+		/** FIFO queue of turns waiting behind the running one (TS loop queue
+		*  parity): prompts during an active turn wait for it to finish. */
+		queued = [];
+		/** Whether a turn is currently executing (queue gate). */
+		turnRunning = false;
+		/** turnId of the executing turn (cancel validation). */
+		executingTurnId;
+		/** Aborts the in-flight approval wait on cancel. */
+		approvalAbort;
+		/**
+		* Rust-side task registry mirror: taskId → launch facts (description /
+		* startedAt / pid) recorded from `task.started`, used to build the
+		* terminal `task.terminated` info from `task.settled`. Entries are removed
+		* once the settle is handled (a task settles exactly once), so the map
+		* stays bounded by the number of tasks in flight.
+		*/
+		taskInfos = /* @__PURE__ */ new Map();
+		/** Notification dedupe (TS `deliveredNotificationKeys` parity): guards a
+		*  single settle from being delivered twice. Keys are removed after the
+		*  delivery completes — a settled task never settles again — so the set
+		*  stays bounded; the mid-turn+idle double-delivery guard is the
+		*  single-call structure of `deliverTaskNotification`, not this set. */
+		deliveredNotificationKeys = /* @__PURE__ */ new Set();
+		/** Registry entries for engine background tasks (TaskList/TaskStop parity):
+		*  taskId → adapter registered with `IAgentTaskService`. Removed once the
+		*  task settles (a task settles exactly once), so the map stays bounded. */
+		engineTaskAdapters = /* @__PURE__ */ new Map();
+		/** Owning RustTurnSession per engine task id (F1): recorded at
+		*  `task.started` from the session whose EventSink delivered the event.
+		*  Tasks launched from background workers (a subagent spawning a
+		*  sub-subagent, or a subagent launching a backgrounded bash) emit their
+		*  start AFTER the launching turn ended, when `activeSession` is undefined
+		*  or a newer turn's session — and the engine's per-task cancel signal
+		*  lives on the OWNING session's task map (`RustTurnSession::new` creates
+		*  a fresh map per turn), so TaskStop must cancel through this session.
+		*  Removed once the task settles, so the map stays bounded. */
+		taskSessions = /* @__PURE__ */ new Map();
+		/** Every subagent agent id this runner has handed out (the engine's
+		*  `agent-<n>` ids across turns): the next-turn seed must continue past
+		*  them so ids stay monotonic within the session (TS
+		*  `nextAvailableAgentId` parity). */
+		engineAgentIds = /* @__PURE__ */ new Set();
+		/** Every RustTurnSession this runner created. Held until the agent scope
+		*  is disposed so a session's EventSink stays open while its background
+		*  tasks are still settling (a subagent launched in turn 1 must be able to
+		*  notify after turn 1 ends), and so teardown can close them all at once
+		*  (TS `taskService.dispose` parity). */
+		sessions = /* @__PURE__ */ new Set();
+		/** Whether the agent scope was disposed: late engine events (background
+		*  task settles racing the teardown) are ignored instead of dispatching
+		*  wire ops on a disposed wire / appending to a disposed context. */
+		disposed = false;
+		constructor(context, eventBus, wire, config, modeService, rulesService, toolRegistry, usageService, profile, scopeContext, sessionContext, sessionMetadata, tasks, modelCatalog, providerRuntime, instantiation, toolPolicy, log) {
+			this.context = context;
+			this.eventBus = eventBus;
+			this.wire = wire;
+			this.config = config;
+			this.modeService = modeService;
+			this.rulesService = rulesService;
+			this.toolRegistry = toolRegistry;
+			this.usageService = usageService;
+			this.profile = profile;
+			this.scopeContext = scopeContext;
+			this.sessionContext = sessionContext;
+			this.sessionMetadata = sessionMetadata;
+			this.tasks = tasks;
+			this.modelCatalog = modelCatalog;
+			this.providerRuntime = providerRuntime;
+			this.instantiation = instantiation;
+			this.toolPolicy = toolPolicy;
+			this.log = log;
+			this.registryId = randomUUID();
+		}
+		/** Agent-scoped Rust subagent registry id (see constructor). */
+		registryId;
+		/** TS `stopHookContinuationUsed` parity: the Stop hook fires at most once
+		* after a continuation was delivered. */
+		stopHookContinuationUsed = false;
+		static isEnabled() {
+			return rustEngineEnabled();
+		}
+		/**
+		* Steer the running turn. Mirrors the TS steer path (`steerTurn` op +
+		* user message in the context) and forwards the text into the engine's
+		* steer queue, where it is drained into the next LLM request. Returns
+		* `false` when there is no steerable turn: either no session is active
+		* (the caller starts a new turn) or the engine's turn already finished
+		* (a steer racing the teardown — between the engine's final steer check
+		* and this runner clearing `activeSession` — would land in a queue that
+		* is never drained again; the caller's `runTurn` fallback queues it as
+		* the next turn instead, so it is never lost).
+		*/
+		steer(payload) {
+			if (this.disposed) return false;
+			const session = this.activeSession;
+			if (session === void 0) return false;
+			const text = payload.input.filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
+			if (text.length === 0) return false;
+			if (!session.steer(text)) return false;
+			this.wire.dispatch(steerTurn({
+				input: [...payload.input],
+				origin: payload.origin
+			}));
+			this.context.append({
+				role: "user",
+				content: [...payload.input],
+				toolCalls: [],
+				origin: payload.origin,
+				id: randomUUID()
+			});
+			return true;
+		}
+		/**
+		* Run one turn through the Rust engine. The turn clock advances at enqueue
+		* time (TS parity); the turn itself either starts immediately (resolves
+		* with its id) or waits behind the running turn (resolves `undefined`,
+		* like TS `state === 'pending'`).
+		*/
+		async runTurn(payload) {
+			if (this.disposed) return void 0;
+			this.wire.dispatch(promptTurn({
+				input: [...payload.input],
+				origin: payload.origin
+			}));
+			const turnId = this.wire.getModel(TurnModel).nextTurnId - 1;
+			const userMessage = {
+				role: "user",
+				content: [...payload.input],
+				toolCalls: [],
+				origin: payload.origin,
+				id: randomUUID()
+			};
+			this.context.append(userMessage);
+			if (this.turnRunning) {
+				this.queued.push({
+					turnId,
+					payload,
+					cancelled: false
+				});
+				return;
+			}
+			this.startQueuedTurn({
+				turnId,
+				payload,
+				cancelled: false
+			});
+			return { turnId };
+		}
+		/** Cancel the active turn; with `turnId`, also cancels a queued turn. */
+		cancel(turnId) {
+			const session = this.activeSession;
+			if (session !== void 0 && (turnId === void 0 || turnId === this.executingTurnId)) {
+				this.approvalAbort?.abort();
+				session.cancel();
+				return true;
+			}
+			let cancelled = false;
+			for (const entry of this.queued) if (entry.turnId === turnId) {
+				entry.cancelled = true;
+				this.wire.dispatch(cancelTurn({ turnId }));
+				cancelled = true;
+			}
+			return cancelled;
+		}
+		/**
+		* Agent-scope teardown (TS `taskService.dispose` parity): every Rust
+		* session is closed — its EventSink stops forwarding, the in-flight turn
+		* is cancelled, and background workers/pollers observe the closed flag and
+		* kill their processes — and late engine events are ignored instead of
+		* dispatching wire ops on a disposed wire. The DI container invokes this
+		* when the agent scope is disposed.
+		*/
+		dispose() {
+			this.disposed = true;
+			this.approvalAbort?.abort();
+			for (const session of this.sessions) session.close();
+			this.sessions.clear();
+			this.taskSessions.clear();
+			this.engineTaskAdapters.clear();
+			RustTurnSession.dropTaskRegistry(this.registryId);
+		}
+		startQueuedTurn(entry) {
+			this.turnRunning = true;
+			this.executingTurnId = entry.turnId;
+			this.runTurnNow(entry.turnId, entry.payload.origin).catch(() => void 0).finally(() => {
+				this.turnRunning = false;
+				this.executingTurnId = void 0;
+				if (this.disposed) {
+					this.queued.length = 0;
+					return;
+				}
+				const next = this.queued.find((queued) => !queued.cancelled);
+				if (next === void 0) return;
+				this.queued.splice(this.queued.indexOf(next), 1);
+				this.startQueuedTurn(next);
+			});
+		}
+		async runTurnNow(turnId, origin) {
+			if (this.disposed) return { turnId };
+			const messages = [{
+				role: "system",
+				content: this.profile.getSystemPrompt()
+			}, ...this.context.get().map((message) => this.toLlmMessage(message))];
+			const provider = await this.providerConfig();
+			const inputJson = JSON.stringify({
+				turnId,
+				origin: toEngineTurnOrigin(origin),
+				usesWorkerRejectionGuidance: this.scopeContext.agentId !== "main",
+				activeTools: this.effectiveActiveTools() ?? null,
+				messages,
+				tools: [],
+				provider,
+				maxStepsPerTurn: this.maxStepsPerTurn() ?? null,
+				maxRetriesPerStep: this.maxRetriesPerStep() ?? null,
+				maxContextTokens: this.maxContextTokens() ?? null,
+				nextAgentId: await this.computeNextAgentId(),
+				killGraceMs: this.killGracePeriodMs(),
+				completionReview: {
+					minSteps: 10,
+					reminder: completion_review_default
+				},
+				cwd: this.profile.data().cwd ?? process.cwd()
+			});
+			const policyJson = JSON.stringify({
+				mode: this.modeService.mode,
+				rules: this.rulesService.rules,
+				sessionApprovedPatterns: this.rulesService.sessionApprovalRulePatterns
+			});
+			const scripted = process.env["DIMI_RUST_ENGINE_SCRIPTED"];
+			const session = new RustTurnSession(inputJson, policyJson, scripted ?? void 0, this.registryId);
+			this.sessions.add(session);
+			this.activeSession = session;
+			session.setToolGate((payloadJson) => {
+				(async () => {
+					const payload = JSON.parse(payloadJson);
+					let verdict = { decision: "allow" };
+					try {
+						const hooksRunner = this.instantiation.invokeFunction((accessor) => accessor.get(IExternalHooksRunnerService));
+						if (hooksRunner !== void 0 && ENGINE_NATIVE_TOOLS.has(payload.toolName)) {
+							const block = await hooksRunner.triggerBlock("PreToolUse", {
+								matcherValue: payload.toolName,
+								signal: new AbortController().signal,
+								sessionId: this.sessionContext.sessionId,
+								inputData: {
+									toolName: payload.toolName,
+									toolInput: isPlainRecord(payload.arguments) ? payload.arguments : {},
+									toolCallId: `native-${payload.toolName}`
+								}
+							});
+							if (block !== void 0) verdict = {
+								decision: "block",
+								reason: block.reason
+							};
+						}
+					} catch {}
+					session.completeToolGate(payload.requestId, JSON.stringify(verdict));
+				})();
+			});
+			try {
+				await this.runEngineSession(session, turnId, provider["model"], origin);
+			} finally {
+				this.activeSession = void 0;
+			}
+			return { turnId };
+		}
+		/**
+		* Run one engine session to completion: register the TS tool ecosystem,
+		* drive the approval loop, mirror the engine events into the context.
+		*/
+		async runEngineSession(session, turnId, providerModel, origin) {
+			const engineNativeTools = ENGINE_NATIVE_TOOLS;
+			const activeSet = this.effectiveActiveTools();
+			const isToolActiveForRunner = (name) => activeSet === void 0 || activeSet.includes(name);
+			for (const info of this.toolRegistry.list()) {
+				if (!isToolActiveForRunner(info.name)) continue;
+				try {
+					if (engineNativeTools.has(info.name)) {
+						if (info.name !== "Bash") if (info.name === "WaitFor") session.registerNativeToolDef(info.name, WAIT_FOR_NATIVE_DESCRIPTION, JSON.stringify(WAIT_FOR_NATIVE_PARAMETERS));
+						else session.registerNativeToolDef(info.name, info.description, JSON.stringify(info.parameters ?? {
+							type: "object",
+							properties: {}
+						}));
+						continue;
+					}
+					const tool = this.toolRegistry.resolve(info.name);
+					if (tool === void 0) continue;
+					session.registerExternalTool(info.name, info.description, JSON.stringify(info.parameters ?? {
+						type: "object",
+						properties: {}
+					}), (payloadJson) => {
+						(async () => {
+							const payload = JSON.parse(payloadJson);
+							try {
+								const toolCalls = (payload.toolCalls ?? []).map((call) => ({
+									type: "function",
+									id: call.id ?? payload.toolCallId ?? payload.requestId,
+									name: call.name,
+									arguments: typeof call.arguments === "string" ? call.arguments : JSON.stringify(call.arguments) ?? "null"
+								}));
+								const execution = await tool.resolveExecution(payload.arguments, { toolCalls });
+								if (execution.isError === true) {
+									session.completeToolCall(payload.requestId, JSON.stringify({
+										toolCallId: payload.toolCallId ?? payload.requestId,
+										toolName: payload.name,
+										output: toText(execution.output),
+										isError: true,
+										stopTurn: execution.stopTurn === true,
+										updates: []
+									}));
+									return;
+								}
+								const signal = new AbortController().signal;
+								const hooksRunner = this.instantiation.invokeFunction((accessor) => accessor.get(IExternalHooksRunnerService));
+								const toolInput = isPlainRecord(payload.arguments) ? payload.arguments : {};
+								const toolCallId = payload.toolCallId ?? payload.requestId;
+								if (hooksRunner !== void 0) {
+									const block = await hooksRunner.triggerBlock("PreToolUse", {
+										matcherValue: payload.name,
+										signal,
+										sessionId: this.sessionContext.sessionId,
+										inputData: {
+											toolName: payload.name,
+											toolInput,
+											toolCallId
+										}
+									});
+									if (block !== void 0) {
+										session.completeToolCall(payload.requestId, JSON.stringify({
+											toolCallId,
+											toolName: payload.name,
+											output: block.reason,
+											isError: true,
+											stopTurn: false,
+											updates: []
+										}));
+										return;
+									}
+								}
+								const result = await execution.execute({
+									turnId: 0,
+									toolCallId,
+									signal,
+									onUpdate: (update) => {
+										if (signal.aborted) return;
+										this.eventBus.publish({
+											type: "tool.progress",
+											turnId,
+											toolCallId,
+											update
+										});
+									}
+								});
+								let finalResult = result;
+								const truncation = this.instantiation.invokeFunction((accessor) => accessor.get(IAgentToolResultTruncationService));
+								if (truncation !== void 0) try {
+									finalResult = await truncation.truncateForModel({
+										toolName: payload.name,
+										toolCallId,
+										result
+									});
+								} catch {}
+								session.completeToolCall(payload.requestId, JSON.stringify({
+									toolCallId,
+									toolName: payload.name,
+									output: toText(finalResult.output),
+									isError: finalResult.isError === true,
+									stopTurn: finalResult.stopTurn === true,
+									updates: []
+								}));
+								if (hooksRunner !== void 0) {
+									const outputText = toText(finalResult.output);
+									const isError = finalResult.isError === true;
+									hooksRunner.fireAndForgetTrigger(isError ? "PostToolUseFailure" : "PostToolUse", {
+										matcherValue: payload.name,
+										signal,
+										sessionId: this.sessionContext.sessionId,
+										inputData: {
+											toolName: payload.name,
+											toolInput,
+											toolCallId,
+											error: isError ? toDimiErrorPayload(outputText) : void 0,
+											toolOutput: isError ? void 0 : outputText.slice(0, 2e3)
+										}
+									});
+								}
+							} catch (error) {
+								session.completeToolCall(payload.requestId, JSON.stringify({
+									toolCallId: payload.toolCallId ?? payload.requestId,
+									toolName: payload.name,
+									output: `Tool "${payload.name}" failed: ${error instanceof Error ? error.message : String(error)}`,
+									isError: true,
+									stopTurn: false,
+									updates: []
+								}));
+							}
+						})();
+					});
+				} catch (error) {
+					if (engineNativeTools.has(info.name) && info.name !== "Bash") {
+						this.log.error("[rustEngineTurnRunner] failed to register native tool def", {
+							name: info.name,
+							error
+						});
+						this.eventBus.publish({
+							type: "turn.ended",
+							turnId,
+							reason: "failed",
+							error: {
+								name: "ToolRegistrationError",
+								message: `Failed to register native tool def "${info.name}"`
+							}
+						});
+						this.eventBus.publish({
+							type: "error",
+							name: "ToolRegistrationError",
+							message: `Failed to register native tool def "${info.name}"`
+						});
+						throw error;
+					}
+					this.log.error("[rustEngineTurnRunner] failed to register external tool", {
+						name: info.name,
+						error
+					});
+				}
+			}
+			let stepUuid;
+			const segments = [];
+			let stepSawToolCall = false;
+			const nativeToolCalls = /* @__PURE__ */ new Map();
+			let usage = emptyUsage();
+			const publish = (event) => {
+				const { type, ...rest } = event;
+				this.eventBus.publish({
+					type,
+					...rest
+				});
+			};
+			const flushParts = (turnId, step) => {
+				for (const segment of segments.splice(0)) {
+					const part = segment.type === "think" ? {
+						type: "think",
+						think: segment.text
+					} : {
+						type: "text",
+						text: segment.text
+					};
+					this.context.appendLoopEvent({
+						type: "content.part",
+						stepUuid,
+						part,
+						uuid: randomUUID(),
+						turnId: String(turnId),
+						step
+					});
+				}
+			};
+			const handleEngineEvent = (event) => {
+				if (this.disposed) return;
+				if (event["type"] === "task.started") {
+					this.taskSessions.set(toText(event["taskId"]), session);
+					this.handleTaskStarted(event);
+					return;
+				}
+				if (event["type"] === "task.output") {
+					this.handleTaskOutput(event);
+					return;
+				}
+				if (event["type"] === "task.settled") {
+					this.handleTaskSettled(event);
+					return;
+				}
+				if (event["type"] === "completion.review.injected") {
+					this.context.append({
+						role: "user",
+						content: [{
+							type: "text",
+							text: wrapSystemReminder(toText(event["reminder"]))
+						}],
+						toolCalls: [],
+						origin: {
+							kind: "system_trigger",
+							name: "completion_review"
+						},
+						id: randomUUID()
+					});
+					return;
+				}
+				const busEvent = { ...event };
+				if (event["type"] === "turn.step.completed") {
+					const engineUsage = event["usage"];
+					if (engineUsage !== void 0) {
+						const inputCacheRead = engineUsage.cachedTokens ?? 0;
+						busEvent["usage"] = {
+							inputOther: Math.max((engineUsage.inputTokens ?? 0) - inputCacheRead, 0),
+							output: engineUsage.outputTokens ?? 0,
+							inputCacheRead,
+							inputCacheCreation: 0
+						};
+					} else busEvent["usage"] = emptyUsage();
+				} else if (event["type"] === "turn.ended" && event["reason"] === "failed") {
+					const rawError = event["error"];
+					if (rawError !== void 0) busEvent["error"] = buildErrorPayload(rawError);
+				} else if (event["type"] === "turn.started" && !isDisplayablePromptOrigin(origin)) delete busEvent["prompt"];
+				publish(busEvent);
+				switch (event["type"]) {
+					case "turn.step.started": {
+						const stepNumber = Number(event["step"] ?? 1);
+						stepUuid = randomUUID();
+						stepSawToolCall = false;
+						this.context.appendLoopEvent({
+							type: "step.begin",
+							uuid: stepUuid,
+							turnId: String(turnId),
+							step: stepNumber
+						});
+						break;
+					}
+					case "thinking.delta": {
+						const last = segments[segments.length - 1];
+						if (last?.type === "think") last.text += toText(event["delta"]);
+						else segments.push({
+							type: "think",
+							text: toText(event["delta"])
+						});
+						break;
+					}
+					case "assistant.delta": {
+						const last = segments[segments.length - 1];
+						if (last?.type === "text") last.text += toText(event["delta"]);
+						else segments.push({
+							type: "text",
+							text: toText(event["delta"])
+						});
+						break;
+					}
+					case "tool.call.delta": break;
+					case "tool.call.started": {
+						const id = toText(event["toolCallId"]);
+						const name = toText(event["name"]);
+						stepSawToolCall = true;
+						if (ENGINE_NATIVE_TOOLS.has(name)) nativeToolCalls.set(id, {
+							name,
+							input: event["args"]
+						});
+						this.context.appendLoopEvent({
+							type: "tool.call",
+							stepUuid,
+							toolCallId: id,
+							name,
+							args: event["args"],
+							uuid: randomUUID(),
+							turnId: String(turnId),
+							step: Number(event["step"] ?? 1)
+						});
+						break;
+					}
+					case "tool.result": {
+						const id = toText(event["toolCallId"]);
+						const output = toText(event["output"]);
+						const isError = event["isError"] === true;
+						const native = nativeToolCalls.get(id);
+						if (native !== void 0) {
+							nativeToolCalls.delete(id);
+							const hooksRunner = this.instantiation.invokeFunction((accessor) => accessor.get(IExternalHooksRunnerService));
+							if (hooksRunner !== void 0) hooksRunner.fireAndForgetTrigger(isError ? "PostToolUseFailure" : "PostToolUse", {
+								matcherValue: native.name,
+								signal: new AbortController().signal,
+								sessionId: this.sessionContext.sessionId,
+								inputData: {
+									toolName: native.name,
+									toolInput: isPlainRecord(native.input) ? native.input : {},
+									toolCallId: id,
+									error: isError ? toDimiErrorPayload(output) : void 0,
+									toolOutput: isError ? void 0 : output.slice(0, 2e3)
+								}
+							});
+						}
+						this.context.appendLoopEvent({
+							type: "tool.result",
+							toolCallId: id,
+							result: {
+								output,
+								isError
+							},
+							parentUuid: stepUuid
+						});
+						break;
+					}
+					case "context.compacted": {
+						const summary = toText(event["summary"]);
+						const tokensBefore = Number(event["tokensBefore"] ?? 0);
+						const compactedCount = Number(event["compactedCount"] ?? 0);
+						this.wire.dispatch(fullCompactionBegin({ source: "auto" }));
+						const result = this.context.applyCompaction({
+							summary,
+							contextSummary: buildCompactionSummaryText(summary),
+							compactedCount,
+							tokensBefore
+						});
+						this.wire.dispatch(fullCompactionComplete({}));
+						this.eventBus.publish({
+							type: "compaction.completed",
+							result
+						});
+						break;
+					}
+					case "turn.step.interrupted":
+						if (stepSawToolCall) flushParts(turnId, Number(event["step"] ?? 1));
+						break;
+					case "turn.step.completed": {
+						const stepFinish = toText(event["finishReason"] ?? "end_turn");
+						const stepNumber = Number(event["step"] ?? 1);
+						flushParts(turnId, stepNumber);
+						const engineUsage = event["usage"];
+						if (engineUsage !== void 0) {
+							const inputCacheRead = engineUsage.cachedTokens ?? 0;
+							usage = {
+								inputOther: Math.max((engineUsage.inputTokens ?? 0) - inputCacheRead, 0),
+								output: engineUsage.outputTokens ?? 0,
+								inputCacheRead,
+								inputCacheCreation: 0
+							};
+						} else usage = emptyUsage();
+						this.usageService.record(providerModel, usage, {
+							kind: "loop",
+							turnId: String(turnId),
+							step: stepNumber
+						});
+						this.context.appendLoopEvent({
+							type: "step.end",
+							uuid: stepUuid,
+							turnId: String(turnId),
+							step: stepNumber,
+							finishReason: stepFinish,
+							usage
+						});
+						if (stepFinish !== "tool_use" && stepFinish !== "filtered") this.runStopHook(turnId);
+						break;
+					}
+					case "turn.ended":
+						this.stopHookContinuationUsed = false;
+						if (event["reason"] === "failed" && event["error"] !== void 0) this.eventBus.publish({
+							type: "error",
+							...buildErrorPayload(event["error"])
+						});
+						break;
+					default: break;
+				}
+			};
+			session.setOnEvent((eventJson) => {
+				try {
+					handleEngineEvent(JSON.parse(eventJson));
+				} catch (error) {
+					this.log.error("[rustEngineTurnRunner] failed to process engine event", { error });
+				}
+			});
+			let progress = JSON.parse(await session.run());
+			while (progress.progress.status === "needsApproval") {
+				const approval = progress.progress.approval;
+				const approvalRequest = {
+					sessionId: this.sessionContext.sessionId,
+					agentId: this.scopeContext.agentId,
+					turnId,
+					toolCallId: approval.toolCallId,
+					toolName: approval.toolName,
+					action: `Approve ${approval.toolName}`,
+					display: {
+						kind: "generic",
+						summary: `Approve ${approval.toolName}`,
+						detail: approval.toolInput
+					}
+				};
+				this.eventBus.publish({
+					type: "permission.approval.requested",
+					...approvalRequest
+				});
+				let response = { decision: "approved" };
+				const approvalController = new AbortController();
+				this.approvalAbort = approvalController;
+				try {
+					const approvalService = this.instantiation.invokeFunction((accessor) => accessor.get(ISessionApprovalService));
+					response = approvalService !== void 0 ? await Promise.race([approvalService.request(approvalRequest), abortOnSignal(approvalController.signal).then(() => ({ decision: "cancelled" }))]) : { decision: "approved" };
+				} catch {
+					response = { decision: "rejected" };
+				} finally {
+					this.approvalAbort = void 0;
+				}
+				this.eventBus.publish({
+					type: "permission.approval.resolved",
+					...approvalRequest,
+					decision: response.decision
+				});
+				this.rulesService.recordApprovalResult({
+					turnId,
+					toolCallId: approvalRequest.toolCallId,
+					toolName: approvalRequest.toolName,
+					action: approvalRequest.action,
+					sessionApprovalRule: response.decision === "approved" && response.scope === "session" ? approvalRequest.toolName : void 0,
+					result: response
+				});
+				if (response.decision === "approved" && response.scope === "session") session.addSessionApproval(approvalRequest.toolName);
+				progress = JSON.parse(await session.resume(JSON.stringify(response)));
+			}
+		}
+		/**
+		* TS `externalHooksService.runStop` parity (P1-3): after a non-tool step,
+		* fire the Stop hook; a returned reason becomes a continuation message
+		* (origin `system_trigger`/`stop_hook`) that keeps the turn alive —
+		* steered into the running turn, or launched as a fresh turn when the
+		* engine already finished (the task-notification fallback). Fires at most
+		* once after a continuation was used, mirroring `stopHookContinuationUsed`.
+		*/
+		runStopHook(turnId) {
+			if (this.stopHookContinuationUsed) return;
+			this.stopHookContinuationUsed = true;
+			const hooksRunner = this.instantiation.invokeFunction((accessor) => accessor.get(IExternalHooksRunnerService));
+			if (hooksRunner === void 0) return;
+			(async () => {
+				try {
+					const reason = (await hooksRunner.triggerBlock("Stop", {
+						signal: new AbortController().signal,
+						sessionId: this.sessionContext.sessionId,
+						inputData: { stopHookActive: false }
+					}))?.reason;
+					if (reason === void 0 || reason.length === 0) return;
+					const origin = {
+						kind: "system_trigger",
+						name: "stop_hook"
+					};
+					if (this.turnRunning && this.activeSession !== void 0 && this.activeSession.steer(reason)) {
+						this.context.append({
+							role: "user",
+							content: [{
+								type: "text",
+								text: reason
+							}],
+							toolCalls: [],
+							origin,
+							id: randomUUID()
+						});
+						this.wire.dispatch(steerTurn({
+							input: [{
+								type: "text",
+								text: reason
+							}],
+							origin
+						}));
+					} else this.runTurn({
+						input: [{
+							type: "text",
+							text: reason
+						}],
+						origin
+					}).catch(() => void 0);
+				} catch {}
+			})();
+		}
+		/**
+		* `task.started` (engine transport) → TS records: the persisted
+		* `task.started` wire op (TaskModel / transcript / TaskList) plus the
+		* `subagent.spawned` session event for subagent launches.
+		*/
+		handleTaskStarted(event) {
+			const taskId = toText(event["taskId"]);
+			const agentId = toText(event["agentId"]);
+			const kind = toText(event["kind"]);
+			const description = toText(event["description"]);
+			const startedAt = Date.now();
+			const pid = toOptionalNumber(event["pid"]);
+			this.taskInfos.set(taskId, {
+				description,
+				startedAt,
+				pid
+			});
+			if (kind === "agent" && agentId !== "") this.engineAgentIds.add(agentId);
+			const info = kind === "agent" ? {
+				taskId,
+				kind: "agent",
+				agentId,
+				subagentType: description,
+				description,
+				status: "running",
+				detached: true,
+				startedAt,
+				endedAt: null
+			} : {
+				taskId,
+				kind: "process",
+				command: description,
+				pid: pid ?? 0,
+				exitCode: null,
+				description,
+				status: "running",
+				detached: true,
+				startedAt,
+				endedAt: null
+			};
+			this.wire.dispatch(taskStarted({ info }));
+			this.registerEngineTask(taskId, agentId, kind, description, pid);
+			if (kind === "agent") {
+				this.eventBus.publish({
+					type: "subagent.spawned",
+					subagentId: agentId,
+					subagentName: description,
+					parentToolCallId: toText(event["parentToolCallId"]),
+					parentAgentId: this.scopeContext.agentId,
+					callerAgentId: this.scopeContext.agentId,
+					description,
+					runInBackground: false
+				});
+				this.eventBus.publish({
+					type: "subagent.started",
+					subagentId: agentId
+				});
+			}
+		}
+		/**
+		* `task.output` (engine transport) → the task-service entry's live sink:
+		* append the streamed delta so TaskOutput shows partial output while the
+		* engine task is still running (TS ProcessTask parity — TS streams chunks
+		* as they arrive; the adapter's settle also appends only the not-yet-
+		* streamed tail, so nothing is duplicated). No wire op / bus event: the
+		* live output is the service's retained buffer, the wire `task.terminated`
+		* tail comes from the settle's full output.
+		*/
+		handleTaskOutput(event) {
+			const taskId = toText(event["taskId"]);
+			const delta = toText(event["delta"]);
+			if (delta.length === 0) return;
+			const adapter = this.engineTaskAdapters.get(taskId);
+			if (adapter !== void 0) {
+				adapter.appendOutput(delta);
+				return;
+			}
+			this.log.debug("[rustEngineTurnRunner] task.output for unregistered task", { taskId });
+		}
+		/**
+		* Register an engine background task with `IAgentTaskService` (TaskList /
+		* TaskStop / TaskOutput parity). The adapter bridges TaskStop into the
+		* engine's per-task cancel (`session.cancelTask`) — the launching session's
+		* worker/poller kills its work and settles "killed" — and its `start`
+		* streams the settle output into the service's sink so TaskOutput and the
+		* terminal info see it.
+		*/
+		registerEngineTask(taskId, agentId, kind, description, pid) {
+			const session = this.taskSessions.get(taskId) ?? this.activeSession;
+			const adapter = new EngineTaskAdapter({
+				taskId,
+				agentId,
+				kind: kind === "agent" ? "agent" : "process",
+				description,
+				pid,
+				subagentType: kind === "agent" ? description : void 0,
+				forceStop: (reason) => {
+					try {
+						session?.cancelTask(taskId, reason);
+					} catch (error) {
+						this.log.error("[rustEngineTurnRunner] failed to cancel engine task", {
+							taskId,
+							error
+						});
+					}
+				}
+			});
+			this.engineTaskAdapters.set(taskId, adapter);
+			try {
+				this.tasks.registerTask(adapter, {
+					taskId,
+					detached: false
+				});
+			} catch (error) {
+				this.log.error("[rustEngineTurnRunner] failed to register engine task", {
+					taskId,
+					error
+				});
+				this.engineTaskAdapters.delete(taskId);
+			}
+		}
+		/**
+		* `task.settled` (engine transport) → TS records: the persisted
+		* `task.terminated` wire op (bounded output tail), the `subagent.completed`
+		* / `subagent.failed` session events, and the completion notification
+		* delivered to the model (context message + `task.notified` + steer/new
+		* turn — TS `activeOrNewTurn` parity).
+		*/
+		handleTaskSettled(event) {
+			const taskId = toText(event["taskId"]);
+			const agentId = toText(event["agentId"]);
+			const kind = toText(event["kind"]);
+			const status = toText(event["status"]);
+			const output = toText(event["output"]);
+			const error = event["error"] === void 0 || event["error"] === null ? void 0 : toText(event["error"]);
+			const launch = this.taskInfos.get(taskId);
+			const endedAt = Date.now();
+			const stopReason = status === "failed" || status === "timed_out" || status === "killed" ? error : void 0;
+			const base = {
+				taskId,
+				description: launch?.description ?? "",
+				status,
+				detached: true,
+				startedAt: launch?.startedAt ?? endedAt,
+				endedAt,
+				stopReason
+			};
+			const info = kind === "agent" ? {
+				...base,
+				kind: "agent",
+				agentId,
+				subagentType: launch?.description ?? ""
+			} : {
+				...base,
+				kind: "process",
+				command: launch?.description ?? "",
+				pid: launch?.pid ?? 0,
+				exitCode: toOptionalNumber(event["exitCode"]) ?? null
+			};
+			this.wire.dispatch(taskTerminated({
+				info,
+				outputTail: output.slice(-TERMINAL_OUTPUT_TAIL_CHARS)
+			}));
+			if (kind === "agent") {
+				if (status === "completed") this.eventBus.publish({
+					type: "subagent.completed",
+					subagentId: agentId,
+					resultSummary: output
+				});
+				else if (status === "failed") this.eventBus.publish({
+					type: "subagent.failed",
+					subagentId: agentId,
+					error: error ?? status
+				});
+			}
+			const adapter = this.engineTaskAdapters.get(taskId);
+			if (adapter !== void 0) {
+				adapter.complete(output, {
+					status,
+					stopReason
+				}, toOptionalNumber(event["exitCode"]));
+				this.engineTaskAdapters.delete(taskId);
+			}
+			this.taskInfos.delete(taskId);
+			this.taskSessions.delete(taskId);
+			if (this.tasks.getTask(taskId)?.terminalNotificationSuppressed === true) return;
+			this.deliverTaskNotification({
+				taskId,
+				agentId,
+				kind,
+				status,
+				description: launch?.description ?? "",
+				output,
+				error
+			});
+		}
+		/**
+		* Deliver a task completion notification to the model — the Rust-engine
+		* equivalent of the TS task domain's detached-task notification
+		* (`TaskNotificationStepRequest`, `activeOrNewTurn` admission): append the
+		* `<notification>` XML as a task-origin user message, fire the
+		* `task.notified` hook event, then fold it into the running turn's next
+		* step (steer) or launch a notification turn when idle.
+		*/
+		deliverTaskNotification(task) {
+			const key = `task:${task.taskId}:${task.status}`;
+			if (this.deliveredNotificationKeys.has(key)) return;
+			this.deliveredNotificationKeys.add(key);
+			const kindLabel = task.kind === "agent" ? "agent" : "process";
+			const notification = {
+				id: key,
+				category: "task",
+				type: `task.${task.status}`,
+				source_kind: "background_task",
+				source_id: task.taskId,
+				agent_id: task.kind === "agent" ? task.agentId : void 0,
+				title: `Background ${kindLabel} ${task.status}`,
+				severity: task.status === "completed" ? "info" : "warning",
+				body: buildTaskNotificationBody(task),
+				children: task.output.length > 0 ? [renderOutputPreviewBlock(task.output)] : void 0
+			};
+			const xml = renderNotificationXml(notification);
+			const origin = {
+				kind: "task",
+				taskId: task.taskId,
+				status: task.status,
+				notificationId: key
+			};
+			try {
+				if (this.turnRunning && this.activeSession !== void 0 && this.activeSession.steer(xml)) {
+					this.context.append({
+						role: "user",
+						content: [{
+							type: "text",
+							text: xml
+						}],
+						toolCalls: [],
+						origin,
+						id: randomUUID()
+					});
+					this.wire.dispatch(steerTurn({
+						input: [{
+							type: "text",
+							text: xml
+						}],
+						origin
+					}));
+				} else this.runTurn({
+					input: [{
+						type: "text",
+						text: xml
+					}],
+					origin
+				}).catch(() => void 0);
+				this.eventBus.publish({
+					type: "task.notified",
+					notificationType: `task.${task.status}`,
+					title: notification.title,
+					body: notification.body,
+					severity: notification.severity,
+					sourceKind: notification.source_kind,
+					sourceId: notification.source_id
+				});
+			} finally {
+				this.deliveredNotificationKeys.delete(key);
+			}
+		}
+		toLlmMessage(message) {
+			const text = message.content.filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
+			const media = message.content.filter((part) => part.type === "image_url" || part.type === "audio_url" || part.type === "video_url").map((part) => {
+				return {
+					type: "media_url",
+					url: part.imageUrl?.url ?? part.audioUrl?.url ?? part.videoUrl?.url
+				};
+			}).filter((part) => part.url !== void 0);
+			const toolCalls = message.toolCalls.map((call) => ({
+				id: call.id,
+				type: "function",
+				function: {
+					name: call.name,
+					arguments: call.arguments
+				}
+			}));
+			return {
+				role: message.role,
+				content: media.length > 0 ? [...media, ...text.length > 0 ? [{
+					type: "text",
+					text
+				}] : []] : text,
+				...message.role === "assistant" && toolCalls.length > 0 ? { toolCalls } : {},
+				...message.role === "tool" && message.toolCallId !== void 0 ? { toolCallId: message.toolCallId } : {}
+			};
+		}
+		/**
+		* The next subagent agent-id number to hand to the engine for this turn
+		* (TS `nextAvailableAgentId` parity): the max known `agent-<n>` suffix
+		* among (a) the ids this runner's engine has already handed out across
+		* turns and (b) the session's persisted agents, plus one. The engine seeds
+		* its per-session counter from it, so ids stay monotonic across turns and
+		* server restarts and never collide with TS-assigned ids.
+		*/
+		async computeNextAgentId() {
+			let maxSuffix = -1;
+			const consider = (id) => {
+				const match = /^agent-(\d+)$/.exec(id);
+				if (match !== null) maxSuffix = Math.max(maxSuffix, Number(match[1]));
+			};
+			for (const id of this.engineAgentIds) consider(id);
+			try {
+				const persisted = (await this.sessionMetadata.read()).agents ?? {};
+				for (const id of Object.keys(persisted)) consider(id);
+			} catch {
+				this.log.warn("[rustEngineTurnRunner] failed to read session metadata; seeding next agent id from in-session engine ids only");
+			}
+			return maxSuffix + 1;
+		}
+		maxStepsPerTurn() {
+			return this.config.get("loop_control")?.maxStepsPerTurn;
+		}
+		/**
+		* The effective engine-side tool allowlist (TS `isToolActiveComposed`
+		* parity): the runner's `IAgentToolPolicyService.isToolActive` composes
+		* the profile allowlist/denylist, the global `[tools]` config, and the
+		* session denylist — with MCP glob semantics for `mcp__*` tools. AllDone
+		* stays active regardless (the completion-review protocol needs it).
+		* `undefined` = unconstrained (all tools).
+		*/
+		effectiveActiveTools() {
+			const all = this.toolRegistry.list().map((info) => info.name);
+			const active = all.filter((name) => {
+				if (name === "AllDone") return true;
+				return this.toolPolicy.isToolActive(name);
+			});
+			return active.length === all.length ? void 0 : active;
+		}
+		maxRetriesPerStep() {
+			return this.config.get("loop_control")?.maxRetriesPerStep;
+		}
+		killGracePeriodMs() {
+			return resolveAgentTaskConfig(this.config)?.killGracePeriodMs ?? 5e3;
+		}
+		maxContextTokens() {
+			const capability = this.profile.data().modelCapabilities;
+			const max = capability.max_input_tokens ?? capability.max_context_tokens;
+			return max > 0 ? max : void 0;
+		}
+		async providerConfig() {
+			const modelAlias = this.profile.data().modelAlias ?? this.profile.getModel();
+			let baseUrl = "";
+			let apiKey = "";
+			try {
+				const model = this.modelCatalog.get(modelAlias);
+				baseUrl = model.baseUrl;
+				apiKey = (await this.providerRuntime.getAuth(model))?.auth.apiKey ?? "";
+			} catch {}
+			return {
+				baseUrl: baseUrl || "https://api.openai.com/v1",
+				apiKey,
+				model: modelAlias || "gpt-4o",
+				thinkingEffort: this.profile.getEffectiveThinkingLevel()
+			};
+		}
+	};
+	RustEngineTurnRunner = __decorate$1([
+		__decorateParam(0, IAgentContextMemoryService),
+		__decorateParam(1, IEventBus),
+		__decorateParam(2, IWireService),
+		__decorateParam(3, IConfigService),
+		__decorateParam(4, IAgentPermissionModeService),
+		__decorateParam(5, IAgentPermissionRulesService),
+		__decorateParam(6, IAgentToolRegistryService),
+		__decorateParam(7, IAgentUsageService),
+		__decorateParam(8, IAgentProfileService),
+		__decorateParam(9, IAgentScopeContext),
+		__decorateParam(10, ISessionContext),
+		__decorateParam(11, ISessionMetadata),
+		__decorateParam(12, IAgentTaskService),
+		__decorateParam(13, IModelCatalog),
+		__decorateParam(14, IProviderRuntime),
+		__decorateParam(15, IInstantiationService),
+		__decorateParam(16, IAgentToolPolicyService),
+		__decorateParam(17, ILogService)
+	], RustEngineTurnRunner);
+	registerScopedService(2, IRustEngineTurnRunner, RustEngineTurnRunner, 0, "rustEngineTurnRunner");
+}));
+//#endregion
 //#region ../../packages/agent-core-v2/src/agent/rpc/prompt-metadata.ts
 function promptMetadataTextFromPayload(payload) {
 	return promptMetadataTextFromContentParts(payload.input);
@@ -213669,6 +215499,7 @@ var init_rpcService = __esmMin((() => {
 	init_telemetry$2();
 	init_toolRegistry();
 	init_loop();
+	init_rustEngineTurnRunner();
 	init_rpc$2();
 	init_prompt_metadata();
 	init_decorateParam();
@@ -213692,7 +215523,8 @@ var init_rpcService = __esmMin((() => {
 		sessionContext;
 		scopeContext;
 		agentLifecycle;
-		constructor(promptService, conversationUndo, loop, toolPolicy, permissionMode, fullCompaction, toolRegistry, context, contextSize, skills, telemetry, eventBus, eventService, plugins, metadata, sessionContext, scopeContext, agentLifecycle) {
+		rustEngineTurnRunner;
+		constructor(promptService, conversationUndo, loop, toolPolicy, permissionMode, fullCompaction, toolRegistry, context, contextSize, skills, telemetry, eventBus, eventService, plugins, metadata, sessionContext, scopeContext, agentLifecycle, rustEngineTurnRunner) {
 			this.promptService = promptService;
 			this.conversationUndo = conversationUndo;
 			this.loop = loop;
@@ -213711,6 +215543,7 @@ var init_rpcService = __esmMin((() => {
 			this.sessionContext = sessionContext;
 			this.scopeContext = scopeContext;
 			this.agentLifecycle = agentLifecycle;
+			this.rustEngineTurnRunner = rustEngineTurnRunner;
 		}
 		async prompt(payload) {
 			if (payload.disabledTools !== void 0) try {
@@ -213720,6 +215553,13 @@ var init_rpcService = __esmMin((() => {
 				throw error;
 			}
 			await this.updatePromptMetadata(promptMetadataTextFromPayload(payload));
+			if (RustEngineTurnRunner.isEnabled()) {
+				const launched = await this.rustEngineTurnRunner.runTurn({
+					input: [...payload.input],
+					origin: { kind: "user" }
+				});
+				return launched === void 0 ? void 0 : { turn_id: launched.turnId };
+			}
 			const handle = await this.promptService.enqueue({ message: {
 				role: "user",
 				content: [...payload.input],
@@ -213732,6 +215572,17 @@ var init_rpcService = __esmMin((() => {
 		}
 		async steer(payload) {
 			this.telemetry.track2("input_steer", { parts: payload.input.length });
+			if (RustEngineTurnRunner.isEnabled()) {
+				if (this.rustEngineTurnRunner.steer({
+					input: [...payload.input],
+					origin: { kind: "user" }
+				})) return { turn_id: 0 };
+				const launched = await this.rustEngineTurnRunner.runTurn({
+					input: [...payload.input],
+					origin: { kind: "user" }
+				});
+				return launched === void 0 ? void 0 : { turn_id: launched.turnId };
+			}
 			const submitted = await this.promptService.enqueueOrSteer({ message: {
 				role: "user",
 				content: [...payload.input],
@@ -213742,6 +215593,10 @@ var init_rpcService = __esmMin((() => {
 			return turn === void 0 ? void 0 : { turn_id: turn.id };
 		}
 		cancel({ turnId }) {
+			if (RustEngineTurnRunner.isEnabled()) {
+				this.rustEngineTurnRunner.cancel(turnId);
+				return;
+			}
 			if (this.loop.status().state === "running") this.telemetry.track2("cancel", {
 				from: "streaming",
 				trace_id: this.loop.status().activeTraceId
@@ -213846,7 +215701,8 @@ var init_rpcService = __esmMin((() => {
 		__decorateParam(14, ISessionMetadata),
 		__decorateParam(15, ISessionContext),
 		__decorateParam(16, IAgentScopeContext),
-		__decorateParam(17, IAgentLifecycleService)
+		__decorateParam(17, IAgentLifecycleService),
+		__decorateParam(18, IRustEngineTurnRunner)
 	], AgentRPCService);
 	registerScopedService(2, IAgentRPCService, AgentRPCService, 0, "rpc");
 }));
@@ -216423,13 +218279,6 @@ var init_args_validator = __esmMin((() => {
 	]);
 }));
 //#endregion
-//#region ../../packages/agent-core-v2/src/agent/toolResultTruncation/toolResultTruncation.ts
-var IAgentToolResultTruncationService;
-var init_toolResultTruncation = __esmMin((() => {
-	init_instantiation();
-	IAgentToolResultTruncationService = createDecorator("agentToolResultTruncationService");
-}));
-//#endregion
 //#region ../../packages/agent-core-v2/src/agent/toolExecutor/toolScheduler.ts
 function createControlledPromise() {
 	let resolve;
@@ -217493,7 +219342,7 @@ var init_src$6 = __esmMin((() => {
 	init_migration();
 	init_sessionLogService();
 	init_telemetry$2();
-	init_events$7();
+	init_events$8();
 	init_telemetryService();
 	init_agentTelemetryContext();
 	init_agentTelemetryContextService();
@@ -217688,6 +219537,8 @@ var init_src$6 = __esmMin((() => {
 	init_wait();
 	init_waitService();
 	init_waitForTool();
+	init_agent_output$1();
+	init_agentOutputTool();
 	init_completion();
 	init_allDoneTool();
 	init_configSection$4();
@@ -218578,7 +220429,7 @@ var modelCatalogItemSchema$1, providerCatalogStatusSchema$1, providerCatalogItem
 		provider: string$2().min(1),
 		reason: string$2().min(1)
 	});
-})), tokenUsageSchema$2, finishReasonSchema$1, usageStatusSchema$2, permissionModeSchema$2, skillSourceSchema$2, userPromptOriginSchema$1, skillActivationOriginSchema$1, pluginCommandOriginSchema$1, injectionOriginSchema$1, shellCommandOriginSchema$1, compactionSummaryOriginSchema$1, systemTriggerOriginSchema$1, taskLifecycleStatusSchema$2, taskOriginSchema$1, cronJobOriginSchema$1, cronMissedOriginSchema$1, hookResultOriginSchema$1, retryOriginSchema$1, promptOriginSchema$1, dimiErrorCodeSchema$1, dimiErrorPayloadSchema$1, dimiErrorPayloadObjectSchema$1, taskInfoBaseSchema$1, processTaskInfoSchema$1, agentTaskInfoSchema$2, questionTaskInfoSchema$1, toolTaskInfoSchema$1, taskInfoSchema$1, compactionResultSchema$1, toolUpdateSchema$1, turnEndReasonSchema$2, agentPhaseSchema$1, agentStatusUpdatedEventSchema$2, sessionMetaUpdatedEventSchema$1, sessionCreatedEventSchema$1, workspaceCreatedEventSchema$1, workspaceUpdatedEventSchema$1, workspaceDeletedEventSchema$1, sessionWorkChangedEventSchema$1, sessionStatusChangedEventSchema$1, modelCatalogChangedEventSchema, skillActivatedEventSchema$1, pluginCommandActivatedEventSchema$1, errorEventSchema$2, warningEventSchema$2, turnStartedEventSchema$2, turnEndedEventSchema$2, turnStepStartedEventSchema$1, turnStepCompletedEventSchema$1, turnStepRetryingEventSchema$1, turnStepInterruptedEventSchema$1, assistantDeltaEventSchema$2, hookResultEventSchema$1, thinkingDeltaEventSchema$2, toolCallDeltaEventSchema$1, toolCallStartedEventSchema$2, toolProgressEventSchema$1, shellOutputEventSchema$1, shellStartedEventSchema$1, shellCompletedEventSchema$1, toolResultEventSchema$2, subagentSpawnedEventSchema$1, subagentStartedEventSchema$1, subagentSuspendedEventSchema$1, subagentCompletedEventSchema$1, subagentFailedEventSchema$1, compactionStartedEventSchema$1, compactionBlockedEventSchema$1, compactionCancelledEventSchema$1, compactionCompletedEventSchema$1, taskStartedEventSchema$1, taskTerminatedEventSchema$1, cronFiredEventSchema$1, promptSubmittedEventSchema$1, promptCompletedEventSchema$2, promptAbortedEventSchema$2, promptSteeredEventSchema$1, toolListUpdatedReasonSchema$1, toolListUpdatedEventSchema$1, mcpServerStatusPayloadSchema$1, mcpServerStatusEventSchema$1, agentEventSchema$1, eventSchema$1, VOLATILE_EVENT_TYPES$1, init_events$6 = __esmMin((() => {
+})), tokenUsageSchema$2, finishReasonSchema$1, usageStatusSchema$2, permissionModeSchema$2, skillSourceSchema$2, userPromptOriginSchema$1, skillActivationOriginSchema$1, pluginCommandOriginSchema$1, injectionOriginSchema$1, shellCommandOriginSchema$1, compactionSummaryOriginSchema$1, systemTriggerOriginSchema$1, taskLifecycleStatusSchema$2, taskOriginSchema$1, cronJobOriginSchema$1, cronMissedOriginSchema$1, hookResultOriginSchema$1, retryOriginSchema$1, promptOriginSchema$1, dimiErrorCodeSchema$1, dimiErrorPayloadSchema$1, dimiErrorPayloadObjectSchema$1, taskInfoBaseSchema$1, processTaskInfoSchema$1, agentTaskInfoSchema$2, questionTaskInfoSchema$1, toolTaskInfoSchema$1, taskInfoSchema$1, compactionResultSchema$1, toolUpdateSchema$1, turnEndReasonSchema$2, agentPhaseSchema$1, agentStatusUpdatedEventSchema$2, sessionMetaUpdatedEventSchema$1, sessionCreatedEventSchema$1, workspaceCreatedEventSchema$1, workspaceUpdatedEventSchema$1, workspaceDeletedEventSchema$1, sessionWorkChangedEventSchema$1, sessionStatusChangedEventSchema$1, modelCatalogChangedEventSchema, skillActivatedEventSchema$1, pluginCommandActivatedEventSchema$1, errorEventSchema$2, warningEventSchema$2, turnStartedEventSchema$2, turnEndedEventSchema$2, turnStepStartedEventSchema$1, turnStepCompletedEventSchema$1, turnStepRetryingEventSchema$1, turnStepInterruptedEventSchema$1, assistantDeltaEventSchema$2, hookResultEventSchema$1, thinkingDeltaEventSchema$2, toolCallDeltaEventSchema$1, toolCallStartedEventSchema$2, toolProgressEventSchema$1, shellOutputEventSchema$1, shellStartedEventSchema$1, shellCompletedEventSchema$1, toolResultEventSchema$2, subagentSpawnedEventSchema$1, subagentStartedEventSchema$1, subagentSuspendedEventSchema$1, subagentCompletedEventSchema$1, subagentFailedEventSchema$1, compactionStartedEventSchema$1, compactionBlockedEventSchema$1, compactionCancelledEventSchema$1, compactionCompletedEventSchema$1, taskStartedEventSchema$1, taskTerminatedEventSchema$1, cronFiredEventSchema$1, promptSubmittedEventSchema$1, promptCompletedEventSchema$2, promptAbortedEventSchema$2, promptSteeredEventSchema$1, toolListUpdatedReasonSchema$1, toolListUpdatedEventSchema$1, mcpServerStatusPayloadSchema$1, mcpServerStatusEventSchema$1, agentEventSchema$1, eventSchema$1, VOLATILE_EVENT_TYPES$1, init_events$7 = __esmMin((() => {
 	init_zod$1();
 	init_display$1();
 	init_message$1();
@@ -219352,7 +221203,7 @@ var modelCatalogItemSchema$1, providerCatalogStatusSchema$1, providerCatalogItem
 })), sessionCursorSchema$1, cursorsBySessionSchema$1, wsEventEnvelopeSchema$1, wsAckEnvelopeSchema$1, serverHelloPayloadSchema$1, serverHelloMessageSchema$1, agentFilterSchema$1, clientHelloPayloadSchema$1, clientHelloMessageSchema$1, clientHelloAckPayloadSchema$1, clientHelloAckMessageSchema$1, watchFsConfigSchema$1, subscribePayloadSchema$1, subscribeMessageSchema$1, subscribeAckPayloadSchema$1, subscribeAckMessageSchema$1, unsubscribePayloadSchema$1, unsubscribeMessageSchema$1, unsubscribeAckPayloadSchema$1, unsubscribeAckMessageSchema$1, watchFsAddPayloadSchema$1, watchFsAddMessageSchema$1, watchFsRemovePayloadSchema$1, watchFsRemoveMessageSchema$1, watchFsAckPayloadSchema$1, watchFsAckMessageSchema$1, abortPayloadSchema$1, abortMessageSchema$1, abortAckPayloadSchema$1, abortAckMessageSchema$1, terminalAttachPayloadSchema$1, terminalAttachMessageSchema$1, terminalAttachAckPayloadSchema$1, terminalAttachAckMessageSchema$1, terminalDetachPayloadSchema$1, terminalDetachMessageSchema$1, terminalDetachAckPayloadSchema$1, terminalDetachAckMessageSchema$1, terminalInputPayloadSchema$1, terminalInputMessageSchema$1, terminalInputAckPayloadSchema$1, terminalInputAckMessageSchema$1, terminalResizePayloadSchema$1, terminalResizeMessageSchema$1, terminalResizeAckPayloadSchema$1, terminalResizeAckMessageSchema$1, terminalClosePayloadSchema$1, terminalCloseMessageSchema$1, terminalCloseAckPayloadSchema$1, terminalCloseAckMessageSchema$1, pingPayloadSchema$1, pingMessageSchema$1, pongPayloadSchema$1, pongMessageSchema$1, resyncRequiredPayloadSchema$1, resyncRequiredMessageSchema$1, wsErrorPayloadSchema$1, wsErrorMessageSchema$1, terminalOutputPayloadSchema$1, terminalExitPayloadSchema$1, clientControlOperations$1, serverSystemOperations$1;
 var init_ws_control$1 = __esmMin((() => {
 	init_zod$1();
-	init_events$6();
+	init_events$7();
 	init_time();
 	sessionCursorSchema$1 = object({
 		seq: number$2().int().nonnegative(),
@@ -219897,7 +221748,7 @@ var init_tool$2 = __esmMin((() => {
 var skillDescriptorSchema$1;
 var init_skill$2 = __esmMin((() => {
 	init_zod$1();
-	init_events$6();
+	init_events$7();
 	skillDescriptorSchema$1 = object({
 		name: string$2().min(1),
 		description: string$2(),
@@ -220630,7 +222481,7 @@ var init_src$5 = __esmMin((() => {
 	init_pagination$1();
 	init_time();
 	init_request_id$2();
-	init_events$6();
+	init_events$7();
 	init_display$1();
 	init_ws_control$1();
 	init_asyncapi$1();
@@ -220669,7 +222520,7 @@ var init_src$5 = __esmMin((() => {
 }));
 //#endregion
 //#region ../../packages/node-sdk/src/events.ts
-var init_events$5 = __esmMin((() => {
+var init_events$6 = __esmMin((() => {
 	init_src$5();
 }));
 //#endregion
@@ -220724,7 +222575,7 @@ var MAIN_AGENT_ID$6, Session;
 var init_session$3 = __esmMin((() => {
 	init_src$6();
 	init_errors$3();
-	init_events$5();
+	init_events$6();
 	MAIN_AGENT_ID$6 = "main";
 	Session = class {
 		id;
@@ -221753,7 +223604,7 @@ var init_helpers = __esmMin((() => {
 		removed: array$2(string$2()),
 		changed: array$2(string$2())
 	});
-})), textPartSchema, imageUrlPartSchema, videoUrlPartSchema, promptPartSchema, emptyPayloadSchema, promptPayloadSchema, steerPayloadSchema, promptLaunchResultSchema, cancelPayloadSchema, runShellCommandPayloadSchema, shellCommandResultSchema, setModelResultSchema, permissionModeSchema$1, setPermissionPayloadSchema, tokenUsageSchema$1, usageStatusSchema$1, agentContextDataSchema, planDataSchema, taskLifecycleStatusSchema$1, taskInfoBaseFields, agentTaskInfoSchema$1, agentRpcContract;
+})), textPartSchema, imageUrlPartSchema, videoUrlPartSchema, promptPartSchema, emptyPayloadSchema, promptPayloadSchema, steerPayloadSchema, promptLaunchResultSchema, cancelPayloadSchema, runShellCommandPayloadSchema, shellCommandResultSchema$1, setModelResultSchema, permissionModeSchema$1, setPermissionPayloadSchema, tokenUsageSchema$1, usageStatusSchema$1, agentContextDataSchema, planDataSchema, taskLifecycleStatusSchema$1, taskInfoBaseFields, agentTaskInfoSchema$1, agentRpcContract;
 var init_rpc$1 = __esmMin((() => {
 	init_zod$1();
 	init_helpers();
@@ -221792,7 +223643,7 @@ var init_rpc$1 = __esmMin((() => {
 		command: string$2(),
 		commandId: string$2().optional()
 	});
-	shellCommandResultSchema = object({
+	shellCommandResultSchema$1 = object({
 		stdout: string$2(),
 		stderr: string$2(),
 		isError: boolean$2().optional(),
@@ -221924,7 +223775,7 @@ var init_services = __esmMin((() => {
 	agentShellCommandContract = {
 		run: {
 			input: tuple([runShellCommandPayloadSchema]),
-			output: shellCommandResultSchema
+			output: shellCommandResultSchema$1
 		},
 		cancel: {
 			input: tuple([string$2()]),
@@ -222868,7 +224719,7 @@ var init_contract$1 = __esmMin((() => {
 //#endregion
 //#region ../../packages/klient/src/contract/global/events.ts
 var configChangedSchema, reloadSummarySchema, sessionMetaUpdatedSchema, globalEvents;
-var init_events$4 = __esmMin((() => {
+var init_events$5 = __esmMin((() => {
 	init_zod$1();
 	configChangedSchema = object({
 		domain: string$2(),
@@ -222932,7 +224783,7 @@ var init_events$4 = __esmMin((() => {
 //#endregion
 //#region ../../packages/klient/src/contract/session/events.ts
 var sessionEvents;
-var init_events$3 = __esmMin((() => {
+var init_events$4 = __esmMin((() => {
 	init_zod$1();
 	init_interaction$1();
 	init_metadata();
@@ -222958,7 +224809,7 @@ var init_events$3 = __esmMin((() => {
 //#endregion
 //#region ../../packages/klient/src/contract/agent/events.ts
 var turnStartedEventSchema$1, turnEndedEventSchema$1, assistantDeltaEventSchema$1, thinkingDeltaEventSchema$1, toolCallStartedEventSchema$1, toolResultEventSchema$1, promptCompletedEventSchema$1, promptAbortedEventSchema$1, permissionApprovalRequestedEventSchema, permissionApprovalResolvedEventSchema, errorEventSchema$1, warningEventSchema$1, agentStatusUpdatedEventSchema$1, agentEvents;
-var init_events$2 = __esmMin((() => {
+var init_events$3 = __esmMin((() => {
 	init_zod$1();
 	turnStartedEventSchema$1 = object({
 		type: literal("turn.started"),
@@ -223592,9 +225443,9 @@ function createKlientFromChannel(channel, options = {}) {
 }
 var init_klient = __esmMin((() => {
 	init_contract$1();
+	init_events$5();
 	init_events$4();
 	init_events$3();
-	init_events$2();
 	init_hub();
 	init_global();
 	init_session$2();
@@ -226020,7 +227871,7 @@ var init_src$4 = __esmMin((() => {
 	init_errors$3();
 	init_logging();
 	init_src$6();
-	init_events$5();
+	init_events$6();
 }));
 //#endregion
 //#region ../../packages/telemetry/src/index.ts
@@ -232272,7 +234123,7 @@ var init_schema$1 = __esmMin((() => {
 		seq: transcriptSeqSchema.optional()
 	});
 })), transcriptResetEventSchema, transcriptOpsEventSchema;
-var init_events$1 = __esmMin((() => {
+var init_events$2 = __esmMin((() => {
 	init_zod$1();
 	init_schema$1();
 	transcriptResetEventSchema = transcriptResetPayloadSchema.extend({ type: literal("transcript.reset") });
@@ -232303,7 +234154,7 @@ var init_src$2 = __esmMin((() => {
 	init_groupTurns();
 	init_foldFacts();
 	init_schema$1();
-	init_events$1();
+	init_events$2();
 }));
 //#endregion
 //#region ../../packages/agent-core-v2/src/agent/contextMemory/protocolMessage.ts
@@ -259106,7 +260957,7 @@ function isVolatileEventType(type) {
 	return volatileEventTypeSet.has(type);
 }
 var VOLATILE_EVENT_TYPES, volatileEventTypeSet;
-var init_events = __esmMin((() => {
+var init_events$1 = __esmMin((() => {
 	VOLATILE_EVENT_TYPES = [
 		"assistant.delta",
 		"thinking.delta",
@@ -259344,11 +261195,11 @@ function registerApprovalsRoutes(app, core) {
 	const listRoute = defineRoute({
 		method: "GET",
 		path: "/sessions/{session_id}/approvals",
-		params: sessionIdParamSchema$9,
+		params: sessionIdParamSchema$10,
 		querystring: listPendingApprovalsQuerySchema,
 		success: { data: listPendingApprovalsResponseSchema },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$7 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$8 },
 			[ErrorCode.SESSION_NOT_FOUND]: {}
 		},
 		description: "List pending approval requests for a session",
@@ -259371,7 +261222,7 @@ function registerApprovalsRoutes(app, core) {
 		body: approvalResolveRequestSchema,
 		success: { data: approvalResolveResultSchema },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$7 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$8 },
 			[ErrorCode.SESSION_NOT_FOUND]: {},
 			[ErrorCode.APPROVAL_NOT_FOUND]: {},
 			[ErrorCode.APPROVAL_ALREADY_RESOLVED]: { dataSchema: approvalAlreadyResolvedDataSchema }
@@ -259434,7 +261285,7 @@ function toWireApproval(interaction, sessionId) {
 		expires_at: new Date(interaction.createdAt + APPROVAL_EXPIRY_MS).toISOString()
 	};
 }
-var sessionIdParamSchema$9, approvalParamsSchema, detailsSchema$7, APPROVAL_EXPIRY_MS;
+var sessionIdParamSchema$10, approvalParamsSchema, detailsSchema$8, APPROVAL_EXPIRY_MS;
 var init_approvals = __esmMin((() => {
 	init_src$6();
 	init_error_codes();
@@ -259443,12 +261294,12 @@ var init_approvals = __esmMin((() => {
 	init_envelope();
 	init_requestLog();
 	init_defineRoute();
-	sessionIdParamSchema$9 = object({ session_id: string$2().min(1) });
+	sessionIdParamSchema$10 = object({ session_id: string$2().min(1) });
 	approvalParamsSchema = object({
 		session_id: string$2().min(1),
 		approval_id: string$2().min(1)
 	});
-	detailsSchema$7 = array$2(object({
+	detailsSchema$8 = array$2(object({
 		path: string$2(),
 		message: string$2()
 	}));
@@ -259507,11 +261358,11 @@ function registerQuestionsRoutes(app, core) {
 	const listRoute = defineRoute({
 		method: "GET",
 		path: "/sessions/{session_id}/questions",
-		params: sessionIdParamSchema$8,
+		params: sessionIdParamSchema$9,
 		querystring: listPendingQuestionsQuerySchema,
 		success: { data: listPendingQuestionsResponseSchema },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$6 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$7 },
 			[ErrorCode.SESSION_NOT_FOUND]: {}
 		},
 		description: "List pending question requests for a session",
@@ -259533,7 +261384,7 @@ function registerQuestionsRoutes(app, core) {
 		params: tailParamsSchema,
 		success: { data: questionResolveResultSchema },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$6 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$7 },
 			[ErrorCode.SESSION_NOT_FOUND]: {},
 			[ErrorCode.QUESTION_NOT_FOUND]: {},
 			[ErrorCode.APPROVAL_ALREADY_RESOLVED]: { dataSchema: questionAlreadyResolvedDataSchema },
@@ -259717,7 +261568,7 @@ function toInProcessResponse(resp, request) {
 	if (resp.method !== void 0 && resp.method !== "click") out.method = resp.method;
 	return out;
 }
-var sessionIdParamSchema$8, tailParamsSchema, detailsSchema$6;
+var sessionIdParamSchema$9, tailParamsSchema, detailsSchema$7;
 var init_questions = __esmMin((() => {
 	init_src$6();
 	init_error_codes();
@@ -259728,12 +261579,12 @@ var init_questions = __esmMin((() => {
 	init_requestLog();
 	init_defineRoute();
 	init_action_suffix();
-	sessionIdParamSchema$8 = object({ session_id: string$2().min(1) });
+	sessionIdParamSchema$9 = object({ session_id: string$2().min(1) });
 	tailParamsSchema = object({
 		session_id: string$2().min(1),
 		tail: string$2().min(1)
 	});
-	detailsSchema$6 = array$2(object({
+	detailsSchema$7 = array$2(object({
 		path: string$2(),
 		message: string$2()
 	}));
@@ -260411,7 +262262,7 @@ function sessionCreatedPayload(payload) {
 var GLOBAL_SESSION_ID, TRANSCRIPT_RESET_TAIL_TURNS, SessionEventBroadcaster, volatileSignalTypeSet, TRANSCRIPT_PROJECTED_EVENT_TYPES;
 var init_sessionEventBroadcaster = __esmMin((() => {
 	init_src$6();
-	init_events();
+	init_events$1();
 	init_src$2();
 	init_approvals();
 	init_questions();
@@ -264961,11 +266812,11 @@ function registerMessagesRoutes(app, core) {
 	const listRoute = defineRoute({
 		method: "GET",
 		path: "/sessions/{session_id}/messages",
-		params: sessionIdParamSchema$7,
+		params: sessionIdParamSchema$8,
 		querystring: messagesListQueryCoercion,
 		success: { data: listMessagesResponseSchema },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$5 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$6 },
 			[ErrorCode.SESSION_NOT_FOUND]: {}
 		},
 		description: "List messages for a session",
@@ -264986,7 +266837,7 @@ function registerMessagesRoutes(app, core) {
 		params: messageIdParamSchema,
 		success: { data: getMessageResponseSchema },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$5 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$6 },
 			[ErrorCode.SESSION_NOT_FOUND]: {},
 			[ErrorCode.MESSAGE_NOT_FOUND]: {}
 		},
@@ -265023,7 +266874,7 @@ function sendMappedError$7(reply, req, err) {
 	log?.error({ err }, "message request failed");
 	reply.send(errEnvelope(ErrorCode.INTERNAL_ERROR, err instanceof Error ? err.message : String(err), requestId, err instanceof Error ? err.stack : void 0));
 }
-var messagesListQueryCoercion, sessionIdParamSchema$7, messageIdParamSchema, detailsSchema$5;
+var messagesListQueryCoercion, sessionIdParamSchema$8, messageIdParamSchema, detailsSchema$6;
 var init_messages = __esmMin((() => {
 	init_src$6();
 	init_protocolMessage();
@@ -265047,12 +266898,12 @@ var init_messages = __esmMin((() => {
 			params: { code: ErrorCode.VALIDATION_FAILED }
 		});
 	});
-	sessionIdParamSchema$7 = object({ session_id: string$2().min(1) });
+	sessionIdParamSchema$8 = object({ session_id: string$2().min(1) });
 	messageIdParamSchema = object({
 		session_id: string$2().min(1),
 		message_id: string$2().min(1)
 	});
-	detailsSchema$5 = array$2(object({
+	detailsSchema$6 = array$2(object({
 		path: string$2(),
 		message: string$2()
 	}));
@@ -265405,6 +267256,107 @@ var init_registerDebugRoutes = __esmMin((() => {
 	init_serviceDispatcherRoutes();
 }));
 //#endregion
+//#region ../../packages/kap-server/src/routes/events.ts
+function registerEventsRoute(app, opts) {
+	app.get("/sessions/:session_id/events", { schema: {
+		params: {
+			type: "object",
+			properties: { session_id: { type: "string" } },
+			required: ["session_id"]
+		},
+		querystring: {
+			type: "object",
+			properties: { event_seq: { type: "string" } },
+			required: []
+		}
+	} }, async (req, reply) => {
+		const { session_id } = req.params;
+		if (!session_id) {
+			await reply.code(400).send({
+				code: 4e4,
+				msg: "session_id required",
+				data: null,
+				request_id: req.id
+			});
+			return;
+		}
+		const eventSeq = parseEventSeq(req.query.event_seq);
+		if (eventSeq !== void 0 && (!Number.isInteger(eventSeq) || eventSeq < 0)) {
+			await reply.code(400).send({
+				code: 4e4,
+				msg: "event_seq must be a non-negative integer",
+				data: null,
+				request_id: req.id
+			});
+			return;
+		}
+		reply.hijack();
+		const raw = reply.raw;
+		raw.writeHead(200, SSE_HEADERS);
+		raw.write(": connected\n\n");
+		let closed = false;
+		const target = { send(envelope) {
+			if (closed) return;
+			raw.write(`event: ${envelope.type}\ndata: ${JSON.stringify(envelope)}\n\n`);
+		} };
+		if (!await opts.broadcaster.subscribe(session_id, target)) {
+			if (await opts.core.accessor.get(ISessionLifecycleService).resume(session_id) === void 0) {
+				closed = true;
+				raw.write("event: error\ndata: {\"code\":40401,\"msg\":\"session not found\"}\n\n");
+				raw.end();
+				return;
+			}
+			if (!await opts.broadcaster.subscribe(session_id, target)) {
+				closed = true;
+				raw.write("event: error\ndata: {\"code\":40401,\"msg\":\"session not found\"}\n\n");
+				raw.end();
+				return;
+			}
+		}
+		if (eventSeq !== void 0) {
+			const result = await opts.broadcaster.getBufferedSince(session_id, { seq: eventSeq });
+			if (result.resyncRequired !== false) raw.write(`event: resync_required\ndata: ${JSON.stringify({
+				type: "resync_required",
+				session_id,
+				reason: result.resyncRequired,
+				current_seq: result.currentSeq,
+				epoch: result.epoch
+			})}\n\n`);
+			else for (const { envelope } of result.events) target.send(envelope);
+		}
+		const heartbeat = setInterval(() => {
+			if (!closed) raw.write(": ping\n\n");
+		}, HEARTBEAT_INTERVAL_MS);
+		req.raw.on("close", () => {
+			closed = true;
+			clearInterval(heartbeat);
+			opts.broadcaster.unsubscribe(session_id, target);
+		});
+	});
+}
+/**
+* Parse the optional `?event_seq=` replay cursor. `undefined` = absent
+* (live-only stream); `NaN` = present but malformed — the caller rejects it
+* with a 400. A valid cursor is a non-negative integer (the journal seq
+* domain, matching `sessionCursorSchema.seq`).
+*/
+function parseEventSeq(raw) {
+	if (raw === void 0) return void 0;
+	if (typeof raw !== "string" || !/^\d+$/.test(raw)) return NaN;
+	return Number(raw);
+}
+var SSE_HEADERS, HEARTBEAT_INTERVAL_MS;
+var init_events = __esmMin((() => {
+	init_src$6();
+	SSE_HEADERS = {
+		"Content-Type": "text/event-stream",
+		"Cache-Control": "no-cache",
+		Connection: "keep-alive",
+		"X-Accel-Buffering": "no"
+	};
+	HEARTBEAT_INTERVAL_MS = 15e3;
+}));
+//#endregion
 //#region ../../packages/kap-server/src/protocol/rest-meta.ts
 var metaCapabilitiesSchema, metaResponseSchema;
 var init_rest_meta = __esmMin((() => {
@@ -266010,7 +267962,7 @@ function registerPromptsRoutes(app, core) {
 	const listRoute = defineRoute({
 		method: "GET",
 		path: "/sessions/{session_id}/prompts",
-		params: sessionIdParamSchema$6,
+		params: sessionIdParamSchema$7,
 		success: { data: promptListResponseSchema },
 		errors: { [ErrorCode.SESSION_NOT_FOUND]: {} },
 		description: "List the active prompt and queued prompts for a session",
@@ -266030,7 +267982,7 @@ function registerPromptsRoutes(app, core) {
 		method: "POST",
 		path: "/sessions/{session_id}/prompts",
 		body: promptSubmissionSchema,
-		params: sessionIdParamSchema$6,
+		params: sessionIdParamSchema$7,
 		success: { data: promptSubmitResultSchema },
 		errors: {
 			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: validationDetailsSchema },
@@ -266096,7 +268048,7 @@ function registerPromptsRoutes(app, core) {
 		method: "POST",
 		path: "/sessions/{session_id}/prompts::steer",
 		body: promptSteerRequestSchema,
-		params: sessionIdParamSchema$6,
+		params: sessionIdParamSchema$7,
 		success: { data: promptSteerResultSchema },
 		errors: {
 			[ErrorCode.VALIDATION_FAILED]: {},
@@ -266588,7 +268540,7 @@ function authModelDetails(err) {
 	if (typeof providerId === "string") details.provider_id = providerId;
 	return Object.keys(details).length === 0 ? null : details;
 }
-var sessionIdParamSchema$6, validationDetailsSchema, authProviderDetailsSchema, authModelDetailsSchema, VIDEO_EXT_BY_MIME, ATTACHMENT_NAME_MAX;
+var sessionIdParamSchema$7, validationDetailsSchema, authProviderDetailsSchema, authModelDetailsSchema, VIDEO_EXT_BY_MIME, ATTACHMENT_NAME_MAX;
 var init_prompts$1 = __esmMin((() => {
 	init_src$6();
 	init_error_codes();
@@ -266599,7 +268551,7 @@ var init_prompts$1 = __esmMin((() => {
 	init_defineRoute();
 	init_mainAgent();
 	init_action_suffix();
-	sessionIdParamSchema$6 = object({ session_id: string$2().min(1) });
+	sessionIdParamSchema$7 = object({ session_id: string$2().min(1) });
 	validationDetailsSchema = array$2(object({
 		path: string$2(),
 		message: string$2()
@@ -266881,7 +268833,7 @@ function registerSessionsRoutes(app, core) {
 		body: createSessionRequestSchema,
 		success: { data: sessionSchema },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$4 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$5 },
 			[ErrorCode.WORKSPACE_NOT_FOUND]: {},
 			[ErrorCode.FS_PATH_NOT_FOUND]: {}
 		},
@@ -266919,6 +268871,7 @@ function registerSessionsRoutes(app, core) {
 			const touched = await registry.createOrTouch(workDir);
 			const handle = await core.accessor.get(ISessionLifecycleService).create({ workDir });
 			if (typeof body.title === "string") await handle.accessor.get(ISessionMetadata).setTitle(body.title);
+			if (body.metadata !== void 0 && Object.keys(body.metadata).length > 0) await handle.accessor.get(ISessionMetadata).update({ custom: { ...body.metadata } });
 			const session = toWireSession({
 				...await handle.accessor.get(ISessionMetadata).read(),
 				workspaceId: touched.id
@@ -266947,7 +268900,7 @@ function registerSessionsRoutes(app, core) {
 		querystring: sessionsListQueryCoercion,
 		success: { data: pageResponseSchema(sessionSchema) },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$4 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$5 },
 			[ErrorCode.WORKSPACE_NOT_FOUND]: {}
 		},
 		description: "List sessions",
@@ -267015,10 +268968,10 @@ function registerSessionsRoutes(app, core) {
 	const getRoute = defineRoute({
 		method: "GET",
 		path: "/sessions/{session_id}",
-		params: sessionIdParamSchema$5,
+		params: sessionIdParamSchema$6,
 		success: { data: sessionSchema },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$4 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$5 },
 			[ErrorCode.SESSION_NOT_FOUND]: {}
 		},
 		description: "Get a session by ID",
@@ -267041,10 +268994,10 @@ function registerSessionsRoutes(app, core) {
 	const getProfileRoute = defineRoute({
 		method: "GET",
 		path: "/sessions/{session_id}/profile",
-		params: sessionIdParamSchema$5,
+		params: sessionIdParamSchema$6,
 		success: { data: sessionSchema },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$4 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$5 },
 			[ErrorCode.SESSION_NOT_FOUND]: {}
 		},
 		description: "Get session profile",
@@ -267067,11 +269020,11 @@ function registerSessionsRoutes(app, core) {
 	const updateProfileRoute = defineRoute({
 		method: "POST",
 		path: "/sessions/{session_id}/profile",
-		params: sessionIdParamSchema$5,
+		params: sessionIdParamSchema$6,
 		body: updateSessionProfileRequestSchema,
 		success: { data: sessionSchema },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$4 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$5 },
 			[ErrorCode.SESSION_NOT_FOUND]: {}
 		},
 		description: "Update session profile (title, metadata, agent_config)",
@@ -267113,7 +269066,7 @@ function registerSessionsRoutes(app, core) {
 			archiveSessionResponseSchema
 		]) },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$4 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$5 },
 			[ErrorCode.SESSION_NOT_FOUND]: {},
 			[ErrorCode.SESSION_BUSY]: {},
 			[ErrorCode.COMPACTION_UNABLE]: {},
@@ -267252,11 +269205,11 @@ function registerSessionsRoutes(app, core) {
 	const listChildrenRoute = defineRoute({
 		method: "GET",
 		path: "/sessions/{session_id}/children",
-		params: sessionIdParamSchema$5,
+		params: sessionIdParamSchema$6,
 		querystring: sessionChildrenListQueryCoercion,
 		success: { data: listSessionChildrenResponseSchema },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$4 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$5 },
 			[ErrorCode.SESSION_NOT_FOUND]: {}
 		},
 		description: "List child sessions",
@@ -267290,11 +269243,11 @@ function registerSessionsRoutes(app, core) {
 	const createChildRoute = defineRoute({
 		method: "POST",
 		path: "/sessions/{session_id}/children",
-		params: sessionIdParamSchema$5,
+		params: sessionIdParamSchema$6,
 		body: createSessionChildRequestSchema,
 		success: { data: sessionSchema },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$4 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$5 },
 			[ErrorCode.SESSION_NOT_FOUND]: {},
 			[ErrorCode.SESSION_BUSY]: {}
 		},
@@ -267331,10 +269284,10 @@ function registerSessionsRoutes(app, core) {
 	const statusRoute = defineRoute({
 		method: "GET",
 		path: "/sessions/{session_id}/status",
-		params: sessionIdParamSchema$5,
+		params: sessionIdParamSchema$6,
 		success: { data: sessionStatusResponseSchema },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$4 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$5 },
 			[ErrorCode.SESSION_NOT_FOUND]: {}
 		},
 		description: "Get realtime session status (best-effort in this slice)",
@@ -267352,10 +269305,10 @@ function registerSessionsRoutes(app, core) {
 	const sessionWarningsRoute = defineRoute({
 		method: "GET",
 		path: "/sessions/{session_id}/warnings",
-		params: sessionIdParamSchema$5,
+		params: sessionIdParamSchema$6,
 		success: { data: sessionWarningsResponseSchema },
 		errors: {
-			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$4 },
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$5 },
 			[ErrorCode.SESSION_NOT_FOUND]: {}
 		},
 		description: "Get session-level warnings (e.g. oversized AGENTS.md)",
@@ -267511,7 +269464,7 @@ function sendMappedError$4(reply, req, err) {
 	log?.error({ err }, "session request failed");
 	reply.send(errEnvelope(ErrorCode.INTERNAL_ERROR, err instanceof Error ? err.message : String(err), requestId, err instanceof Error ? err.stack : void 0));
 }
-var booleanQueryParam, DEFAULT_SESSION_LIST_PAGE_SIZE, sessionsListQueryCoercion, sessionIdParamSchema$5, sessionChildrenListQueryCoercion, sessionActionTailParamSchema, sessionActionRequestSchema, detailsSchema$4, DEFAULT_UNDO_MESSAGE_PAGE_SIZE, MAX_UNDO_MESSAGE_PAGE_SIZE;
+var booleanQueryParam, DEFAULT_SESSION_LIST_PAGE_SIZE, sessionsListQueryCoercion, sessionIdParamSchema$6, sessionChildrenListQueryCoercion, sessionActionTailParamSchema, sessionActionRequestSchema, detailsSchema$5, DEFAULT_UNDO_MESSAGE_PAGE_SIZE, MAX_UNDO_MESSAGE_PAGE_SIZE;
 var init_sessions = __esmMin((() => {
 	init_src$6();
 	init_error_codes();
@@ -267555,7 +269508,7 @@ var init_sessions = __esmMin((() => {
 			params: { code: ErrorCode.VALIDATION_FAILED }
 		});
 	});
-	sessionIdParamSchema$5 = object({ session_id: string$2().min(1) });
+	sessionIdParamSchema$6 = object({ session_id: string$2().min(1) });
 	sessionChildrenListQueryCoercion = object({
 		before_id: string$2().min(1).optional(),
 		after_id: string$2().min(1).optional(),
@@ -267577,7 +269530,7 @@ var init_sessions = __esmMin((() => {
 		count: number$2().int().positive().optional(),
 		page_size: number$2().int().min(1).max(100).optional()
 	}));
-	detailsSchema$4 = array$2(object({
+	detailsSchema$5 = array$2(object({
 		path: string$2(),
 		message: string$2()
 	}));
@@ -267585,6 +269538,60 @@ var init_sessions = __esmMin((() => {
 	MAX_UNDO_MESSAGE_PAGE_SIZE = 100;
 }));
 //#endregion
+//#region ../../packages/kap-server/src/routes/shell.ts
+function registerShellRoute(app, core) {
+	const runShellCommandRoute = defineRoute({
+		method: "POST",
+		path: "/sessions/{session_id}/shell",
+		params: sessionIdParamSchema$5,
+		body: shellCommandRequestSchema,
+		success: { data: shellCommandResultSchema },
+		errors: {
+			[ErrorCode.VALIDATION_FAILED]: { detailsSchema: detailsSchema$4 },
+			[ErrorCode.SESSION_NOT_FOUND]: {}
+		},
+		description: "Run a user-initiated `!` shell command in a session",
+		tags: ["sessions"]
+	}, async (req, reply) => {
+		const { session_id } = req.params;
+		const session = await core.accessor.get(ISessionLifecycleService).resume(session_id);
+		if (session === void 0) {
+			reply.send(errEnvelope(ErrorCode.SESSION_NOT_FOUND, `session ${session_id} does not exist`, req.id));
+			return;
+		}
+		const result = await (await ensureMainAgent(session)).accessor.get(IAgentShellCommandService).run({
+			command: req.body.command,
+			commandId: req.body.commandId
+		});
+		reply.send(okEnvelope(result, req.id));
+	});
+	app.post(runShellCommandRoute.path, runShellCommandRoute.options, runShellCommandRoute.handler);
+}
+var sessionIdParamSchema$5, shellCommandRequestSchema, shellCommandResultSchema, detailsSchema$4;
+var init_shell = __esmMin((() => {
+	init_src$6();
+	init_zod$1();
+	init_envelope();
+	init_defineRoute();
+	init_error_codes();
+	init_mainAgent();
+	sessionIdParamSchema$5 = object({ session_id: string$2().min(1) });
+	shellCommandRequestSchema = object({
+		command: string$2(),
+		commandId: string$2().optional()
+	});
+	shellCommandResultSchema = object({
+		stdout: string$2(),
+		stderr: string$2(),
+		isError: boolean$2().optional(),
+		backgrounded: boolean$2().optional()
+	});
+	detailsSchema$4 = array$2(object({
+		path: string$2(),
+		message: string$2()
+	}));
+}));
+//#endregion
 //#region ../../packages/kap-server/src/routes/shutdown.ts
 function registerShutdownRoutes(app, opts) {
 	const route = defineRoute({
@@ -269820,6 +271827,11 @@ async function registerApiV1Routes(app, core, opts) {
 		registerConfigRoutes(apiV1, core);
 		registerModelCatalogRoutes(apiV1, core);
 		registerSessionsRoutes(apiV1, core);
+		registerShellRoute(apiV1, core);
+		registerEventsRoute(apiV1, {
+			broadcaster: opts.broadcaster,
+			core
+		});
 		registerSessionExportRoute(apiV1, core, { serverVersion: opts.serverVersion });
 		registerSkillsRoutes(apiV1, core);
 		registerMessagesRoutes(apiV1, core);
@@ -269878,6 +271890,7 @@ var init_registerApiV1Routes = __esmMin((() => {
 	init_guiStore();
 	init_messages();
 	init_registerDebugRoutes();
+	init_events();
 	init_meta();
 	init_modelCatalog();
 	init_oauth();
@@ -269885,6 +271898,7 @@ var init_registerApiV1Routes = __esmMin((() => {
 	init_questions();
 	init_sessionExport();
 	init_sessions();
+	init_shell();
 	init_shutdown();
 	init_snapshot();
 	init_skills$1();
@@ -273846,7 +275860,9 @@ var DEFAULT_MAX_BUFFER_SIZE, DEFAULT_FLUSH_INTERVAL_MS, DEFAULT_MAX_BATCH_SIZE,
 var init_wsConnectionV1 = __esmMin((() => {
 	init_ws_control();
 	init_src$2();
+	init_src$6();
 	init_node$3();
+	init_error_codes();
 	init_protocol();
 	init_sessionEventBroadcaster();
 	init_fsWatchBridge();
@@ -273864,6 +275880,7 @@ var init_wsConnectionV1 = __esmMin((() => {
 		socket;
 		broadcaster;
 		fsWatchBridge;
+		core;
 		validateCredential;
 		maxBufferSize;
 		flushIntervalMs;
@@ -273875,6 +275892,12 @@ var init_wsConnectionV1 = __esmMin((() => {
 		/** Per-session subscription state: legacy agent allowlist + opt-in transcript grades. */
 		subscriptions = /* @__PURE__ */ new Map();
 		/**
+		* Terminal services this connection has attached to (one per session,
+		* resolved lazily). Tracked so teardown can detach every terminal sink
+		* the connection owns.
+		*/
+		terminalServices = /* @__PURE__ */ new Set();
+		/**
 		* Serializes control-frame handling in receive order. Frames arrive
 		* back-to-back (e.g. `client_hello` immediately followed by
 		* `subscribe_v2`), and a later handler reads subscription state the
@@ -273896,6 +275919,7 @@ var init_wsConnectionV1 = __esmMin((() => {
 			this.socket = opts.socket;
 			this.broadcaster = opts.broadcaster;
 			this.fsWatchBridge = opts.fsWatchBridge;
+			this.core = opts.core;
 			this.validateCredential = opts.validateCredential;
 			this.logger = opts.logger;
 			this.maxBufferSize = opts.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE;
@@ -273959,6 +275983,21 @@ var init_wsConnectionV1 = __esmMin((() => {
 				case "watch_fs_remove":
 					this.enqueueControl(() => this.onWatchFs(frame, false));
 					return;
+				case "terminal_attach":
+					this.enqueueControl(() => this.onTerminalAttach(frame));
+					return;
+				case "terminal_input":
+					this.enqueueControl(() => this.onTerminalInput(frame));
+					return;
+				case "terminal_resize":
+					this.enqueueControl(() => this.onTerminalResize(frame));
+					return;
+				case "terminal_close":
+					this.enqueueControl(() => this.onTerminalClose(frame));
+					return;
+				case "terminal_detach":
+					this.enqueueControl(() => this.onTerminalDetach(frame));
+					return;
 				default: return;
 			}
 		}
@@ -274104,6 +276143,120 @@ var init_wsConnectionV1 = __esmMin((() => {
 			}));
 		}
 		/**
+		* `terminal_attach` — attach this connection's sink to a session terminal
+		* stream. The sink's frames (`terminal_output` / `terminal_exit`) are
+		* delivered over the same subscription buffer as session events (coalesced
+		* only when mergeable — terminal frames never merge, they just share the
+		* flush window). `since_seq` replays buffered frames past the cursor, like
+		* the REST/WS attach contract.
+		*/
+		async onTerminalAttach(frame) {
+			const parsed = terminalAttachMessageSchema.safeParse(frame);
+			if (!parsed.success) {
+				this.sendImmediateFrame(buildAck(frame.id ?? "", 1, "invalid terminal_attach payload", {}));
+				return;
+			}
+			const { session_id, terminal_id, since_seq } = parsed.data.payload;
+			try {
+				const terminals = await this.resolveTerminalService(session_id);
+				const sink = {
+					id: this.id,
+					send: (terminalFrame) => this.sendSubscribedFrame(terminalFrame)
+				};
+				const { replayed } = await terminals.attach(terminal_id, sink, { sinceSeq: since_seq });
+				this.sendImmediateFrame(buildAck(frame.id ?? "", 0, "success", {
+					attached: true,
+					replayed
+				}));
+			} catch (error) {
+				this.sendTerminalErrorAck(frame.id, error);
+			}
+		}
+		/** `terminal_input` — write bytes to the attached terminal's pty. */
+		async onTerminalInput(frame) {
+			const parsed = terminalInputMessageSchema.safeParse(frame);
+			if (!parsed.success) {
+				this.sendImmediateFrame(buildAck(frame.id ?? "", 1, "invalid terminal_input payload", {}));
+				return;
+			}
+			const { session_id, terminal_id, data } = parsed.data.payload;
+			try {
+				await (await this.resolveTerminalService(session_id)).write(terminal_id, data);
+				this.sendImmediateFrame(buildAck(frame.id ?? "", 0, "success", { accepted: true }));
+			} catch (error) {
+				this.sendTerminalErrorAck(frame.id, error);
+			}
+		}
+		/** `terminal_resize` — resize the attached terminal's pty. */
+		async onTerminalResize(frame) {
+			const parsed = terminalResizeMessageSchema.safeParse(frame);
+			if (!parsed.success) {
+				this.sendImmediateFrame(buildAck(frame.id ?? "", 1, "invalid terminal_resize payload", {}));
+				return;
+			}
+			const { session_id, terminal_id, cols, rows } = parsed.data.payload;
+			try {
+				await (await this.resolveTerminalService(session_id)).resize(terminal_id, cols, rows);
+				this.sendImmediateFrame(buildAck(frame.id ?? "", 0, "success", { resized: true }));
+			} catch (error) {
+				this.sendTerminalErrorAck(frame.id, error);
+			}
+		}
+		/** `terminal_close` — close the terminal's pty (idempotent). */
+		async onTerminalClose(frame) {
+			const parsed = terminalCloseMessageSchema.safeParse(frame);
+			if (!parsed.success) {
+				this.sendImmediateFrame(buildAck(frame.id ?? "", 1, "invalid terminal_close payload", {}));
+				return;
+			}
+			const { session_id, terminal_id } = parsed.data.payload;
+			try {
+				await (await this.resolveTerminalService(session_id)).close(terminal_id);
+				this.sendImmediateFrame(buildAck(frame.id ?? "", 0, "success", { closed: true }));
+			} catch (error) {
+				this.sendTerminalErrorAck(frame.id, error);
+			}
+		}
+		/** `terminal_detach` — detach this connection's sink from a terminal stream. */
+		async onTerminalDetach(frame) {
+			const parsed = terminalDetachMessageSchema.safeParse(frame);
+			if (!parsed.success) {
+				this.sendImmediateFrame(buildAck(frame.id ?? "", 1, "invalid terminal_detach payload", {}));
+				return;
+			}
+			const { session_id, terminal_id } = parsed.data.payload;
+			try {
+				(await this.resolveTerminalService(session_id)).detach(terminal_id, this.id);
+				this.sendImmediateFrame(buildAck(frame.id ?? "", 0, "success", { detached: true }));
+			} catch (error) {
+				this.sendTerminalErrorAck(frame.id, error);
+			}
+		}
+		/**
+		* Resolve a session's `ISessionTerminalService` (cold-loading a
+		* persisted-but-not-live session, matching the REST terminal route).
+		* The resolved service is remembered so `onClose` can detach every sink
+		* this connection owns.
+		*/
+		async resolveTerminalService(sessionId) {
+			const session = await this.core.accessor.get(ISessionLifecycleService).resume(sessionId);
+			if (session === void 0) throw new Error2(ErrorCodes.SESSION_NOT_FOUND, `session ${sessionId} does not exist`);
+			const terminals = session.accessor.get(ISessionTerminalService);
+			this.terminalServices.add(terminals);
+			return terminals;
+		}
+		/** Ack a terminal control failure with the wire error code when known. */
+		sendTerminalErrorAck(id, error) {
+			let code = 1;
+			let msg = "internal error";
+			if (isError2(error)) {
+				if (error.code === ErrorCodes.SESSION_NOT_FOUND) code = ErrorCode.SESSION_NOT_FOUND;
+				else if (error.code === ErrorCodes.TERMINAL_NOT_FOUND) code = ErrorCode.TERMINAL_NOT_FOUND;
+				msg = error.message;
+			} else if (error instanceof Error) msg = error.message;
+			this.sendImmediateFrame(buildAck(id ?? "", code, msg, {}));
+		}
+		/**
 		* Shared attach path behind `client_hello` (legacy inline subscriptions)
 		* and `subscribe`. Subscribes the connection via the broadcaster, then
 		* either replays durable events since the client's cursor (with the
@@ -274248,6 +276401,7 @@ var init_wsConnectionV1 = __esmMin((() => {
 			this.outbound = [];
 			this.broadcaster.removeGlobalTarget(this);
 			for (const sid of this.subscriptions.keys()) this.broadcaster.unsubscribe(sid, this);
+			for (const terminals of this.terminalServices) terminals.detachAllForSink(this.id);
 			this.fsWatchBridge?.detachConnection(this);
 		}
 	};
@@ -274266,6 +276420,7 @@ function registerWsV1(core, opts) {
 			broadcaster,
 			fsWatchBridge: opts.fsWatchBridge,
 			connectionRegistry: registry,
+			core,
 			validateCredential: opts.validateCredential,
 			remoteAddress: req.socket.remoteAddress ?? null,
 			userAgent: req.headers["user-agent"] ?? null,
@@ -296567,6 +298722,15 @@ function stringifyToolOutput(output) {
 	if (typeof output === "string") return output;
 	return JSON.stringify(output) ?? String(output);
 }
+function stringifyToolArgs(args) {
+	if (typeof args === "string") return args;
+	return JSON.stringify(args) ?? String(args);
+}
+function truncateChars(text, max) {
+	if (text.length <= max) return text;
+	const suffix = `… (${text.length - max} more chars)`;
+	return `${text.slice(0, max - suffix.length)}${suffix}`;
+}
 function writeVersion(version, outputFormat, stdout, stderr) {
 	if (outputFormat === "stream-json") {
 		const message = {
@@ -296595,16 +298759,23 @@ function writeResumeHint(sessionId, outputFormat, stdout, stderr) {
 	}
 	stderr.write(`${content}\n`);
 }
-var PROMPT_BLOCK_BULLET, PROMPT_BLOCK_INDENT, PromptTranscriptWriter, PromptJsonWriter, PromptBlockWriter;
+var PROMPT_BLOCK_BULLET, PROMPT_BLOCK_INDENT, TOOL_CALL_MARK, TOOL_RESULT_MARK, RETRY_MARK, MAX_TOOL_CALL_ARGS_CHARS, MAX_TOOL_RESULT_CHARS, PromptTranscriptWriter, PromptJsonWriter, PromptBlockWriter;
 var init_prompt_render = __esmMin((() => {
 	PROMPT_BLOCK_BULLET = "• ";
 	PROMPT_BLOCK_INDENT = "  ";
+	TOOL_CALL_MARK = "⚒ ";
+	TOOL_RESULT_MARK = "⚒ result: ";
+	RETRY_MARK = "↻ retry";
+	MAX_TOOL_CALL_ARGS_CHARS = 500;
+	MAX_TOOL_RESULT_CHARS = 2e3;
 	PromptTranscriptWriter = class {
 		assistantWriter;
 		thinkingWriter;
+		toolWriter;
 		constructor(stdout, stderr) {
 			this.assistantWriter = new PromptBlockWriter(stdout);
 			this.thinkingWriter = new PromptBlockWriter(stderr);
+			this.toolWriter = new PromptBlockWriter(stderr);
 		}
 		writeAssistantDelta(delta) {
 			this.thinkingWriter.finish();
@@ -296619,10 +298790,25 @@ var init_prompt_render = __esmMin((() => {
 		writeThinkingDelta(delta) {
 			this.thinkingWriter.write(delta);
 		}
-		writeToolCall() {}
+		writeToolCall(toolCallId, name, args) {
+			this.thinkingWriter.finish();
+			this.assistantWriter.finish();
+			this.toolWriter.write(`${TOOL_CALL_MARK}${name}(${truncateChars(stringifyToolArgs(args), MAX_TOOL_CALL_ARGS_CHARS)})`);
+			this.toolWriter.finish();
+		}
 		writeToolCallDelta() {}
-		writeToolResult() {}
-		writeRetrying() {}
+		writeToolResult(toolCallId, output) {
+			this.toolWriter.finish();
+			this.toolWriter.write(`${TOOL_RESULT_MARK}${truncateChars(stringifyToolOutput(output), MAX_TOOL_RESULT_CHARS)}`);
+			this.toolWriter.finish();
+		}
+		writeRetrying(event) {
+			this.thinkingWriter.finish();
+			this.assistantWriter.finish();
+			const error = [event.errorName, event.errorMessage].filter(Boolean).join(": ");
+			this.toolWriter.write(`${RETRY_MARK} ${event.failedAttempt}/${event.maxAttempts} (${error}) — ${event.delayMs}ms`);
+			this.toolWriter.finish();
+		}
 		flushAssistant() {
 			this.assistantWriter.finish();
 		}
@@ -296630,6 +298816,7 @@ var init_prompt_render = __esmMin((() => {
 		finish() {
 			this.thinkingWriter.finish();
 			this.assistantWriter.finish();
+			this.toolWriter.finish();
 		}
 	};
 	PromptJsonWriter = class {