@khorsheed/dsh-local-agent 0.2.0-rc.3 → 0.2.0

package/lib/index.js

@@ -4,9 +4,11 @@ import { appendFileSync, chmodSync, closeSync, fsyncSync, mkdirSync, openSync, r
 import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import z from "@deepseek-ai/schemastery";
+import * as sessionModule from "@deepseek-ai/dsh-session";
 import { SessionId } from "@deepseek-ai/dsh-session";
 import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { createServer } from "node:net";
+import { createScope } from "@deepseek-ai/dsh-scope";
 import { scrubbedParentEnv } from "@deepseek-ai/dsh-subprocess";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 //#region lib/types/cli-version.js
@@ -1260,6 +1262,65 @@ let LocalAgentGateway = (() => {
 	};
 })();
 //#endregion
+//#region lib/types/mode-skills.js
+/**
+* Mode skills, installed the CLI's own way: a member with a mode gets the
+* skills that mode contributes (e.g. the 剪辑 mode's `video-studio`) written
+* into its harness home's skill directory — `skills/<name>/SKILL.md`, the
+* layout Codex (`$CODEX_HOME`), Claude Code (`$CLAUDE_CONFIG_DIR`) and Kimi
+* (`$KIMI_CODE_HOME`, its auto-discovered user skill directory) load. The home is shared by every member of that harness, so each skill is
+* named `dsh-<name>` and says it applies only alongside the mode's tools.
+* Harnesses without a known skill directory get none. Best-effort:
+* a failed write never fails the member's tool listing.
+* @module @khorsheed/dsh-local-agent/mode-skills
+*/
+/** Harnesses whose CLI loads `<home>/skills/<name>/SKILL.md`. */
+const SKILL_HOMES = /* @__PURE__ */ new Set([
+	"codex",
+	"claude-code",
+	"kimi"
+]);
+/** The skill directory of a harness home, or undefined when its CLI has none we know. */
+function harnessSkillsDir(harness, home) {
+	return SKILL_HOMES.has(harness) ? join(home, "skills") : void 0;
+}
+/** The SKILL.md a mode skill installs as. */
+function modeSkillFile(skill, mode) {
+	const name = `dsh-${skill.name}`;
+	const description = `${skill.description} (dsh mode "${mode}": use only when your tools include this mode's tools.)`.replace(/\s+/g, " ");
+	return {
+		name,
+		text: `---\nname: ${name}\ndescription: ${JSON.stringify(description)}\n---\n\n${skill.content.trim()}\n`
+	};
+}
+/**
+* Write the mode's skills into the harness's skill directory, skipping files
+* already up to date.
+* @param dir - the harness skill directory.
+* @param mode - the member's mode id.
+* @param skills - the mode's skills.
+* @returns the installed skill names.
+*/
+function installModeSkills(dir, mode, skills) {
+	const installed = [];
+	for (const skill of skills) {
+		const file = modeSkillFile(skill, mode);
+		const target = join(dir, file.name, "SKILL.md");
+		let current;
+		try {
+			current = readFileSync(target, "utf8");
+		} catch {
+			current = void 0;
+		}
+		if (current !== file.text) {
+			mkdirSync(join(dir, file.name), { recursive: true });
+			writeFileSync(target, file.text);
+		}
+		installed.push(file.name);
+	}
+	return installed;
+}
+//#endregion
 //#region lib/types/member-channel.js
 /**
 * Member channel, host side: the loopback listener the bridge MCP servers call
@@ -1288,6 +1349,8 @@ let LocalAgentGateway = (() => {
 *    `busy`; else the facade `resume` with a provenance-tagged prompt.
 * @module @khorsheed/dsh-local-agent/member-channel
 */
+/** How long one bridged mode-tool call may run before it is cancelled. */
+const MODE_TOOL_TIMEOUT_MS = 18e5;
 /**
 * The member-channel host: owns the loopback unix-socket listener and the
 * delivery chain. Mounted by the plugin's `apply` and disposed with its fiber.
@@ -1296,11 +1359,13 @@ var MemberChannel = class {
 	ctx;
 	registry;
 	socketPath;
+	modeTools;
 	server;
-	constructor(ctx, registry, socketPath) {
+	constructor(ctx, registry, socketPath, modeTools) {
 		this.ctx = ctx;
 		this.registry = registry;
 		this.socketPath = socketPath;
+		this.modeTools = modeTools;
 	}
 	/**
 	* Start listening. A listener failure (e.g. a socket path beyond the
@@ -1360,7 +1425,8 @@ var MemberChannel = class {
 	async answer(socket, line) {
 		let outcome;
 		try {
-			outcome = await this.handle(JSON.parse(line));
+			const request = JSON.parse(line);
+			outcome = request !== null && typeof request === "object" && "modeTools" in request ? await this.handleModeTools(request) : await this.handle(request);
 		} catch (error) {
 			outcome = {
 				ok: false,
@@ -1458,6 +1524,75 @@ var MemberChannel = class {
 			receipt: "sent"
 		};
 	}
+	/**
+	* The member's mode tools: the room says which mode the member has; the
+	* preset tool host lists or runs that mode's plugin tools. No room, no mode
+	* or no host = an empty list.
+	* @param request - the bridge callback.
+	* @returns the list or the call result.
+	*/
+	async handleModeTools(request) {
+		const run = typeof request.token === "string" ? this.registry.resolveMemberRun(request.token) : void 0;
+		if (run === void 0) return {
+			ok: false,
+			error: "localAgent: unknown or expired member token"
+		};
+		const mode = this.modeTools === void 0 ? void 0 : await this.probeRoom()?.memberMode?.(run);
+		if ("list" in request.modeTools) {
+			if (mode === void 0) {
+				this.modeTools?.note({
+					childSessionId: run.childSessionId,
+					provider: run.provider,
+					mode: false
+				});
+				return {
+					ok: true,
+					tools: []
+				};
+			}
+			try {
+				const tools = await this.modeTools.list(run.childSessionId, mode.preset, mode.cwd);
+				await this.installSkills(run, mode.preset);
+				return {
+					ok: true,
+					tools
+				};
+			} catch (error) {
+				this.ctx.logger.warn(`localAgent: mode tools for ${run.childSessionId} unavailable: ${String(error)}`);
+				return {
+					ok: true,
+					tools: []
+				};
+			}
+		}
+		if (mode === void 0) return {
+			ok: false,
+			error: "This member has no mode tools"
+		};
+		const { name, arguments: args } = request.modeTools.call;
+		try {
+			return {
+				ok: true,
+				result: await this.modeTools.call(run.childSessionId, mode.preset, name, args ?? {}, AbortSignal.timeout(MODE_TOOL_TIMEOUT_MS), mode.cwd)
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: String(error)
+			};
+		}
+	}
+	/** Install the mode's skills into the member's harness skill directory (best-effort). */
+	async installSkills(run, preset) {
+		try {
+			const harness = this.registry.list().map((name) => this.registry.get(name)).find((candidate) => candidate?.delegationProvider === run.provider);
+			const dir = harness === void 0 ? void 0 : harnessSkillsDir(harness.name, this.registry.homeDir(harness.name));
+			if (dir === void 0) return;
+			installModeSkills(dir, preset, await this.modeTools.skills(run.childSessionId, preset));
+		} catch (error) {
+			this.ctx.logger.warn(`localAgent: mode skills for ${run.childSessionId} not installed: ${String(error)}`);
+		}
+	}
 	/** Probe the optional room gate without importing any room package. */
 	probeRoom() {
 		const room = this.ctx.get.call(this.ctx, "room");
@@ -1479,6 +1614,10 @@ var MemberChannel = class {
 			to: request.to,
 			content: request.text,
 			parentSessionId: from.parentSessionId,
+			...request.kind === "task" || request.kind === "notify" ? { kind: request.kind } : {},
+			...typeof request.inReplyTo === "string" ? { inReplyTo: request.inReplyTo } : {},
+			...typeof request.note === "string" ? { note: request.note } : {},
+			...typeof request.task === "string" ? { task: request.task } : {},
 			provenance: {
 				childSessionId: from.childSessionId,
 				provider: from.provider,
@@ -1507,6 +1646,251 @@ var MemberChannel = class {
 	}
 };
 //#endregion
+//#region lib/types/preset-tool-host.js
+/**
+* Preset tool host: lets an external CLI member use the plugin tools of a
+* host agent preset (a mode), through its member bridge, ON THE MEMBER'S OWN
+* SESSION. The tool registry keys scoped tools by an agent identity, and
+* plugin tools read only `agent.id` and `agent.session` from it — so the
+* member gets a model-less stand-in: `{ id, session }` over its own child
+* session, given a scope (`createScope`) with the preset mounted. Calls run
+* through the registry's normal pipeline (policies, approvals, timeouts) as
+* that stand-in, so plugin state (a video project) belongs to the member's
+* session and the mode's panels show there; the session also records the mode
+* (`agent-preset/selected`), so per-session plugin visibility follows it.
+* Only PLUGIN tools are offered (`Symbol.for('dsh.tool.origin')` channel
+* `plugin`; the CLI brings its own shell, files and todo).
+*
+* Everything host-side is probed, never injected: without `sessions`,
+* `agentPresets` or `tools` the member simply gets no extra tools.
+* @module @khorsheed/dsh-local-agent/preset-tool-host
+*/
+/** Owners whose tools the bridge already serves itself (room), or that delegate from dsh (the local-agent family). */
+const skippedOwner = (owner) => owner === "@khorsheed/dsh-room" || owner.startsWith("@khorsheed/dsh-local-agent");
+/** How long a freshly mounted preset may take to finish registering its tools, and how often to look. */
+const SETTLE_MS = 3e3;
+const SETTLE_STEP_MS = 150;
+const ORIGIN = Symbol.for("dsh.tool.origin");
+/** The mode a session records: its header, overridden by the latest selection. */
+function sessionPreset(session) {
+	let preset = session.header.agentPreset ?? void 0;
+	for (const event of session.snapshotEvents()) if (event.type === "agent-preset/selected") preset = event.data?.agentPreset ?? preset;
+	return preset;
+}
+/** Whether a definition is a plugin tool the bridge may forward. */
+function isPluginTool(definition) {
+	const origin = definition?.[ORIGIN];
+	return origin?.channel === "plugin" && !skippedOwner(String(origin.owner));
+}
+/** Map registry content blocks to MCP content (text and images; anything else as text). */
+function mcpContent(blocks) {
+	return blocks.map((block) => {
+		if (block.type === "text") return {
+			type: "text",
+			text: block.text ?? ""
+		};
+		if (block.type === "image" && typeof block.data === "string") return {
+			type: "image",
+			data: block.data,
+			mimeType: block.mediaType ?? block.mimeType ?? "image/png"
+		};
+		return {
+			type: "text",
+			text: JSON.stringify(block)
+		};
+	});
+}
+/** The per-member preset agents and the list/call operations the bridge forwards. */
+var PresetToolHost = class {
+	ctx;
+	diagnostics;
+	hosts = /* @__PURE__ */ new Map();
+	/** Stand-in → the member's child session, for routing approvals its calls raise. */
+	standIns = /* @__PURE__ */ new WeakMap();
+	/** The member a stand-in agent acts for, if it is one of ours. */
+	memberOf(agent) {
+		return typeof agent === "object" && agent !== null ? this.standIns.get(agent) : void 0;
+	}
+	/**
+	* @param ctx - the local-agent plugin context.
+	* @param diagnostics - optional JSONL file each listing appends a summary to
+	*   (what the preset agent's scope saw and which tools passed the filter).
+	*/
+	constructor(ctx, diagnostics) {
+		this.ctx = ctx;
+		this.diagnostics = diagnostics;
+	}
+	/** Append one diagnostics line (best-effort). */
+	note(entry) {
+		if (this.diagnostics === void 0) return;
+		try {
+			appendFileSync(this.diagnostics, `${JSON.stringify({
+				time: (/* @__PURE__ */ new Date()).toISOString(),
+				...entry
+			})}\n`);
+		} catch {}
+	}
+	probe(name) {
+		return this.ctx.get.call(this.ctx, name);
+	}
+	/** The member's stand-in, scoped with its preset on first use (and re-scoped when the preset changed). */
+	async agentFor(childSessionId, preset, _cwd) {
+		const sessions = this.probe("sessions");
+		const presets = this.probe("agentPresets");
+		const session = sessions?.get(SessionId(childSessionId));
+		if (presets?.mount === void 0 || session === void 0) return void 0;
+		const current = this.hosts.get(childSessionId);
+		if (current !== void 0 && current.preset === preset && (await current.agent).agent.session === session) return (await current.agent).agent;
+		if (current !== void 0) {
+			this.hosts.delete(childSessionId);
+			current.agent.then((handle) => handle.dispose()).catch(() => {});
+		}
+		const agent = (async () => {
+			const resolved = await presets.resolve(preset);
+			const member = {
+				id: childSessionId,
+				session
+			};
+			this.standIns.set(member, childSessionId);
+			const scope = createScope(this.ctx, member);
+			member.ctx = scope.ctx;
+			try {
+				await presets.mount(scope.ctx, resolved.id);
+			} catch (error) {
+				await scope.dispose();
+				throw error;
+			}
+			if (sessionPreset(session) !== resolved.id) session.append("agent-preset/selected", { agentPreset: resolved.id });
+			return {
+				agent: member,
+				dispose: () => scope.dispose()
+			};
+		})();
+		this.hosts.set(childSessionId, {
+			preset,
+			agent
+		});
+		try {
+			return (await agent).agent;
+		} catch (error) {
+			this.hosts.delete(childSessionId);
+			throw error;
+		}
+	}
+	/**
+	* The preset's plugin tools, for a member's `tools/list`.
+	* @param childSessionId - the member's child session.
+	* @param preset - the member's mode.
+	* @param cwd - the member's working directory.
+	* @returns the tools, empty when the host lacks the capabilities.
+	*/
+	async list(childSessionId, preset, cwd) {
+		const tools = this.probe("tools");
+		const fresh = this.hosts.get(childSessionId)?.preset !== preset;
+		const agent = await this.agentFor(childSessionId, preset, cwd);
+		if (tools === void 0 || agent === void 0) {
+			this.note({
+				childSessionId,
+				preset,
+				tools: tools !== void 0,
+				agent: agent !== void 0
+			});
+			return [];
+		}
+		let schemas = tools.schemas(agent);
+		if (fresh) for (let waited = 0; waited < SETTLE_MS; waited += SETTLE_STEP_MS) {
+			await new Promise((resolve) => setTimeout(resolve, SETTLE_STEP_MS));
+			const next = tools.schemas(agent);
+			if (next.length === schemas.length && waited >= 450) break;
+			schemas = next;
+		}
+		const listed = schemas.filter((schema) => isPluginTool(tools.get(schema.name, agent)));
+		this.note({
+			childSessionId,
+			preset,
+			agent: agent.id,
+			scope: schemas.map((schema) => {
+				const origin = tools.get(schema.name, agent)?.[ORIGIN];
+				return origin === void 0 ? schema.name : `${schema.name}<${String(origin.channel)}:${String(origin.owner)}>`;
+			}),
+			listed: listed.map((schema) => schema.name)
+		});
+		return listed.map((schema) => ({
+			name: schema.name,
+			description: schema.description ?? "",
+			inputSchema: schema.parameters ?? {
+				type: "object",
+				properties: {}
+			}
+		}));
+	}
+	/**
+	* Run one plugin tool for a member through the registry's execution
+	* pipeline (policies, approvals, timeouts), as the member's preset agent.
+	* @param childSessionId - the member's child session.
+	* @param preset - the member's mode.
+	* @param name - the tool name.
+	* @param args - the tool arguments.
+	* @param signal - cancellation.
+	* @param cwd - the member's working directory.
+	* @returns the MCP result.
+	*/
+	async call(childSessionId, preset, name, args, signal, cwd) {
+		const tools = this.probe("tools");
+		const agent = await this.agentFor(childSessionId, preset, cwd);
+		if (tools === void 0 || agent === void 0) return {
+			content: [{
+				type: "text",
+				text: "Mode tools are unavailable on this host"
+			}],
+			isError: true
+		};
+		if (!isPluginTool(tools.get(name, agent))) return {
+			content: [{
+				type: "text",
+				text: `Unknown tool ${name} in mode ${preset}`
+			}],
+			isError: true
+		};
+		const result = await tools.execute({
+			callId: `bridge-${randomUUID()}`,
+			name,
+			arguments: args,
+			agent,
+			signal
+		});
+		return {
+			content: mcpContent(result.content),
+			isError: result.isError
+		};
+	}
+	/**
+	* The skills the member's mode contributes: visible in its scope, absent
+	* from the global view (installed skills every CLI already sees stay out).
+	* @param childSessionId - the member's child session.
+	* @param preset - the member's mode.
+	* @returns the mode's skills with their content; empty without a skill registry.
+	*/
+	async skills(childSessionId, preset) {
+		const registry = this.probe("skills");
+		const agent = await this.agentFor(childSessionId, preset, void 0);
+		if (registry?.list === void 0 || agent === void 0) return [];
+		const global = new Set((await registry.list()).map((skill) => skill.name));
+		const own = (await registry.list({ scope: agent })).filter((skill) => !global.has(skill.name));
+		return (await Promise.all(own.map((skill) => registry.get(skill.name, { scope: agent })))).flatMap((skill) => skill === void 0 ? [] : [{
+			name: skill.name,
+			description: skill.description,
+			content: skill.content
+		}]);
+	}
+	/** Dispose every preset agent. */
+	async dispose() {
+		const hosts = [...this.hosts.values()];
+		this.hosts.clear();
+		await Promise.all(hosts.map((host) => host.agent.then((handle) => handle.dispose()).catch(() => {})));
+	}
+};
+//#endregion
 //#region lib/types/member-inbox.js
 /** Durable human input; the provider FIFO remains the sole execution order. */
 var MemberInbox = class {
@@ -2793,6 +3177,8 @@ var LiveStreamPublisher = class {
 	persist;
 	onError;
 	states = /* @__PURE__ */ new Map();
+	/** Items shown live but not yet in the log: their step cannot open before the earlier steps close. */
+	previews = /* @__PURE__ */ new Map();
 	constructor(streams, session, turn, persist, onError) {
 		this.streams = streams;
 		this.session = session;
@@ -2800,8 +3186,29 @@ var LiveStreamPublisher = class {
 		this.persist = persist;
 		this.onError = onError;
 	}
+	/**
+	* Show an item live without writing it to the session: a step may open in
+	* the log only after every earlier step has closed, so a later item that
+	* streams first waits here (browser-only) until the driver can open it.
+	*/
+	preview(step, kind, text, options = {}) {
+		const id = `${this.turn}:${step}${options.itemId === void 0 ? "" : `:${options.itemId}`}`;
+		const previous = this.previews.get(id);
+		if (previous?.text === text && previous.kind === kind) return;
+		const item = {
+			id,
+			turn: this.turn,
+			step,
+			kind,
+			text,
+			receivedAt: previous?.receivedAt ?? options.receivedAt ?? Date.now()
+		};
+		this.previews.set(id, item);
+		this.streams.publish(String(this.session.id), item);
+	}
 	update(step, kind, text, options = {}) {
 		const id = `${this.turn}:${step}${options.itemId === void 0 ? "" : `:${options.itemId}`}`;
+		this.previews.delete(id);
 		let state = this.states.get(id);
 		if (state?.item.text === text && state.item.kind === kind) return;
 		const receivedAt = options.receivedAt ?? Date.now();
@@ -2860,6 +3267,11 @@ var LiveStreamPublisher = class {
 	}
 	/** Call only after the corresponding native final message has been appended. */
 	finish(step) {
+		for (const [id, item] of this.previews) {
+			if (item.step !== step) continue;
+			this.previews.delete(id);
+			this.streams.finish(String(this.session.id), id);
+		}
 		for (const [id, state] of this.states) {
 			if (state.item.step !== step) continue;
 			if (state.timer !== void 0) clearTimeout(state.timer);
@@ -2879,6 +3291,8 @@ var LiveStreamPublisher = class {
 	}
 	/** A producer failure keeps a durable partial, without claiming completion. */
 	dispose() {
+		for (const id of this.previews.keys()) this.streams.finish(String(this.session.id), id);
+		this.previews.clear();
 		for (const [id, state] of this.states) {
 			this.checkpoint(id);
 			if (state.timer !== void 0) clearTimeout(state.timer);
@@ -3536,6 +3950,11 @@ function parseScopeFlag(input) {
 		...scope === void 0 ? {} : { scope }
 	};
 }
+/** A delegation record without its requested model. */
+function withoutModel(record) {
+	const { model: _model, ...rest } = record;
+	return rest;
+}
 /** Map a login failure to a command error, naming the swallowed signal. */
 function loginFailure(harness, exitCode, signal) {
 	return `${harness.name} login exited with ${signal ?? `code ${exitCode ?? "unknown"}`}; try /${harness.name} login again.`;
@@ -4142,7 +4561,8 @@ var LocalAgentRegistry = class {
 	recordDelegation(record) {
 		const binding = this.memberControls.binding(record.childSessionId);
 		if (binding !== void 0) record = {
-			...record,
+			...withoutModel(record),
+			...binding.model === void 0 ? {} : { model: binding.model },
 			...binding.effort === void 0 ? {} : { effort: binding.effort },
 			...binding.configurationLock === void 0 ? {} : { configurationLock: binding.configurationLock }
 		};
@@ -4667,8 +5087,12 @@ var LocalAgentRegistry = class {
 	* const handle = await ctx.sessionPersistence.open(SessionId(childSessionId), 'write')
 	* try {
 	*   const cold = await handle.read(0)
+	*   // Close a turn a restart interrupted, or the next round's turn/start
+	*   // makes the stored log unreadable.
+	*   const closers = interruptedTurnClosers(cold.events)
+	*   if (closers.length > 0) await handle.append(closers)
 	*   const session = ctx.sessions.prepare(SessionId(childSessionId), {
-	*     seed: [...cold.events],
+	*     seed: [...cold.events, ...closers],
 	*     meta: structuredClone(handle.header),
 	*     inheritedEventCount: handle.inheritedEventCount,
 	*     eventState: cold.eventState,
@@ -4676,7 +5100,7 @@ var LocalAgentRegistry = class {
 	*   // The seeded constructor's session/end-seed marker lands before enter()
 	*   // installs publication hooks — push the unstored suffix through the
 	*   // handle directly, or the writer's contiguous cursor diverges.
-	*   const unstored = session.snapshotEvents().slice(cold.events.length)
+	*   const unstored = session.snapshotEvents().slice(cold.events.length + closers.length)
 	*   if (unstored.length > 0) await handle.append(unstored)
 	*   const detach = ctx.sessions.enter(session)
 	*   try { ctx.sessions.announce(session) }
@@ -4904,13 +5328,16 @@ var LocalAgentRegistry = class {
 		const handle = await this.acquireChildWriteHandle(childSessionId);
 		try {
 			const cold = await handle.read(0);
+			const closeOpenTurn = sessionModule.interruptedTurnClosers;
+			const closers = closeOpenTurn === void 0 ? [] : closeOpenTurn(cold.events);
+			if (closers.length > 0) await handle.append(closers);
 			const session = sessions.prepare(SessionId(childSessionId), {
-				seed: [...cold.events],
+				seed: [...cold.events, ...closers],
 				meta: structuredClone(handle.header),
 				inheritedEventCount: handle.inheritedEventCount,
 				eventState: cold.eventState
 			});
-			const unstored = session.snapshotEvents().slice(cold.events.length);
+			const unstored = session.snapshotEvents().slice(cold.events.length + closers.length);
 			if (unstored.length > 0) await handle.append(unstored);
 			const detach = sessions.enter(session);
 			try {
@@ -4940,18 +5367,41 @@ var LocalAgentRegistry = class {
 	* @param session - the live child session to sync.
 	*/
 	async syncChildSession(session, strict = false) {
+		const id = String(session.id);
 		try {
-			const handle = await this.acquireChildWriteHandle(String(session.id), session.header);
-			const stored = await handle.read(0);
-			const suffix = session.snapshotEvents().slice(stored.events.length);
-			if (suffix.length > 0) await handle.append(suffix);
-			await handle.flush();
+			try {
+				await this.syncChildSessionOnce(session);
+			} catch (error) {
+				if (!/append seq mismatch/.test(error instanceof Error ? error.message : String(error))) throw error;
+				await this.releaseChildWriteHandle(id);
+				await this.syncChildSessionOnce(session);
+			}
 		} catch (error) {
 			if (strict) throw error;
-			this.ctx.logger.warn(`localAgent: syncing child session ${String(session.id)} to persistence failed: ${error instanceof Error ? error.message : String(error)}`);
+			this.ctx.logger.warn(`localAgent: syncing child session ${id} to persistence failed: ${error instanceof Error ? error.message : String(error)}`);
 		}
 	}
 	/**
+	* One sync pass. While the write handle is open the host routes every live
+	* append into the writer's buffer, so the routed events are drained first
+	* (`sessions.flush`: drain + flush) and only what is STILL missing — events
+	* from before the handle opened, or a host that routes nothing — goes in
+	* explicitly, bounded to the events that existed before the drain. Appending
+	* routed-but-undrained events explicitly as well would land them twice: the
+	* explicit write wins, the buffered copy then fails contiguity forever, and
+	* every later flush — the host's tool-execution checkpoint included —
+	* throws "append seq mismatch".
+	*/
+	async syncChildSessionOnce(session) {
+		const handle = await this.acquireChildWriteHandle(String(session.id), session.header);
+		const known = session.snapshotEvents().length;
+		await this.ctx.get("sessions")?.flush(session);
+		const stored = await handle.read(0);
+		const missing = session.snapshotEvents().slice(stored.events.length, known);
+		if (missing.length > 0) await handle.append(missing);
+		await handle.flush();
+	}
+	/**
 	* Get or open the child session's registry-owned WRITE handle (the
 	* {@link childWriteHandles} cache). When the caller carries the session
 	* header (a sync), a missing stored session is created from it; a create
@@ -5543,10 +5993,29 @@ async function apply(ctx, config) {
 	const registry = new LocalAgentRegistry(ctx, config.homesRoot, config.loginPromptTimeoutMs ?? 1e4);
 	ctx.provide(LOCAL_AGENT_SERVICE, registry);
 	new LocalAgentGateway(ctx);
-	const memberChannel = new MemberChannel(ctx, registry, registry.memberBridgeSocketPath());
+	const modeTools = new PresetToolHost(ctx, join(config.homesRoot, "mode-tools.jsonl"));
+	const memberChannel = new MemberChannel(ctx, registry, registry.memberBridgeSocketPath(), modeTools);
 	memberChannel.start();
+	ctx.on("approval/request", async (request, next) => {
+		const child = modeTools.memberOf(request.agent);
+		const delegation = child === void 0 ? void 0 : registry.getDelegation(child);
+		const room = ctx.get.call(ctx, "room");
+		if (child === void 0 || delegation === void 0 || room?.askMemberApproval === void 0) return next();
+		const reason = request.displayReason ?? request.reason;
+		const outcome = await room.askMemberApproval({
+			childSessionId: child,
+			parentSessionId: delegation.parentSessionId,
+			provider: delegation.provider
+		}, {
+			toolName: request.toolName,
+			...reason === void 0 ? {} : { reason },
+			...request.signal === void 0 ? {} : { signal: request.signal }
+		});
+		return outcome === "unavailable" ? next() : outcome;
+	}, { prepend: true });
 	ctx.effect(() => () => {
 		memberChannel.dispose();
+		modeTools.dispose();
 	});
 	ctx.commands.register({
 		name: "local-agent",