dsh-deeppilot 0.6.0-alpha.2 → 0.6.0-alpha.4

package/lib/index.js

@@ -1,10 +1,11 @@
 import { createRequire } from "node:module";
-import { createServer } from "node:http";
 import { createHash, createPrivateKey, createPublicKey, randomBytes, randomUUID, sign, timingSafeEqual, verify } from "node:crypto";
-import { access, chmod, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+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";
 import { homedir, networkInterfaces } from "node:os";
+import * as Cordis from "@deepseek-ai/cordis";
+import { Context } from "@deepseek-ai/cordis";
 import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { connect } from "node:http2";
 import { spawn } from "node:child_process";
@@ -13,8 +14,11 @@ import { fileURLToPath } from "node:url";
 import { request } from "node:https";
 import z from "@deepseek-ai/schemastery";
 import { isIP } from "node:net";
+import { createServer } from "node:http";
 //#region src/device-auth.ts
-const PAIRING_CODE_TTL_MS = 3e5;
+function getPairingCodeTtlMs() {
+	return Number(process.env.DEEPPILOT_PAIRING_TTL_MS) || 3e5;
+}
 const AUTH_CHALLENGE_TTL_MS = 3e4;
 const DEVICE_SCOPES = [
 	"sessions.read",
@@ -104,7 +108,7 @@ var PairingCodeManager = class {
 	issue(now = Date.now()) {
 		const grant = {
 			code: randomBytes(24).toString("base64url"),
-			expiresAt: now + PAIRING_CODE_TTL_MS
+			expiresAt: now + getPairingCodeTtlMs()
 		};
 		this.active = grant;
 		return { ...grant };
@@ -339,6 +343,9 @@ function requiredScope(type) {
 function sanitizeImageName(value) {
 	return value.replace(/[\u0000-\u001F\u007F]/g, "").trim().slice(0, 120);
 }
+function sanitizeDocumentField(value, maxChars) {
+	return value.replace(/[\u0000-\u001F\u007F]/g, " ").trim().slice(0, maxChars);
+}
 /** Error code for a failed approval/question response outcome. */
 function pendingResponseErrorCode(reason) {
 	switch (reason) {
@@ -724,9 +731,11 @@ var BridgeConnection = class {
 				const p = env.payload;
 				const text = typeof p?.text === "string" ? p.text : "";
 				const rawImages = Array.isArray(p?.images) ? p.images : [];
-				if (!p?.sessionId || text.trim().length === 0 && rawImages.length === 0) return this.fail(env.id, "E_PROTOCOL", "sessionId and text or images required");
+				const rawDocuments = Array.isArray(p?.documents) ? p.documents : [];
+				if (!p?.sessionId || text.trim().length === 0 && rawImages.length === 0 && rawDocuments.length === 0) return this.fail(env.id, "E_PROTOCOL", "sessionId and prompt content required");
 				if (text.length > 262144) return this.fail(env.id, "E_PROTOCOL", "prompt text too long");
 				if (rawImages.length > 4) return this.fail(env.id, "E_PROTOCOL", "too many images");
+				if (rawDocuments.length > 4 || rawImages.length + rawDocuments.length > 4) return this.fail(env.id, "E_PROTOCOL", "too many prompt attachments");
 				const images = [];
 				for (const image of rawImages) {
 					if (!IMAGE_MEDIA_TYPES.has(String(image?.mediaType)) || typeof image?.data !== "string" || image.data.length === 0 || image.data.length > 8388608) return this.fail(env.id, "E_PROTOCOL", "invalid image attachment");
@@ -736,7 +745,20 @@ var BridgeConnection = class {
 						...typeof image.name === "string" && sanitizeImageName(image.name).length > 0 ? { name: sanitizeImageName(image.name) } : {}
 					});
 				}
-				const userSeq = await this.deps.bridge.sendPrompt(p.sessionId, text, images);
+				const documents = [];
+				for (const document of rawDocuments) {
+					if (typeof document?.name !== "string" || typeof document?.mediaType !== "string" || typeof document?.text !== "string" || document.text.length === 0 || document.text.length > 262144) return this.fail(env.id, "E_PROTOCOL", "invalid document attachment");
+					const name = sanitizeDocumentField(document.name, 180);
+					const mediaType = sanitizeDocumentField(document.mediaType, 120).toLowerCase();
+					if (!name || !mediaType || mediaType.startsWith("image/")) return this.fail(env.id, "E_PROTOCOL", "invalid document attachment");
+					documents.push({
+						name,
+						mediaType,
+						text: document.text,
+						...document.truncated === true ? { truncated: true } : {}
+					});
+				}
+				const userSeq = await this.deps.bridge.sendPrompt(p.sessionId, text, images, documents);
 				if (!userSeq.ok) return this.fail(env.id, managementErrorCode(userSeq.kind), userSeq.message);
 				this.send("s2c.ack", { userSeq: userSeq.value }, env.id);
 				return;
@@ -855,6 +877,44 @@ function unwrapStreamItem(item) {
 	return item;
 }
 //#endregion
+//#region src/document-payload.ts
+const PREFIX = "[DeepPilot document:";
+const SUFFIX = "]";
+/**
+* DSH 0.1.2 has durable image attachments but no generic file content block.
+* Documents therefore travel as a bounded, explicitly-labelled text block.
+* The marker lets the canonical phone row recover an attachment chip without
+* exposing the complete document body as ordinary user-authored bubble text.
+*/
+function documentPromptBlock(document) {
+	const marker = {
+		v: 1,
+		name: document.name,
+		mediaType: document.mediaType,
+		...document.truncated ? { truncated: true } : {}
+	};
+	const encoded = Buffer.from(JSON.stringify(marker), "utf8").toString("base64url");
+	return `${PREFIX}${encoded}${SUFFIX}\nAttached document: ${document.name}\n\n${document.text}`;
+}
+function projectedDocument(text) {
+	if (!text.startsWith(PREFIX)) return void 0;
+	const end = text.indexOf(SUFFIX, 20);
+	if (end < 0) return void 0;
+	try {
+		const decoded = JSON.parse(Buffer.from(text.slice(20, end), "base64url").toString("utf8"));
+		if (decoded.v !== 1 || typeof decoded.name !== "string" || typeof decoded.mediaType !== "string") return void 0;
+		if (!decoded.name.trim() || !decoded.mediaType.trim()) return void 0;
+		return {
+			name: decoded.name,
+			mediaType: decoded.mediaType,
+			text: text.slice(end + 1).replace(/^\nAttached document:[^\n]*\n\n/, ""),
+			...decoded.truncated === true ? { truncated: true } : {}
+		};
+	} catch {
+		return;
+	}
+}
+//#endregion
 //#region src/host-event-projection.ts
 const MAX_MESSAGE_PROJECTION_BYTES = 262144;
 /** One durable host event sequence becomes exactly one phone message row.
@@ -1049,7 +1109,7 @@ function contentText(content) {
 		if (typeof part === "string") return part;
 		if (part && typeof part === "object") {
 			const piece = part;
-			if (piece.type === "text" && typeof piece.text === "string") return piece.text;
+			if (piece.type === "text" && typeof piece.text === "string") return projectedDocument(piece.text) ? "" : piece.text;
 		}
 		return "";
 	}).join("");
@@ -1060,22 +1120,34 @@ function messageAttachments(data) {
 	const obj = data;
 	if (obj.message && typeof obj.message === "object") return messageAttachments(obj.message);
 	if (!Array.isArray(obj.content)) return [];
-	return obj.content.flatMap((part) => {
-		if (!part || typeof part !== "object") return [];
+	const attachments = [];
+	for (const part of obj.content) {
+		if (!part || typeof part !== "object") continue;
 		const block = part;
-		if (block.type !== "image" || !block.attachment) return [];
+		if (block.type === "text" && typeof block.text === "string") {
+			const document = projectedDocument(block.text);
+			if (document) attachments.push({
+				kind: "document",
+				name: document.name,
+				mediaType: document.mediaType,
+				...document.truncated ? { truncated: true } : {}
+			});
+			continue;
+		}
+		if (block.type !== "image" || !block.attachment) continue;
 		const attachmentId = typeof block.attachment.attachmentId === "string" && block.attachment.attachmentId.length > 0 ? block.attachment.attachmentId : void 0;
 		const width = typeof block.attachment.width === "number" && Number.isFinite(block.attachment.width) ? block.attachment.width : void 0;
 		const height = typeof block.attachment.height === "number" && Number.isFinite(block.attachment.height) ? block.attachment.height : void 0;
-		return [{
+		attachments.push({
 			kind: "image",
 			...typeof block.attachment.name === "string" ? { name: block.attachment.name } : {},
 			...typeof block.attachment.mediaType === "string" ? { mediaType: block.attachment.mediaType } : {},
 			...attachmentId ? { attachmentId } : {},
 			...width !== void 0 ? { width } : {},
 			...height !== void 0 ? { height } : {}
-		}];
-	});
+		});
+	}
+	return attachments;
 }
 function attachmentProjection(data) {
 	const attachments = messageAttachments(data);
@@ -2139,7 +2211,7 @@ var HostBridge = class {
 			return null;
 		}
 	}
-	async sendPrompt(sessionId, text, images = []) {
+	async sendPrompt(sessionId, text, images = [], documents = []) {
 		try {
 			const content = [];
 			if (text.trim().length > 0) content.push({
@@ -2150,6 +2222,10 @@ var HostBridge = class {
 				type: "image",
 				...image
 			});
+			for (const document of documents) content.push({
+				type: "text",
+				text: documentPromptBlock(document)
+			});
 			const response = await this.apiProxy.sessions.prompt({
 				rpcId: randomUUID(),
 				payload: {
@@ -2476,16 +2552,150 @@ function projectSessionModels(value) {
 }
 /** Project a history page (raw events) into MessageProjection rows. */
 //#endregion
+//#region src/dsh012-remote-interactions.ts
+/**
+* Resident DSH 0.1.2-alpha.3 Remote Events client for phone interactions.
+*
+* The Host-side `approval/request` and `user-questions/request` events are
+* owned once by DSH API Remotes. API Gateway then fans each pending waterfall
+* out to every connected Client and settles the first result. DeepPilot joins
+* that official Client plane in-process instead of registering a competing
+* Host waterfall listener or replacing the official Web composer.
+*/
+let clientFaces;
+/**
+* Load DSH's browser-distributed Client faces into a tiny Host-side module
+* table. Published `lib/client.js` files register with `window.__ModuleLoader__`
+* rather than exporting ESM values, so a normal Node import cannot consume
+* them. The shim runs only while the three official bundles register; their
+* apply functions then operate against a non-browser Cordis Context.
+*/
+function pluginModule(value, specifier) {
+	if (typeof value !== "object" || value === null) throw new Error(`${specifier} Client bundle returned no exports`);
+	if (typeof value.apply !== "function") throw new Error(`${specifier} has no Client apply() export`);
+	return value;
+}
+async function loadClientFaces() {
+	clientFaces ??= (async () => {
+		const modules = /* @__PURE__ */ new Map([["@deepseek-ai/cordis", Cordis]]);
+		const loaderGlobal = globalThis;
+		const previousWindow = loaderGlobal.window;
+		loaderGlobal.window = { __ModuleLoader__: { load: (definition) => {
+			const exports = definition.factory((id) => {
+				if (!modules.has(id)) throw new Error(`resident DSH Client cannot resolve ${JSON.stringify(id)}`);
+				return modules.get(id);
+			});
+			modules.set(definition.id, exports);
+		} } };
+		try {
+			for (const specifier of [
+				"@deepseek-ai/dsh-typert-registry/client",
+				"@deepseek-ai/dsh-client-connection/client",
+				"@deepseek-ai/dsh-api-gateway/client"
+			]) await import(specifier);
+		} finally {
+			if (previousWindow === void 0) delete loaderGlobal.window;
+			else loaderGlobal.window = previousWindow;
+		}
+		return {
+			typert: pluginModule(modules.get("@deepseek-ai/dsh-typert-registry"), "@deepseek-ai/dsh-typert-registry/client"),
+			connection: pluginModule(modules.get("@deepseek-ai/dsh-client-connection"), "@deepseek-ai/dsh-client-connection/client"),
+			gateway: pluginModule(modules.get("@deepseek-ai/dsh-api-gateway"), "@deepseek-ai/dsh-api-gateway/client")
+		};
+	})();
+	return clientFaces;
+}
+const agentScopeKey = Symbol("deeppilot.dsh-client.agent-scope");
+function scopeOf(ctx) {
+	return ctx[agentScopeKey];
+}
+function createAgentScope(ctx, identity) {
+	return ctx.plugin(function deeppilotAgentScope() {}).ctx.extend({
+		[agentScopeKey]: identity,
+		[Context.filter](listenerCtx) {
+			const listenerIdentity = scopeOf(listenerCtx);
+			return listenerIdentity === void 0 || listenerIdentity === identity;
+		}
+	});
+}
+function inProcessStream(gateway, endpoint, payload, signal) {
+	return (async function* () {
+		yield* await gateway.wireStream.open(endpoint, payload, signal);
+	})();
+}
+/**
+* Start one headless official DSH Client backed by the Host's in-process
+* Connection and Gateway carriers.
+*
+* The returned disposer tears down the Remote Events generation, all pending
+* listeners, and every lazily minted Agent scope.
+*/
+async function startDsh012RemoteInteractions(hostCtx, handlers) {
+	const connection = hostCtx.get("connection");
+	const gateway = hostCtx.get("typertGateway");
+	if (connection === void 0) throw new Error("dsh 0.1.2-alpha.3 Host connection is unavailable");
+	if (gateway === void 0) throw new Error("dsh 0.1.2-alpha.3 typertGateway is unavailable");
+	const faces = await loadClientFaces();
+	const client = new Context();
+	const fetchHandler = connection.createSharedFetchHandler("/api");
+	const transport = {
+		fetch: (input, init) => fetchHandler.fetch(new Request(input, init)),
+		openStream: (endpoint, payload, signal) => inProcessStream(gateway, endpoint, payload, signal),
+		ownsHost: true
+	};
+	try {
+		faces.typert.apply(client);
+		const transportGlobal = globalThis;
+		const previousTransport = transportGlobal.__DSH_TRANSPORT__;
+		transportGlobal.__DSH_TRANSPORT__ = transport;
+		try {
+			faces.connection.apply(client);
+		} finally {
+			if (previousTransport === void 0) delete transportGlobal.__DSH_TRANSPORT__;
+			else transportGlobal.__DSH_TRANSPORT__ = previousTransport;
+		}
+		const typert = client.get("typert");
+		if (typert === void 0) throw new Error("resident DSH Client typert service was not installed");
+		const scopes = /* @__PURE__ */ new Map();
+		typert.contexts.registerClient("agent", {
+			identity: (candidate) => scopeOf(candidate),
+			resolve: (identity) => {
+				let scope = scopes.get(identity);
+				if (scope === void 0) {
+					scope = createAgentScope(client, identity);
+					scopes.set(identity, scope);
+				}
+				return scope;
+			}
+		});
+		faces.gateway.apply(client);
+		const remote = client.get("remote");
+		if (remote === void 0) throw new Error("resident DSH Client remote service was not installed");
+		remote.$on("approval/request", function(request, next) {
+			return handlers.approval(scopeOf(this) ?? "", request, next);
+		});
+		remote.$on("user-questions/request", function(request, next) {
+			return handlers.question(scopeOf(this) ?? "", request, next);
+		});
+		return async () => {
+			await client.fiber.dispose();
+		};
+	} catch (error) {
+		await client.fiber.dispose();
+		throw error;
+	}
+}
+//#endregion
 //#region src/dsh012-api-proxy.ts
 /**
 * Compatibility façade for the DSH 0.1.2 controller API.
 *
 * DeepPilot's phone protocol deliberately speaks one stable in-process
 * `apiProxy` vocabulary. Harness 0.1.2 removed that service in favor of
-* direct Session/Workspace controllers plus scoped Cordis interaction events.
+* direct Session/Workspace controllers plus Gateway-backed Remote Events.
 * This adapter rebuilds the small subset the bridge needs from those public
-* controllers, keeping the protocol implementation isolated from the Host API
-* migration. It is intentionally Host-only.
+* controllers and joins the official Client interaction plane in-process,
+* keeping the phone protocol isolated from the Host API migration.
 */
 /** Direct-controller facade with the exact legacy shape HostBridge consumes. */
 var Dsh012ApiProxy = class {
@@ -2494,13 +2704,27 @@ var Dsh012ApiProxy = class {
 	workspaceController;
 	directoryPicker;
 	interactions = /* @__PURE__ */ new Map();
-	constructor(ctx) {
+	shouldSurfaceInteraction;
+	constructor(ctx, options = {}) {
 		this.ctx = ctx;
 		const session = ctx.get("sessionController");
 		if (session === void 0) throw new Error("dsh 0.1.2 sessionController is unavailable");
 		this.session = session;
 		this.workspaceController = ctx.get("workspaceController");
 		this.directoryPicker = ctx.get("directoryPickerController");
+		this.shouldSurfaceInteraction = options.shouldSurfaceInteraction ?? (() => true);
+	}
+	/**
+	* Decide whether this Gateway Client can surface a phone card. The decision
+	* fails open to false so a broken device registry delegates this delivery
+	* while the official Web Client remains able to answer.
+	*/
+	canSurfaceInteraction(kind) {
+		try {
+			return this.shouldSurfaceInteraction(kind);
+		} catch {
+			return false;
+		}
 	}
 	sessions = {
 		list: async () => this.call(async () => {
@@ -2613,71 +2837,79 @@ var Dsh012ApiProxy = class {
 				value
 			});
 		});
-		const offApproval = this.ctx.on("approval/request", ((request) => {
-			const rpcId = randomUUID();
-			const sessionId = String(request.agent?.session?.id ?? request.agent?.id ?? "");
-			const response = deferred();
-			const abort = () => response.resolve("cancelled");
-			request.signal?.addEventListener("abort", abort, { once: true });
-			this.interactions.set(rpcId, {
-				resolve: response.resolve,
-				map: (value) => {
-					const outcome = value?.outcome;
-					return outcome === "allowed-once" || outcome === "rejected" ? outcome : "unavailable";
-				}
-			});
-			queue.push({
-				type: "approval/requested",
-				rpcId,
-				sessionId,
-				approvalId: rpcId,
-				toolName: String(request.toolName ?? "tool"),
-				reason: String(request.reason ?? "")
-			});
-			return response.promise.finally(() => {
-				request.signal?.removeEventListener("abort", abort);
-				this.interactions.delete(rpcId);
-				queue.push({
-					type: "approval/resolved",
-					approvalId: rpcId
-				});
-			});
-		}), { global: true });
-		const offQuestion = this.ctx.on("user-questions/request", ((request) => {
-			const rpcId = randomUUID();
-			const sessionId = String(request.agent?.session?.id ?? request.agent?.id ?? "");
-			const response = deferred();
-			const abort = () => response.reject(/* @__PURE__ */ new Error("question cancelled"));
-			request.signal?.addEventListener("abort", abort, { once: true });
-			this.interactions.set(rpcId, {
-				resolve: response.resolve,
-				map: (value) => value?.answer ?? value
-			});
-			queue.push({
-				type: "question/requested",
-				rpcId,
-				sessionId,
-				questions: request.questions ?? []
-			});
-			return response.promise.finally(() => {
-				request.signal?.removeEventListener("abort", abort);
-				this.interactions.delete(rpcId);
-				queue.push({
-					type: "question/resolved",
-					questionRpcId: rpcId
-				});
+		let disposeInteractions;
+		try {
+			disposeInteractions = await startDsh012RemoteInteractions(this.ctx, {
+				approval: (sessionId, request, next) => this.answerApproval(queue, sessionId, request, next),
+				question: (sessionId, request, next) => this.answerQuestion(queue, sessionId, request, next)
 			});
-		}), { global: true });
+		} catch (error) {
+			console.warn(`[deeppilot] DSH Remote interaction client unavailable: ${toError(error).message}`);
+		}
 		try {
 			yield* queue.iterate();
 		} finally {
 			offEvent();
 			offProjection?.();
-			offApproval();
-			offQuestion();
+			await disposeInteractions?.();
 			queue.close();
 		}
 	}
+	answerApproval(queue, sessionId, request, next) {
+		if (!this.canSurfaceInteraction("approval")) return next();
+		const rpcId = randomUUID();
+		const response = deferred();
+		const abort = () => response.resolve("cancelled");
+		request.signal?.addEventListener("abort", abort, { once: true });
+		this.interactions.set(rpcId, {
+			resolve: response.resolve,
+			map: (value) => {
+				const outcome = value?.outcome;
+				return outcome === "allowed-once" || outcome === "rejected" ? outcome : "unavailable";
+			}
+		});
+		queue.push({
+			type: "approval/requested",
+			rpcId,
+			sessionId,
+			approvalId: rpcId,
+			toolName: String(request.toolName ?? "tool"),
+			reason: String(request.reason ?? "")
+		});
+		return response.promise.finally(() => {
+			request.signal?.removeEventListener("abort", abort);
+			this.interactions.delete(rpcId);
+			queue.push({
+				type: "approval/resolved",
+				approvalId: rpcId
+			});
+		});
+	}
+	answerQuestion(queue, sessionId, request, next) {
+		if (!this.canSurfaceInteraction("question")) return next();
+		const rpcId = randomUUID();
+		const response = deferred();
+		const abort = () => response.reject(/* @__PURE__ */ new Error("question cancelled"));
+		request.signal?.addEventListener("abort", abort, { once: true });
+		this.interactions.set(rpcId, {
+			resolve: response.resolve,
+			map: (value) => value?.answer ?? value
+		});
+		queue.push({
+			type: "question/requested",
+			rpcId,
+			sessionId,
+			questions: request.questions ?? []
+		});
+		return response.promise.finally(() => {
+			request.signal?.removeEventListener("abort", abort);
+			this.interactions.delete(rpcId);
+			queue.push({
+				type: "question/resolved",
+				questionRpcId: rpcId
+			});
+		});
+	}
 	async *hostEvents(signal) {
 		const queue = new AsyncFrameQueue(signal);
 		const listen = (event, type, project) => this.ctx.on(event, ((...args) => queue.push({
@@ -2967,6 +3199,28 @@ function parseRemote(value) {
 		updatedAt: int(s, "updatedAt", "remote.updatedAt")
 	};
 }
+function parseLocal(value) {
+	const s = rec(value, "local");
+	const phase = str(s, "phase", "local.phase");
+	if (![
+		"disabled",
+		"starting",
+		"online",
+		"error",
+		"stopped"
+	].includes(phase)) reject("local.phase");
+	const endpoints = s.endpoints;
+	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");
+	return {
+		phase,
+		port: int(s, "port", "local.port"),
+		endpoints,
+		...typeof message === "string" ? { message } : {},
+		updatedAt: int(s, "updatedAt", "local.updatedAt")
+	};
+}
 function parseRelayTestStep(value) {
 	const st = rec(value, "step");
 	const id = str(st, "id", "step.id");
@@ -3048,6 +3302,7 @@ function parseReport(value) {
 		historyBufferMax: int(s, "historyBufferMax", "historyBufferMax"),
 		debug: bool(s, "debug", "debug"),
 		lanAddresses,
+		local: parseLocal(s.local),
 		remote: parseRemote(s.remote),
 		devices: devices.map(parseDevice)
 	};
@@ -3207,7 +3462,32 @@ function applyReportRemote(ctx, snapshot, pairingStarter, deviceRevoker, deviceS
 	});
 }
 //#endregion
+//#region src/relay-url.ts
+/**
+* Normalize an operator-configured relay URL without a backtracking regular
+* expression. Scanning from the end keeps even pathological inputs linear.
+*/
+function normalizeRelayBaseUrl(value) {
+	const trimmed = value.trim();
+	let end = trimmed.length;
+	while (end > 0 && trimmed.charCodeAt(end - 1) === 47) end -= 1;
+	return end === trimmed.length ? trimmed : trimmed.slice(0, end);
+}
+//#endregion
 //#region src/relay-test.ts
+/**
+* Relay connectivity self-test used by the settings page "测试中继" button.
+*
+* Two steps mirror what zero-touch enrollment actually does:
+*   1. health  — GET {url}/healthz        → is the relay reachable?
+*   2. enroll  — POST {url}/v1/enroll     → does the shared key grant a token?
+*
+* The enroll step doubles as a repair path: a token it issues is handed back
+* via `onEnrolled` so the bridge caches it and flips push readiness without
+* waiting for the next app registration.
+*
+* Transport is injectable (`fetchImpl`) so tests never touch the network.
+*/
 const DEFAULT_TIMEOUT_MS = 6e3;
 async function requestJson(fetchImpl, url, init, timeoutMs) {
 	const response = await fetchImpl(url, {
@@ -3224,7 +3504,7 @@ async function requestJson(fetchImpl, url, init, timeoutMs) {
 	};
 }
 async function runRelayProbe(options) {
-	const base = options.url.trim().replace(/\/+$/, "");
+	const base = normalizeRelayBaseUrl(options.url);
 	const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 	const fetchImpl = options.fetchImpl ?? fetch;
 	const steps = [];
@@ -3534,7 +3814,7 @@ var RelayClient = class {
 	debug;
 	log;
 	constructor(opts) {
-		this.base = opts.url.trim().replace(/\/+$/, "");
+		this.base = normalizeRelayBaseUrl(opts.url);
 		this.token = (opts.token ?? "").trim();
 		this.timeoutMs = opts.timeoutMs ?? 1e4;
 		this.debug = opts.debug === true;
@@ -3665,6 +3945,137 @@ function tunnelHelperArguments(originURL, statePath, options) {
 		String(normalizeFunnelConnectionLimit(options.maxConnectionsPerSource))
 	];
 }
+/**
+* Summarize a fatal helper crash from its stderr tail. Go panics dump the
+* actual reason on the `panic:` line while the trailing stack frames are
+* `file.go:NN +0xOFF` noise — the old behavior of reporting only the final
+* line surfaced exactly that noise (e.g. `.../singleflight.go:194 +0x45c`)
+* and hid the real panic message. Keep the crash header line (a raw
+* `panic:`, a runtime `fatal error:`, or net/http's `http: panic serving`),
+* plus an optional `[signal ...]` continuation and the first non-runtime
+* stack frame's symbol + `file.go:NN` as a location hint. Pointer offsets
+* are not architecture stable, so they are deliberately dropped.
+*
+* The frame symbol sits on the line just above the indented source line in a
+* Go dump, e.g.:
+*   tailscale.com/net/dnscache.(*Resolver).lookupIP(0x1400012c000, {...})
+*       tailscale.com@v1.102.3/net/dnscache/dnscache.go:604 +0x25c
+* The first symbol (shortened) is used because a bare `file.go:NN` is not
+* unique across tailscale (singleflight.go is one example).
+*/
+function helperCrashSummary(stderr) {
+	const lines = stderr.split(/\r?\n/);
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (line === "") continue;
+		const logTimestamp = /^(\d{4}\/\d{2}\/\d{2} \d{2}:\d{2}:\d{2} )/.exec(line)?.[1] ?? "";
+		if (!/^(panic:|fatal error:|http: panic serving)/.test(logTimestamp.length > 0 ? line.slice(logTimestamp.length) : line)) continue;
+		let summary = logTimestamp.length > 0 ? line.slice(logTimestamp.length) : line;
+		const next = lines[i + 1]?.trim();
+		if (next?.startsWith("[signal")) summary += " " + next;
+		let lastSymbol;
+		for (let j = i + 1; j < lines.length; j++) {
+			const frame = lines[j];
+			const trimmed = frame.trim();
+			if (trimmed === "") continue;
+			const sourceMatch = /^\s+(\S+\.go:\d+)/.exec(frame);
+			if (sourceMatch !== null) {
+				const source = sourceMatch[1];
+				if (source.startsWith("runtime/") || source.startsWith("runtime\\")) {
+					lastSymbol = void 0;
+					continue;
+				}
+				const slash = Math.max(source.lastIndexOf("/"), source.lastIndexOf("\\"));
+				const file = slash >= 0 ? source.slice(slash + 1) : source;
+				const symbol = lastSymbol !== void 0 ? shortenSymbol(lastSymbol) : void 0;
+				summary += " @ " + (symbol !== void 0 ? `${symbol} (${file})` : file);
+				break;
+			}
+			if (trimmed.includes("(") || trimmed.endsWith(")")) lastSymbol = trimmed;
+		}
+		return summary.replace(/\s+/g, " ").trim();
+	}
+	for (let i = lines.length - 1; i >= 0; i--) {
+		const line = lines[i].trim();
+		if (line !== "") return line;
+	}
+	return "";
+}
+/** Shrink a Go frame symbol to `pkg.Receiver.method` form (drop module-root
+*  path, generic type arguments and the trailing call arguments), so the
+*  summary hint stays readable. Keeps a `.funcN` closure suffix when present
+*  (e.g. `doCall.func2`), since it identifies the exact closure.
+*
+*  A symbol looks like:
+*    tailscale.com/util/singleflight.(*Group[...]).doCall.func2(0x…, …)
+*  The trailing call arguments form a balanced paren group that starts at
+*  the function name — that group is stripped first; generics appear only
+*  inside `(*Group[...])` receiver brackets before the final method dot, so
+*  they are removed by trimming from the first `[` to the matching `]`.
+*/
+function shortenSymbol(symbol) {
+	const trimmed = symbol.trim();
+	let end = trimmed.length;
+	if (trimmed.endsWith(")")) {
+		let depth = 0;
+		for (let i = trimmed.length - 1; i >= 0; i--) {
+			const ch = trimmed[i];
+			if (ch === ")") depth++;
+			else if (ch === "(") {
+				depth--;
+				if (depth === 0) {
+					end = i;
+					break;
+				}
+			}
+		}
+	}
+	let name = trimmed.slice(0, end).trim();
+	const bracketOpen = name.indexOf("[");
+	if (bracketOpen >= 0) {
+		const bracketClose = name.indexOf("]", bracketOpen);
+		if (bracketClose > bracketOpen) name = name.slice(0, bracketOpen) + name.slice(bracketClose + 1);
+	}
+	const slash = Math.max(name.lastIndexOf("/"), name.lastIndexOf("\\"));
+	return slash >= 0 ? name.slice(slash + 1) : name;
+}
+/** Shared by crash summary and dump: whether the stderr looks like a Go
+*  panic/fatal-error crash (vs. an ordinary exit). */
+function looksLikeCrash(stderr) {
+	return /(?:^|\n)\s*(?:\d{4}\/\d{2}\/\d{2} \d{2}:\d{2}:\d{2} )?(?:panic:|fatal error:|http: panic serving)/.test(stderr);
+}
+/** Turn a crash stderr tail into a status message and optionally persist the
+*  full dump under the state dir. Keeps at most MAX_CRASH_DUMPS dump files. */
+async function analyzeCrashExit(stderr, statePath) {
+	const summary = helperCrashSummary(stderr) || "helper exited";
+	if (!looksLikeCrash(stderr) || stderr.trim() === "") return { summary };
+	const target = statePath.trim();
+	if (target === "") return { summary };
+	try {
+		const file = join(target, `crash-${Date.now()}.log`);
+		await writeFile(file, stderr, { mode: 384 });
+		await trimCrashDumps(target);
+		return {
+			summary,
+			dumpPath: file
+		};
+	} catch {
+		return { summary };
+	}
+}
+/** Remove oldest crash-*.log files beyond MAX_CRASH_DUMPS. */
+async function trimCrashDumps(dir) {
+	let names;
+	try {
+		names = (await readdir(dir)).filter((name) => name.startsWith("crash-") && name.endsWith(".log"));
+	} catch {
+		return;
+	}
+	if (names.length <= 6) return;
+	names.sort();
+	const excess = names.length - 6;
+	await Promise.all(names.slice(0, excess).map((name) => rm(join(dir, name), { force: true }).catch(() => {})));
+}
 /** Parse one helper IPC line without ever evaluating or interpolating it. */
 function parseHelperEvent(line) {
 	try {
@@ -3819,7 +4230,7 @@ var RemoteSupervisor = class {
 		let stderrBuffer = "";
 		child.stderr.setEncoding("utf8");
 		child.stderr.on("data", (chunk) => {
-			stderrBuffer = (stderrBuffer + chunk).slice(-2e3);
+			stderrBuffer = (stderrBuffer + chunk).slice(-16e3);
 		});
 		child.once("error", (error) => {
 			this.setStatus({
@@ -3827,7 +4238,7 @@ var RemoteSupervisor = class {
 				message: `helper launch failed: ${String(error)}`
 			});
 		});
-		child.once("exit", (code, signal) => {
+		child.once("exit", () => {
 			if (this.child === child) this.child = void 0;
 			if (this.stopping) {
 				this.setStatus({
@@ -3836,12 +4247,15 @@ var RemoteSupervisor = class {
 				});
 				return;
 			}
-			const detail = stderrBuffer.trim().split("\n").at(-1);
-			this.setStatus({
-				phase: "error",
-				message: detail || `helper exited (${signal ?? String(code)})`
+			analyzeCrashExit(stderrBuffer, this.options.statePath).then((analysis) => {
+				if (this.stopping) return;
+				const message = analysis.summary + (analysis.dumpPath !== void 0 ? ` (full dump: ${analysis.dumpPath})` : "");
+				this.setStatus({
+					phase: "error",
+					message
+				});
+				this.scheduleRestart(originURL, "crash");
 			});
-			this.scheduleRestart(originURL, "crash");
 		});
 	}
 	async dispose() {
@@ -4134,6 +4548,24 @@ var UpdateChecker = class {
 	dispose() {}
 };
 //#endregion
+//#region src/local-policy.ts
+const DEFAULT_LOCAL_PORT = 3098;
+const MIN_LOCAL_PORT = 1024;
+const MAX_LOCAL_PORT = 65535;
+function normalizeLocalPort(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 1024 && value <= 65535 ? value : DEFAULT_LOCAL_PORT;
+}
+function localEndpointURLs(addresses, port) {
+	const normalizedPort = normalizeLocalPort(port);
+	return [...new Set(addresses)].map((address) => `http://${address}:${normalizedPort}`);
+}
+function localListenError(error, port) {
+	const code = error?.code;
+	if (code === "EADDRINUSE") return `local port ${port} is already in use`;
+	if (code === "EACCES") return `permission denied while opening local port ${port}`;
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
 //#region src/config.ts
 /** Operator-run relay used by distributed builds; overridable via config. */
 const DEFAULT_RELAY_URL = "https://pilot.hailab.dev";
@@ -4142,6 +4574,13 @@ const Config = z.object({
 	devicesPath: z.string().default(join(bridgeDataDir(), "devices-v2.json")),
 	historyBufferMax: z.natural().min(100).default(2e3),
 	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，修改后本地连接会短暂重连）")
+	}).default({
+		enabled: true,
+		port: DEFAULT_LOCAL_PORT
+	}),
 	remote: z.object({
 		enabled: z.boolean().default(false),
 		provider: z.union(["tailscale-funnel"]).default("tailscale-funnel"),
@@ -4364,12 +4803,64 @@ function shouldReEnrollRelayToken(transport, outcome, reason, opts) {
 	return transport === "relay" && outcome === "failed" && reason === "HTTP 401" && opts.hasEnrollKey && opts.usedCellToken && opts.tokenStillCurrent;
 }
 //#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.
+*/
+function createPhoneServer(handlers) {
+	const server = createServer((req, res) => {
+		const path = requestPath(req);
+		if (path === "/phone/health") handlers.health(req, res);
+		else if (path === "/phone/pair") handlers.pair(req, res);
+		else {
+			res.statusCode = 404;
+			res.end("not found");
+		}
+	});
+	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");
+			return;
+		}
+		handlers.upgrade(req, socket, head);
+	});
+	return server;
+}
+function requestPath(req) {
+	try {
+		return new URL(req.url ?? "/", "http://phone.local").pathname;
+	} catch {
+		return "/";
+	}
+}
+function listen(server, port, host) {
+	return new Promise((resolve, reject) => {
+		const onError = (error) => {
+			server.off("listening", onListening);
+			reject(error);
+		};
+		const onListening = () => {
+			server.off("error", onError);
+			resolve();
+		};
+		server.once("error", onError);
+		server.once("listening", onListening);
+		server.listen(port, host);
+	});
+}
+function closeServer(server) {
+	if (server === void 0 || !server.listening) return Promise.resolve();
+	return new Promise((resolve) => server.close(() => resolve()));
+}
+//#endregion
 //#region src/index.ts
 /**
 * dsh-deeppilot — data bridge between the DSH host and DeepPilot
-* clients. Registers exactly one WebSocket upgrade route (/phone) plus an
-* optional health probe (/phone/health) on the existing web server. The web
-* UI is never touched.
+* 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.
 *
 * Data plane: an in-process HostBridge consumes a local compatibility façade
 * over DSH 0.1.2 Session/Workspace controllers, mirrors session summaries,
@@ -4380,7 +4871,7 @@ function shouldReEnrollRelayToken(transport, outcome, reason, opts) {
 * Swift models mirror that v2 contract.
 */
 const name = "deeppilot";
-/** No eager service requirement: profiles without a web stack simply skip. */
+/** No eager web-service requirement: independent transports start on their own. */
 const inject = [];
 const SERVER_VERSION = readOwnPackageVersion();
 const MAX_CLIENT_CONNECTIONS = 16;
@@ -4420,6 +4911,7 @@ function apply(ctx, options) {
 	*/
 	let liveSource;
 	let scheduleRemoteReconcile;
+	let scheduleLocalReconcile;
 	const currentConfig = () => {
 		if (liveSource !== void 0) return normalizeOptions(liveSource());
 		return normalizeOptions(options);
@@ -4428,9 +4920,15 @@ function apply(ctx, options) {
 	const settingsHooks = {
 		setSource: (source) => {
 			liveSource = source;
-			queueMicrotask(() => scheduleRemoteReconcile?.());
+			queueMicrotask(() => {
+				scheduleLocalReconcile?.();
+				scheduleRemoteReconcile?.();
+			});
 		},
-		onChange: () => queueMicrotask(() => scheduleRemoteReconcile?.())
+		onChange: () => queueMicrotask(() => {
+			scheduleLocalReconcile?.();
+			scheduleRemoteReconcile?.();
+		})
 	};
 	ctx.inject(["settings"], (settingsCtx) => {
 		settingsCtx.settings.installSection(ctx, "deeppilot", Config, normalizeOptions(void 0), settingsHooks);
@@ -4836,6 +5334,16 @@ function apply(ctx, options) {
 		maxPayload: MAX_FRAME_BYTES
 	});
 	let remoteSupervisor;
+	let localState = {
+		phase: currentConfig().enabled === true && currentConfig().local?.enabled !== false ? "starting" : "disabled",
+		port: normalizeLocalPort(currentConfig().local?.port),
+		endpoints: [],
+		updatedAt: Date.now()
+	};
+	const localStatus = (addresses) => ({
+		...localState,
+		endpoints: localState.phase === "online" ? localEndpointURLs(addresses, localState.port) : []
+	});
 	const remoteStatus = () => remoteSupervisor?.status() ?? {
 		provider: "tailscale-funnel",
 		phase: currentConfig().remote?.enabled === true ? "stopped" : "disabled",
@@ -4869,6 +5377,7 @@ function apply(ctx, options) {
 			}));
 		} catch {}
 		const update = updateInfo();
+		const lanAddresses = localLANIPv4Addresses();
 		return {
 			protocolVersion: 2,
 			serverVersion: SERVER_VERSION,
@@ -4881,7 +5390,8 @@ function apply(ctx, options) {
 			activeConnections: connections.size,
 			historyBufferMax: currentConfig().historyBufferMax ?? 2e3,
 			debug: currentConfig().debug === true,
-			lanAddresses: localLANIPv4Addresses(),
+			lanAddresses,
+			local: localStatus(lanAddresses),
 			remote: remoteStatus(),
 			devices
 		};
@@ -5151,7 +5661,173 @@ function apply(ctx, options) {
 			res.end(JSON.stringify({ ok: false }));
 		}
 	};
-	ctx.inject(["sessionController"], (sub) => {
+	const phoneHandlers = {
+		health: handleHealth,
+		pair: handlePair,
+		upgrade: handleUpgrade
+	};
+	let localServer;
+	let appliedLocalKey;
+	let localDisposed = false;
+	let localTail = Promise.resolve();
+	const reconcileLocal = async () => {
+		if (localDisposed) return;
+		const config = currentConfig();
+		const localConfig = config.local ?? {};
+		const next = {
+			enabled: config.enabled === true && localConfig.enabled !== false,
+			port: normalizeLocalPort(localConfig.port)
+		};
+		const nextKey = JSON.stringify(next);
+		if (nextKey === appliedLocalKey) return;
+		appliedLocalKey = nextKey;
+		const previous = localServer;
+		localServer = void 0;
+		await closeServer(previous);
+		if (localDisposed) return;
+		if (!next.enabled) {
+			localState = {
+				phase: "disabled",
+				port: next.port,
+				endpoints: [],
+				updatedAt: Date.now()
+			};
+			log("local transport disabled");
+			return;
+		}
+		localState = {
+			phase: "starting",
+			port: next.port,
+			endpoints: [],
+			updatedAt: Date.now()
+		};
+		const server = createPhoneServer(phoneHandlers);
+		localServer = server;
+		try {
+			await listen(server, next.port, "0.0.0.0");
+			if (localDisposed || localServer !== server) {
+				await closeServer(server);
+				return;
+			}
+			localState = {
+				phase: "online",
+				port: next.port,
+				endpoints: [],
+				updatedAt: Date.now()
+			};
+			log(`local transport listening on 0.0.0.0:${next.port}`);
+		} catch (error) {
+			if (localServer === server) localServer = void 0;
+			await closeServer(server);
+			const message = localListenError(error, next.port);
+			localState = {
+				phase: "error",
+				port: next.port,
+				endpoints: [],
+				message,
+				updatedAt: Date.now()
+			};
+			log("local transport failed: " + message);
+		}
+	};
+	scheduleLocalReconcile = () => {
+		localTail = localTail.then(reconcileLocal).catch((error) => log("local reconcile failed: " + String(error)));
+	};
+	const originServer = createPhoneServer(phoneHandlers);
+	let originURL;
+	let appliedRemoteKey;
+	let remoteDisposed = false;
+	let remoteTail = Promise.resolve();
+	const reconcileRemote = async () => {
+		if (remoteDisposed || originURL === void 0) return;
+		const config = currentConfig();
+		const remoteConfig = config.remote ?? {};
+		const remotePort = remoteConfig.funnelPort === 8443 || remoteConfig.funnelPort === 1e4 ? remoteConfig.funnelPort : 443;
+		const helperPath = remoteConfig.helperPath?.trim() || void 0;
+		const next = {
+			enabled: config.enabled === true && remoteConfig.enabled === true && remoteConfig.provider === "tailscale-funnel",
+			hostname: normalizeRemoteHostname(remoteConfig.hostname),
+			statePath: remoteConfig.statePath?.trim() || join(dataDir, "tailscale"),
+			helperPath,
+			funnelPort: remotePort,
+			maxConnectionsPerSource: normalizeFunnelConnectionLimit(remoteConfig.maxConnectionsPerSource)
+		};
+		const nextKey = JSON.stringify(next);
+		if (nextKey === appliedRemoteKey) return;
+		const previous = remoteSupervisor;
+		remoteSupervisor = void 0;
+		if (previous !== void 0) await previous.dispose();
+		if (remoteDisposed) return;
+		const supervisor = new RemoteSupervisor({
+			enabled: next.enabled,
+			hostname: next.hostname,
+			statePath: next.statePath,
+			...next.helperPath ? { helperPath: next.helperPath } : {},
+			funnelPort: next.funnelPort,
+			maxConnectionsPerSource: next.maxConnectionsPerSource,
+			log
+		});
+		remoteSupervisor = supervisor;
+		appliedRemoteKey = nextKey;
+		await supervisor.start(originURL);
+	};
+	scheduleRemoteReconcile = () => {
+		remoteTail = remoteTail.then(reconcileRemote).catch((error) => log("remote reconcile failed: " + String(error)));
+	};
+	ctx.effect(() => {
+		scheduleLocalReconcile?.();
+		listen(originServer, 0, "127.0.0.1").then(() => {
+			const address = originServer.address();
+			if (address && typeof address === "object") {
+				originURL = `http://127.0.0.1:${address.port}`;
+				scheduleRemoteReconcile?.();
+			}
+		}, (error) => log("remote origin failed: " + String(error)));
+		return async () => {
+			localDisposed = true;
+			remoteDisposed = true;
+			scheduleLocalReconcile = void 0;
+			scheduleRemoteReconcile = void 0;
+			const activeLocal = localServer;
+			localServer = void 0;
+			await Promise.allSettled([closeServer(activeLocal), closeServer(originServer)]);
+			localState = {
+				phase: "stopped",
+				port: localState.port,
+				endpoints: [],
+				updatedAt: Date.now()
+			};
+			await Promise.allSettled([localTail, remoteTail.then(async () => {
+				const supervisor = remoteSupervisor;
+				remoteSupervisor = void 0;
+				if (supervisor !== void 0) await supervisor.dispose();
+			})]);
+		};
+	}, "deeppilot: independent transports");
+	const sweep = setInterval(() => {
+		const now = Date.now();
+		for (const connection of connections) if (connection.isStale(now, 6e4)) {
+			log("dropping stale connection");
+			connection.closeIdle();
+			connections.delete(connection);
+		}
+	}, 3e4);
+	ctx.effect(() => () => clearInterval(sweep), "deeppilot: stale sweep");
+	/**
+	* Whether the resident Gateway Client represents a real phone surface. A
+	* paired device remains answerable even while offline: HostBridge retains an
+	* authoritative pending snapshot that the app pulls on reconnect, while
+	* APNs is only a best-effort wakeup. With no paired device this Client calls
+	* `next()`; Gateway's independent official Web delivery is unaffected.
+	*/
+	const hasPairedPhoneSurface = (_kind) => {
+		return (auth.devices?.list() ?? []).some((device) => device.revokedAt === void 0);
+	};
+	ctx.inject([
+		"sessionController",
+		"connection",
+		"typertGateway"
+	], (sub) => {
 		if (currentConfig().enabled !== true) {
 			log("bridge disabled; data plane stays inactive");
 			return;
@@ -5159,7 +5835,7 @@ function apply(ctx, options) {
 		const apiCtx = sub;
 		let proxy;
 		try {
-			proxy = new Dsh012ApiProxy(apiCtx);
+			proxy = new Dsh012ApiProxy(apiCtx, { shouldSurfaceInteraction: hasPairedPhoneSurface });
 		} catch (error) {
 			log("dsh 0.1.2 session bridge unavailable: " + String(error));
 			return;
@@ -5179,7 +5855,7 @@ function apply(ctx, options) {
 		const webCtx = sub;
 		const web = webCtx.webServer;
 		if (!web) {
-			log("webServer service absent in this profile; bridge stays inactive");
+			log("webServer service absent; 3080 compatibility routes unavailable (independent transports remain active)");
 			return;
 		}
 		webCtx.effect(() => web.registerUpgrade({
@@ -5196,98 +5872,8 @@ function apply(ctx, options) {
 			path: "/phone/pair",
 			handler: handlePair
 		}), "deeppilot: /phone/pair");
-		const sweep = setInterval(() => {
-			const now = Date.now();
-			for (const connection of connections) if (connection.isStale(now, 6e4)) {
-				log("dropping stale connection");
-				connection.closeIdle();
-				connections.delete(connection);
-			}
-		}, 3e4);
-		webCtx.effect(() => () => clearInterval(sweep), "deeppilot: stale sweep");
-		const originServer = createServer((req, res) => {
-			let path = "/";
-			try {
-				path = new URL(req.url ?? "/", "http://phone.local").pathname;
-			} catch {}
-			if (path === "/phone/health") handleHealth(req, res);
-			else if (path === "/phone/pair") handlePair(req, res);
-			else {
-				res.statusCode = 404;
-				res.end("not found");
-			}
-		});
-		originServer.on("upgrade", (req, socket, head) => {
-			let path = "/";
-			try {
-				path = new URL(req.url ?? "/", "http://phone.local").pathname;
-			} catch {}
-			if (path !== "/phone") {
-				socket.end("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
-				return;
-			}
-			handleUpgrade(req, socket, head);
-		});
-		let originURL;
-		let appliedRemoteKey;
-		let remoteDisposed = false;
-		let reconcileTail = Promise.resolve();
-		const reconcileRemote = async () => {
-			if (remoteDisposed || originURL === void 0) return;
-			const config = currentConfig();
-			const remoteConfig = config.remote ?? {};
-			const remotePort = remoteConfig.funnelPort === 8443 || remoteConfig.funnelPort === 1e4 ? remoteConfig.funnelPort : 443;
-			const helperPath = remoteConfig.helperPath?.trim() || void 0;
-			const next = {
-				enabled: config.enabled === true && remoteConfig.enabled === true && remoteConfig.provider === "tailscale-funnel",
-				hostname: normalizeRemoteHostname(remoteConfig.hostname),
-				statePath: remoteConfig.statePath?.trim() || join(dataDir, "tailscale"),
-				helperPath,
-				funnelPort: remotePort,
-				maxConnectionsPerSource: normalizeFunnelConnectionLimit(remoteConfig.maxConnectionsPerSource)
-			};
-			const nextKey = JSON.stringify(next);
-			if (nextKey === appliedRemoteKey) return;
-			const previous = remoteSupervisor;
-			remoteSupervisor = void 0;
-			if (previous !== void 0) await previous.dispose();
-			if (remoteDisposed) return;
-			const supervisor = new RemoteSupervisor({
-				enabled: next.enabled,
-				hostname: next.hostname,
-				statePath: next.statePath,
-				...next.helperPath ? { helperPath: next.helperPath } : {},
-				funnelPort: next.funnelPort,
-				maxConnectionsPerSource: next.maxConnectionsPerSource,
-				log
-			});
-			remoteSupervisor = supervisor;
-			appliedRemoteKey = nextKey;
-			await supervisor.start(originURL);
-		};
-		scheduleRemoteReconcile = () => {
-			reconcileTail = reconcileTail.then(reconcileRemote).catch((error) => log("remote reconcile failed: " + String(error)));
-		};
-		originServer.listen(0, "127.0.0.1", () => {
-			const address = originServer.address();
-			if (address && typeof address === "object") {
-				originURL = `http://127.0.0.1:${address.port}`;
-				scheduleRemoteReconcile?.();
-			}
-		});
-		originServer.on("error", (error) => log("remote origin failed: " + String(error)));
-		webCtx.effect(() => () => {
-			remoteDisposed = true;
-			scheduleRemoteReconcile = void 0;
-			originServer.close();
-			reconcileTail = reconcileTail.then(async () => {
-				const supervisor = remoteSupervisor;
-				remoteSupervisor = void 0;
-				if (supervisor !== void 0) await supervisor.dispose();
-			});
-		}, "deeppilot: embedded Funnel");
-		if (enabledNow()) log("/phone WebSocket registered");
-		else log("bridge disabled; /phone refuses connections until re-enabled and restarted");
+		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();