dsh-deeppilot 0.9.9 → 0.9.13

package/lib/index.js

@@ -4,9 +4,9 @@ import { access, appendFile, chmod, mkdir, readFile, readdir, rename, rm, stat,
 import { dirname, join, resolve } from "node:path";
 import { WebSocketServer } from "ws";
 import { homedir, networkInterfaces } from "node:os";
+import { closeSync, constants, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import z from "@deepseek-ai/schemastery";
 import { spawn } from "node:child_process";
-import { closeSync, constants, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { connect } from "node:http2";
 import { createServer } from "node:http";
@@ -41,7 +41,8 @@ const ERROR_CODES = {
 	E_NOT_FOUND: "session or request not found",
 	E_BUSY: "session is busy",
 	E_UNSUPPORTED: "protocol version or capability unsupported",
-	E_INTERNAL: "internal error"
+	E_INTERNAL: "internal error",
+	E_STEER_UNAVAILABLE: "queued item can no longer steer the current turn"
 };
 /** Bridge 未携带 code 的结果（内部守卫失败等）落到这一档。 */
 const WIRE_ERROR_FALLBACK = "E_INTERNAL";
@@ -116,6 +117,13 @@ const DOMAIN_TABLES = {
 		"session-not-found": "E_NOT_FOUND",
 		"agent-busy": "E_BUSY",
 		"session-conflict": "E_BUSY"
+	},
+	queue: {
+		"session/queue-item-not-found": "E_NOT_FOUND",
+		"session/steer-unavailable": "E_STEER_UNAVAILABLE",
+		"session/agent-busy": "E_BUSY",
+		"session/writer-held": "E_BUSY",
+		"gateway/bad-request": "E_PROTOCOL"
 	}
 };
 /**
@@ -249,6 +257,10 @@ function isEnvelope(value) {
 */
 const PUSH_SCOPE_BY_TYPE = {
 	"s2c.session.event": "sessions.read",
+	"s2c.session.delta": "sessions.read",
+	"s2c.plugin.update.status": "sessions.read",
+	"s2c.plugin.update.progress": "sessions.manage",
+	"s2c.session.queue": "sessions.read",
 	"s2c.skills.changed": "sessions.read",
 	"s2c.commands.changed": "sessions.read",
 	"s2c.models.changed": "sessions.read",
@@ -2560,6 +2572,7 @@ const sessionRows = [
 			if (invalid) return invalid;
 			const p = checked.value;
 			if (p.clientSendId !== void 0 && !validSendId(p.clientSendId)) return reject$1("E_PROTOCOL", "invalid clientSendId");
+			if (p.mode !== void 0 && p.mode !== "queue" && p.mode !== "steer") return reject$1("E_PROTOCOL", "invalid prompt mode");
 			if (!isOptionalField(p, "text", (v) => isText(v, 262144, false)) || !isOptionalField(p, "images", Array.isArray) || !isOptionalField(p, "documents", Array.isArray)) return reject$1("E_PROTOCOL", "invalid prompt fields");
 			for (const key of ["images", "documents"]) {
 				const items = p[key];
@@ -2607,6 +2620,7 @@ const sessionRows = [
 				text,
 				images,
 				documents,
+				...p.mode === "steer" ? { mode: "steer" } : {},
 				...p.clientSendId !== void 0 ? { clientSendId: p.clientSendId } : {}
 			});
 		},
@@ -2616,22 +2630,56 @@ const sessionRows = [
 			const images = payload.images;
 			const documents = payload.documents;
 			const clientSendId = payload.clientSendId;
+			const steer = payload.mode === "steer";
+			if (steer && ctx.bridge.capabilities.promptQueue !== true) return ctx.fail("E_UNSUPPORTED", "prompt queue not supported");
+			const mode = steer ? "steer" : "queue";
 			if (clientSendId !== void 0) {
 				const receipt = await ctx.bridge.promptDeliveries.dispatch(ctx.deviceId, clientSendId, {
 					sessionId,
 					content: {
 						text,
 						images,
-						documents
+						documents,
+						...steer ? { mode } : {}
 					}
-				}, () => ctx.bridge.sendPrompt(sessionId, text, images, documents));
+				}, () => ctx.bridge.sendPrompt(sessionId, text, images, documents, {
+					mode,
+					clientSendId
+				}));
 				ctx.send("s2c.ack", receipt);
 				return;
 			}
-			const userSeq = await ctx.bridge.sendPrompt(sessionId, text, images, documents);
+			const userSeq = await ctx.bridge.sendPrompt(sessionId, text, images, documents, { mode });
 			if (!userSeq.ok) return ctx.fail(userSeq.code, userSeq.message);
 			ctx.send("s2c.ack", { userSeq: userSeq.value });
 		}
+	},
+	{
+		type: "c2s.session.queue.update",
+		stage: "authenticated",
+		scopes: ["prompt.send"],
+		capability: "promptQueue",
+		doc: "PROTOCOL.md c2s.session.queue.update",
+		validate: (payload) => {
+			const checked = payloadObject(payload);
+			if (!checked.ok) return checked;
+			const invalid = requireSessionId(checked.value);
+			if (invalid) return invalid;
+			if (!isText(checked.value.itemId, 256)) return reject$1("E_PROTOCOL", "invalid itemId");
+			const action = checked.value.action;
+			if (action === "edit") return reject$1("E_UNSUPPORTED", "queue edit not supported");
+			if (action !== "remove" && action !== "steer") return reject$1("E_PROTOCOL", "invalid queue action");
+			return accept({
+				sessionId: checked.value.sessionId,
+				itemId: checked.value.itemId,
+				action
+			});
+		},
+		handle: async (ctx, payload) => {
+			const result = await ctx.bridge.updateQueue(payload.sessionId, payload.itemId, payload.action);
+			if (!result.ok) return ctx.fail(result.code, result.message);
+			ctx.send("s2c.ack", result.value);
+		}
 	}
 ];
 //#endregion
@@ -2701,16 +2749,24 @@ const commandRows = [...[
 	stage: "authenticated",
 	scopes: ["sessions.read"],
 	capability: "commands",
+	conditionalCapabilities: ["sessionMarkdown"],
 	doc: "PROTOCOL.md c2s.session.export",
-	validate: sessionPayload,
+	validate: (value) => {
+		const result = sessionPayload(value);
+		if (!result.ok) return result;
+		if (result.value.format !== void 0 && result.value.format !== "zip" && result.value.format !== "markdown") return reject$1("E_PROTOCOL", "导出格式无效");
+		return result;
+	},
 	handle: async (ctx, payload) => {
+		const format = payload.format;
+		if (format === "markdown" && ctx.bridge.capabilities.sessionMarkdown !== true) return ctx.fail("E_UNSUPPORTED", "当前主机不支持导出对话正文");
 		const signal = AbortSignal.any([ctx.signal ?? new AbortController().signal, AbortSignal.timeout(6e5)]);
 		let reader;
 		const cancel = () => {
 			reader?.cancel().catch(() => {});
 		};
 		try {
-			reader = (await ctx.bridge.exportSession(payload.sessionId, signal)).body.getReader();
+			reader = (format === void 0 ? await ctx.bridge.exportSession(payload.sessionId, signal) : await ctx.bridge.exportSession(payload.sessionId, signal, format)).body.getReader();
 			signal.addEventListener("abort", cancel, { once: true });
 			let index = 0, bytes = 0;
 			while (true) {
@@ -2730,9 +2786,10 @@ const commandRows = [...[
 			signal.throwIfAborted();
 			ctx.send("s2c.ack", {
 				sessionId: payload.sessionId,
-				fileName: "dsh-session-log.zip",
+				fileName: format === "markdown" ? "dsh-session.md" : "dsh-session-log.zip",
 				chunks: index,
-				bytes
+				bytes,
+				...format === void 0 ? {} : { mediaType: format === "markdown" ? "text/markdown; charset=utf-8" : "application/zip" }
 			});
 		} catch (error) {
 			const failure = hostFailureOf(error, "command/export-cancelled");
@@ -2749,6 +2806,570 @@ const commandRows = [...[
 		}
 	}
 }];
+//#endregion
+//#region src/plugin-update.ts
+const PACKAGE = "dsh-deeppilot";
+const PHASES = [
+	"preparing",
+	"installing",
+	"verifying",
+	"restart-required",
+	"done",
+	"rolled-back",
+	"failed"
+];
+const CELLS = Symbol.for("deeppilot.plugin-update.cells.v1");
+const globals = globalThis;
+const cells = globals[CELLS] ??= /* @__PURE__ */ new Map();
+const ownerKey = (deviceId) => createHash("sha256").update(deviceId).digest("hex");
+const validVersion = (value) => typeof value === "string" && /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(value) && value.length <= 128;
+const validUpdateRequestId = (value) => typeof value === "string" && /^[A-Za-z0-9._:-]{1,128}$/.test(value);
+const terminal = (phase) => [
+	"done",
+	"failed",
+	"rolled-back",
+	"restart-required"
+].includes(phase);
+const publicRecord = ({ ownerKey: _owner, restartVersion: _restartVersion, restartPhase: _restartPhase, restartBoot: _restartBoot, ...record }) => ({ ...record });
+var PluginUpdateError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+/** 精确镜像 alpha2 公开 registryPlan，避免静态依赖让旧宿主无法加载插件；由真实函数对照测试守卫。 */
+function updateRegistryPlan(requested, configured) {
+	const own = configured.resolved === null ? null : normalizeUpdateRegistry(configured.resolved);
+	const fallbacks = configured.fallbackRegistries.map(normalizeUpdateRegistry);
+	const ownIsPublic = own !== null && (own === "https://registry.npmjs.org/" || fallbacks.includes(own));
+	const keyOf = (registry) => registry === null ? own : normalizeUpdateRegistry(registry);
+	const known = [];
+	const keys = [];
+	for (const registry of [configured.registry, ...configured.fallbackRegistries]) {
+		if (registry === null && !ownIsPublic) continue;
+		const key = keyOf(registry);
+		if (keys.includes(key)) continue;
+		known.push(registry === null ? null : normalizeUpdateRegistry(registry));
+		keys.push(key);
+	}
+	const first = requested === void 0 ? configured.registry : requested;
+	const firstKey = keyOf(first);
+	const normalizedFirst = first === null ? null : normalizeUpdateRegistry(first);
+	if ((first === null || firstKey === own) && !ownIsPublic) return [normalizedFirst];
+	if (!keys.includes(firstKey)) return [normalizedFirst];
+	return [normalizedFirst, ...known.filter((_registry, index) => keys[index] !== firstKey)];
+}
+function normalizeUpdateRegistry(registry) {
+	const parsed = new URL(registry);
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error("registry unavailable");
+	if (!parsed.pathname.endsWith("/")) parsed.pathname += "/";
+	return parsed.href;
+}
+function updateRegistrySources(requested, configured) {
+	return [...new Set(updateRegistryPlan(requested, configured).map((registry) => {
+		const resolved = registry === null ? configured.resolved : registry;
+		if (!resolved) throw new Error("registry unresolved");
+		return normalizeUpdateRegistry(resolved);
+	}))];
+}
+/** 只接受具有完整规范摘要的强 SRI；宽松 base64 解码不能把截断值或弱摘要当作安装凭据。 */
+function strongIntegrity(value) {
+	if (typeof value !== "string") return void 0;
+	const match = /^(sha256|sha384|sha512)-([A-Za-z0-9+/]+={0,2})$/.exec(value);
+	if (!match) return void 0;
+	const digest = Buffer.from(match[2], "base64");
+	const bytes = {
+		sha256: 32,
+		sha384: 48,
+		sha512: 64
+	}[match[1]];
+	return digest.length === bytes && digest.toString("base64") === match[2] ? value : void 0;
+}
+/** 精确版本事实由元数据读取；软件源地址、上游响应体及包管理器诊断不进入对外错误。 */
+async function readTargetManifestFacts(registry, version, fetcher) {
+	const base = new URL(registry);
+	if (!["http:", "https:"].includes(base.protocol) || base.username || base.password || base.search || base.hash || !validVersion(version)) throw new Error("registry unavailable");
+	base.pathname = base.pathname.replace(/\/?$/, "/") + encodeURIComponent(PACKAGE) + "/" + encodeURIComponent(version);
+	const response = await fetcher(base, {
+		signal: AbortSignal.timeout(1e4),
+		redirect: "error",
+		headers: { accept: "application/json" }
+	});
+	if (!response.ok || !response.body) throw new Error("manifest unavailable");
+	const reader = response.body.getReader();
+	const chunks = [];
+	let bytes = 0;
+	try {
+		while (true) {
+			const next = await reader.read();
+			if (next.done) break;
+			bytes += next.value.length;
+			if (bytes > 1048576) throw new Error("manifest too large");
+			chunks.push(next.value);
+		}
+	} finally {
+		await reader.cancel().catch(() => {});
+		reader.releaseLock();
+	}
+	const manifest = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+	if (manifest.name !== PACKAGE || manifest.version !== version || !manifest.dsh?.bundle) throw new Error("manifest mismatch");
+	const protocol = manifest.deepPilot?.protocolVersion;
+	return {
+		protocolVersion: typeof protocol === "number" && Number.isSafeInteger(protocol) && protocol > 0 ? protocol : void 0,
+		integrity: strongIntegrity(manifest.dist?.integrity)
+	};
+}
+/** 检查界面只预览首个软件源的协议；实际安装必须通过全部可回退源的强校验。 */
+async function readTargetProtocol(registry, version, fetcher = fetch) {
+	return (await readTargetManifestFacts(registry, version, fetcher)).protocolVersion;
+}
+var PluginUpdater = class {
+	options;
+	state;
+	path;
+	listVersions;
+	updateBundle;
+	listBundles;
+	registries;
+	constructor(options) {
+		this.options = options;
+		this.path = resolve(options.journalPath);
+		this.listVersions = options.manager.listVersions.bind(options.manager);
+		this.updateBundle = options.manager.updateBundle.bind(options.manager);
+		this.listBundles = options.manager.listBundles.bind(options.manager);
+		this.registries = options.manager.registries.bind(options.manager);
+		let state = cells.get(this.path);
+		if (!state) {
+			state = {
+				bootId: randomUUID(),
+				records: [],
+				listeners: /* @__PURE__ */ new Set(),
+				runningVersion: options.currentVersion,
+				healthy: true
+			};
+			if (existsSync(this.path)) try {
+				if (statSync(this.path).size > 262144) throw new Error("oversized journal");
+				const data = JSON.parse(readFileSync(this.path, "utf8"));
+				if (data.version !== 1 || !Array.isArray(data.records) || data.records.length > 128 || data.records.some((record) => !record || !validUpdateRequestId(record.clientRequestId) || !validVersion(record.fromVersion) || !validVersion(record.toVersion) || !PHASES.includes(record.phase) || !Number.isSafeInteger(record.startedAt) || record.startedAt < 0 || typeof record.message !== "string" || record.message.length > 1024 || !/^[a-f0-9]{64}$/.test(record.ownerKey) || record.restartVersion !== void 0 && !validVersion(record.restartVersion) || record.restartBoot !== void 0 && (typeof record.restartBoot !== "string" || record.restartBoot.length > 128) || record.restartPhase !== void 0 && record.restartPhase !== "done" && record.restartPhase !== "rolled-back") || new Set(data.records.map((record) => record.clientRequestId)).size !== data.records.length) throw new Error("invalid journal");
+				state.records = data.records;
+			} catch {
+				state.healthy = false;
+			}
+			cells.set(this.path, state);
+		}
+		this.state = state;
+		state.runningVersion = options.currentVersion;
+	}
+	save() {
+		mkdirSync(dirname(this.path), {
+			recursive: true,
+			mode: 448
+		});
+		const temp = this.path + "." + randomUUID() + ".tmp";
+		const fd = openSync(temp, "wx", 384);
+		try {
+			writeFileSync(fd, JSON.stringify({
+				version: 1,
+				records: this.state.records
+			}));
+			fsyncSync(fd);
+		} finally {
+			closeSync(fd);
+		}
+		renameSync(temp, this.path);
+		const directory = openSync(dirname(this.path), "r");
+		try {
+			fsyncSync(directory);
+		} catch (error) {
+			if (![
+				"EPERM",
+				"EISDIR",
+				"EINVAL"
+			].includes(String(error.code))) throw error;
+		} finally {
+			closeSync(directory);
+		}
+	}
+	transition(record, phase, message) {
+		const before = { ...record };
+		record.phase = phase;
+		record.message = message;
+		if (phase === "restart-required") record.restartBoot = this.state.bootId;
+		try {
+			this.save();
+		} catch (error) {
+			Object.assign(record, before);
+			record.restartBoot = before.restartBoot;
+			throw error;
+		}
+		for (const listener of this.state.listeners) try {
+			listener({
+				clientRequestId: record.clientRequestId,
+				phase,
+				message
+			}, record.ownerKey);
+		} catch {}
+	}
+	subscribe(deviceId, listener) {
+		const key = ownerKey(deviceId);
+		const wrapped = (event, owner) => {
+			if (owner === key) listener(event);
+		};
+		this.state.listeners.add(wrapped);
+		return () => {
+			this.state.listeners.delete(wrapped);
+		};
+	}
+	recover() {
+		if (this.state.active || !this.state.healthy) return;
+		for (const record of this.state.records) if (record.phase === "restart-required" && record.restartBoot !== this.state.bootId && this.options.currentVersion === (record.restartVersion ?? record.toVersion)) this.transition(record, record.restartPhase ?? "done", record.restartPhase === "rolled-back" ? "重启后已运行旧版本，宿主回滚完成" : "重启后已运行目标版本，更新完成");
+		else if (!terminal(record.phase)) {
+			if (this.options.currentVersion === record.toVersion) this.transition(record, "done", "已重新连接到目标版本，更新完成");
+			else this.transition(record, "failed", "上次更新已中断，结果无法确认；请检查当前版本，原请求不会自动重试");
+		}
+	}
+	async check(deviceId) {
+		let reason;
+		try {
+			this.recover();
+		} catch {
+			reason = "更新日志保存失败，暂时无法确认更新结果";
+		}
+		if (!this.state.healthy) reason = "更新日志无法读取，已停用安装以保护上次更新记录";
+		const finish = (status) => {
+			const journal = [...this.state.records].reverse().find((record) => record.ownerKey === ownerKey(deviceId));
+			return {
+				...status,
+				...journal ? { journal: publicRecord(journal) } : {}
+			};
+		};
+		const base = {
+			currentVersion: this.options.currentVersion,
+			protocolVersion: 2,
+			latestVersion: null,
+			updateAvailable: false,
+			compatible: false,
+			protocolCompatible: false,
+			versions: [],
+			checkedAt: Date.now()
+		};
+		try {
+			const listed = await this.listVersions(PACKAGE);
+			if (listed.status !== "listed") return finish({
+				...base,
+				reason: reason ?? "暂时无法读取可更新版本，请稍后重试"
+			});
+			const registry = listed.registry ?? (await this.registries()).resolved;
+			if (!registry) return finish({
+				...base,
+				reason: reason ?? "无法确定软件源，暂时不能核对目标版本协议"
+			});
+			const versions = await Promise.all(listed.versions.slice(0, 10).map(async (entry) => {
+				let protocolVersion;
+				try {
+					protocolVersion = await readTargetProtocol(registry, entry.version, this.options.fetch);
+				} catch {}
+				return {
+					version: entry.version,
+					compatible: entry.bundle && entry.incompatible === void 0,
+					...protocolVersion === void 0 ? {} : { protocolVersion }
+				};
+			}));
+			const latest = versions[0];
+			return finish({
+				...base,
+				latestVersion: latest?.version ?? null,
+				updateAvailable: versions.length > 0,
+				compatible: latest?.compatible ?? false,
+				protocolCompatible: latest?.protocolVersion === 2,
+				versions,
+				...reason ? { reason } : versions.some((entry) => entry.protocolVersion === void 0) ? { reason: "部分目标版本缺少可核验的协议声明，暂时不可安装" } : {}
+			});
+		} catch {
+			return finish({
+				...base,
+				reason: reason ?? "暂时无法检查更新，请确认网络后重试"
+			});
+		}
+	}
+	/** The apply frame is the phone's explicit confirmation. check() never mutates packages. */
+	async apply(deviceId, version, clientRequestId) {
+		if (!validVersion(version) || !validUpdateRequestId(clientRequestId)) throw new PluginUpdateError("E_PROTOCOL", "更新版本或请求标识无效");
+		if (!this.state.healthy) throw new PluginUpdateError("E_INTERNAL", "更新日志无法读取，暂时不能安装");
+		const previous = this.state.records.find((record) => record.clientRequestId === clientRequestId);
+		if (previous) {
+			if (previous.ownerKey !== ownerKey(deviceId)) throw new PluginUpdateError("E_FORBIDDEN", "更新请求不属于当前设备");
+			if (previous.toVersion !== version) throw new PluginUpdateError("E_PROTOCOL", "同一更新请求不能更换目标版本");
+			this.recover();
+			return publicRecord(previous);
+		}
+		const pending = this.state.pending;
+		if (pending?.record.clientRequestId === clientRequestId) {
+			if (pending.record.ownerKey !== ownerKey(deviceId)) throw new PluginUpdateError("E_FORBIDDEN", "更新请求不属于当前设备");
+			if (pending.record.toVersion !== version) throw new PluginUpdateError("E_PROTOCOL", "同一更新请求不能更换目标版本");
+			return pending.accepted;
+		}
+		if (this.state.active) throw new PluginUpdateError("E_BUSY", "已有插件更新正在进行，请稍后检查结果");
+		if (this.state.records.length >= 128) throw new PluginUpdateError("E_INTERNAL", "更新记录已满，请在电脑端检查后再更新");
+		const record = {
+			clientRequestId,
+			fromVersion: this.options.currentVersion,
+			toVersion: version,
+			phase: "preparing",
+			startedAt: Date.now(),
+			message: "目标校验已通过，准备开始安装",
+			ownerKey: ownerKey(deviceId)
+		};
+		let accept;
+		let refuse;
+		const accepted = new Promise((resolve_, reject_) => {
+			accept = resolve_;
+			refuse = reject_;
+		});
+		this.state.pending = {
+			record,
+			accepted
+		};
+		const operation = Promise.resolve().then(async () => {
+			let registry;
+			try {
+				registry = await this.prepare(record);
+				this.state.records.push(record);
+				try {
+					this.save();
+				} catch {
+					this.state.records.splice(this.state.records.indexOf(record), 1);
+					throw new PluginUpdateError("E_INTERNAL", "更新日志保存失败，尚未开始安装");
+				}
+			} catch (error) {
+				if (this.state.active === operation) this.state.active = void 0;
+				if (this.state.pending?.record === record) this.state.pending = void 0;
+				refuse(error instanceof PluginUpdateError ? error : new PluginUpdateError("E_INTERNAL", "无法核对目标版本，尚未开始安装"));
+				return;
+			}
+			if (this.state.pending?.record === record) this.state.pending = void 0;
+			accept(publicRecord(record));
+			await new Promise((resolve_) => setImmediate(resolve_));
+			try {
+				await this.run(record, registry);
+			} catch {
+				try {
+					this.transition(record, "failed", "更新结果无法确认，请检查当前版本；原请求不会自动重试");
+				} catch {}
+			}
+		}).finally(() => {
+			if (this.state.active === operation) this.state.active = void 0;
+		});
+		this.state.active = operation;
+		return accepted;
+	}
+	/** Useful to isolated tests; production never waits for this from disposal. */
+	async settled() {
+		await this.state.active;
+	}
+	/** 所有可执行目标校验在受理前完成；宿主安装及其回滚处理仍属于独立的后续任务。 */
+	async prepare(record) {
+		let listed;
+		try {
+			listed = await this.listVersions(PACKAGE);
+		} catch {
+			throw new PluginUpdateError("E_INTERNAL", "无法核对可更新版本，尚未开始安装");
+		}
+		if (listed.status !== "listed" || listed.installed !== record.fromVersion) throw new PluginUpdateError("E_PROTOCOL", "安装版本已变化或无法读取，请重新检查更新");
+		const target = listed.versions.find((entry) => entry.version === record.toVersion);
+		if (!target?.bundle || target.incompatible !== void 0) throw new PluginUpdateError("E_UNSUPPORTED", "目标版本不存在或不兼容当前宿主，尚未开始安装");
+		try {
+			const sources = updateRegistrySources(listed.registry, await this.registries());
+			let integrity;
+			for (const source of sources) {
+				const facts = await readTargetManifestFacts(source, record.toVersion, this.options.fetch ?? fetch);
+				if (facts.protocolVersion !== 2) throw new PluginUpdateError("E_UNSUPPORTED", "候选软件源的目标协议不兼容或缺少声明，尚未开始安装");
+				if (!facts.integrity) throw new PluginUpdateError("E_UNSUPPORTED", "候选软件源缺少有效的强完整性摘要，尚未开始安装");
+				if (integrity !== void 0 && facts.integrity !== integrity) throw new PluginUpdateError("E_UNSUPPORTED", "候选软件源的目标包完整性摘要不一致，尚未开始安装");
+				integrity = facts.integrity;
+			}
+			const current = updateRegistrySources(listed.registry, await this.registries());
+			if (JSON.stringify(current) !== JSON.stringify(sources)) throw new PluginUpdateError("E_BUSY", "软件源配置已变化，请重新检查更新");
+		} catch (error) {
+			if (error instanceof PluginUpdateError) throw error;
+			throw new PluginUpdateError("E_INTERNAL", "无法核验全部候选软件源的目标协议与完整性，尚未开始安装");
+		}
+		return listed.registry;
+	}
+	async run(record, registry) {
+		this.transition(record, "installing", "宿主正在安装目标版本，连接可能暂时中断");
+		const outcome = await this.updateBundle(PACKAGE, record.toVersion, {
+			registry,
+			requestId: record.clientRequestId
+		});
+		const result = outcome.result;
+		if (outcome.from !== record.fromVersion || outcome.to !== record.toVersion) return this.transition(record, "failed", "宿主返回的更新版本不一致，请检查当前安装");
+		if (outcome.restore) {
+			const restored = outcome.restore;
+			if (restored.application === "restart-required") {
+				record.restartVersion = record.fromVersion;
+				record.restartPhase = "rolled-back";
+				return this.transition(record, "restart-required", "目标安装失败，旧版已重新安装；请在电脑端重启 DSH 后确认恢复");
+			}
+			if (restored.application === "applied" && (restored.version === void 0 || restored.version === record.fromVersion)) {
+				if ((await this.listBundles()).find((bundle) => bundle.name === PACKAGE)?.version === record.fromVersion) return this.transition(record, "rolled-back", "目标安装失败，宿主已自动恢复旧版本");
+				return this.transition(record, "failed", "宿主已尝试回滚，但无法核对实际旧版本，请在电脑端检查插件");
+			}
+			return this.transition(record, "failed", "目标安装失败，宿主恢复旧版也未完成，请在电脑端检查插件");
+		}
+		if (outcome.step !== "install" || result.application === "failed" || result.application === "cancelled" || result.application === "overridden") return this.transition(record, "failed", installFailureMessage(result));
+		if (result.version !== void 0 && result.version !== record.toVersion) return this.transition(record, "failed", "实际安装版本与目标不一致，请在电脑端检查");
+		if (result.application === "restart-required") return this.transition(record, "restart-required", "目标版本已安装，宿主需要重启；请在电脑端重启 DSH 后重新连接");
+		this.transition(record, "verifying", "正在核对实际安装版本");
+		if ((await this.listBundles()).find((bundle) => bundle.name === PACKAGE)?.version !== record.toVersion) return this.transition(record, "failed", "无法确认实际安装版本，请在电脑端检查");
+		if (this.state.runningVersion !== record.toVersion) return this.transition(record, "restart-required", "目标版本已安装，当前插件尚未重新加载；请在电脑端重启 DSH 后重新连接");
+		this.transition(record, "done", "目标版本已加载，更新完成");
+	}
+};
+function installFailureMessage(result) {
+	if (result.error?.code === "incompatible-version" || result.error?.incompatible?.length || result.packageResult?.incompatible?.length) return "目标版本不兼容当前宿主，安装已拒绝（incompatible-version）";
+	if (result.pendingBuilds?.length || result.packageResult?.kind === "build-blocked") return "安装需要在电脑端明确批准构建脚本，更新未完成（build-blocked）";
+	const kind = result.packageResult?.kind;
+	const reasons = {
+		"pnpm-missing": "电脑端缺少包管理器，更新未完成",
+		timeout: "安装等待超时，请检查电脑端后重试",
+		"not-found": "软件源尚未提供目标包，更新未完成",
+		"no-matching-version": "软件源尚未提供目标版本，更新未完成",
+		network: "安装无法连接软件源，请恢复网络后重新检查",
+		"disk-full": "电脑端磁盘空间不足，更新未完成",
+		permission: "电脑端没有写入插件的权限，更新未完成",
+		integrity: "目标包完整性校验失败，更新未完成"
+	};
+	if (kind && reasons[kind]) return `${reasons[kind]}（${kind}）`;
+	if (result.application === "cancelled") return "宿主已取消目标版本安装，请检查当前版本";
+	return "宿主未完成目标版本安装，请检查当前版本";
+}
+function supportsPluginUpdate(value) {
+	if (!value || typeof value !== "object") return false;
+	return [
+		"listVersions",
+		"updateBundle",
+		"listBundles",
+		"registries"
+	].every((key) => typeof value[key] === "function");
+}
+//#endregion
+//#region src/wire-plugin-update.ts
+function payloadObject$1(value) {
+	if (value === void 0 || value === null) return {
+		ok: true,
+		value: {}
+	};
+	if (typeof value !== "object" || Array.isArray(value)) return {
+		ok: false,
+		code: "E_PROTOCOL",
+		message: "更新请求必须是对象"
+	};
+	return {
+		ok: true,
+		value
+	};
+}
+const updaters = /* @__PURE__ */ new WeakMap();
+/** Bridge replacement and optional host service discovery can arrive in either order. */
+function setPluginUpdater(bridge, updater) {
+	if (updater) updaters.set(bridge, updater);
+	else updaters.delete(bridge);
+}
+const observers = /* @__PURE__ */ new WeakMap();
+function observe(ctx, updater, deviceId) {
+	if (!ctx.canReceive("sessions.manage")) return;
+	const signal = ctx.signal;
+	if (signal?.aborted || signal && observers.get(signal)?.has(updater)) return;
+	let stop = () => {};
+	const unsubscribe = updater.subscribe(deviceId, (event) => {
+		if (!ctx.canReceive("sessions.manage")) {
+			stop();
+			return;
+		}
+		ctx.send("s2c.plugin.update.progress", event);
+		if (!signal && finished(event.phase)) stop();
+	});
+	stop = () => {
+		unsubscribe();
+		signal?.removeEventListener("abort", stop);
+		if (signal) observers.get(signal)?.delete(updater);
+	};
+	if (signal) {
+		let connections = observers.get(signal);
+		if (!connections) {
+			connections = /* @__PURE__ */ new Set();
+			observers.set(signal, connections);
+		}
+		connections.add(updater);
+		signal.addEventListener("abort", stop, { once: true });
+	}
+}
+const finished = (phase) => phase === void 0 || [
+	"done",
+	"failed",
+	"rolled-back",
+	"restart-required"
+].includes(phase);
+const pluginUpdateRows = [{
+	type: "c2s.plugin.update.check",
+	stage: "authenticated",
+	scopes: ["sessions.read"],
+	widgetPolicy: "deny",
+	capability: "pluginUpdate",
+	doc: "PROTOCOL.md c2s.plugin.update.check",
+	validate: payloadObject$1,
+	handle: async (ctx) => {
+		const updater = updaters.get(ctx.bridge);
+		if (!updater) return ctx.fail("E_UNSUPPORTED", "当前宿主不支持插件自更新");
+		if (!ctx.deviceId) return ctx.fail("E_FORBIDDEN", "请先完成设备认证");
+		observe(ctx, updater, ctx.deviceId);
+		const status = await updater.check(ctx.deviceId);
+		ctx.send("s2c.plugin.update.status", status);
+	}
+}, {
+	type: "c2s.plugin.update.apply",
+	stage: "authenticated",
+	scopes: ["sessions.manage"],
+	widgetPolicy: "deny",
+	capability: "pluginUpdate",
+	doc: "PROTOCOL.md c2s.plugin.update.apply",
+	validate: (value) => {
+		const result = payloadObject$1(value);
+		if (!result.ok) return result;
+		const version = result.value.version;
+		if (typeof version !== "string" || version.length > 128 || version.trim().length === 0 || !validUpdateRequestId(result.value.clientRequestId)) return {
+			ok: false,
+			code: "E_PROTOCOL",
+			message: "更新版本或请求标识无效"
+		};
+		return result;
+	},
+	handle: async (ctx, payload) => {
+		const updater = updaters.get(ctx.bridge);
+		if (!updater) return ctx.fail("E_UNSUPPORTED", "当前宿主不支持插件自更新");
+		if (!ctx.deviceId) return ctx.fail("E_FORBIDDEN", "请先完成设备认证");
+		try {
+			const record = await updater.apply(ctx.deviceId, payload.version, payload.clientRequestId);
+			ctx.send("s2c.ack", {
+				clientRequestId: record.clientRequestId,
+				accepted: true
+			});
+			if (ctx.canReceive("sessions.manage")) {
+				ctx.send("s2c.plugin.update.progress", {
+					clientRequestId: record.clientRequestId,
+					phase: record.phase,
+					message: record.message
+				});
+				if (!finished(record.phase)) observe(ctx, updater, ctx.deviceId);
+			}
+		} catch (error) {
+			if (error instanceof PluginUpdateError) return ctx.fail(error.code, error.message);
+			ctx.fail("E_INTERNAL", "暂时无法启动插件更新，请检查当前版本");
+		}
+	}
+}];
 /** 第一个缺失的 scope；消息与迁移前一致（`scope <name> required`）。 */
 function scopeRejection(row, scopes) {
 	for (const scope of row.scopes) if (!scopes.has(scope)) return {
@@ -2828,6 +3449,7 @@ function accept(value) {
 const WIRE_FRAME_ROWS = [
 	...sessionRows,
 	...commandRows,
+	...pluginUpdateRows,
 	...scheduleRows,
 	...interactionRows,
 	...pushRows,
@@ -3323,7 +3945,7 @@ var BridgeConnection = class {
 			...payload,
 			hostAudience: this.deps.audience
 		};
-		if (type === "s2c.session.event") {
+		if (type === "s2c.session.event" || type === "s2c.session.queue") {
 			const sessionId = payload?.sessionId;
 			if (typeof sessionId === "string") {
 				const buffered = this.openingSessionEvents.get(sessionId);
@@ -3448,6 +4070,30 @@ function normalizeFunnelConnectionLimit(value) {
 	return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 16 ? value : 8;
 }
 //#endregion
+//#region src/tailscale-version.ts
+/**
+* 内嵌 helper 上报的 tailscale.com 模块版本。
+*
+* 版本的唯一来源是 helper 启动事件（`helper/main.go` 读 Go 构建信息里的
+* `tailscale.com` 依赖版本），不是 go.mod、也不是插件常量：用户可能通过
+* `remote.helperPath` 换成自己编译的 helper，界面必须显示实际在跑的那一个。
+*
+* 两条边界都要守卫：
+* - 宿主侧 `parseHelperEvent` 把 helper 的 stdout 当成不可信输入，格式不对
+*   就丢弃，避免把任意文本渲染进设置页；
+* - 设置页侧 `reportSchema` 同样校验 Host RPC 返回值，旧 Host 不带该字段
+*   时保持 undefined（页面显示「未获取」），不当作错误。
+*
+* 接受 Go 模块版本形态：`v1.104.2`、`v1.104.2-pre.1`、
+* `v0.0.0-20260101000000-abcdef123456`。长度上限防止异常输入撑爆界面。
+*/
+const TAILSCALE_VERSION_PATTERN = /^v?\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]{1,64})?$/;
+const MAX_TAILSCALE_VERSION_LENGTH = 80;
+/** 判断外部输入是否是合法的 Tailscale 模块版本字符串。 */
+function isTailscaleVersion(value) {
+	return typeof value === "string" && value.length <= MAX_TAILSCALE_VERSION_LENGTH && TAILSCALE_VERSION_PATTERN.test(value);
+}
+//#endregion
 //#region src/remote-supervisor.ts
 const RESTART_DELAYS_MS = [
 	1e3,
@@ -3636,7 +4282,8 @@ function parseHelperEvent(line) {
 			phase: value.phase,
 			...typeof value.publicURL === "string" ? { publicURL: value.publicURL } : {},
 			...typeof value.authURL === "string" ? { authURL: value.authURL } : {},
-			...typeof value.message === "string" ? { message: value.message.slice(0, 500) } : {}
+			...typeof value.message === "string" ? { message: value.message.slice(0, 500) } : {},
+			...isTailscaleVersion(value.tailscaleVersion) ? { tailscaleVersion: value.tailscaleVersion } : {}
 		};
 	} catch {
 		return null;
@@ -5838,6 +6485,50 @@ function scheduleMutationCodec(persistValues) {
 	};
 }
 //#endregion
+//#region src/notification-text.ts
+/**
+* 通知正文的纯文本投影。
+*
+* 为什么需要：s2c.notify 与 APNs 的 body 是"可直接展示"的文本（PROTOCOL §6），
+* 客户端不得改写；而来源（助手回复、审批原因、提问）都是 Host 给的 Markdown。
+* 直接截原文会把链接地址、URL 编码的中文路径、代码块符号带进锁屏横幅，
+* 所以 Bridge 出站前在这里统一转成纯文本。
+*
+* 只做"去标记、留可读文字"，不追求完整 Markdown 语义；任何无法识别的写法原样保留。
+*/
+/** 把 Markdown 拆成段落并逐段转为单行纯文本；清洗后为空的段落被丢弃。 */
+function notificationParagraphs(markdown) {
+	return stripCodeFences(markdown.replace(/\r\n?/g, "\n")).split(/\n[ \t]*\n/).map(plainParagraph).filter((paragraph) => paragraph.length > 0);
+}
+/**
+* 通知正文：`last` 取最后一个非空段落（任务完成 / 异常结束——回复结尾通常是结论），
+* `all` 把全部段落合成一行（审批原因、提问原文）。长度上限由调用方负责。
+*/
+function notificationPlainText(markdown, pick) {
+	const paragraphs = notificationParagraphs(markdown);
+	return pick === "last" ? paragraphs.at(-1) ?? "" : paragraphs.join(" ");
+}
+/** 围栏代码块整体丢弃：横幅里放不下代码，留一半反而更难读。未闭合的围栏丢到文末。 */
+function stripCodeFences(text) {
+	return text.replace(/^[ \t]*(`{3,}|~{3,})[^\n]*\n[\s\S]*?(?:^[ \t]*\1[ \t]*$|(?![\s\S]))/gm, "\n");
+}
+function plainParagraph(paragraph) {
+	return decodePercentRuns(stripInline(paragraph.split("\n").filter((line) => !(line.includes("|") && line.includes("-") && /^[\s|:-]+$/.test(line))).filter((line) => !/^\s*([*_-])(\s*\1){2,}\s*$/.test(line)).map((line) => line.replace(/^\s*(>\s?)+/, "").replace(/^\s*#{1,6}\s+/, "").replace(/^\s*([-*+]|\d+[.)])\s+(\[[ xX]\]\s+)?/, "").replace(/^\s*\|(.*?)\|?\s*$/, (_row, cells) => cells.replace(/\s*\|\s*/g, "  "))).join(" "))).replace(/\s+/g, " ").trim();
+}
+function stripInline(text) {
+	return text.replace(/!\[[^\]]*\]\((?:[^()]|\([^()]*\))*\)/g, "").replace(/\[([^\]]+)\]\((?:[^()]|\([^()]*\))*\)/g, "$1").replace(/\[([^\]]+)\]\[[^\]]*\]/g, "$1").replace(/<((?:https?|mailto):[^>\s]+)>/g, "$1").replace(/<\/?[A-Za-z][^>]*>/g, "").replace(/(`+)([^`]+?)\1/g, "$2").replace(/(\*\*|__|~~)(?=\S)([\s\S]*?\S)\1/g, "$2").replace(/(^|[^\w*])\*(?=\S)([^*\n]*?\S)\*(?![\w*])/g, "$1$2").replace(/(^|[^\w])_(?=\S)([^_\n]*?\S)_(?!\w)/g, "$1$2");
+}
+/** 正文里残留的 %E6%8F%90 这类编码串解码成原字符；解不开（非法 UTF-8）就保持原样。 */
+function decodePercentRuns(text) {
+	return text.replace(/(?:%[0-9A-Fa-f]{2})+/g, (run) => {
+		try {
+			return decodeURIComponent(run);
+		} catch {
+			return run;
+		}
+	});
+}
+//#endregion
 //#region src/host-api.ts
 /**
 * Subagent sessions are host-internal workers of a parent conversation.
@@ -5863,6 +6554,11 @@ function unwrapStreamItem(item) {
 }
 //#endregion
 //#region src/host-capabilities.ts
+const pluginUpdateProbes = /* @__PURE__ */ new WeakMap();
+function setPluginUpdateProbe(proxy, probe) {
+	if (probe) pluginUpdateProbes.set(proxy, probe);
+	else pluginUpdateProbes.delete(proxy);
+}
 /** 每位一行：Host 上必须存在的依赖。缺失即该位为 false，相关帧回 E_UNSUPPORTED。 */
 const HOST_CAPABILITY_PROBES = {
 	models: (proxy) => typeof proxy.sessions.models === "function",
@@ -5872,7 +6568,11 @@ const HOST_CAPABILITY_PROBES = {
 	sessionFork: (proxy) => typeof proxy.sessions.fork === "function",
 	sessionRestore: (proxy) => typeof proxy.workspace?.unarchiveSession === "function",
 	projectSelection: (proxy) => typeof proxy.workspace?.list === "function" && typeof proxy.workspace?.create === "function",
-	schedules: (proxy) => proxy.schedule !== void 0
+	schedules: (proxy) => proxy.schedule !== void 0,
+	promptQueue: (proxy) => typeof proxy.sessions.updateQueue === "function",
+	sessionMarkdown: (proxy) => proxy.commands?.markdownAvailable === true && typeof proxy.commands?.export === "function",
+	assistantStream: (proxy) => proxy.assistantStreamAvailable === true,
+	pluginUpdate: (proxy) => pluginUpdateProbes.get(proxy)?.() === true
 };
 /**
 * 按当前 apiProxy 与推送出口算出 welcome 能力位。`push` 位描述「当前离线推送
@@ -5895,6 +6595,10 @@ function capabilityBits(proxy, pushOutlet) {
 		sessionRestore: HOST_CAPABILITY_PROBES.sessionRestore(proxy),
 		projectSelection: HOST_CAPABILITY_PROBES.projectSelection(proxy),
 		schedules: HOST_CAPABILITY_PROBES.schedules(proxy),
+		promptQueue: HOST_CAPABILITY_PROBES.promptQueue(proxy),
+		sessionMarkdown: HOST_CAPABILITY_PROBES.sessionMarkdown(proxy),
+		assistantStream: HOST_CAPABILITY_PROBES.assistantStream(proxy),
+		pluginUpdate: HOST_CAPABILITY_PROBES.pluginUpdate(proxy),
 		push: pushOutlet?.isAvailable() === true,
 		widgetPush: true,
 		liveActivityPush: true,
@@ -5902,6 +6606,258 @@ function capabilityBits(proxy, pushOutlet) {
 	};
 }
 //#endregion
+//#region src/prompt-queue.ts
+/**
+* 运行中排队与转向（PROTOCOL.md「运行中排队与转向扩展」）的纯函数部分。
+*
+* 职责：
+* - Host `requestId` 与 wire `clientSendId` 的互转：Bridge 发送带 clientSendId 的
+*   prompt 时以 `dp:` 前缀拼出确定的 requestId，Host 把它记为用户来源的 `rpcId`；
+*   快照时反向剥掉前缀，发起设备即可把待发送项与队列项对上。
+* - 把 DSH `inbox` 投影（`{ "next-turn": Message[], "next-step": Message[] }`，
+*   来源是持久化的 `agent/inbox/spliced` 事件）折叠成 `s2c.session.queue` 的条目。
+*
+* 不持有状态：缓存、去重与推送时机在 host-bridge。
+*/
+const REQUEST_ID_PREFIX = "dp:";
+/** 快照正文上限（Unicode 码点）。只用于列表展示，完整正文仍在 Host 日志里。 */
+const MAX_QUEUE_TEXT_CODE_POINTS = 4096;
+/** clientSendId -> Host requestId。 */
+function promptRequestId(clientSendId) {
+	return REQUEST_ID_PREFIX + clientSendId;
+}
+/** Host 来源 rpcId -> clientSendId；不是本 Bridge 用 clientSendId 发出的返回 undefined。 */
+function clientSendIdOf(rpcId) {
+	if (typeof rpcId !== "string" || !rpcId.startsWith(REQUEST_ID_PREFIX)) return void 0;
+	const id = rpcId.slice(3);
+	return validSendId(id) ? id : void 0;
+}
+/**
+* inbox 投影 -> 队列条目，保持 Host 的先进先出顺序：先 `next-turn`（排队），
+* 再 `next-step`（转向）。值形状不对时返回 undefined，调用方据此不推送，
+* 而不是把「读不懂」当成「队列为空」——客户端会把消失的项当作已发出。
+*/
+function projectQueue(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const inbox = value;
+	const nextTurn = inbox["next-turn"];
+	const nextStep = inbox["next-step"];
+	if (!Array.isArray(nextTurn) || !Array.isArray(nextStep)) return void 0;
+	const items = [];
+	for (const [list, placement] of [[nextTurn, "queued"], [nextStep, "steering"]]) for (const message of list) {
+		const item = queueItemOf(message, placement);
+		if (item) items.push(item);
+	}
+	return items;
+}
+function queueItemOf(message, placement) {
+	if (message === null || typeof message !== "object" || typeof message.id !== "string" || message.id.length === 0) return;
+	const texts = [];
+	let imageCount = 0;
+	let documentCount = 0;
+	for (const block of Array.isArray(message.content) ? message.content : []) {
+		if (block === null || typeof block !== "object") continue;
+		if (block.type === "image") imageCount += 1;
+		else if (block.type === "text" && typeof block.text === "string") {
+			if (projectedDocument(block.text) !== void 0) documentCount += 1;
+			else texts.push(block.text);
+		}
+	}
+	const codePoints = Array.from(texts.join("\n"));
+	const truncated = codePoints.length > MAX_QUEUE_TEXT_CODE_POINTS;
+	const source = message.source;
+	const clientSendId = source?.kind === "user" ? clientSendIdOf(source.rpcId) : void 0;
+	return {
+		itemId: message.id,
+		placement,
+		text: truncated ? codePoints.slice(0, MAX_QUEUE_TEXT_CODE_POINTS).join("") : codePoints.join(""),
+		...truncated ? { truncated: true } : {},
+		imageCount,
+		documentCount,
+		...clientSendId !== void 0 ? { clientSendId } : {}
+	};
+}
+/** Bound by serialized UTF-8 size, including escaping, without splitting a Unicode code point. */
+function bounded(payload) {
+	if (Buffer.byteLength(JSON.stringify(payload)) <= 262144) return payload;
+	const points = Array.from(payload.text);
+	let low = 0;
+	let high = points.length;
+	while (low < high) {
+		const mid = Math.ceil((low + high) / 2);
+		const candidate = {
+			...payload,
+			text: points.slice(0, mid).join(""),
+			truncated: true
+		};
+		if (Buffer.byteLength(JSON.stringify(candidate)) <= 262144) low = mid;
+		else high = mid - 1;
+	}
+	return {
+		...payload,
+		text: points.slice(0, low).join(""),
+		truncated: true
+	};
+}
+function isFrame(value) {
+	if (!value || typeof value !== "object") return false;
+	const frame = value;
+	if (typeof frame.attemptId !== "string" || !frame.attemptId || !Number.isSafeInteger(frame.revision)) return false;
+	if (frame.type === "start") return Number.isSafeInteger(frame.turn) && Number.isSafeInteger(frame.step);
+	if (frame.type !== "chunk" && frame.type !== "end") return false;
+	if (!Number.isSafeInteger(frame.index) || frame.index < 0) return false;
+	if (frame.type === "chunk") return Number.isSafeInteger(frame.time) && !!frame.chunk && typeof frame.chunk.type === "string";
+	return frame.outcome?.kind === "abandoned" || frame.outcome?.kind === "committed" && ["assistant/message", "assistant/attempt"].includes(frame.outcome.eventType) && Number.isSafeInteger(frame.outcome.seq);
+}
+/**
+* One process-local attempt per session. Only the small pending window retains text;
+* the durable session event remains the source of truth for the completed reply.
+*/
+var AssistantStream = class {
+	emit;
+	isViewed;
+	attempts = /* @__PURE__ */ new Map();
+	constructor(emit, isViewed) {
+		this.emit = emit;
+		this.isViewed = isViewed;
+	}
+	accept(sessionId, value) {
+		if (!sessionId || !isFrame(value)) return;
+		const frame = value;
+		let state = this.attempts.get(sessionId);
+		if (frame.type === "start") {
+			if (state?.attemptId === frame.attemptId && frame.revision <= state.revision) return;
+			this.abandon(sessionId);
+			state = {
+				attemptId: frame.attemptId,
+				streamId: randomUUID(),
+				revision: frame.revision,
+				nextIndex: 0,
+				turn: frame.turn,
+				step: frame.step,
+				pending: [],
+				pendingBytes: 0
+			};
+			this.attempts.set(sessionId, state);
+			this.emit({
+				sessionId,
+				streamId: state.streamId,
+				kind: "stream.start",
+				text: "",
+				ts: Date.now()
+			});
+			return;
+		}
+		if (!state || state.attemptId !== frame.attemptId || frame.revision <= state.revision || frame.index < state.nextIndex) return;
+		state.revision = frame.revision;
+		if (frame.type === "end") {
+			if (frame.outcome.kind === "committed") this.flush(sessionId);
+			this.clearPending(sessionId);
+			this.attempts.delete(sessionId);
+			this.emit({
+				sessionId,
+				streamId: state.streamId,
+				kind: "stream.end",
+				text: "",
+				ts: Date.now(),
+				outcome: frame.outcome
+			});
+			return;
+		}
+		state.nextIndex = frame.index + 1;
+		if (state.finalSeq !== void 0 || !this.isViewed(sessionId)) return;
+		const kind = frame.chunk.type === "text-delta" ? "message.delta" : frame.chunk.type === "reasoning-delta" ? "thinking.delta" : void 0;
+		if (!kind || typeof frame.chunk.text !== "string" || frame.chunk.text.length === 0) return;
+		const previous = state.pending.at(-1)?.kind === kind ? state.pending.at(-1) : void 0;
+		if (previous?.truncated) return;
+		const payload = bounded({
+			sessionId,
+			streamId: state.streamId,
+			kind,
+			text: (previous?.text ?? "") + frame.chunk.text,
+			ts: frame.time
+		});
+		const next = {
+			kind,
+			text: payload.text,
+			ts: payload.ts,
+			...payload.truncated ? { truncated: true } : {}
+		};
+		const oldBytes = previous ? Buffer.byteLength(JSON.stringify(previous)) : 0;
+		const newBytes = Buffer.byteLength(JSON.stringify(next));
+		if (state.pendingBytes - oldBytes + newBytes > 524288) this.flush(sessionId);
+		if (previous && state.pending.at(-1) === previous) {
+			state.pending[state.pending.length - 1] = next;
+			state.pendingBytes -= oldBytes;
+		} else if (previous) {
+			const tail = bounded({
+				sessionId,
+				streamId: state.streamId,
+				kind,
+				text: frame.chunk.text,
+				ts: frame.time
+			});
+			next.text = tail.text;
+			next.truncated = tail.truncated ? true : void 0;
+			state.pending.push(next);
+		} else state.pending.push(next);
+		state.pendingBytes += Buffer.byteLength(JSON.stringify(next));
+		state.timer ??= setTimeout(() => this.flush(sessionId), 50);
+		state.timer.unref?.();
+	}
+	/** The Host appends the durable event BEFORE publishing committed end. */
+	beforeEvent(sessionId, event) {
+		const state = this.attempts.get(sessionId);
+		if (!state || event.type !== "assistant/message" && event.type !== "assistant/attempt") return void 0;
+		const data = event.data;
+		if (data?.turn !== state.turn || data?.step !== state.step) return void 0;
+		this.flush(sessionId);
+		state.finalSeq = event.seq;
+		return state.streamId;
+	}
+	flush(sessionId) {
+		const state = this.attempts.get(sessionId);
+		if (!state) return;
+		if (state.timer) clearTimeout(state.timer);
+		state.timer = void 0;
+		const pending = state.pending;
+		state.pending = [];
+		state.pendingBytes = 0;
+		for (const text of pending) this.emit({
+			sessionId,
+			streamId: state.streamId,
+			...text
+		});
+	}
+	/** Closing the last viewer must not deliver its buffered text on a later open. */
+	clearPending(sessionId) {
+		const state = this.attempts.get(sessionId);
+		if (!state) return;
+		if (state.timer) clearTimeout(state.timer);
+		state.timer = void 0;
+		state.pending = [];
+		state.pendingBytes = 0;
+	}
+	abandon(sessionId) {
+		const state = this.attempts.get(sessionId);
+		if (!state) return;
+		this.clearPending(sessionId);
+		this.attempts.delete(sessionId);
+		this.emit({
+			sessionId,
+			streamId: state.streamId,
+			kind: "stream.end",
+			text: "",
+			ts: Date.now(),
+			outcome: { kind: "abandoned" }
+		});
+	}
+	dispose() {
+		for (const sessionId of this.attempts.keys()) this.clearPending(sessionId);
+		this.attempts.clear();
+	}
+};
+//#endregion
 //#region src/host-bridge.ts
 const MAX_RING_DEFAULT = 2e3;
 /**
@@ -5924,7 +6880,13 @@ var HostBridge = class {
 	* and restore them. Excluded from `summaries` and from the live broadcast. */
 	archivedSummaries = /* @__PURE__ */ new Map();
 	subagentSessionIds = /* @__PURE__ */ new Set();
+	/**
+	* 每个会话最近一次已知的队列（inbox 投影的折叠结果）及其指纹。来源是实时
+	* 投影通知或打开会话时读到的基线；指纹用来丢掉内容没变的重复通知。
+	*/
+	queues = /* @__PURE__ */ new Map();
 	sinks = /* @__PURE__ */ new Set();
+	assistantStream = new AssistantStream((payload) => this.pushAssistantDelta(payload), (sessionId) => this.hasStreamViewer(sessionId));
 	ring = [];
 	cursor = 0;
 	userReceiptSeq = 0;
@@ -5988,6 +6950,7 @@ var HostBridge = class {
 	}
 	removeSink(sink) {
 		this.sinks.delete(sink);
+		this.dropSinkSessions(sink);
 	}
 	/** Whether the ring still holds everything after the cursor. */
 	canResumeFrom(cursor) {
@@ -6007,9 +6970,21 @@ var HostBridge = class {
 	}
 	markSinkClosed(sink, sessionId) {
 		this.sinkSessions.get(sink)?.delete(sessionId);
+		if (!this.hasStreamViewer(sessionId)) this.assistantStream.clearPending(sessionId);
 	}
 	dropSinkSessions(sink) {
+		const sessions = this.sinkSessions.get(sink);
 		this.sinkSessions.delete(sink);
+		for (const sessionId of sessions ?? []) if (!this.hasStreamViewer(sessionId)) this.assistantStream.clearPending(sessionId);
+	}
+	hasStreamViewer(sessionId) {
+		if (this.disposed || this.subagentSessionIds.has(sessionId)) return false;
+		return [...this.sinks].some((sink) => this.isViewedBy(sink, sessionId) && sink.canReceive("sessions.read"));
+	}
+	/** Instant publications bypass record(): no cursor, ring, notification or push side effect. */
+	pushAssistantDelta(payload) {
+		if (this.disposed || this.subagentSessionIds.has(payload.sessionId)) return;
+		for (const sink of this.sinks) if (this.isViewedBy(sink, payload.sessionId) && sink.canReceive("sessions.read")) sink.push("s2c.session.delta", payload);
 	}
 	isViewedBy(sink, sessionId) {
 		return this.sinkSessions.get(sink)?.has(sessionId) ?? false;
@@ -6020,8 +6995,10 @@ var HostBridge = class {
 	*  PROTOCOL §6 + §7), then fan the same payload out to offline devices
 	*  holding an APNs token. */
 	emitNotify(args) {
-		if ((args.category === "turn.completed" || args.category === "session.error") && this.subagentSessionIds.has(args.sessionId)) return;
-		const body = args.body.length > 120 ? args.body.slice(0, 119) + "…" : args.body;
+		const turnEnd = args.category === "turn.completed" || args.category === "session.error";
+		if (turnEnd && this.subagentSessionIds.has(args.sessionId)) return;
+		const plain = notificationPlainText(args.body, turnEnd ? "last" : "all") || (args.fallbackBody ?? "");
+		const body = plain.length > 120 ? plain.slice(0, 119) + "…" : plain;
 		const approvalExtras = args.category === "approval.required" && args.toolName ? {
 			toolName: args.toolName.slice(0, 80),
 			...args.detail ? { detail: args.detail.slice(0, 600) } : {}
@@ -6049,12 +7026,12 @@ var HostBridge = class {
 		if (this.subagentSessionIds.has(sessionId)) return;
 		const row = this.summaries.get(sessionId);
 		const title = ok ? "任务完成" : "任务异常结束";
-		const body = this.lastAssistantText.get(sessionId) ?? row?.title ?? "";
 		this.emitNotify({
 			sessionId,
 			category: ok ? "turn.completed" : "session.error",
 			title,
-			body,
+			body: this.lastAssistantText.get(sessionId) ?? "",
+			fallbackBody: row?.title ?? "",
 			notificationId: "n-" + (this.cursor + 1)
 		});
 	}
@@ -6067,11 +7044,15 @@ var HostBridge = class {
 			this.pushOutlet?.fanOut(notification);
 		} catch {}
 	}
-	/** Remember the latest assistant text so notifications can quote it. */
+	/**
+	* Remember the latest assistant text so notifications can quote it. 存完整原文：
+	* 按字符数截尾会从链接地址中间切开（横幅只剩 URL 编码的路径），段落选择与
+	* Markdown 清洗统一留到 emitNotify。条目随 sessions.list / 归档清理。
+	*/
 	captureAssistantText(sessionId, event) {
 		if (event.type !== "assistant/message") return;
 		const text = messageText(event.data).trim();
-		if (text.length > 0) this.lastAssistantText.set(sessionId, text.slice(-160));
+		if (text.length > 0) this.lastAssistantText.set(sessionId, text);
 	}
 	/**
 	* Replay buffered pushes after the given cursor; false when the gap is
@@ -6150,6 +7131,7 @@ var HostBridge = class {
 		if (this.disposed) return;
 		this.disposed = true;
 		this.abort.abort();
+		this.assistantStream.dispose();
 		this.sinks.clear();
 		this.sinkSessions.clear();
 		this.pushOutlet = void 0;
@@ -6168,7 +7150,9 @@ var HostBridge = class {
 				const frame = unwrapStreamItem(item);
 				this.onMuxFrame(frame);
 			}
-		} catch {}
+		} catch {} finally {
+			this.assistantStream.dispose();
+		}
 	}
 	onHostFrame(frame) {
 		switch (frame.type) {
@@ -6207,12 +7191,30 @@ var HostBridge = class {
 			case "commands/changed":
 				this.record("s2c.commands.changed", {});
 				break;
+			case "session/assistant-stream": {
+				const sessionId = String(frame.sessionId ?? "");
+				if (frame.isSubagent === true) this.subagentSessionIds.add(sessionId);
+				if (this.subagentSessionIds.has(sessionId)) {
+					this.assistantStream.abandon(sessionId);
+					break;
+				}
+				this.assistantStream.accept(sessionId, frame.value);
+				break;
+			}
+			case "session/assistant-stream-disposed":
+				this.assistantStream.abandon(String(frame.sessionId ?? ""));
+				break;
 			case "session/event": {
 				const event = frame.event;
 				const sessionId = String(frame.sessionId ?? "");
 				if (!event || !sessionId) break;
 				if (frame.isSubagent === true) this.subagentSessionIds.add(sessionId);
-				if (this.subagentSessionIds.has(sessionId)) break;
+				if (this.subagentSessionIds.has(sessionId)) {
+					this.assistantStream.abandon(sessionId);
+					break;
+				}
+				const streamId = this.assistantStream.beforeEvent(sessionId, event);
+				if (event.type === "turn/end") this.assistantStream.abandon(sessionId);
 				if (event.type === "agent-preset/selected") this.record("s2c.skills.changed", { sessionId });
 				this.noteActivity(sessionId, event);
 				this.captureAssistantText(sessionId, event);
@@ -6222,7 +7224,10 @@ var HostBridge = class {
 					sessionId,
 					kind: projection.kind,
 					seq: event.seq,
-					data: projection.data
+					data: {
+						...projection.data,
+						...streamId && projection.kind === "message.final" ? { streamId } : {}
+					}
 				});
 				if (projection?.kind === "turn.end") this.emitTurnCompletedNotify(sessionId, projection.data.ok === true);
 				break;
@@ -6243,6 +7248,7 @@ var HostBridge = class {
 						...current ? { current } : {}
 					});
 				}
+				if (p.key === "inbox") this.applyInbox(p.sessionId, p.value, "live");
 				this.applyProjection(p.sessionId, String(p.key ?? ""), p.value);
 				break;
 			}
@@ -6418,6 +7424,43 @@ var HostBridge = class {
 		row.lastActivityTs = Date.now();
 		this.pushSummary(row);
 	}
+	/**
+	* 折叠一次 inbox 投影。只有实时变化才广播 s2c.session.queue；基线只补缓存，
+	* 打开会话的那台设备另由 pushQueueSnapshot 点对点拿到快照。
+	*
+	* 基线只补缺不覆盖：实时通知带的是完整投影值，收到过就以它为准；基线读取与
+	* 实时变化并发时，较早算出的基线不得盖掉较新的实时值。
+	*/
+	applyInbox(sessionId, value, origin) {
+		if (this.capabilities.promptQueue !== true) return;
+		if (this.subagentSessionIds.has(sessionId)) return;
+		if (origin === "baseline" && this.queues.has(sessionId)) return;
+		const items = projectQueue(value);
+		if (items === void 0) return;
+		const fingerprint = JSON.stringify(items);
+		const previous = this.queues.get(sessionId);
+		this.queues.set(sessionId, {
+			items,
+			fingerprint
+		});
+		if (origin === "live" && previous?.fingerprint !== fingerprint) this.record("s2c.session.queue", {
+			sessionId,
+			items
+		});
+	}
+	/**
+	* 打开会话时补发的快照：不占 seq，与 tail 同属打开响应。还没读到过该会话的
+	* 投影（基线失败、Host 不提供或子代理会话）时不发，因为未知不等于空队列。
+	*/
+	pushQueueSnapshot(sink, sessionId) {
+		if (this.disposed) return;
+		const queue = this.queues.get(sessionId);
+		if (queue === void 0) return;
+		sink.push("s2c.session.queue", {
+			sessionId,
+			items: queue.items
+		});
+	}
 	applyProjection(sessionId, key, value) {
 		const row = this.summaries.get(sessionId);
 		if (!row) return;
@@ -6544,7 +7587,7 @@ var HostBridge = class {
 				hasMore: Boolean(result.hasMore) || page.dropped > 0
 			});
 			this.deriveTitleFallback(sessionId, messages);
-			this.refreshProjections(sessionId);
+			this.refreshProjections(sessionId).then(() => this.pushQueueSnapshot(sink, sessionId));
 			return true;
 		} catch {
 			return false;
@@ -6570,8 +7613,14 @@ var HostBridge = class {
 				return;
 			}
 			const baseline = result.value;
-			if (baseline === null || baseline === void 0) return;
-			for (const [key, value] of Object.entries(baseline.values ?? {})) this.applyProjection(sessionId, key, value);
+			if (baseline === null || baseline === void 0) {
+				this.queues.delete(sessionId);
+				return;
+			}
+			for (const [key, value] of Object.entries(baseline.values ?? {})) {
+				if (key === "inbox") this.applyInbox(sessionId, value, "baseline");
+				this.applyProjection(sessionId, key, value);
+			}
 		} catch (error) {
 			this.diagnostic("sessions.projections threw: " + String(error?.message ?? error));
 		}
@@ -6642,12 +7691,15 @@ var HostBridge = class {
 			return wireErrorOf("command", hostFailureOf(error, "command/invalid-response"));
 		}
 	}
-	async exportSession(sessionId, signal) {
+	async exportSession(sessionId, signal, format) {
 		const api = this.apiProxy.commands;
 		if (!api) throw Object.assign(/* @__PURE__ */ new Error("当前主机不支持日志导出"), { code: "command/export-unsupported" });
 		return api.export({
 			rpcId: randomUUID(),
-			payload: { sessionId }
+			payload: {
+				sessionId,
+				...format === void 0 ? {} : { format }
+			}
 		}, signal);
 	}
 	/** 由会话目录决定技能可见性；不读取正文，也不把本机路径发给移动端。 */
@@ -6863,6 +7915,47 @@ var HostBridge = class {
 			};
 		}
 	}
+	/**
+	* 删除或转向一条排队项。ack 只表示 Host 已提交变更，真实状态以随后的
+	* s2c.session.queue 为准；不做幂等，项已消失时 Host 回 queue-item-not-found。
+	*/
+	async updateQueue(sessionId, itemId, action) {
+		const update = this.apiProxy.sessions.updateQueue;
+		if (typeof update !== "function") return {
+			ok: false,
+			code: "E_UNSUPPORTED",
+			message: "prompt queue unavailable on this host version"
+		};
+		try {
+			const response = await update.call(this.apiProxy.sessions, {
+				rpcId: randomUUID(),
+				payload: {
+					sessionId,
+					itemId,
+					action: { kind: action }
+				}
+			});
+			if (!response.result) return {
+				ok: false,
+				code: "E_INTERNAL",
+				message: "queue update returned no result"
+			};
+			if (!response.result.ok) return wireErrorOf("queue", response.result.error);
+			return {
+				ok: true,
+				value: {
+					sessionId,
+					itemId
+				}
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				code: "E_INTERNAL",
+				message: String(error)
+			};
+		}
+	}
 	async cancelSession(sessionId) {
 		const cancel = this.apiProxy.sessions.cancel;
 		if (typeof cancel !== "function") return {
@@ -7296,7 +8389,7 @@ var HostBridge = class {
 			replayed: result.replayed
 		};
 	}
-	async sendPrompt(sessionId, text, images = [], documents = []) {
+	async sendPrompt(sessionId, text, images = [], documents = [], options = {}) {
 		try {
 			const content = [];
 			if (text.trim().length > 0) content.push({
@@ -7312,10 +8405,10 @@ var HostBridge = class {
 				text: documentPromptBlock(document)
 			});
 			const response = await this.apiProxy.sessions.prompt({
-				rpcId: randomUUID(),
+				rpcId: options.clientSendId !== void 0 ? promptRequestId(options.clientSendId) : randomUUID(),
 				payload: {
 					sessionId,
-					mode: "queue",
+					mode: options.mode ?? "queue",
 					content,
 					clientTimeZone: localTimeZone()
 				}
@@ -7847,6 +8940,11 @@ var DshCommandApi = class {
 	get available() {
 		return this.ctx.get("commands") !== void 0 && typeof this.ctx.get("typertGateway")?.invoke === "function";
 	}
+	get markdownAvailable() {
+		const connection = this.connection();
+		const route = connection?.fetchRoutes instanceof Map ? connection.fetchRoutes.get("/api/session.markdown") : void 0;
+		return typeof connection?.createSharedFetchHandler === "function" && route?.methods instanceof Set && route.methods.has("GET") && typeof route.fetch === "function" && typeof this.ctx.get("sessionQuery")?.readSession === "function";
+	}
 	connection() {
 		return this.ctx.get("connection");
 	}
@@ -7957,9 +9055,13 @@ var DshCommandApi = class {
 		} });
 		if (result?.ok !== true) throw fail(typeof result?.error?.code === "string" ? result.error.code : "command/invalid-response", typeof result?.error?.message === "string" ? result.error.message : "反馈未能保存");
 	}
-	async export(sessionId, signal) {
-		const response = await this.connection().createSharedFetchHandler("/api").fetch(new Request("http://localhost/api/session.export?includeDescendants=true&sessionId=" + encodeURIComponent(sessionId), { signal }), this.owner());
-		if (!response.ok || !response.body || !response.headers.get("content-type")?.includes("application/zip")) throw fail("command/export-unavailable", "主机未能生成会话日志归档");
+	async export(sessionId, signal, format) {
+		const markdown = format === "markdown";
+		const path = markdown ? "/api/session.markdown?sessionId=" : "/api/session.export?includeDescendants=true&sessionId=";
+		const response = await this.connection().createSharedFetchHandler("/api").fetch(new Request("http://localhost" + path + encodeURIComponent(sessionId), { signal }), this.owner());
+		const contentType = response.headers.get("content-type");
+		const matches = markdown ? contentType?.split(";")[0]?.trim().toLowerCase() === "text/markdown" : contentType?.includes("application/zip");
+		if (!response.ok || !response.body || !matches) throw fail("command/export-unavailable", markdown ? "主机未能生成会话对话正文" : "主机未能生成会话日志归档");
 		return response;
 	}
 };
@@ -7976,6 +9078,15 @@ var DshCommandApi = class {
 /** Direct-controller adapter with the shape HostBridge consumes. */
 var DshApiProxy = class {
 	ctx;
+	/** Probe the Host's generated reflection, not this adapter's listener registration. */
+	get assistantStreamAvailable() {
+		const typert = this.ctx.get("typert");
+		try {
+			return typert?.getPackage?.("@deepseek-ai/dsh-api-session-controller", "host")?.model?.services?.some((service) => service.key === "sessionController" && service.types?.some((type) => type.name === "SessionAssistantStreamFrame")) === true;
+		} catch {
+			return false;
+		}
+	}
 	commandApi;
 	get commands() {
 		if (!this.commandApi.available) return void 0;
@@ -7984,7 +9095,8 @@ var DshApiProxy = class {
 			execute: (request) => this.call(() => this.commandApi.execute(request.payload.sessionId, request.payload.line, request.payload.attachments, request.payload.expectedDefinitionId)),
 			permissions: (request) => this.call(() => this.commandApi.permissions(request.payload.sessionId)),
 			feedback: (request) => this.call(() => this.commandApi.feedback(request.payload.sessionId, request.payload.text, request.payload.category)),
-			export: (request, signal) => this.commandApi.export(request.payload.sessionId, signal)
+			markdownAvailable: this.commandApi.markdownAvailable,
+			export: (request, signal) => this.commandApi.export(request.payload.sessionId, signal, request.payload.format)
 		};
 	}
 	session;
@@ -8002,6 +9114,7 @@ var DshApiProxy = class {
 		this.session = session;
 		this.workspaceController = ctx.get("workspaceController");
 		if (this.workspaceController === void 0) delete this.workspace?.unarchiveSession;
+		if (typeof this.session.updateQueue !== "function") delete this.sessions.updateQueue;
 		this.directoryPicker = ctx.get("directoryPickerController");
 		this.shouldSurfaceInteraction = options.shouldSurfaceInteraction ?? (() => true);
 		this.resolveSchedule();
@@ -8105,16 +9218,33 @@ var DshApiProxy = class {
 		}),
 		history: async (request) => this.call(async () => {
 			const sessionId = request.payload.sessionId;
+			const beforeSeq = request.payload?.beforeSeq;
+			const limit = normalizePageLimit(request.payload?.maxMessages);
+			const inspect = this.session.inspect;
+			if (inspect === void 0) {
+				const page = await this.session.page({
+					address: {
+						kind: "session",
+						sessionId
+					},
+					...beforeSeq === void 0 ? {} : { throughSeq: beforeSeq - 1 },
+					maxMessages: limit
+				}, new AbortController().signal);
+				return {
+					events: page.records.map((record) => ({ event: record.event })),
+					hasMore: page.hasMore
+				};
+			}
 			let inspected;
 			try {
-				inspected = await this.session.inspect(sessionId);
+				inspected = await inspect.call(this.session, sessionId);
 			} catch (error) {
 				console.warn(`[deeppilot] session history unavailable for ${JSON.stringify(sessionId)}: ${toError(error).code}: ${toError(error).message}`);
 				throw error;
 			}
 			const window = historyWindow(inspected.events, {
-				beforeSeq: request.payload?.beforeSeq,
-				limit: normalizePageLimit(request.payload?.maxMessages)
+				beforeSeq,
+				limit
 			});
 			return {
 				events: window.events,
@@ -8131,6 +9261,7 @@ var DshApiProxy = class {
 		selectModel: async (request) => this.call(() => this.session.selectModel(request.payload ?? {})),
 		rename: async (request) => this.call(() => this.session.rename(request.payload)),
 		cancel: async (request) => this.call(() => this.session.cancel(request.payload)),
+		updateQueue: async (request) => this.call(() => this.session.updateQueue(request.payload)),
 		attachment: async (request) => this.call(() => this.session.attachment(request.payload)),
 		projections: async (request) => this.call(() => this.session.projections(request.payload, new AbortController().signal))
 	};
@@ -8198,6 +9329,18 @@ var DshApiProxy = class {
 				event
 			});
 		}), { global: true });
+		const offAssistantStream = this.ctx.on("agent/assistant-stream", (({ agent, frame }) => {
+			queue.push({
+				type: "session/assistant-stream",
+				sessionId: String(agent.session.id),
+				isSubagent: agent.session.header?.origin === "subagent",
+				value: frame
+			});
+		}), { global: true });
+		const offAgentDisposed = this.ctx.on("agent/disposed", (({ agent }) => queue.push({
+			type: "session/assistant-stream-disposed",
+			sessionId: String(agent.session.id)
+		})), { global: true });
 		const offProjection = this.ctx.get("sessionProjections")?.onChanged?.((session, key, value) => {
 			queue.push({
 				type: "session/projection",
@@ -8223,6 +9366,8 @@ var DshApiProxy = class {
 			yield* queue.iterate();
 		} finally {
 			offEvent();
+			offAssistantStream();
+			offAgentDisposed();
 			offProjection?.();
 			offSkills();
 			offCommands.forEach((dispose) => dispose());
@@ -8627,15 +9772,18 @@ function parseRemote(value) {
 	const publicURL = s.publicURL;
 	const authURL = s.authURL;
 	const message = s.message;
+	const tailscaleVersion = s.tailscaleVersion;
 	if (publicURL !== void 0 && typeof publicURL !== "string") reject("remote.publicURL");
 	if (authURL !== void 0 && typeof authURL !== "string") reject("remote.authURL");
 	if (message !== void 0 && typeof message !== "string") reject("remote.message");
+	if (tailscaleVersion !== void 0 && !isTailscaleVersion(tailscaleVersion)) reject("remote.tailscaleVersion");
 	return {
 		provider,
 		phase,
 		...typeof publicURL === "string" ? { publicURL } : {},
 		...typeof authURL === "string" ? { authURL } : {},
 		...typeof message === "string" ? { message } : {},
+		...typeof tailscaleVersion === "string" ? { tailscaleVersion } : {},
 		updatedAt: int(s, "updatedAt", "remote.updatedAt")
 	};
 }
@@ -9676,6 +10824,23 @@ function apply(ctx, options) {
 		return updated;
 	}, () => pushGateway.relayTest(), () => pushGateway.selfTest());
 	const state = {};
+	let pluginUpdater;
+	ctx.inject(["pluginManager"], (sub) => {
+		const manager = sub.pluginManager;
+		if (!supportsPluginUpdate(manager)) return;
+		const updater = new PluginUpdater({
+			manager,
+			currentVersion: SERVER_VERSION,
+			journalPath: join(dataDir, "update-journal.json")
+		});
+		pluginUpdater = updater;
+		if (state.bridge) setPluginUpdater(state.bridge, updater);
+		sub.effect(() => () => {
+			if (pluginUpdater !== updater) return;
+			pluginUpdater = void 0;
+			if (state.bridge) setPluginUpdater(state.bridge, void 0);
+		}, "deeppilot: optional plugin updater");
+	});
 	let pendingUpgrades = 0;
 	const authRateLimiter = new AuthRateLimiter();
 	const readJSONBody = async (req, maxBytes = 16384) => {
@@ -10007,8 +11172,10 @@ function apply(ctx, options) {
 			log("DSH session bridge unavailable: " + String(error), "warn");
 			return;
 		}
+		setPluginUpdateProbe(proxy, () => pluginUpdater !== void 0);
 		const bridge = new HostBridge(proxy, cfg.historyBufferMax, join(dataDir, "prompt-deliveries-v1.json"), join(dataDir, "schedule-mutations-v1.json"), join(dataDir, "fork-mutations-v1.json"), log);
 		bridge.setPushOutlet(pushGateway);
+		setPluginUpdater(bridge, pluginUpdater);
 		state.bridge = bridge;
 		bridge.start();
 		log("data plane active (mux + host streams)");