dsh-deeppilot 0.6.1 → 0.7.0

package/lib/index.js

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { createHash, createPrivateKey, createPublicKey, randomBytes, randomUUID, sign, timingSafeEqual, verify } from "node:crypto";
+import { X509Certificate, createHash, createPrivateKey, createPublicKey, randomBytes, randomUUID, sign, timingSafeEqual, verify } from "node:crypto";
 import { access, chmod, mkdir, readFile, readdir, rename, rm, unlink, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { WebSocketServer } from "ws";
@@ -11,10 +11,11 @@ import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { connect } from "node:http2";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { request } from "node:https";
+import { createServer, request } from "node:https";
 import z from "@deepseek-ai/schemastery";
 import { isIP } from "node:net";
-import { createServer } from "node:http";
+import { createServer as createServer$1 } from "node:http";
+import { generate } from "selfsigned";
 function validSendId(id) {
 	return typeof id === "string" && /^\d{13}-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
 }
@@ -243,6 +244,10 @@ function validateRequest(type, value) {
 			ids.add(answer.id);
 		}
 	}
+	if (type === "c2s.liveActivity.register" || type === "c2s.liveActivity.unregister") {
+		if (!text(p.activityId, 128)) return "invalid activityId";
+		if (type === "c2s.liveActivity.register" && (!text(p.sessionId) || typeof p.deviceToken !== "string" || !/^[0-9a-fA-F]{32,512}$/.test(p.deviceToken) || !["development", "production"].includes(p.environment) || !optional("enrollKey", (v) => text(v, 128)))) return "invalid live activity registration";
+	}
 	if (type === "c2s.push.register" || type === "c2s.widget.push.register") {
 		if (p.environment !== void 0 && p.environment !== "production" && p.environment !== "development") return "invalid APNs environment";
 		if (!optional("enrollKey", (v) => text(v, 128))) return "invalid enrollKey";
@@ -462,7 +467,8 @@ var DeviceStore = class DeviceStore {
 			firstSeenTs: existing?.firstSeenTs ?? now,
 			lastSeenTs: now,
 			...existing?.apns ? { apns: existing.apns } : {},
-			...existing?.widgetApns ? { widgetApns: existing.widgetApns } : {}
+			...existing?.widgetApns ? { widgetApns: existing.widgetApns } : {},
+			...existing?.liveActivity ? { liveActivity: existing.liveActivity } : {}
 		};
 		this.devices.set(deviceId, next);
 		this.flush();
@@ -488,6 +494,7 @@ var DeviceStore = class DeviceStore {
 		record.revokedAt = now;
 		delete record.apns;
 		delete record.widgetApns;
+		delete record.liveActivity;
 		this.flush();
 		return true;
 	}
@@ -533,6 +540,29 @@ var DeviceStore = class DeviceStore {
 		delete record.apns;
 		this.flush();
 	}
+	setLiveActivity(deviceId, registration) {
+		const record = this.authorized(deviceId);
+		if (!record || !isValidApnsToken(registration.token)) return;
+		const old = record.liveActivity;
+		record.liveActivity = old?.activityId === registration.activityId ? {
+			...registration,
+			expiresAt: old.expiresAt,
+			endedState: old.endedState
+		} : registration;
+		this.flush();
+	}
+	endLiveActivity(deviceId, token, state) {
+		const registration = this.devices.get(deviceId)?.liveActivity;
+		if (!registration || registration.token !== token || registration.endedState) return;
+		registration.endedState = state;
+		this.flush();
+	}
+	clearLiveActivity(deviceId, activityId, token) {
+		const record = this.devices.get(deviceId);
+		if (record?.liveActivity?.activityId !== activityId || token !== void 0 && record.liveActivity.token !== token) return;
+		delete record.liveActivity;
+		this.flush();
+	}
 	setWidgetPushToken(deviceId, token, environment, now) {
 		const record = this.authorized(deviceId);
 		if (!record || !isValidApnsToken(token)) return;
@@ -613,8 +643,9 @@ function requiredScope(type) {
 	if (type === "c2s.session.sendPrompt" || type === "c2s.session.delivery") return "prompt.send";
 	if (type === "c2s.pending.list") return "interactions.respond";
 	if (type === "c2s.approval.respond" || type === "c2s.question.respond") return "interactions.respond";
+	if (type === "c2s.liveActivity.register" || type === "c2s.liveActivity.unregister") return "notifications.register";
 	if (type === "c2s.push.register" || type === "c2s.widget.push.register") return "notifications.register";
-	if (type === "c2s.workspace.create" || type === "c2s.session.create" || type === "c2s.session.rename" || type === "c2s.session.archive" || type === "c2s.session.cancel" || type === "c2s.session.selectModel") return "sessions.manage";
+	if (type === "c2s.workspace.create" || type === "c2s.session.create" || type === "c2s.session.rename" || type === "c2s.session.archive" || type === "c2s.session.unarchive" || type === "c2s.session.cancel" || type === "c2s.session.selectModel") return "sessions.manage";
 	if (type.startsWith("c2s.")) return "sessions.read";
 }
 /** Broadcast and replay authorization. Unknown frame types fail closed. */
@@ -693,6 +724,8 @@ var BridgeConnection = class {
 	deviceId;
 	scopes = /* @__PURE__ */ new Set();
 	widgetClient = false;
+	liveActivityRegistrationGeneration = 0;
+	pendingLiveActivityId;
 	authChallenge;
 	constructor(ws, deps) {
 		this.ws = ws;
@@ -992,6 +1025,18 @@ var BridgeConnection = class {
 				this.send("s2c.session.archived", { sessionId: p.sessionId }, env.id);
 				return;
 			}
+			case "c2s.sessions.archived":
+				this.send("s2c.sessions.archived.snapshot", { sessions: this.deps.bridge.listArchivedSessions() }, env.id);
+				return;
+			case "c2s.session.unarchive": {
+				const p = env.payload;
+				if (!p?.sessionId) return this.fail(env.id, "E_PROTOCOL", "sessionId required");
+				if (!this.deps.bridge.capabilities.sessionRestore) return this.fail(env.id, "E_UNSUPPORTED", "session restore unavailable on this host version");
+				const result = await this.deps.bridge.unarchiveSession(p.sessionId);
+				if (!result.ok) return this.fail(env.id, managementErrorCode(result.kind), result.message);
+				this.send("s2c.session.unarchived", { sessionId: p.sessionId }, env.id);
+				return;
+			}
 			case "c2s.session.cancel": {
 				const p = env.payload;
 				if (!p?.sessionId) return this.fail(env.id, "E_PROTOCOL", "sessionId required");
@@ -1119,6 +1164,49 @@ var BridgeConnection = class {
 				this.send("s2c.ack", {}, env.id);
 				return;
 			}
+			case "c2s.liveActivity.unregister": {
+				const p = env.payload;
+				if (this.pendingLiveActivityId === p.activityId) {
+					this.liveActivityRegistrationGeneration += 1;
+					this.pendingLiveActivityId = void 0;
+				}
+				this.deps.devices.clearLiveActivity(this.deviceId, p.activityId);
+				this.send("s2c.ack", {}, env.id);
+				return;
+			}
+			case "c2s.liveActivity.register": {
+				const p = env.payload;
+				const initial = this.deviceId && this.deps.devices.authorized(this.deviceId);
+				if (!initial || ![
+					"notifications.register",
+					"sessions.read",
+					"interactions.respond"
+				].every((scope) => initial.scopes?.includes(scope))) return this.fail(env.id, "E_FORBIDDEN", "live activity permissions required");
+				const generation = ++this.liveActivityRegistrationGeneration;
+				this.pendingLiveActivityId = p.activityId;
+				if (p.enrollKey) await this.deps.onPushEnrollKey?.(p.enrollKey);
+				if (generation !== this.liveActivityRegistrationGeneration) return this.fail(env.id, "E_BUSY", "live activity registration superseded");
+				const record = this.deviceId && this.deps.devices.authorized(this.deviceId);
+				if (this.closed || !record || ![
+					"notifications.register",
+					"sessions.read",
+					"interactions.respond"
+				].every((scope) => record.scopes?.includes(scope))) return this.fail(env.id, "E_FORBIDDEN", "live activity permissions required");
+				if (!this.deps.bridge.listSessions().some((row) => row.id === p.sessionId)) return this.fail(env.id, "E_NOT_FOUND", "session not found");
+				const previous = record.liveActivity;
+				if (previous?.activityId === p.activityId && previous.sessionId !== p.sessionId) return this.fail(env.id, "E_PROTOCOL", "activity is bound to another session");
+				this.deps.devices.setLiveActivity(record.deviceId, {
+					activityId: p.activityId,
+					sessionId: p.sessionId,
+					token: p.deviceToken.toLowerCase(),
+					environment: p.environment,
+					updatedAt: Date.now(),
+					expiresAt: Date.now() + 288e5
+				});
+				this.deps.bridge.refreshLiveActivities();
+				this.send("s2c.ack", { enabled: this.deps.bridge.capabilities.push }, env.id);
+				return;
+			}
 			case "c2s.widget.push.register":
 			case "c2s.push.register": {
 				const widget = env.type === "c2s.widget.push.register";
@@ -1298,6 +1386,7 @@ function projectEvent(sessionId, event) {
 			kind: "turn.end",
 			data: { ok: event.data?.reason?.kind === "completed" }
 		};
+		case "system/message": return null;
 		case "user/message": return {
 			kind: "message.final",
 			data: { ...limitMessageProjection({
@@ -1358,14 +1447,28 @@ function projectEvent(sessionId, event) {
 		}
 		case "tool/result": {
 			const data = event.data;
+			const ok = data?.error === void 0;
+			const result = limitMessageProjection({
+				seq: event.seq,
+				role: "tool",
+				ts: tsOf(event),
+				tool: {
+					name: "result",
+					state: ok ? "ok" : "error",
+					summary: ok ? summarizeResult(data?.message?.content) : "失败"
+				},
+				...ok ? attachmentProjection(data?.message) : {}
+			});
 			return {
 				kind: "tool.end",
 				data: {
-					seq: event.seq,
-					role: "tool",
-					ok: !event.data || data?.error === void 0,
-					...data?.callId ? { callId: String(data.callId) } : {},
-					ts: tsOf(event)
+					seq: result.seq,
+					role: result.role,
+					ts: result.ts,
+					ok,
+					summary: result.tool?.summary,
+					...result.attachments ? { attachments: result.attachments } : {},
+					...data?.callId ? { callId: String(data.callId) } : {}
 				}
 			};
 		}
@@ -1560,6 +1663,7 @@ function projectHistory(events) {
 			ts: tsOf(event)
 		};
 		switch (event.type) {
+			case "system/message": break;
 			case "user/message":
 				messages.push({
 					...base,
@@ -1602,19 +1706,23 @@ function projectHistory(events) {
 				const target = callId ? toolByCall.get(callId) : void 0;
 				const failed = data?.error !== void 0;
 				const summary = failed ? "失败" : summarizeResult(data?.message?.content);
-				if (target?.tool) target.tool = {
-					...target.tool,
-					state: failed ? "error" : "ok",
-					summary
-				};
-				else messages.push({
+				const attachments = failed ? {} : attachmentProjection(data?.message);
+				if (target?.tool) {
+					target.tool = {
+						...target.tool,
+						state: failed ? "error" : "ok",
+						summary
+					};
+					if (attachments.attachments) Object.assign(target, attachments);
+				} else messages.push({
 					...base,
 					role: "tool",
 					tool: {
 						name: "result",
 						state: failed ? "error" : "ok",
 						summary
-					}
+					},
+					...attachments
 				});
 				break;
 			}
@@ -1738,9 +1846,13 @@ var HostBridge = class {
 	historyBufferMax;
 	id = ++BRIDGE_SEQ;
 	summaries = /* @__PURE__ */ new Map();
+	activeTools = /* @__PURE__ */ new Map();
 	approvals = /* @__PURE__ */ new Map();
 	questions = /* @__PURE__ */ new Map();
 	archivedSessionIds = /* @__PURE__ */ new Set();
+	/** Mirrors archived rows from the last sessions.list so the phone can browse
+	* and restore them. Excluded from `summaries` and from the live broadcast. */
+	archivedSummaries = /* @__PURE__ */ new Map();
 	subagentSessionIds = /* @__PURE__ */ new Set();
 	sinks = /* @__PURE__ */ new Set();
 	ring = [];
@@ -1775,9 +1887,11 @@ var HostBridge = class {
 			notifyAllCategories: true,
 			models: typeof this.apiProxy.sessions.models === "function" && typeof this.apiProxy.sessions.selectModel === "function",
 			sessionManagement: typeof this.apiProxy.sessions.rename === "function" && typeof this.apiProxy.workspace?.archiveSession === "function",
+			sessionRestore: typeof this.apiProxy.workspace?.unarchiveSession === "function",
 			projectSelection: typeof this.apiProxy.workspace?.list === "function" && typeof this.apiProxy.workspace?.create === "function",
 			push: this.pushOutlet?.isAvailable() === true,
-			widgetPush: true
+			widgetPush: true,
+			liveActivityPush: true
 		};
 	}
 	diagnostic(message) {
@@ -1823,7 +1937,7 @@ var HostBridge = class {
 	*  PROTOCOL §6 + §7), then fan the same payload out to offline devices
 	*  holding an APNs token. */
 	emitNotify(args) {
-		if (this.subagentSessionIds.has(args.sessionId)) return;
+		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;
 		this.record("s2c.notify", {
 			notificationId: args.notificationId,
@@ -1890,16 +2004,23 @@ var HostBridge = class {
 		for (const sink of receivers) sink.replayDone();
 		return true;
 	}
+	refreshLiveActivities() {
+		try {
+			this.pushOutlet?.liveActivityChanged?.(this.listSessions());
+		} catch {}
+	}
 	record(type, payload, except) {
 		if (this.disposed) return;
+		if (type === "s2c.sessions.delta") this.refreshLiveActivities();
 		if (type === "s2c.sessions.delta" || type.startsWith("s2c.pending.")) {
 			const fingerprint = JSON.stringify([
-				this.listSessions().map(({ id, title, status, lastActivityTs, todos, pendingApproval, pendingQuestion }) => ({
+				this.listSessions().map(({ id, title, status, lastActivityTs, todos, todoItems, pendingApproval, pendingQuestion }) => ({
 					id,
 					title,
 					status,
 					lastActivityTs,
 					todos,
+					todoItems,
 					pendingApproval,
 					pendingQuestion
 				})),
@@ -1992,9 +2113,12 @@ var HostBridge = class {
 				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;
 				this.noteActivity(sessionId, event);
 				this.captureAssistantText(sessionId, event);
 				const projection = projectEvent(sessionId, event);
+				this.captureActivity(sessionId, event, projection?.data.tool);
 				if (projection) this.record("s2c.session.event", {
 					sessionId,
 					kind: projection.kind,
@@ -2029,6 +2153,7 @@ var HostBridge = class {
 					summary,
 					riskLevel: riskOf(toolName)
 				});
+				if (p.callId) this.loadApprovalArguments(p.approvalId, p.callId);
 				this.emitNotify({
 					sessionId,
 					category: "approval.required",
@@ -2111,17 +2236,27 @@ var HostBridge = class {
 			const workspaceBySession = /* @__PURE__ */ new Map();
 			for (const workspace of workspaces) for (const sessionId of workspace.sessionIds ?? []) workspaceBySession.set(String(sessionId), workspace);
 			const next = /* @__PURE__ */ new Map();
-			const subagentIds = /* @__PURE__ */ new Set();
+			const nextArchived = /* @__PURE__ */ new Map();
 			for (const row of response.result.value.items ?? []) {
-				if (this.archivedSessionIds.has(row.sessionId)) continue;
-				if (isSubagentRow(row)) {
-					subagentIds.add(row.sessionId);
+				if (isSubagentRow(row)) this.subagentSessionIds.add(row.sessionId);
+				if (this.subagentSessionIds.has(row.sessionId)) continue;
+				const summary = toSummary(row, this.approvals, this.questions, workspaceBySession.get(row.sessionId));
+				if (this.archivedSessionIds.has(row.sessionId)) {
+					nextArchived.set(row.sessionId, {
+						...summary,
+						archived: true
+					});
 					continue;
 				}
-				next.set(row.sessionId, toSummary(row, this.approvals, this.questions, workspaceBySession.get(row.sessionId)));
+				next.set(row.sessionId, summary);
+			}
+			for (const [id, calls] of this.activeTools) {
+				const row = next.get(id);
+				if (!row || row.status !== "running" && !row.pendingApproval && !row.pendingQuestion) this.activeTools.delete(id);
+				else row.activity = [...calls.values()].at(-1) ?? null;
 			}
-			this.subagentSessionIds = subagentIds;
 			this.summaries = next;
+			this.archivedSummaries = nextArchived;
 			const removedIds = [...previousIds].filter((id) => !next.has(id));
 			for (const id of this.lastAssistantText.keys()) if (!next.has(id)) this.lastAssistantText.delete(id);
 			this.record("s2c.sessions.delta", {
@@ -2139,6 +2274,24 @@ var HostBridge = class {
 		row.title = firstUser.text.replace(/\s+/g, " ").trim().slice(0, 60);
 		this.pushSummary(row);
 	}
+	captureActivity(sessionId, event, tool) {
+		const row = this.summaries.get(sessionId);
+		if (!row) return;
+		const data = event.data;
+		if (event.type === "tool/call" && data?.callId) {
+			const calls = this.activeTools.get(sessionId) ?? /* @__PURE__ */ new Map();
+			const detail = [tool?.name, tool?.summary].filter(Boolean).join(": ");
+			calls.set(data.callId, Array.from(detail).slice(0, 160).join(""));
+			if (calls.size > 64) calls.delete(calls.keys().next().value);
+			this.activeTools.set(sessionId, calls);
+		} else if (event.type === "tool/result" && data?.callId) this.activeTools.get(sessionId)?.delete(data.callId);
+		else if (event.type === "turn/start" || event.type === "turn/end") this.activeTools.delete(sessionId);
+		else return;
+		const activity = [...this.activeTools.get(sessionId)?.values() ?? []].at(-1) ?? null;
+		if (row.activity === activity) return;
+		row.activity = activity;
+		this.pushSummary(row);
+	}
 	noteActivity(sessionId, event) {
 		const row = this.summaries.get(sessionId);
 		if (!row) return;
@@ -2197,6 +2350,14 @@ var HostBridge = class {
 		return [...this.summaries.values()].sort((a, b) => b.lastActivityTs - a.lastActivityTs);
 	}
 	/**
+	* Archived rows from the last sessions.list, newest first. Served only on
+	* demand so the live session list and its broadcast keep their shape for
+	* clients that predate `c2s.sessions.archived`.
+	*/
+	listArchivedSessions() {
+		return [...this.archivedSummaries.values()].sort((a, b) => b.lastActivityTs - a.lastActivityTs);
+	}
+	/**
 	* Complete transient interaction state. Unlike the replay ring, this remains
 	* authoritative after a long disconnect and is rehydrated by apiProxy's mux
 	* stream when the bridge itself restarts.
@@ -2208,6 +2369,7 @@ var HostBridge = class {
 				sessionId: pending.sessionId,
 				toolName: pending.toolName,
 				summary: pending.reason,
+				...pending.toolArguments !== void 0 ? { toolArguments: pending.toolArguments } : {},
 				riskLevel: riskOf(pending.toolName)
 			})),
 			questions: [...this.questions.entries()].map(([requestId, pending]) => ({
@@ -2217,6 +2379,35 @@ var HostBridge = class {
 			}))
 		};
 	}
+	/** Resolve only the exact invocation in this session; never guess from the latest tool. */
+	async loadApprovalArguments(requestId, callId) {
+		const pending = this.approvals.get(requestId);
+		if (!pending) return;
+		try {
+			const response = await this.apiProxy.sessions.history({
+				rpcId: randomUUID(),
+				payload: {
+					sessionId: pending.sessionId,
+					maxMessages: 200
+				}
+			});
+			if (this.disposed || this.approvals.get(requestId) !== pending || !response.result?.ok) return;
+			const args = ((response.result.value.events ?? []).map((row) => row.event).find((event) => {
+				const data = event.data;
+				return event.type === "tool/call" && data?.callId === callId && data?.name === pending.toolName;
+			})?.data)?.arguments;
+			if (typeof args !== "string" || !args.trim()) return;
+			pending.toolArguments = args;
+			this.record("s2c.pending.approval", {
+				requestId,
+				sessionId: pending.sessionId,
+				toolName: pending.toolName,
+				summary: pending.reason,
+				riskLevel: riskOf(pending.toolName),
+				toolArguments: args
+			});
+		} catch {}
+	}
 	/** Tail history for an opened session; pushes s2c.session.tail to the sink. */
 	async openSession(sink, sessionId, tailCount) {
 		try {
@@ -2430,6 +2621,38 @@ var HostBridge = class {
 			};
 		}
 	}
+	async unarchiveSession(sessionId) {
+		const unarchive = this.apiProxy.workspace?.unarchiveSession;
+		if (typeof unarchive !== "function") return {
+			ok: false,
+			kind: "unsupported",
+			message: "session restore unavailable on this host version"
+		};
+		try {
+			const response = await unarchive.call(this.apiProxy.workspace, {
+				rpcId: randomUUID(),
+				payload: { sessionId }
+			});
+			if (!response.result) return {
+				ok: false,
+				kind: "internal",
+				message: "session restore returned no result"
+			};
+			if (!response.result.ok) return hostSessionManagementError(response.result.error);
+			this.archivedSessionIds = new Set((response.result.value.archivedSessionIds ?? []).map(String));
+			await this.refreshSummaries();
+			return {
+				ok: true,
+				value: true
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				kind: "internal",
+				message: String(error)
+			};
+		}
+	}
 	async cancelSession(sessionId) {
 		const cancel = this.apiProxy.sessions.cancel;
 		if (typeof cancel !== "function") return {
@@ -3163,6 +3386,7 @@ var Dsh012ApiProxy = class {
 		if (session === void 0) throw new Error("dsh 0.1.2 sessionController is unavailable");
 		this.session = session;
 		this.workspaceController = ctx.get("workspaceController");
+		if (typeof this.workspaceController?.unarchiveSession !== "function") delete this.workspace?.unarchiveSession;
 		this.directoryPicker = ctx.get("directoryPickerController");
 		this.shouldSurfaceInteraction = options.shouldSurfaceInteraction ?? (() => true);
 	}
@@ -3180,7 +3404,7 @@ var Dsh012ApiProxy = class {
 	}
 	sessions = {
 		list: async () => this.call(async () => {
-			return { items: (await this.session.list({}, new AbortController().signal)).items.map(toPhoneSessionRow).filter((row) => !isSubagentRow(row)) };
+			return { items: (await this.session.list({}, new AbortController().signal)).items.map(toPhoneSessionRow) };
 		}),
 		history: async (request) => this.call(async () => {
 			const sessionId = request.payload.sessionId;
@@ -3242,6 +3466,12 @@ var Dsh012ApiProxy = class {
 		archiveSession: async (request) => this.call(async () => {
 			if (this.workspaceController === void 0) throw unavailable("workspace controller unavailable");
 			return { archivedSessionIds: [...(await this.workspaceController.archiveSession(request.payload)).archivedSessionIds] };
+		}),
+		unarchiveSession: async (request) => this.call(async () => {
+			if (this.workspaceController === void 0) throw unavailable("workspace controller unavailable");
+			const unarchive = this.workspaceController.unarchiveSession;
+			if (typeof unarchive !== "function") throw unavailable("session restore unavailable on this host version");
+			return { archivedSessionIds: [...(await unarchive.call(this.workspaceController, request.payload)).archivedSessionIds] };
 		})
 	};
 	host = {
@@ -3278,6 +3508,7 @@ var Dsh012ApiProxy = class {
 			queue.push({
 				type: "session/event",
 				sessionId: String(session.id),
+				isSubagent: session.header?.origin === "subagent",
 				event
 			});
 		}), { global: true });
@@ -3326,7 +3557,8 @@ var Dsh012ApiProxy = class {
 			sessionId,
 			approvalId: rpcId,
 			toolName: String(request.toolName ?? "tool"),
-			reason: String(request.reason ?? "")
+			reason: String(request.reason ?? ""),
+			...request.callId ? { callId: request.callId } : {}
 		});
 		return response.promise.finally(() => {
 			request.signal?.removeEventListener("abort", abort);
@@ -3665,10 +3897,16 @@ function parseLocal(value) {
 	if (!Array.isArray(endpoints) || endpoints.some((entry) => typeof entry !== "string")) reject("local.endpoints");
 	const message = s.message;
 	if (message !== void 0 && typeof message !== "string") reject("local.message");
+	const tlsFingerprint = s.tlsFingerprint;
+	if (tlsFingerprint !== void 0 && typeof tlsFingerprint !== "string") reject("local.tlsFingerprint");
+	const tlsIdentityRegenerated = s.tlsIdentityRegenerated;
+	if (tlsIdentityRegenerated !== void 0 && typeof tlsIdentityRegenerated !== "boolean") reject("local.tlsIdentityRegenerated");
 	return {
 		phase,
 		port: int(s, "port", "local.port"),
 		endpoints,
+		...typeof tlsFingerprint === "string" ? { tlsFingerprint } : {},
+		...tlsIdentityRegenerated === true ? { tlsIdentityRegenerated: true } : {},
 		...typeof message === "string" ? { message } : {},
 		updatedAt: int(s, "updatedAt", "local.updatedAt")
 	};
@@ -4094,6 +4332,12 @@ function p8ToDer(pem) {
 }
 /** Pure payload builder so tests can assert the wire format without sockets. */
 function apnsPayload(notification) {
+	if ("kind" in notification && notification.kind === "liveactivity") return { aps: {
+		timestamp: notification.timestamp,
+		event: notification.event,
+		"content-state": notification.contentState,
+		...notification.event === "end" ? { "dismissal-date": notification.timestamp + 300 } : { "stale-date": notification.timestamp + 180 }
+	} };
 	if ("kind" in notification && notification.kind === "widget") return { aps: { "content-changed": true } };
 	return alertPayload(notification);
 }
@@ -4117,6 +4361,12 @@ function alertPayload(notification) {
 	};
 }
 function pushHeaders(bundleId, notification) {
+	if ("kind" in notification && notification.kind === "liveactivity") return {
+		"apns-topic": bundleId + ".push-type.liveactivity",
+		"apns-push-type": "liveactivity",
+		"apns-priority": notification.event === "end" ? "10" : "5",
+		"apns-expiration": String(notification.timestamp + 180)
+	};
 	if ("kind" in notification && notification.kind === "widget") return {
 		"apns-topic": bundleId + ".push-type.widgets",
 		"apns-push-type": "widgets",
@@ -5023,9 +5273,10 @@ const MAX_LOCAL_PORT = 65535;
 function normalizeLocalPort(value) {
 	return typeof value === "number" && Number.isInteger(value) && value >= 1024 && value <= 65535 ? value : DEFAULT_LOCAL_PORT;
 }
+/** The LAN listener is TLS-only, so every advertised endpoint is `https://`. */
 function localEndpointURLs(addresses, port) {
 	const normalizedPort = normalizeLocalPort(port);
-	return [...new Set(addresses)].map((address) => `http://${address}:${normalizedPort}`);
+	return [...new Set(addresses)].map((address) => `https://${address}:${normalizedPort}`);
 }
 function localListenError(error, port) {
 	const code = error?.code;
@@ -5044,7 +5295,7 @@ const Config = z.object({
 	debug: z.boolean().default(false),
 	local: z.object({
 		enabled: z.boolean().default(true),
-		port: z.natural().min(MIN_LOCAL_PORT).max(MAX_LOCAL_PORT).default(DEFAULT_LOCAL_PORT).description("DeepPilot 局域网独立端口（默认 3098，修改后本地连接会短暂重连）")
+		port: z.natural().min(MIN_LOCAL_PORT).max(MAX_LOCAL_PORT).default(DEFAULT_LOCAL_PORT).description("DeepPilot 局域网独立端口（仅 TLS；默认 3098，修改后本地连接会短暂重连）")
 	}).default({
 		enabled: true,
 		port: DEFAULT_LOCAL_PORT
@@ -5331,14 +5582,91 @@ var WidgetPushScheduler = class {
 	}
 };
 //#endregion
+//#region src/live-activity.ts
+function liveActivityState(session) {
+	const total = Math.max(0, session?.todos?.total ?? session?.todoItems?.length ?? 0);
+	const done = Math.min(total, Math.max(0, session?.todos?.done ?? 0));
+	const task = session?.todoItems?.find((item) => item.status === "in_progress") ?? session?.todoItems?.find((item) => item.status === "pending");
+	return {
+		title: Array.from(session?.title ?? "").slice(0, 100).join(""),
+		task: Array.from(session?.activity?.trim() || task?.content || "").slice(0, 160).join(""),
+		done,
+		total,
+		phase: !session || total === 0 ? "unavailable" : session.pendingApproval ? "approval" : session.pendingQuestion ? "question" : session.status === "running" ? "running" : session.status === "idle" ? "ended" : "unavailable"
+	};
+}
+/** Persist terminal state before coalescing so a rapid next round cannot revive an activity. */
+var LiveActivityPushManager = class {
+	devices;
+	send;
+	latest = /* @__PURE__ */ new Map();
+	sent = /* @__PURE__ */ new Map();
+	scheduler;
+	constructor(devices, send, intervalMs = 15e3) {
+		this.devices = devices;
+		this.send = send;
+		this.scheduler = new WidgetPushScheduler(() => this.flush(), intervalMs);
+	}
+	changed(sessions) {
+		this.latest = new Map(sessions.map((session) => [session.id, session]));
+		for (const device of this.devices()?.list() ?? []) {
+			const r = device.liveActivity;
+			if (!r) continue;
+			const state = liveActivityState(this.latest.get(r.sessionId));
+			if (state.phase === "ended" || state.phase === "unavailable") this.devices()?.endLiveActivity(device.deviceId, r.token, state);
+		}
+		this.scheduler.changed();
+	}
+	async flush() {
+		const devices = this.devices();
+		if (!devices) return;
+		const valid = /* @__PURE__ */ new Set();
+		for (const device of devices.list()) {
+			const r = device.liveActivity;
+			if (!r) continue;
+			const key = device.deviceId + ":" + r.token;
+			valid.add(key);
+			if (device.revokedAt !== void 0 || ![
+				"notifications.register",
+				"sessions.read",
+				"interactions.respond"
+			].every((scope) => device.scopes?.some((value) => value === scope)) || r.expiresAt <= Date.now()) {
+				devices.clearLiveActivity(device.deviceId, r.activityId, r.token);
+				continue;
+			}
+			const state = r.endedState ?? liveActivityState(this.latest.get(r.sessionId));
+			const fingerprint = JSON.stringify(state);
+			if (this.sent.get(key) === fingerprint) continue;
+			if (devices.authorized(device.deviceId)?.liveActivity?.token !== r.token) continue;
+			const result = await this.send(r.token, r.environment, {
+				kind: "liveactivity",
+				event: r.endedState ? "end" : "update",
+				timestamp: Math.floor(Date.now() / 1e3),
+				contentState: state
+			}).catch(() => ({ outcome: "failed" }));
+			if (result.outcome === "sent") this.sent.set(key, fingerprint);
+			else if (result.outcome === "invalid-token") devices.clearLiveActivity(device.deviceId, r.activityId, r.token);
+			else this.scheduler.changed();
+		}
+		for (const key of this.sent.keys()) if (!valid.has(key)) this.sent.delete(key);
+	}
+	dispose() {
+		this.scheduler.dispose();
+	}
+};
+//#endregion
 //#region src/phone-server.ts
 /**
 * A deliberately narrow transport listener. Both the LAN endpoint and the
 * loopback-only Funnel origin use this factory, so neither can accidentally
 * inherit DSH's wider web/API route surface.
+*
+* With `tls` the listener speaks HTTPS/WSS only (the LAN posture); without
+* it the listener is plain HTTP, which is reserved for the loopback Funnel
+* origin where tailscaled terminates TLS.
 */
-function createPhoneServer(handlers) {
-	const server = createServer((req, res) => {
+function createPhoneServer(handlers, tls) {
+	const onRequest = (req, res) => {
 		const path = requestPath(req);
 		if (path === "/phone/health") handlers.health(req, res);
 		else if (path === "/phone/pair") handlers.pair(req, res);
@@ -5346,7 +5674,12 @@ function createPhoneServer(handlers) {
 			res.statusCode = 404;
 			res.end("not found");
 		}
-	});
+	};
+	const server = tls === void 0 ? createServer$1(onRequest) : createServer({
+		key: tls.key,
+		cert: tls.cert,
+		minVersion: "TLSv1.2"
+	}, onRequest);
 	server.on("upgrade", (req, socket, head) => {
 		if (requestPath(req) !== "/phone") {
 			socket.end("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
@@ -5383,12 +5716,175 @@ function closeServer(server) {
 	return new Promise((resolve) => server.close(() => resolve()));
 }
 //#endregion
+//#region src/lan-tls.ts
+const LAN_TLS_COMMON_NAME = "dsh-deeppilot";
+const LAN_TLS_KEY_FILE = "key.pem";
+const LAN_TLS_CERT_FILE = "cert.pem";
+const CERT_VALIDITY_MS = 31536e7;
+/** Re-sign this far ahead of expiry so a long-running host never serves a stale leaf. */
+const CERT_RENEW_LEAD_MS = 2592e6;
+/** Compute the pinned public-key fingerprint of a PEM certificate. */
+function spkiFingerprint(certPem) {
+	const der = createPublicKey(certPem).export({
+		type: "spki",
+		format: "der"
+	});
+	return "sha256:" + createHash("sha256").update(der).digest("base64url");
+}
+/**
+* Load the LAN listener's TLS identity from `dir`, creating or repairing it
+* as needed. The private key is the durable identity: it is created once and
+* reused for every subsequent certificate, so pinned devices survive
+* certificate renewals. Only a missing or unreadable key forces a new one.
+*/
+async function loadOrCreateLanTlsIdentity(dir, now = Date.now()) {
+	await mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const keyPath = join(dir, LAN_TLS_KEY_FILE);
+	const certPath = join(dir, LAN_TLS_CERT_FILE);
+	let key = await readPem(keyPath);
+	let regenerated = false;
+	if (key === void 0 || !validPrivateKey(key)) {
+		regenerated = true;
+		key = void 0;
+	}
+	let cert = regenerated ? void 0 : await readPem(certPath);
+	let resigned = false;
+	const existing = key !== void 0 && cert !== void 0 ? inspectCertificate(cert, key, now) : void 0;
+	if (existing === void 0) {
+		const issued = await issueCertificate(key, now);
+		if (key === void 0) {
+			key = pemFile(issued.key);
+			await writePrivate(keyPath, key);
+		} else resigned = true;
+		cert = pemFile(issued.cert);
+		await writePrivate(certPath, cert);
+	}
+	if (key === void 0 || cert === void 0) throw new Error("LAN TLS identity unavailable");
+	return {
+		key,
+		cert,
+		fingerprint: spkiFingerprint(cert),
+		notAfter: existing ?? new X509Certificate(cert).validToDate.getTime(),
+		regenerated,
+		resigned
+	};
+}
+async function readPem(path) {
+	try {
+		const text = await readFile(path, "utf8");
+		return text.trim().length > 0 ? text : void 0;
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		return;
+	}
+}
+function validPrivateKey(pem) {
+	try {
+		return createPrivateKey(pem).asymmetricKeyType === "ec";
+	} catch {
+		return false;
+	}
+}
+/**
+* Return the certificate's expiry when it is usable with `keyPem`, or
+* `undefined` when it must be re-issued (malformed, wrong key, or expiring).
+*/
+function inspectCertificate(certPem, keyPem, now) {
+	try {
+		const cert = new X509Certificate(certPem);
+		const certSpki = cert.publicKey.export({
+			type: "spki",
+			format: "der"
+		});
+		const keySpki = createPublicKey(createPrivateKey(keyPem)).export({
+			type: "spki",
+			format: "der"
+		});
+		if (!certSpki.equals(keySpki)) return void 0;
+		const notAfter = cert.validToDate.getTime();
+		if (!(cert.validFromDate.getTime() <= now && notAfter - CERT_RENEW_LEAD_MS > now)) return void 0;
+		return notAfter;
+	} catch {
+		return;
+	}
+}
+async function issueCertificate(existingKey, now) {
+	const notBeforeDate = /* @__PURE__ */ new Date(now - 3e5);
+	const notAfterDate = new Date(now + CERT_VALIDITY_MS);
+	const keyPair = existingKey === void 0 ? void 0 : {
+		privateKey: createPrivateKey(existingKey).export({
+			type: "pkcs8",
+			format: "pem"
+		}),
+		publicKey: createPublicKey(existingKey).export({
+			type: "spki",
+			format: "pem"
+		})
+	};
+	const result = await generate([{
+		name: "commonName",
+		value: LAN_TLS_COMMON_NAME
+	}], {
+		keyType: "ec",
+		curve: "P-256",
+		algorithm: "sha256",
+		notBeforeDate,
+		notAfterDate,
+		...keyPair ? { keyPair } : {},
+		extensions: [
+			{
+				name: "basicConstraints",
+				cA: false,
+				critical: true
+			},
+			{
+				name: "keyUsage",
+				digitalSignature: true,
+				keyAgreement: true,
+				critical: true
+			},
+			{
+				name: "extKeyUsage",
+				serverAuth: true
+			},
+			{
+				name: "subjectAltName",
+				altNames: [{
+					type: 2,
+					value: LAN_TLS_COMMON_NAME
+				}]
+			}
+		]
+	});
+	return {
+		key: existingKey ?? result.private,
+		cert: result.cert
+	};
+}
+/** Exact on-disk form, so a freshly issued value equals its later reload. */
+function pemFile(pem) {
+	return pem.replace(/\r\n/g, "\n").trimEnd() + "\n";
+}
+async function writePrivate(path, contents) {
+	const tmp = `${path}.${process.pid}.tmp`;
+	try {
+		await writeFile(tmp, contents, { mode: 384 });
+		await rename(tmp, path);
+	} catch (error) {
+		await unlink(tmp).catch(() => {});
+		throw error;
+	}
+}
+//#endregion
 //#region src/index.ts
 /**
 * dsh-deeppilot — data bridge between the DSH host and DeepPilot
-* clients. Owns independent, narrowly routed LAN and Funnel-origin listeners;
-* temporary compatibility routes remain on the existing DSH web server. The
-* web UI and the rest of DSH's API are never exposed by these listeners.
+* clients. Owns independent, narrowly routed LAN (TLS-only, pinned by paired
+* devices) and loopback Funnel-origin listeners. The web UI and the rest of
+* DSH's API are never exposed by these listeners.
 *
 * Data plane: an in-process HostBridge consumes a local compatibility façade
 * over DSH 0.1.2 Session/Workspace controllers, mirrors session summaries,
@@ -5399,7 +5895,7 @@ function closeServer(server) {
 * Swift models mirror that v2 contract.
 */
 const name = "deeppilot";
-/** No eager web-service requirement: independent transports start on their own. */
+/** No web-service requirement: the plugin owns its own transport listeners. */
 const inject = [];
 const SERVER_VERSION = readOwnPackageVersion();
 const MAX_CLIENT_CONNECTIONS = 16;
@@ -5818,8 +6314,27 @@ function apply(ctx, options) {
 			}
 		}
 	});
+	const liveActivityPush = new LiveActivityPushManager(() => auth.devices ?? void 0, async (deviceToken, environment, notification) => {
+		if (!enabledNow()) return { outcome: "failed" };
+		const resolved = resolvePushConfig(currentConfig());
+		if (!resolved.ok) return { outcome: "failed" };
+		const send = await senderFor(resolved.value);
+		if (!send) return { outcome: "failed" };
+		const result = await send({
+			deviceToken,
+			environment,
+			notification
+		});
+		if (resolved.value.kind === "relay" && result.reason === "HTTP 401" && enrollmentCell.token === resolved.value.token && enrollmentCell.enrollKey) {
+			enrollmentCell.token = void 0;
+			persistEnrollment();
+			await ensureRelayEnrolled(resolved.value.url);
+		}
+		return result;
+	});
 	const makePushOutlet = () => ({
 		widgetChanged: () => widgetPush.changed(),
+		liveActivityChanged: (sessions) => liveActivityPush.changed(sessions),
 		isAvailable: () => {
 			const resolved = resolvePushConfig(currentConfig());
 			if (!resolved.ok) return false;
@@ -5911,9 +6426,27 @@ function apply(ctx, options) {
 		endpoints: [],
 		updatedAt: Date.now()
 	};
+	let lanTlsIdentity;
+	let tlsIdentityRegenerated = false;
+	const loadLanTls = () => {
+		lanTlsIdentity ??= (async () => {
+			await ready;
+			const identity = await loadOrCreateLanTlsIdentity(join(dataDir, "lan-tls"));
+			if (identity.regenerated) {
+				tlsIdentityRegenerated = true;
+				log(`LAN TLS identity created: fingerprint=${identity.fingerprint}; previously paired LAN devices must pair again`);
+			} else if (identity.resigned) log(`LAN TLS certificate renewed (fingerprint unchanged: ${identity.fingerprint})`);
+			return identity;
+		})();
+		lanTlsIdentity.catch(() => {
+			lanTlsIdentity = void 0;
+		});
+		return lanTlsIdentity;
+	};
 	const localStatus = (addresses) => ({
 		...localState,
-		endpoints: localState.phase === "online" ? localEndpointURLs(addresses, localState.port) : []
+		endpoints: localState.phase === "online" ? localEndpointURLs(addresses, localState.port) : [],
+		...tlsIdentityRegenerated ? { tlsIdentityRegenerated: true } : {}
 	});
 	const remoteStatus = () => remoteSupervisor?.status() ?? {
 		provider: "tailscale-funnel",
@@ -6113,13 +6646,15 @@ function apply(ctx, options) {
 			}, Date.now());
 			authRateLimiter.recordSuccess(source);
 			log(`device paired id=${auditLabel(record.deviceId)} source=${auditLabel(source)}`);
+			const tlsFingerprint = req.socket.encrypted === true ? (await lanTlsIdentity)?.fingerprint : void 0;
 			res.statusCode = 201;
 			res.end(JSON.stringify({
 				ok: true,
 				v: 2,
 				deviceId: record.deviceId,
 				audience,
-				scopes: record.scopes ?? []
+				scopes: record.scopes ?? [],
+				...tlsFingerprint ? { tlsFingerprint } : {}
 			}));
 		} catch (error) {
 			res.statusCode = error instanceof SyntaxError || error instanceof TypeError ? 400 : 503;
@@ -6272,9 +6807,15 @@ function apply(ctx, options) {
 			endpoints: [],
 			updatedAt: Date.now()
 		};
-		const server = createPhoneServer(phoneHandlers);
-		localServer = server;
+		let server;
 		try {
+			const tls = await loadLanTls();
+			if (localDisposed || appliedLocalKey !== nextKey) return;
+			server = createPhoneServer(phoneHandlers, {
+				key: tls.key,
+				cert: tls.cert
+			});
+			localServer = server;
 			await listen(server, next.port, "0.0.0.0");
 			if (localDisposed || localServer !== server) {
 				await closeServer(server);
@@ -6284,12 +6825,15 @@ function apply(ctx, options) {
 				phase: "online",
 				port: next.port,
 				endpoints: [],
+				tlsFingerprint: tls.fingerprint,
 				updatedAt: Date.now()
 			};
-			log(`local transport listening on 0.0.0.0:${next.port}`);
+			log(`local transport listening on https://0.0.0.0:${next.port} (tls fingerprint ${tls.fingerprint})`);
 		} catch (error) {
-			if (localServer === server) localServer = void 0;
-			await closeServer(server);
+			if (server !== void 0) {
+				if (localServer === server) localServer = void 0;
+				await closeServer(server);
+			}
 			const message = localListenError(error, next.port);
 			localState = {
 				phase: "error",
@@ -6422,30 +6966,6 @@ function apply(ctx, options) {
 			bridge.dispose();
 		}, "deeppilot: host streams");
 	});
-	ctx.inject(["webServer"], (sub) => {
-		const webCtx = sub;
-		const web = webCtx.webServer;
-		if (!web) {
-			log("webServer service absent; 3080 compatibility routes unavailable (independent transports remain active)");
-			return;
-		}
-		webCtx.effect(() => web.registerUpgrade({
-			path: "/phone",
-			handler: handleUpgrade
-		}), "deeppilot: /phone WebSocket");
-		webCtx.effect(() => web.register({
-			kind: "exact",
-			path: "/phone/health",
-			handler: handleHealth
-		}), "deeppilot: /phone/health");
-		webCtx.effect(() => web.register({
-			kind: "exact",
-			path: "/phone/pair",
-			handler: handlePair
-		}), "deeppilot: /phone/pair");
-		if (enabledNow()) log("/phone compatibility routes registered on DSH web server");
-		else log("bridge disabled; /phone refuses connections until re-enabled");
-	});
 	ctx.effect(() => async () => {
 		closeAllConnections();
 		const bridge = state.bridge;
@@ -6455,6 +6975,7 @@ function apply(ctx, options) {
 		cachedSender = void 0;
 		updateChecker.dispose();
 		widgetPush.dispose();
+		liveActivityPush.dispose();
 		const wssClosed = new Promise((resolve) => wss.close(() => resolve()));
 		await Promise.allSettled([
 			enrollmentWriteTail,