@lobehub/cli 0.0.56 → 0.0.58

package/dist/index.js

@@ -13,7 +13,7 @@ import { finished, pipeline } from "node:stream/promises";
 import { Duplex, PassThrough, Readable, Transform, Writable, getDefaultHighWaterMark, pipeline as pipeline$1 } from "node:stream";
 import readline, { createInterface } from "node:readline";
 import { EventEmitter, addAbortListener, on, once, setMaxListeners } from "node:events";
-import fs$1, { access, copyFile, mkdir, open, readFile, readdir, realpath, rename, rm, stat, unlink as unlink$1, writeFile } from "node:fs/promises";
+import fs$1, { access, copyFile, mkdir, open, readFile, readdir, readlink, realpath, rename, rm, stat, unlink as unlink$1, writeFile } from "node:fs/promises";
 import crypto$1, { X509Certificate, createHash, randomBytes, randomUUID, sign } from "node:crypto";
 import { text } from "node:stream/consumers";
 import { ReadableStream as ReadableStream$1 } from "node:stream/web";
@@ -24,8 +24,8 @@ import zlib, { zstdDecompress } from "node:zlib";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { aborted, callbackify, debuglog, inspect, promisify, stripVTControlCharacters } from "node:util";
 import { URL as URL$1, fileURLToPath, pathToFileURL } from "node:url";
-import * as net from "node:net";
-import { BlockList, connect, createServer as createServer$2, isIP } from "node:net";
+import * as net$1 from "node:net";
+import net, { BlockList, connect, createServer as createServer$2, isIP } from "node:net";
 import { spawn as spawn$1 } from "child_process";
 import * as fs$3 from "fs";
 import { createRequire as createRequire$1 } from "module";
@@ -20140,28 +20140,68 @@ function clearCredentials() {
 //#endregion
 //#region src/auth/refresh.ts
 const CLIENT_ID$1 = "lobehub-cli";
+/** HTTP statuses that say "ask again later" rather than "this token is dead". */
+const TRANSIENT_STATUSES = new Set([
+	408,
+	425,
+	429
+]);
+/**
+* The one OAuth error that proves the stored refresh token itself is finished (RFC 6749 §5.2).
+* Its neighbours — `invalid_client`, `invalid_request`, `unauthorized_client` — describe how the
+* request was built, not whether the credential still lives, so re-authenticating over them just
+* walks the user into the same wall.
+*/
+const CREDENTIAL_SPENT_ERROR = "invalid_grant";
 /**
 * Get a valid access token, refreshing if expired.
-* Returns null if no credentials or refresh fails.
 */
 async function getValidToken(bufferSeconds = 60) {
 	const credentials = loadCredentials();
-	if (!credentials) return null;
-	if (credentials.expiresAt && Date.now() / 1e3 < credentials.expiresAt - bufferSeconds) return { credentials };
-	if (!credentials.refreshToken) return null;
+	if (!credentials) return { status: "no-login" };
+	if (credentials.expiresAt && Date.now() / 1e3 < credentials.expiresAt - bufferSeconds) return {
+		credentials,
+		status: "ok"
+	};
+	if (!credentials.refreshToken) return { status: "no-login" };
 	const refreshed = await refreshAccessToken$1(resolveServerUrl(), credentials.refreshToken);
-	if (!refreshed) return null;
+	if (refreshed.status !== "ok") return refreshed;
 	const updated = {
-		accessToken: refreshed.access_token,
-		expiresAt: refreshed.expires_in ? Math.floor(Date.now() / 1e3) + refreshed.expires_in : void 0,
-		refreshToken: refreshed.refresh_token || credentials.refreshToken
+		accessToken: refreshed.token.access_token,
+		expiresAt: refreshed.token.expires_in ? Math.floor(Date.now() / 1e3) + refreshed.token.expires_in : void 0,
+		refreshToken: refreshed.token.refresh_token || credentials.refreshToken
 	};
 	saveCredentials(updated);
-	return { credentials: updated };
+	return {
+		credentials: updated,
+		status: "ok"
+	};
+}
+/**
+* How to explain a lookup that produced no token, or `undefined` when there is nothing to
+* diagnose and the caller's own "log in first" message fits.
+*/
+function describeTokenLookup(lookup) {
+	switch (lookup.status) {
+		case "spent": return {
+			detail: `The stored login is no longer valid (${lookup.detail}).`,
+			fix: `Run '${"lh"} login' again.`
+		};
+		case "refused": return {
+			detail: `The server refused the refresh request: ${lookup.detail}. The stored login is intact, so the credential is not what it is objecting to.`,
+			fix: "Check the server URL and anything sitting in front of it — signing in again will not change the answer."
+		};
+		case "unavailable": return {
+			detail: `Could not reach the server to refresh the access token: ${lookup.detail}. The stored login is untouched, so this is the network or the server rather than a signed-out session.`,
+			fix: "Retry in a moment; the stored login does not need renewing."
+		};
+		default: return;
+	}
 }
 async function refreshAccessToken$1(serverUrl, refreshToken) {
+	let res;
 	try {
-		const res = await fetch(`${serverUrl}/oidc/token`, {
+		res = await fetch(`${serverUrl}/oidc/token`, {
 			body: new URLSearchParams({
 				client_id: CLIENT_ID$1,
 				grant_type: "refresh_token",
@@ -20170,12 +20210,42 @@ async function refreshAccessToken$1(serverUrl, refreshToken) {
 			headers: { "Content-Type": "application/x-www-form-urlencoded" },
 			method: "POST"
 		});
-		const body = await res.json();
-		if (!res.ok || body.error || !body.access_token) return null;
-		return body;
-	} catch {
-		return null;
+	} catch (error) {
+		return {
+			detail: error instanceof Error ? error.message : String(error),
+			status: "unavailable"
+		};
+	}
+	const body = await res.json().catch(() => void 0);
+	if (!res.ok) {
+		const detail = body?.error ? `${body.error}${body.error_description ? `: ${body.error_description}` : ""}` : `HTTP ${res.status}`;
+		if (res.status >= 500 || TRANSIENT_STATUSES.has(res.status)) return {
+			detail,
+			status: "unavailable"
+		};
+		return body?.error === CREDENTIAL_SPENT_ERROR ? {
+			detail,
+			status: "spent"
+		} : {
+			detail,
+			status: "refused"
+		};
 	}
+	if (body?.error) return body.error === CREDENTIAL_SPENT_ERROR ? {
+		detail: body.error,
+		status: "spent"
+	} : {
+		detail: body.error,
+		status: "refused"
+	};
+	if (!body?.access_token) return {
+		detail: "the response carried no access token",
+		status: "unavailable"
+	};
+	return {
+		status: "ok",
+		token: body
+	};
 }
 
 //#endregion
@@ -20377,8 +20447,9 @@ async function getAuthAndServer() {
 		serverUrl: resolveServerUrl()
 	};
 	const result = await getValidToken();
-	if (!result) {
-		log$12.error(`No authentication found. Run '${"lh"} login' (or 'npx -y ${cliPackageName} login') first, or set ${CLI_API_KEY_ENV}.`);
+	if (result.status !== "ok") {
+		const report = describeTokenLookup(result);
+		log$12.error(report ? `${report.detail} ${report.fix}` : `No authentication found. Run '${"lh"} login' (or 'npx -y ${cliPackageName} login') first, or set ${CLI_API_KEY_ENV}.`);
 		process.exit(1);
 	}
 	const serverUrl = resolveServerUrl();
@@ -20455,12 +20526,13 @@ async function getAuthInfo(workspaceId) {
 		serverUrl
 	};
 	const result = await getValidToken();
-	if (!result) {
+	if (result.status !== "ok") {
 		if (readCliApiKeyEnv()) {
 			log$12.error(`API key auth from ${CLI_API_KEY_ENV} is not supported for /webapi/* routes. Run OIDC login instead.`);
 			process.exit(1);
 		}
-		log$12.error(`No authentication found. Run '${"lh"} login' first.`);
+		const report = describeTokenLookup(result);
+		log$12.error(report ? `${report.detail} ${report.fix}` : `No authentication found. Run '${"lh"} login' first.`);
 		process.exit(1);
 	}
 	const accessToken = result.credentials.accessToken;
@@ -20490,8 +20562,9 @@ async function getAgentStreamAuthInfo(workspaceId) {
 		tokenType: "apiKey"
 	};
 	const result = await getValidToken();
-	if (!result) {
-		log$12.error(`No authentication found. Run '${"lh"} login' first, or set ${CLI_API_KEY_ENV}.`);
+	if (result.status !== "ok") {
+		const report = describeTokenLookup(result);
+		log$12.error(report ? `${report.detail} ${report.fix}` : `No authentication found. Run '${"lh"} login' first, or set ${CLI_API_KEY_ENV}.`);
 		process.exit(1);
 		return {
 			headers: {},
@@ -26088,7 +26161,11 @@ var init_heteroSelectorCapabilities = __esmMin((() => {
 				source: "catalog"
 			}
 		},
-		"kimi-code": {},
+		"kimi-code": { model: {
+			encodings: [MODEL_FLAGS_ENCODING],
+			resolve: resolvePersistedModel,
+			source: "catalog"
+		} },
 		"opencode": { model: {
 			encodings: [MODEL_FLAGS_ENCODING],
 			resolve: resolvePersistedModel,
@@ -26128,7 +26205,7 @@ var init_heteroSelectorCapabilities = __esmMin((() => {
 
 //#endregion
 //#region ../../packages/types/src/agent/agencyConfig.ts
-var HETEROGENEOUS_AGENT_TYPES, modelFlagsOf, CODEX_MODEL_FLAGS$1, GROK_BUILD_MODEL_FLAGS, OPENCODE_MODEL_FLAGS, PI_MODEL_FLAGS, QODER_MODEL_FLAGS;
+var HETEROGENEOUS_AGENT_TYPES, modelFlagsOf, CODEX_MODEL_FLAGS$1, GROK_BUILD_MODEL_FLAGS, KIMI_CODE_MODEL_FLAGS, OPENCODE_MODEL_FLAGS, PI_MODEL_FLAGS, QODER_MODEL_FLAGS;
 var init_agencyConfig = __esmMin((() => {
 	init_heterogeneousAgent();
 	init_heteroSelectorCapabilities();
@@ -26136,6 +26213,7 @@ var init_agencyConfig = __esmMin((() => {
 	modelFlagsOf = (type) => HETERO_SELECTOR_CAPABILITIES[type].model.encodings.flatMap((encoding) => encoding.kind === "flag" ? encoding.flags : []);
 	CODEX_MODEL_FLAGS$1 = modelFlagsOf("codex");
 	GROK_BUILD_MODEL_FLAGS = modelFlagsOf("grok-build");
+	KIMI_CODE_MODEL_FLAGS = modelFlagsOf("kimi-code");
 	OPENCODE_MODEL_FLAGS = modelFlagsOf("opencode");
 	PI_MODEL_FLAGS = modelFlagsOf("pi");
 	QODER_MODEL_FLAGS = modelFlagsOf("qoder");
@@ -26282,6 +26360,12 @@ var init_chatConfig = __esmMin((() => {
 			"high",
 			"xhigh"
 		]).optional(),
+		grok4_7ReasoningEffort: _enum([
+			"low",
+			"medium",
+			"high",
+			"xhigh"
+		]).optional(),
 		hy3ReasoningEffort: _enum([
 			"no_think",
 			"low",
@@ -26728,6 +26812,8 @@ var init_agentRuntime = __esmMin((() => {
 		RequestTrigger["Openapi"] = "openapi";
 		/** A run the user deferred to a future time (`topic.metadata.scheduledRun`). */
 		RequestTrigger["Scheduled"] = "scheduled";
+		/** A provider event on a pull request (CI failure, review) woke the agent that opened it. */
+		RequestTrigger["Scm"] = "scm";
 		RequestTrigger["SemanticSearch"] = "semantic_search";
 		RequestTrigger["SignupEmailLLMReview"] = "signup_email_llm_review";
 		RequestTrigger["Topic"] = "topic";
@@ -26758,7 +26844,7 @@ var init_pageSelection = __esmMin((() => {
 
 //#endregion
 //#region ../../packages/types/src/message/common/metadata.ts
-var LocalSystemToolSnapshotSchema, ModelUsageSchema, ModelPerformanceSchema, EmojiReactionSchema, MessageSignalSchema, MessageTaskCallbackSchema, MessageWorkMetadataSchema, AgentDispatchMetadataSchema, BotSenderMetadataSchema, MessageMetadataSchema;
+var LocalSystemToolSnapshotSchema, ModelUsageSchema, ModelPerformanceSchema, EmojiReactionSchema, MessageSignalSchema, MessageTaskCallbackSchema, MessageWorkMetadataSchema, AgentDispatchMetadataSchema, ExternalOriginMetadataSchema, BotSenderMetadataSchema, MessageMetadataSchema;
 var init_metadata = __esmMin((() => {
 	init_zod$1();
 	init_agentRuntime();
@@ -26846,6 +26932,13 @@ var init_metadata = __esmMin((() => {
 		kind: _enum(["callAgent"]),
 		visibility: literal("internal")
 	});
+	ExternalOriginMetadataSchema = object$2({
+		kind: string(),
+		label: string(),
+		provider: string(),
+		resourceId: string().optional(),
+		url: string().optional()
+	});
 	BotSenderMetadataSchema = object$2({
 		avatar: string().optional(),
 		fullName: string().optional(),
@@ -26855,6 +26948,7 @@ var init_metadata = __esmMin((() => {
 	});
 	MessageMetadataSchema = ModelUsageSchema.merge(ModelPerformanceSchema).extend({
 		botSender: BotSenderMetadataSchema.optional(),
+		externalOrigin: ExternalOriginMetadataSchema.optional(),
 		agentDispatch: AgentDispatchMetadataSchema.optional(),
 		collapsed: boolean().optional(),
 		contextSelections: array(ContextSelectionSchema).optional(),
@@ -28572,6 +28666,12 @@ var init_aiModel = __esmMin((() => {
 			"high",
 			"xhigh"
 		]).optional(),
+		grok4_7ReasoningEffort: _enum([
+			"low",
+			"medium",
+			"high",
+			"xhigh"
+		]).optional(),
 		grok4_20ReasoningEffort: _enum([
 			"low",
 			"medium",
@@ -28644,6 +28744,7 @@ var init_aiModel = __esmMin((() => {
 		"grok4_3ReasoningEffort",
 		"grok4_5ReasoningEffort",
 		"grok4_6ReasoningEffort",
+		"grok4_7ReasoningEffort",
 		"hy3ReasoningEffort",
 		"kimiK3ReasoningEffort",
 		"ring2_6ReasoningEffort",
@@ -29056,7 +29157,12 @@ var init_preference = __esmMin((() => {
 		* enable the per-topic acceptance tray above the composer (author a topic's
 		* delivery checklist inline)
 		*/
-		enableTopicAcceptance: boolean().optional()
+		enableTopicAcceptance: boolean().optional(),
+		/**
+		* expose a port on the working device through a tunnel link, so a dev server
+		* running there can be opened from this UI
+		*/
+		enableDeviceTunnel: boolean().optional()
 	});
 	GithubIntegrationPreferenceSchema = object$2({
 		acceptOnMerge: boolean().optional(),
@@ -40423,8 +40529,12 @@ function registerBotCommand(program) {
 		const client = await getTrpcClient();
 		const input = { id: botId };
 		const existing = await findBot(client, botId);
-		const { credentials } = extractCredentials(await resolvePlatform(client, options.platform ?? existing.platform), options);
-		if (Object.keys(credentials).length > 0) input.credentials = credentials;
+		const platform = options.platform ?? existing.platform;
+		const { credentials } = extractCredentials(await resolvePlatform(client, platform), options);
+		if (Object.keys(credentials).length > 0) input.credentials = platform === existing.platform ? {
+			...existing.credentials,
+			...credentials
+		} : credentials;
 		if (options.appId) input.applicationId = options.appId;
 		if (options.platform) input.platform = options.platform;
 		const settingsPatch = {};
@@ -42916,8 +43026,20 @@ var AmpAdapter = class {
 };
 
 //#endregion
-//#region ../../packages/heterogeneous-agents/src/errors/claudeCodeQuota.ts
-const CLI_CREDIT_LIMIT_PATTERNS = [/you'?ve reached your .{0,40}\blimit\b/i, /\/usage-credits\b/i];
+//#region ../../packages/heterogeneous-agents/src/errors/cliQuota.ts
+/**
+* Quota wording shared by CLI-wrapped agents.
+*
+* Every local CLI agent bills against its own subscription and prints the
+* same kind of sentence when that subscription is spent — CC's `You've hit
+* your weekly limit`, Kimi Code's `You've reached your weekly (7-day) usage
+* limit`, a gateway's `已达到 5 小时使用上限`. The patterns therefore live here
+* rather than in one adapter, and `classifyCliQuotaMessage` is the single
+* place that turns them into a taxonomy kind.
+*/
+/** Remedies that only a top-up clears — waiting for a window never helps. */
+const CLI_CREDIT_REMEDY_PATTERNS = [/\/usage-credits\b/i];
+const CLI_CREDIT_LIMIT_PATTERNS = [/you'?ve reached your .{0,40}\blimit\b/i, ...CLI_CREDIT_REMEDY_PATTERNS];
 const CLI_USER_RATE_LIMIT_PATTERNS = [
 	/you'?ve hit your limit/i,
 	/you'?ve hit your \S+ limit/i,
@@ -42935,6 +43057,50 @@ const CLI_USER_RATE_LIMIT_PATTERNS = [
 * misleading "usage limit reached" reset-time guide).
 */
 const CLI_SERVER_THROTTLE_PATTERNS = [/not your usage limit/i, /server is temporarily limiting requests/i];
+/**
+* Wording that promises the window reopens by itself — Kimi Code's
+* `Your quota will reset when the current 7-day window ends`, CC's
+* `resets 6:30pm (Asia/Shanghai)`, a gateway's `2026-06-19 22:00:00 后可继续
+* 使用`. It is what separates a plan window (wait, or schedule the
+* continuation) from exhausted credits (top up or switch model), because both
+* open with the same "you've reached your … limit" sentence.
+*/
+const CLI_QUOTA_RESET_PATTERNS = [
+	/\bresets?\b/i,
+	/\b(?:refresh|renew)(?:ed|es|s)?\b/i,
+	/后可继续使用/,
+	/(?:额度|配额|上限)[^。]{0,12}(?:重置|刷新|恢复)/
+];
+/**
+* The window a rejected quota belongs to, in the vocabulary the rate-limit
+* guide already renders (`seven_day` → 周期上限, `five_hour` → 5 小时上限).
+* CC ships it as structured `rate_limit_info`; CLIs that only print prose
+* (Kimi Code: `You've reached your weekly (7-day) usage limit`) get it read
+* back out of the sentence so the card can name the window.
+*/
+const CLI_RATE_LIMIT_TYPE_PATTERNS = [[/\bweekly\b|\b7[\s-]?day\b|\bseven[\s-]?day\b|每周|7\s*天|七天/i, "seven_day"], [/\b5[\s-]?hour\b|\bfive[\s-]?hour\b|\bsession limit\b|5\s*小时/i, "five_hour"]];
+/**
+* Classify a CLI's free-form failure text as a user-side quota rejection.
+*
+* Deliberately agent-agnostic: every CLI-wrapped agent bills against its own
+* subscription and prints the same kind of sentence when that subscription is
+* spent, so the classification lives with the patterns rather than in one
+* adapter. Returns `undefined` for anything that is not unambiguously the
+* user's own quota — a bare 429, `rate limited`, or a provider-side throttle
+* that disclaims the plan limit belongs to the retry (overloaded) path.
+*/
+const classifyCliQuotaMessage = (message) => {
+	if (!message) return;
+	if (CLI_SERVER_THROTTLE_PATTERNS.some((pattern) => pattern.test(message))) return;
+	if (!CLI_USER_RATE_LIMIT_PATTERNS.some((pattern) => pattern.test(message))) return;
+	const resets = CLI_QUOTA_RESET_PATTERNS.some((pattern) => pattern.test(message));
+	const kind = CLI_CREDIT_REMEDY_PATTERNS.some((pattern) => pattern.test(message)) || !resets && CLI_CREDIT_LIMIT_PATTERNS.some((pattern) => pattern.test(message)) ? "credit_limit" : "usage_limit";
+	const rateLimitType = CLI_RATE_LIMIT_TYPE_PATTERNS.find(([pattern]) => pattern.test(message))?.[1];
+	return {
+		kind,
+		...rateLimitType ? { rateLimitType } : {}
+	};
+};
 
 //#endregion
 //#region ../../packages/heterogeneous-agents/src/adapters/claudeCode.ts
@@ -43483,7 +43649,7 @@ const getRateLimitTerminalError = (result, agentType, rateLimitInfo) => {
 		agentType,
 		clearEchoedContent: true,
 		code: "rate_limit",
-		details: { kind: CLI_CREDIT_LIMIT_PATTERNS.some((pattern) => pattern.test(rawMessage)) ? "credit_limit" : "usage_limit" },
+		details: { kind: classifyCliQuotaMessage(rawMessage)?.kind ?? "usage_limit" },
 		error: rawMessage,
 		message: rawMessage,
 		rateLimitInfo,
@@ -47374,9 +47540,9 @@ init_config();
 * error card instead of the heterogeneous status guide (install CLI / sign in).
 *
 * This helper mirrors the desktop in-process classifier
-* (`HeterogeneousAgentCtr.getSessionErrorPayload`) for the two guide codes a
+* (`HeterogeneousAgentCtr.getSessionErrorPayload`) for the guide codes a
 * process-level failure can produce: `cli_not_found`,
-* `working_directory_not_found`, and `auth_required`.
+* `working_directory_not_found`, `rate_limit` and `auth_required`.
 * The returned shape is persisted verbatim as the `ChatMessageError.body`, so
 * it must carry `agentType` + `code` — that pair is what
 * `isHeterogeneousAgentStatusGuideError` gates the dedicated UI on.
@@ -47434,6 +47600,19 @@ const classifyHeteroProcessFailure = (params) => {
 		command,
 		stderr: detail
 	});
+	const quota = classifyCliQuotaMessage(detail);
+	if (detail && quota) return {
+		agentType,
+		code: "rate_limit",
+		details: { kind: quota.kind },
+		error: detail,
+		message: detail,
+		...quota.rateLimitType ? { rateLimitInfo: {
+			rateLimitType: quota.rateLimitType,
+			status: "rejected"
+		} } : {},
+		stderr: detail
+	};
 	if (detail && isHeterogeneousAgentAuthRequired(agentType, detail)) return buildHeterogeneousAgentAuthRequiredError({
 		agentType,
 		command,
@@ -234816,7 +234995,7 @@ const createLogger = (namespace) => ({
 //#endregion
 //#region ../../packages/local-file-shell/src/git/branches.ts
 const log$3 = createLogger("local-file-shell:git");
-const execFileAsync$6 = promisify(execFile);
+const execFileAsync$7 = promisify(execFile);
 /** Reject obviously invalid branch refs early to avoid a confusing git error. */
 const isInvalidBranchRef = (name) => /[\s~^:?*[\\]/.test(name) || name.startsWith("-") || name.includes("..");
 /**
@@ -234825,7 +235004,7 @@ const isInvalidBranchRef = (name) => /[\s~^:?*[\\]/.test(name) || name.startsWit
 */
 const listGitBranches = async (dirPath) => {
 	try {
-		const { stdout } = await execFileAsync$6("git", [
+		const { stdout } = await execFileAsync$7("git", [
 			"for-each-ref",
 			"--sort=-committerdate",
 			"--format=%(HEAD)%09%(refname:short)%09%(upstream:short)",
@@ -234860,7 +235039,7 @@ const listGitBranches = async (dirPath) => {
 const listGitRemoteBranches = async (dirPath) => {
 	let defaultRef;
 	try {
-		const { stdout } = await execFileAsync$6("git", [
+		const { stdout } = await execFileAsync$7("git", [
 			"symbolic-ref",
 			"--short",
 			"refs/remotes/origin/HEAD"
@@ -234873,7 +235052,7 @@ const listGitRemoteBranches = async (dirPath) => {
 		defaultRef = void 0;
 	}
 	try {
-		const { stdout } = await execFileAsync$6("git", [
+		const { stdout } = await execFileAsync$7("git", [
 			"for-each-ref",
 			"--sort=-committerdate",
 			"--format=%(refname:short)",
@@ -234917,7 +235096,7 @@ const checkoutGitBranch = async (payload) => {
 		branch
 	] : ["checkout", branch];
 	try {
-		await execFileAsync$6("git", args, {
+		await execFileAsync$7("git", args, {
 			cwd: dirPath,
 			timeout: 1e4
 		});
@@ -234950,7 +235129,7 @@ const renameGitBranch = async (payload) => {
 		success: false
 	};
 	try {
-		await execFileAsync$6("git", [
+		await execFileAsync$7("git", [
 			"branch",
 			"-m",
 			from,
@@ -234989,7 +235168,7 @@ const deleteGitBranch = async (payload) => {
 		success: false
 	};
 	try {
-		await execFileAsync$6("git", [
+		await execFileAsync$7("git", [
 			"branch",
 			"-D",
 			branch
@@ -235017,7 +235196,7 @@ const deleteGitBranch = async (payload) => {
 const pullGitBranch = async (payload) => {
 	const { path: dirPath } = payload;
 	try {
-		const { stdout } = await execFileAsync$6("git", ["pull", "--ff-only"], {
+		const { stdout } = await execFileAsync$7("git", ["pull", "--ff-only"], {
 			cwd: dirPath,
 			timeout: 6e4
 		});
@@ -235042,7 +235221,7 @@ const pullGitBranch = async (payload) => {
 const pushGitBranch = async (payload) => {
 	const { path: dirPath } = payload;
 	try {
-		const { stderr } = await execFileAsync$6("git", [
+		const { stderr } = await execFileAsync$7("git", [
 			"push",
 			"-u",
 			"origin",
@@ -235089,7 +235268,7 @@ const revertGitFile = async (payload) => {
 	};
 	let existsAtHead;
 	try {
-		await execFileAsync$6("git", [
+		await execFileAsync$7("git", [
 			"cat-file",
 			"-e",
 			`HEAD:${filePath}`
@@ -235102,7 +235281,7 @@ const revertGitFile = async (payload) => {
 		existsAtHead = false;
 	}
 	try {
-		if (existsAtHead) await execFileAsync$6("git", [
+		if (existsAtHead) await execFileAsync$7("git", [
 			"checkout",
 			"HEAD",
 			"--",
@@ -235113,7 +235292,7 @@ const revertGitFile = async (payload) => {
 		});
 		else {
 			try {
-				await execFileAsync$6("git", [
+				await execFileAsync$7("git", [
 					"rm",
 					"--cached",
 					"--quiet",
@@ -235203,12 +235382,12 @@ const detectRepoType = async (dirPath) => {
 
 //#endregion
 //#region ../../packages/local-file-shell/src/git/upstream.ts
-const execFileAsync$5 = promisify(execFile);
+const execFileAsync$6 = promisify(execFile);
 const GIT_TIMEOUT = 5e3;
 /** Local-only git read. Every step of the resolver degrades to "unknown", never throws. */
 const runGit = async (args, cwd) => {
 	try {
-		const { stdout } = await execFileAsync$5("git", args, {
+		const { stdout } = await execFileAsync$6("git", args, {
 			cwd,
 			timeout: GIT_TIMEOUT
 		});
@@ -235396,7 +235575,7 @@ const getDefaultRemote = async (dirPath) => {
 /** Exit-status-only probe — `runGit` cannot tell success-with-no-output from failure. */
 const gitSucceeds = async (args, cwd) => {
 	try {
-		await execFileAsync$5("git", args, {
+		await execFileAsync$6("git", args, {
 			cwd,
 			timeout: GIT_TIMEOUT
 		});
@@ -235436,7 +235615,7 @@ const isCommitSafeForPullRequestLookup = async (dirPath, sha) => {
 //#endregion
 //#region ../../packages/local-file-shell/src/git/info.ts
 const log$2 = createLogger("local-file-shell:git");
-const execFileAsync$4 = promisify(execFile);
+const execFileAsync$5 = promisify(execFile);
 const GITHUB_PULL_REQUEST_FIELDS = "number,url,title,state,isDraft,mergeable,mergeStateStatus,mergedAt,reviewDecision,statusCheckRollup,headRefName";
 const failureConclusions$1 = new Set([
 	"action_required",
@@ -235541,7 +235720,7 @@ const getGitBranch = async (dirPath) => {
 */
 const findPullRequestByCommit = async (dirPath, sha) => {
 	try {
-		const { stdout } = await execFileAsync$4("gh", ["api", `repos/{owner}/{repo}/commits/${sha}/pulls`], {
+		const { stdout } = await execFileAsync$5("gh", ["api", `repos/{owner}/{repo}/commits/${sha}/pulls`], {
 			cwd: dirPath,
 			timeout: 8e3
 		});
@@ -235594,7 +235773,7 @@ const getLinkedPullRequest = async (payload) => {
 		status: "ok"
 	};
 	const viewPullRequest = async (number) => {
-		const { stdout } = await execFileAsync$4("gh", [
+		const { stdout } = await execFileAsync$5("gh", [
 			"pr",
 			"view",
 			String(number),
@@ -235620,7 +235799,7 @@ const getLinkedPullRequest = async (payload) => {
 				...upstream ? { upstream } : {}
 			};
 		}
-		const { stdout } = await execFileAsync$4("gh", [
+		const { stdout } = await execFileAsync$5("gh", [
 			"pr",
 			"list",
 			"--head",
@@ -235687,7 +235866,7 @@ const getLinkedPullRequest = async (payload) => {
 /** Bucket dirty files into added / modified / deleted via `git status --porcelain -z`. */
 const getGitWorkingTreeStatus = async (dirPath) => {
 	try {
-		const { stdout } = await execFileAsync$4("git", [
+		const { stdout } = await execFileAsync$5("git", [
 			"status",
 			"--porcelain",
 			"-u",
@@ -235738,7 +235917,7 @@ const getGitWorkingTreeStatus = async (dirPath) => {
 */
 const getGitAheadBehind = async (dirPath) => {
 	try {
-		await execFileAsync$4("git", [
+		await execFileAsync$5("git", [
 			"fetch",
 			"--no-tags",
 			"--quiet",
@@ -235749,7 +235928,7 @@ const getGitAheadBehind = async (dirPath) => {
 		});
 	} catch {}
 	try {
-		const { stdout: upstreamOut } = await execFileAsync$4("git", [
+		const { stdout: upstreamOut } = await execFileAsync$5("git", [
 			"rev-parse",
 			"--abbrev-ref",
 			"--symbolic-full-name",
@@ -235764,7 +235943,7 @@ const getGitAheadBehind = async (dirPath) => {
 			behind: 0,
 			hasUpstream: false
 		};
-		const { stdout } = await execFileAsync$4("git", [
+		const { stdout } = await execFileAsync$5("git", [
 			"rev-list",
 			"--left-right",
 			"--count",
@@ -235779,7 +235958,7 @@ const getGitAheadBehind = async (dirPath) => {
 		let pushTarget;
 		let pushTargetExists = false;
 		try {
-			const { stdout: branchOut } = await execFileAsync$4("git", [
+			const { stdout: branchOut } = await execFileAsync$5("git", [
 				"symbolic-ref",
 				"--short",
 				"HEAD"
@@ -235791,7 +235970,7 @@ const getGitAheadBehind = async (dirPath) => {
 			if (branch) {
 				pushTarget = `origin/${branch}`;
 				try {
-					await execFileAsync$4("git", [
+					await execFileAsync$5("git", [
 						"rev-parse",
 						"--verify",
 						"--quiet",
@@ -235826,7 +236005,7 @@ const getGitAheadBehind = async (dirPath) => {
 //#endregion
 //#region ../../packages/local-file-shell/src/git/pullRequest.ts
 const log$1 = createLogger("local-file-shell:git");
-const execFileAsync$3 = promisify(execFile);
+const execFileAsync$4 = promisify(execFile);
 const GITHUB_PULL_REQUEST_DETAIL_FIELDS = "number,title,body,state,isDraft,isCrossRepository,mergedAt,mergeable,mergeStateStatus,reviewDecision,autoMergeRequest,baseRefName,headRefName,headRefOid,url,author,additions,deletions,changedFiles,commits,comments,reviews,statusCheckRollup";
 const failureConclusions = new Set([
 	"action_required",
@@ -235901,7 +236080,7 @@ const normalizePullRequestActivity = (raw) => ({
 	}))
 });
 const getPullRequestActivity = async (payload) => {
-	const { stdout } = await execFileAsync$3("gh", [
+	const { stdout } = await execFileAsync$4("gh", [
 		"pr",
 		"view",
 		String(payload.number),
@@ -235977,7 +236156,7 @@ const getPullRequestMergeContext = async (payload) => {
 	const { path: dirPath, number, repo, baseRefName, headRefOid } = payload;
 	assertBranchName(baseRefName);
 	if (!/^[a-f\d]{40}$/i.test(headRefOid)) return EMPTY_MERGE_CONTEXT;
-	const exec = (args) => execFileAsync$3("gh", args, {
+	const exec = (args) => execFileAsync$4("gh", args, {
 		cwd: dirPath,
 		timeout: 8e3
 	});
@@ -236016,7 +236195,7 @@ const isGhMissing = (error) => {
 const getPullRequestDetail = async (payload) => {
 	const { path: dirPath, number } = payload;
 	try {
-		const { stdout } = await execFileAsync$3("gh", [
+		const { stdout } = await execFileAsync$4("gh", [
 			"pr",
 			"view",
 			String(number),
@@ -236137,7 +236316,7 @@ const pullRequestActionArgs = (number, action) => {
 const runPullRequestAction = async (payload) => {
 	const { path: dirPath, number, action } = payload;
 	try {
-		for (const argv of pullRequestActionArgs(number, action)) await execFileAsync$3("gh", argv, {
+		for (const argv of pullRequestActionArgs(number, action)) await execFileAsync$4("gh", argv, {
 			cwd: dirPath,
 			timeout: 6e4
 		});
@@ -236158,7 +236337,7 @@ const runPullRequestAction = async (payload) => {
 //#endregion
 //#region ../../packages/local-file-shell/src/git/workingTree.ts
 const log = createLogger("local-file-shell:git");
-const execFileAsync$2 = promisify(execFile);
+const execFileAsync$3 = promisify(execFile);
 const MAX_PATCH_BYTES = 256 * 1024;
 /**
 * Split the output of `git diff HEAD --` into one block per file. Each block
@@ -236425,7 +236604,7 @@ const runGitCaptureStream = (cwd, args, timeoutMs) => new Promise((resolve, reje
 const fetchTrackedPatchPerFile = async (cwd, entry, maxBytes) => {
 	let text;
 	try {
-		const { stdout } = await execFileAsync$2("git", [
+		const { stdout } = await execFileAsync$3("git", [
 			"-c",
 			"core.quotepath=off",
 			"diff",
@@ -236489,7 +236668,7 @@ const mapWithConcurrency$1 = async (items, limit, fn) => {
 */
 const listSubmodulePaths = async (dirPath) => {
 	try {
-		const { stdout } = await execFileAsync$2("git", ["submodule", "status"], {
+		const { stdout } = await execFileAsync$3("git", ["submodule", "status"], {
 			cwd: dirPath,
 			timeout: 5e3
 		});
@@ -236527,7 +236706,7 @@ const getGitWorkingTreeFiles = async (dirPath) => {
 	const modified = [];
 	const deleted = [];
 	try {
-		const { stdout } = await execFileAsync$2("git", [
+		const { stdout } = await execFileAsync$3("git", [
 			"status",
 			"--porcelain",
 			"-u",
@@ -236575,7 +236754,7 @@ const collectWorkingTreePatches = async (dirPath, recurseSubmodules) => {
 	const entries = [];
 	const submoduleDirtyEntries = [];
 	try {
-		const { stdout } = await execFileAsync$2("git", [
+		const { stdout } = await execFileAsync$3("git", [
 			"status",
 			"--porcelain",
 			"-u",
@@ -236700,7 +236879,7 @@ const getGitWorkingTreePatches = (dirPath) => collectWorkingTreePatches(dirPath,
 */
 const collectBranchDiff = async (dirPath, baseRefOverride, recurseSubmodules) => {
 	try {
-		await execFileAsync$2("git", [
+		await execFileAsync$3("git", [
 			"fetch",
 			"--no-tags",
 			"--quiet",
@@ -236712,7 +236891,7 @@ const collectBranchDiff = async (dirPath, baseRefOverride, recurseSubmodules) =>
 	} catch {}
 	let baseRef = baseRefOverride;
 	if (!baseRef) try {
-		const { stdout } = await execFileAsync$2("git", [
+		const { stdout } = await execFileAsync$3("git", [
 			"symbolic-ref",
 			"--short",
 			"refs/remotes/origin/HEAD"
@@ -236801,7 +236980,7 @@ const getGitBranchDiff = (payload) => collectBranchDiff(payload.path, payload.ba
 
 //#endregion
 //#region ../../packages/local-file-shell/src/git/worktrees.ts
-const execFileAsync$1 = promisify(execFile);
+const execFileAsync$2 = promisify(execFile);
 const normalizeBranchRef = (ref) => ref.startsWith("refs/heads/") ? ref.slice(11) : ref;
 const safeRealpath$1 = async (target) => {
 	try {
@@ -236861,10 +237040,10 @@ const readStatus = async (worktree) => {
 };
 const listGitWorktrees = async (dirPath) => {
 	try {
-		const [{ stdout: rootStdout }, { stdout }] = await Promise.all([execFileAsync$1("git", ["rev-parse", "--show-toplevel"], {
+		const [{ stdout: rootStdout }, { stdout }] = await Promise.all([execFileAsync$2("git", ["rev-parse", "--show-toplevel"], {
 			cwd: dirPath,
 			timeout: 5e3
-		}), execFileAsync$1("git", [
+		}), execFileAsync$2("git", [
 			"worktree",
 			"list",
 			"--porcelain",
@@ -236918,7 +237097,7 @@ const removeGitWorktree = async (payload) => {
 		success: false
 	};
 	try {
-		await execFileAsync$1("git", [
+		await execFileAsync$2("git", [
 			"worktree",
 			"remove",
 			worktree.path
@@ -236960,7 +237139,7 @@ const addGitWorktree = async (payload) => {
 		success: false
 	};
 	try {
-		await execFileAsync$1("git", [
+		await execFileAsync$2("git", [
 			"worktree",
 			"add",
 			"-b",
@@ -237224,6 +237403,244 @@ const quotaCache = new QuotaSnapshotCache({ freshMs: KIMI_CODE_QUOTA_FRESH_MS })
 */
 const getKimiCodeQuota = (params = {}) => quotaCache.get(createQuotaCacheKey("kimi-code", params.env), () => fetchKimiCodeQuota({ env: params.env }), { force: params.force });
 
+//#endregion
+//#region ../../packages/device-control/src/listeningPorts.ts
+const execFileAsync$1 = promisify(execFile);
+const MAX_PORTS = 50;
+const COMMAND_TIMEOUT_MS = 5e3;
+const classifyAddress = (address) => {
+	const bare = address.replaceAll(/^\[|\]$/g, "");
+	if (bare === "*" || bare === "0.0.0.0" || bare === "::" || bare === "::0") return "any";
+	if (bare.startsWith("127.")) return "ipv4-loopback";
+	if (bare === "::1" || bare === "::ffff:127.0.0.1") return "ipv6-loopback";
+	return "unreachable";
+};
+/** Parse `lsof -nP -iTCP -sTCP:LISTEN -F pcn` field output. */
+const parseLsofListen = (output) => {
+	const entries = [];
+	let pid;
+	let command;
+	for (const line of output.split("\n")) {
+		const tag = line[0];
+		const value = line.slice(1);
+		if (tag === "p") {
+			pid = Number(value);
+			command = void 0;
+		} else if (tag === "c") command = value;
+		else if (tag === "n") {
+			const sep = value.lastIndexOf(":");
+			const port = Number(value.slice(sep + 1));
+			if (sep > 0 && Number.isInteger(port) && port > 0) entries.push({
+				address: value.slice(0, sep),
+				command,
+				pid,
+				port
+			});
+		}
+	}
+	return entries;
+};
+/** Parse `lsof -a -p <pids> -d cwd -Fpn` into pid → cwd. */
+const parseLsofCwd = (output) => {
+	const cwds = /* @__PURE__ */ new Map();
+	let pid;
+	for (const line of output.split("\n")) if (line[0] === "p") pid = Number(line.slice(1));
+	else if (line[0] === "n" && pid !== void 0) cwds.set(pid, line.slice(1));
+	return cwds;
+};
+const LISTEN_STATE = "0A";
+const decodeProcIpv4 = (hex) => [
+	hex.slice(6, 8),
+	hex.slice(4, 6),
+	hex.slice(2, 4),
+	hex.slice(0, 2)
+].map((byte) => Number.parseInt(byte, 16)).join(".");
+const decodeProcIpv6 = (hex) => {
+	if (/^0+$/.test(hex)) return "::";
+	if (hex === "00000000000000000000000001000000") return "::1";
+	if (hex === "0000000000000000FFFF00000100007F") return "::ffff:127.0.0.1";
+	return hex;
+};
+/** Parse `/proc/net/tcp` or `/proc/net/tcp6` into listening sockets keyed by inode. */
+const parseProcNetTcp = (content, family) => content.split("\n").slice(1).map((line) => line.trim().split(/\s+/)).filter((cols) => cols.length > 9 && cols[3] === LISTEN_STATE).map((cols) => {
+	const [addrHex, portHex] = cols[1].split(":");
+	return {
+		address: family === "v4" ? decodeProcIpv4(addrHex) : decodeProcIpv6(addrHex.toUpperCase()),
+		inode: cols[9],
+		port: Number.parseInt(portHex, 16)
+	};
+});
+/** Parse `netstat -ano -p TCP` / `-p TCPv6` LISTENING rows. */
+const parseNetstat = (output) => output.split("\n").map((line) => line.trim().split(/\s+/)).filter((cols) => cols[0] === "TCP" && cols[3] === "LISTENING").map((cols) => {
+	const local = cols[1];
+	const sep = local.lastIndexOf(":");
+	return {
+		address: local.slice(0, sep),
+		pid: Number(cols[4]),
+		port: Number(local.slice(sep + 1))
+	};
+});
+/** Parse `tasklist /FO CSV /NH` into pid → image name. */
+const parseTasklist = (output) => {
+	const names = /* @__PURE__ */ new Map();
+	for (const line of output.split("\n")) {
+		const cols = line.match(/"([^"]*)"/g)?.map((col) => col.slice(1, -1));
+		if (cols && cols.length > 1) names.set(Number(cols[1]), cols[0]);
+	}
+	return names;
+};
+const isInside = (dir, root) => {
+	if (!dir || !root) return false;
+	const rel = path.relative(path.resolve(root), path.resolve(dir));
+	return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+};
+/**
+* Fold raw sockets into one row per port, keep only loopback-reachable ones,
+* drop this process's own listeners, and put the project's ports first.
+*/
+const summarizeListeners = (entries, options) => {
+	const byPort = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (options.ownPid !== void 0 && entry.pid === options.ownPid) continue;
+		const kind = classifyAddress(entry.address);
+		if (kind === "unreachable") continue;
+		const existing = byPort.get(entry.port);
+		if (existing) existing.kinds.add(kind);
+		else byPort.set(entry.port, {
+			entry,
+			kinds: new Set([kind])
+		});
+	}
+	return [...byPort.values()].map(({ entry, kinds }) => {
+		const v4 = kinds.has("any") || kinds.has("ipv4-loopback");
+		const v6 = kinds.has("any") || kinds.has("ipv6-loopback");
+		const cwd = entry.pid === void 0 ? void 0 : options.cwds?.get(entry.pid);
+		return {
+			...entry.command ? { command: entry.command } : {},
+			...cwd ? { cwd } : {},
+			inProject: isInside(cwd, options.cwd),
+			loopback: v4 && v6 ? "both" : v4 ? "ipv4" : "ipv6",
+			...entry.pid === void 0 ? {} : { pid: entry.pid },
+			port: entry.port
+		};
+	}).sort((a, b) => Number(b.inProject) - Number(a.inProject) || a.port - b.port).slice(0, MAX_PORTS);
+};
+const run = async (file, args) => (await execFileAsync$1(file, args, {
+	maxBuffer: 4 * 1024 * 1024,
+	timeout: COMMAND_TIMEOUT_MS
+})).stdout;
+const collectDarwin = async () => {
+	const entries = parseLsofListen(await run("lsof", [
+		"-nP",
+		"-iTCP",
+		"-sTCP:LISTEN",
+		"-F",
+		"pcn"
+	]).catch((error) => {
+		if (error.code === 1) return error.stdout ?? "";
+		throw error;
+	}));
+	const pids = [...new Set(entries.map((e) => e.pid).filter((p) => !!p))];
+	return {
+		cwds: pids.length ? parseLsofCwd(await run("lsof", [
+			"-a",
+			"-p",
+			pids.join(","),
+			"-d",
+			"cwd",
+			"-Fpn"
+		]).catch((error) => error.stdout ?? "")) : /* @__PURE__ */ new Map(),
+		entries
+	};
+};
+const collectLinux = async () => {
+	const sockets = [...parseProcNetTcp(await readFile("/proc/net/tcp", "utf8").catch(() => ""), "v4"), ...parseProcNetTcp(await readFile("/proc/net/tcp6", "utf8").catch(() => ""), "v6")];
+	const wanted = new Set(sockets.map((s) => s.inode));
+	const owner = /* @__PURE__ */ new Map();
+	for (const pidDir of await readdir("/proc").catch(() => [])) {
+		if (!/^\d+$/.test(pidDir)) continue;
+		const fds = await readdir(`/proc/${pidDir}/fd`).catch(() => []);
+		for (const fd of fds) {
+			const target = await readlink(`/proc/${pidDir}/fd/${fd}`).catch(() => "");
+			const inode = /^socket:\[(\d+)\]$/.exec(target)?.[1];
+			if (inode && wanted.has(inode)) owner.set(inode, Number(pidDir));
+		}
+	}
+	const cwds = /* @__PURE__ */ new Map();
+	const commands = /* @__PURE__ */ new Map();
+	for (const pid of new Set(owner.values())) {
+		const cwd = await readlink(`/proc/${pid}/cwd`).catch(() => void 0);
+		if (cwd) cwds.set(pid, cwd);
+		const comm = await readFile(`/proc/${pid}/comm`, "utf8").catch(() => void 0);
+		if (comm) commands.set(pid, comm.trim());
+	}
+	return {
+		cwds,
+		entries: sockets.map((socket) => {
+			const pid = owner.get(socket.inode);
+			return {
+				address: socket.address,
+				...pid === void 0 ? {} : {
+					command: commands.get(pid),
+					pid
+				},
+				port: socket.port
+			};
+		})
+	};
+};
+const collectWindows = async () => {
+	const [v4, v6, tasks] = await Promise.all([
+		run("netstat", [
+			"-ano",
+			"-p",
+			"TCP"
+		]),
+		run("netstat", [
+			"-ano",
+			"-p",
+			"TCPv6"
+		]),
+		run("tasklist", [
+			"/FO",
+			"CSV",
+			"/NH"
+		]).catch(() => "")
+	]);
+	const names = parseTasklist(tasks);
+	const entries = [...parseNetstat(v4), ...parseNetstat(v6)].map((entry) => ({
+		...entry,
+		command: entry.pid === void 0 ? void 0 : names.get(entry.pid)
+	}));
+	return {
+		cwds: /* @__PURE__ */ new Map(),
+		entries
+	};
+};
+const listListeningPorts = async (params = {}) => {
+	const collect = process.platform === "darwin" ? collectDarwin : process.platform === "linux" ? collectLinux : process.platform === "win32" ? collectWindows : void 0;
+	if (!collect) return {
+		ports: [],
+		supported: false
+	};
+	try {
+		const { cwds, entries } = await collect();
+		return {
+			ports: summarizeListeners(entries, {
+				cwd: params.cwd ? await realpath(params.cwd).catch(() => params.cwd) : void 0,
+				cwds,
+				ownPid: process.pid
+			}),
+			supported: true
+		};
+	} catch {
+		return {
+			ports: [],
+			supported: false
+		};
+	}
+};
+
 //#endregion
 //#region ../../packages/device-control/src/projectFileSearchManager.ts
 var import_out = /* @__PURE__ */ __toESM$2(require_out());
@@ -246808,6 +247225,7 @@ const executeDeviceRpc = async (method, params, deps) => {
 		case "getKimiCodeQuota": return getKimiCodeQuota(params);
 		case "listProjectSkills": return listProjectSkills(params, deps);
 		case "prepareSkillDirectory": return prepareSkillDirectory(params, deps);
+		case "listListeningPorts": return listListeningPorts(params);
 		case "browseDirectory": return browseDirectory(params);
 		case "statPath": return statPath(params);
 		case "getProjectFileIndex": return deps.getProjectFileIndex(params);
@@ -248905,7 +249323,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const EventEmitter$2 = __require("events");
 	const https = __require("https");
 	const http$2 = __require("http");
-	const net$1 = __require("net");
+	const net$2 = __require("net");
 	const tls = __require("tls");
 	const { randomBytes: randomBytes$1, createHash: createHash$2 } = __require("crypto");
 	const { Duplex: Duplex$3, Readable: Readable$1 } = __require("stream");
@@ -249651,7 +250069,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	*/
 	function netConnect(options) {
 		options.path = options.socketPath;
-		return net$1.connect(options);
+		return net$2.connect(options);
 	}
 	/**
 	* Create a `tls.TLSSocket` and initiate a connection.
@@ -249662,7 +250080,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	*/
 	function tlsConnect(options) {
 		options.path = void 0;
-		if (!options.servername && options.servername !== "") options.servername = net$1.isIP(options.host) ? "" : options.host;
+		if (!options.servername && options.servername !== "") options.servername = net$2.isIP(options.host) ? "" : options.host;
 		return tls.connect(options);
 	}
 	/**
@@ -250445,6 +250863,610 @@ var import_websocket = /* @__PURE__ */ __toESM$2(require_websocket(), 1);
 var import_websocket_server = /* @__PURE__ */ __toESM$2(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
+//#endregion
+//#region ../../packages/device-gateway-client/src/loopback.ts
+/**
+* Which loopback address actually answers on a port.
+*
+* The gateway pins tunnel targets to `127.0.0.1`, but plenty of dev servers
+* bind `localhost`, which newer Node resolves to `::1` only — `vite` with no
+* `--host` does exactly that on macOS. Dialing `127.0.0.1` then gets
+* ECONNREFUSED for a server that is plainly running. So before a tunnel dials
+* out, probe the port and fall back to `::1` when IPv4 refuses. Both are
+* loopback, so the security boundary is unchanged.
+*
+* Probing is a TCP connect-and-close, done before the real request so the
+* request itself (and any streamed body) is only ever sent once. Results are
+* cached briefly per port; a stale answer costs one failed request, after
+* which the cache entry is dropped.
+*/
+const PROBE_TIMEOUT_MS = 1e3;
+/** Every spelling of loopback a proxy exclusion list might need. */
+const LOOPBACK_NO_PROXY = [
+	"localhost",
+	"127.0.0.1",
+	"::1",
+	"[::1]"
+];
+/**
+* Make sure loopback traffic never goes to an HTTP proxy.
+*
+* A tunnel only ever dials this machine, but with `HTTP_PROXY` set, Node's
+* env-proxy mode (`NODE_USE_ENV_PROXY=1`) sends requests to the proxy unless
+* `NO_PROXY` matches the host — and the common `NO_PROXY=...,::1` does not
+* match the bracketed `[::1]` a URL carries, so the `::1` fallback below
+* would land on the proxy and come back as its 502. Adding every loopback
+* spelling is correct for any process: nothing should proxy loopback.
+*
+* Node reads these variables per request, so this takes effect immediately.
+* Bun snapshots them at startup, so a source run under `bun` with a proxy set
+* still needs `[::1]` in `NO_PROXY` from the environment.
+*/
+const ensureLoopbackBypassesProxy = (env = process.env) => {
+	if (![
+		"HTTP_PROXY",
+		"HTTPS_PROXY",
+		"http_proxy",
+		"https_proxy",
+		"ALL_PROXY",
+		"all_proxy"
+	].some((name) => !!env[name])) return;
+	const entries = [];
+	for (const name of ["NO_PROXY", "no_proxy"]) for (const entry of (env[name] ?? "").split(",")) {
+		const host = entry.trim();
+		if (host && !entries.includes(host)) entries.push(host);
+	}
+	for (const host of LOOPBACK_NO_PROXY) if (!entries.includes(host)) entries.push(host);
+	const merged = entries.join(",");
+	for (const name of ["NO_PROXY", "no_proxy"]) if (env[name] !== merged) env[name] = merged;
+};
+const CACHE_TTL_MS = 3e4;
+const tcpProbe = (host, port) => new Promise((resolve) => {
+	const socket = net.connect({
+		host,
+		port
+	});
+	const done = (ok) => {
+		socket.destroy();
+		resolve(ok);
+	};
+	socket.setTimeout(PROBE_TIMEOUT_MS, () => done(false));
+	socket.once("connect", () => done(true));
+	socket.once("error", () => done(false));
+});
+var LoopbackResolver = class {
+	cache = /* @__PURE__ */ new Map();
+	constructor(probe = tcpProbe) {
+		this.probe = probe;
+	}
+	/**
+	* The host to dial for `target`. Anything other than `127.0.0.1` passes
+	* through untouched; for `127.0.0.1` the answer is `::1` only when IPv4
+	* refuses and IPv6 accepts. If neither answers, `127.0.0.1` is returned so
+	* the real request produces the real error.
+	*/
+	async resolve(target) {
+		if (target.host !== "127.0.0.1") return target.host;
+		const cached = this.cache.get(target.port);
+		if (cached && cached.expires > Date.now()) return cached.host;
+		let host = "127.0.0.1";
+		if (!await this.probe("127.0.0.1", target.port) && await this.probe("::1", target.port)) host = "::1";
+		this.cache.set(target.port, {
+			expires: Date.now() + CACHE_TTL_MS,
+			host
+		});
+		return host;
+	}
+	/** Forget a port's answer, e.g. after a request to it failed to connect. */
+	forget(port) {
+		this.cache.delete(port);
+	}
+};
+
+//#endregion
+//#region ../../packages/device-gateway-client/src/types.ts
+/** Bytes per `tunnel_data` frame. */
+const TUNNEL_CHUNK_SIZE = 64 * 1024;
+/** Unacked bytes one side may have in flight before it must wait. */
+const TUNNEL_FLOW_WINDOW = 512 * 1024;
+/** Largest WebSocket message relayed either way; bigger closes with 1009. */
+const TUNNEL_WS_MAX_MESSAGE = 1024 * 1024;
+
+//#endregion
+//#region ../../packages/device-gateway-client/src/wsTunnel.ts
+const defaultFactory = (url, protocols) => new wrapper_default(url, protocols, {
+	handshakeTimeout: 1e4,
+	maxPayload: TUNNEL_WS_MAX_MESSAGE
+});
+/** Close codes a socket may legally send; anything else becomes 1000/1011. */
+const sendableCode = (code, fallback = 1e3) => code && (code >= 1e3 && code <= 1003 || code >= 1007 && code <= 1014 || code >= 3e3 && code <= 4999) ? code : fallback;
+/**
+* Relay backpressure. Frames to the gateway go through a socket whose `send`
+* never blocks, so a local app emitting faster than the uplink drains would
+* grow this process's memory without bound. Above the high mark the upstream
+* is paused (its TCP window then pushes back on the app) until the queue
+* drains below the low mark. The hard cap is a backstop for a queue that
+* keeps growing anyway — it closes the tunnel with 1013 "try again later".
+*/
+const WS_RELAY_HIGH_WATER = 4 * 1024 * 1024;
+const WS_RELAY_LOW_WATER = 1024 * 1024;
+const WS_RELAY_HARD_LIMIT = 32 * 1024 * 1024;
+const WS_RELAY_DRAIN_POLL_MS = 50;
+var DeviceWsTunnelHost = class {
+	tunnels = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	get activeCount() {
+		return this.tunnels.size;
+	}
+	open(frame) {
+		const { connId } = frame;
+		if (this.tunnels.has(connId)) return;
+		const tunnel = {
+			closed: false,
+			connId,
+			opened: false
+		};
+		this.tunnels.set(connId, tunnel);
+		this.dial(tunnel, frame);
+	}
+	async dial(tunnel, frame) {
+		const { connId, head, target } = frame;
+		const host = this.options.loopback ? await this.options.loopback.resolve(target) : target.host;
+		if (tunnel.closed) return;
+		const authority = host.includes(":") ? `[${host}]` : host;
+		let socket;
+		try {
+			socket = (this.options.createSocket ?? defaultFactory)(`ws://${authority}:${target.port}${head.path}`, head.protocols);
+		} catch (error) {
+			this.release(tunnel);
+			this.fail(connId, error);
+			return;
+		}
+		tunnel.socket = socket;
+		socket.on("open", () => {
+			tunnel.opened = true;
+			this.options.send({
+				connId,
+				ok: true,
+				...socket.protocol ? { protocol: socket.protocol } : {},
+				type: "tunnel_ws_open_ack"
+			});
+		});
+		socket.on("message", (data, isBinary) => {
+			if (tunnel.closed) return;
+			this.options.send({
+				...isBinary ? { binary: true } : {},
+				connId,
+				data: isBinary ? data.toString("base64") : data.toString("utf8"),
+				type: "tunnel_ws_message"
+			});
+			this.applyBackpressure(tunnel);
+		});
+		const forgetHost = () => this.options.loopback?.forget(target.port);
+		socket.on("close", (code, reason) => {
+			if (tunnel.closed) return;
+			this.release(tunnel);
+			if (!tunnel.opened) {
+				forgetHost();
+				this.options.send({
+					connId,
+					error: "UPSTREAM_CLOSED",
+					ok: false,
+					type: "tunnel_ws_open_ack"
+				});
+				return;
+			}
+			this.options.send({
+				code,
+				connId,
+				reason: reason.toString("utf8"),
+				type: "tunnel_ws_close"
+			});
+		});
+		socket.on("error", (error) => {
+			if (tunnel.closed) return;
+			if (!tunnel.opened) {
+				forgetHost();
+				this.release(tunnel);
+				this.fail(connId, error);
+				return;
+			}
+			this.options.logger.warn(`[tunnel] ws ${connId} upstream error: ${error.message}`);
+		});
+	}
+	/** A browser message for the upstream socket. */
+	message(frame) {
+		const tunnel = this.tunnels.get(frame.connId);
+		if (!tunnel?.socket || tunnel.closed || !tunnel.opened) return;
+		tunnel.socket.send(frame.binary ? Buffer$1.from(frame.data, "base64") : frame.data);
+	}
+	/** The browser side closed; close upstream to match. */
+	close(frame) {
+		const tunnel = this.tunnels.get(frame.connId);
+		if (!tunnel || tunnel.closed) return;
+		this.release(tunnel);
+		try {
+			tunnel.socket?.close(sendableCode(frame.code), (frame.reason ?? "").slice(0, 100));
+		} catch {
+			tunnel.socket?.terminate();
+		}
+	}
+	/** Drop every upstream socket, e.g. when the device socket goes away. */
+	closeAll() {
+		for (const tunnel of this.tunnels.values()) {
+			this.release(tunnel);
+			tunnel.socket?.terminate();
+		}
+	}
+	applyBackpressure(tunnel) {
+		const backlog = this.options.backlog?.() ?? 0;
+		if (backlog > 33554432) {
+			this.options.logger.warn(`[tunnel] ws ${tunnel.connId} relay backlog ${backlog}B, closing`);
+			this.release(tunnel);
+			tunnel.socket?.close(1013, "RELAY_BACKLOG");
+			this.options.send({
+				code: 1013,
+				connId: tunnel.connId,
+				reason: "RELAY_BACKLOG",
+				type: "tunnel_ws_close"
+			});
+			return;
+		}
+		if (backlog <= 4194304 || tunnel.drainTimer) return;
+		tunnel.socket?.pause();
+		tunnel.drainTimer = setInterval(() => {
+			if (tunnel.closed) return;
+			if ((this.options.backlog?.() ?? 0) > 1048576) return;
+			clearInterval(tunnel.drainTimer);
+			tunnel.drainTimer = void 0;
+			tunnel.socket?.resume();
+		}, WS_RELAY_DRAIN_POLL_MS);
+	}
+	/** Mark closed, forget it, and stop any drain polling. */
+	release(tunnel) {
+		tunnel.closed = true;
+		this.tunnels.delete(tunnel.connId);
+		if (tunnel.drainTimer) {
+			clearInterval(tunnel.drainTimer);
+			tunnel.drainTimer = void 0;
+		}
+	}
+	fail(connId, error) {
+		const code = error && typeof error === "object" && "code" in error ? String(error.code) : void 0;
+		this.options.send({
+			connId,
+			error: code ?? (error instanceof Error ? error.message : "TUNNEL_WS_OPEN_FAILED"),
+			ok: false,
+			type: "tunnel_ws_open_ack"
+		});
+	}
+};
+
+//#endregion
+//#region ../../packages/device-gateway-client/src/tunnel.ts
+/**
+* Device half of the HTTP tunnel: turns the gateway's tunnel frames into a real
+* HTTP request against a loopback port on this machine and streams the response
+* back frame by frame.
+*
+* The gateway owns the browser-facing HTTP semantics (auth, ingress URLs,
+* header sanitising) and pins the target host, so this side only has to be a
+* faithful, well-paced HTTP client.
+*/
+/** Only loopback targets are servable — defence in depth behind the gateway's pin. */
+const LOOPBACK_HOSTS$1 = new Set([
+	"127.0.0.1",
+	"::1",
+	"localhost"
+]);
+/**
+* Response headers that describe the *upstream* transfer and no longer hold
+* once the body has been decoded and re-framed. `content-encoding` matters
+* most: `fetch` transparently gunzips, so forwarding it would hand the browser
+* decoded bytes labelled as compressed.
+*/
+const RESPONSE_HEADER_DENYLIST = new Set([
+	"connection",
+	"content-encoding",
+	"content-length",
+	"keep-alive",
+	"trailer",
+	"transfer-encoding",
+	"upgrade"
+]);
+const noopLogger$1 = {
+	debug: () => {},
+	error: () => {},
+	info: () => {},
+	warn: () => {}
+};
+const describeError = (error) => {
+	if (error && typeof error === "object") {
+		const { cause, code, message } = error;
+		const causeCode = cause && typeof cause === "object" ? cause.code : void 0;
+		return code ?? causeCode ?? message ?? "TUNNEL_ERROR";
+	}
+	return String(error ?? "TUNNEL_ERROR");
+};
+var DeviceTunnelHost = class {
+	connections = /* @__PURE__ */ new Map();
+	fetchImpl;
+	logger;
+	maxConcurrent;
+	send;
+	loopback;
+	sockets;
+	constructor(options) {
+		this.fetchImpl = options.fetchImpl ?? ((url, init) => globalThis.fetch(url, init));
+		this.logger = options.logger ?? noopLogger$1;
+		this.maxConcurrent = options.maxConcurrent ?? 32;
+		this.send = options.send;
+		this.loopback = options.loopback ?? new LoopbackResolver();
+		ensureLoopbackBypassesProxy();
+		this.sockets = new DeviceWsTunnelHost({
+			loopback: this.loopback,
+			backlog: options.backlog,
+			createSocket: options.createUpstreamSocket,
+			logger: this.logger,
+			send: options.send
+		});
+	}
+	/** HTTP requests and WebSockets in flight; both count against the limit. */
+	get activeCount() {
+		return this.connections.size + this.sockets.activeCount;
+	}
+	handleFrame(frame) {
+		switch (frame.type) {
+			case "tunnel_open":
+				this.handleOpen(frame);
+				return;
+			case "tunnel_data": {
+				const conn = this.connections.get(frame.connId);
+				if (!conn || conn.closed) return;
+				if (frame.data) {
+					const bytes = Buffer$1.from(frame.data, "base64");
+					if (conn.bodyless) this.send({
+						bytes: bytes.byteLength,
+						connId: frame.connId,
+						type: "tunnel_ack"
+					});
+					else conn.bodyQueue.push(new Uint8Array(bytes));
+				}
+				if (frame.fin) conn.bodyFin = true;
+				this.wakeBody(conn);
+				return;
+			}
+			case "tunnel_ack":
+				this.ack(frame.connId, frame.bytes);
+				return;
+			case "tunnel_close":
+				this.closeConnection(frame.connId, frame.reason ?? "PEER_CLOSED", false);
+				return;
+			case "tunnel_ws_open": {
+				const refusal = this.refuse(frame.target.host);
+				if (refusal) {
+					this.send({
+						connId: frame.connId,
+						error: refusal,
+						ok: false,
+						type: "tunnel_ws_open_ack"
+					});
+					return;
+				}
+				this.sockets.open(frame);
+				return;
+			}
+			case "tunnel_ws_message":
+				this.sockets.message(frame);
+				return;
+			case "tunnel_ws_close":
+				this.sockets.close(frame);
+				return;
+			default: return;
+		}
+	}
+	/** Abort every in-flight tunnel, e.g. when the device socket drops. */
+	closeAll(reason) {
+		for (const connId of this.connections.keys()) this.closeConnection(connId, reason, false);
+		this.sockets.closeAll();
+	}
+	/** Why an open must be refused, or undefined when it may proceed. */
+	refuse(host) {
+		if (!LOOPBACK_HOSTS$1.has(host)) return "TUNNEL_TARGET_NOT_LOOPBACK";
+		if (this.activeCount >= this.maxConcurrent) return "TUNNEL_LIMIT_REACHED";
+	}
+	handleOpen(frame) {
+		const { connId, head, target } = frame;
+		if (this.connections.has(connId)) return;
+		const refusal = this.refuse(target.host);
+		if (refusal) {
+			this.send({
+				connId,
+				error: refusal,
+				ok: false,
+				type: "tunnel_open_ack"
+			});
+			return;
+		}
+		const method = head.method.toUpperCase();
+		const conn = {
+			abort: new AbortController(),
+			bodyFin: false,
+			bodyless: method === "GET" || method === "HEAD",
+			bodyQueue: [],
+			bodyWaiters: [],
+			closed: false,
+			connId,
+			headSent: false,
+			seq: 0,
+			unacked: 0,
+			waiters: []
+		};
+		this.connections.set(connId, conn);
+		this.serve(conn, head, target).catch((error) => {
+			this.logger.warn(`[tunnel] ${connId} failed: ${describeError(error)}`);
+		});
+	}
+	async serve(conn, head, target) {
+		const body = conn.bodyless ? void 0 : new ReadableStream({
+			cancel: () => {
+				conn.bodyQueue.length = 0;
+				this.wakeBody(conn);
+			},
+			pull: async (controller) => {
+				while (conn.bodyQueue.length === 0 && !conn.bodyFin && !conn.closed) await new Promise((resolve) => conn.bodyWaiters.push(resolve));
+				if (conn.closed) throw new Error("TUNNEL_CLOSED");
+				const chunk = conn.bodyQueue.shift();
+				if (!chunk) {
+					controller.close();
+					return;
+				}
+				controller.enqueue(chunk);
+				this.send({
+					bytes: chunk.byteLength,
+					connId: conn.connId,
+					type: "tunnel_ack"
+				});
+			}
+		}, { highWaterMark: 0 });
+		try {
+			const host = await this.loopback.resolve(target);
+			const authority = host.includes(":") ? `[${host}]` : host;
+			const response = await this.fetchImpl(`http://${authority}:${target.port}${head.path}`, {
+				body,
+				...body ? { duplex: "half" } : {},
+				headers: head.headers,
+				method: head.method.toUpperCase(),
+				redirect: "manual",
+				signal: conn.abort.signal
+			});
+			if (conn.closed) return;
+			this.send({
+				connId: conn.connId,
+				head: {
+					headers: collectResponseHeaders(response.headers),
+					status: response.status
+				},
+				ok: true,
+				type: "tunnel_open_ack"
+			});
+			conn.headSent = true;
+			if (response.body) {
+				const reader = response.body.getReader();
+				try {
+					for (;;) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						if (conn.closed) return;
+						await this.sendBodyChunk(conn, value);
+					}
+				} finally {
+					reader.releaseLock();
+				}
+			}
+			if (conn.closed) return;
+			conn.seq += 1;
+			this.send({
+				connId: conn.connId,
+				data: "",
+				fin: true,
+				seq: conn.seq,
+				type: "tunnel_data"
+			});
+			this.dropConnection(conn.connId);
+		} catch (error) {
+			if (conn.closed) return;
+			const reason = describeError(error);
+			if (!conn.headSent) this.loopback.forget(target.port);
+			if (conn.headSent) this.send({
+				connId: conn.connId,
+				reason,
+				type: "tunnel_close"
+			});
+			else this.send({
+				connId: conn.connId,
+				error: reason,
+				ok: false,
+				type: "tunnel_open_ack"
+			});
+			this.dropConnection(conn.connId);
+		}
+	}
+	/** Split into protocol-sized frames and pace them against the flow window. */
+	async sendBodyChunk(conn, chunk) {
+		for (let offset = 0; offset < chunk.byteLength; offset += TUNNEL_CHUNK_SIZE) {
+			const slice = chunk.subarray(offset, offset + TUNNEL_CHUNK_SIZE);
+			while (conn.unacked >= 524288 && !conn.closed) await new Promise((resolve) => conn.waiters.push(resolve));
+			if (conn.closed) return;
+			conn.seq += 1;
+			conn.unacked += slice.byteLength;
+			this.send({
+				connId: conn.connId,
+				data: Buffer$1.from(slice.buffer, slice.byteOffset, slice.byteLength).toString("base64"),
+				seq: conn.seq,
+				type: "tunnel_data"
+			});
+		}
+	}
+	/** Gateway acked delivered bytes — refill the window and wake parked senders. */
+	ack(connId, bytes) {
+		const conn = this.connections.get(connId);
+		if (!conn) return;
+		conn.unacked = Math.max(0, conn.unacked - bytes);
+		this.wake(conn);
+	}
+	closeConnection(connId, reason, notify) {
+		const conn = this.connections.get(connId);
+		if (!conn) return;
+		conn.closed = true;
+		conn.abort.abort();
+		conn.bodyQueue.length = 0;
+		this.wakeBody(conn);
+		this.wake(conn);
+		this.connections.delete(connId);
+		if (notify) this.send({
+			connId,
+			reason,
+			type: "tunnel_close"
+		});
+	}
+	dropConnection(connId) {
+		const conn = this.connections.get(connId);
+		if (!conn) return;
+		conn.closed = true;
+		this.wake(conn);
+		this.wakeBody(conn);
+		this.connections.delete(connId);
+	}
+	wake(conn) {
+		const waiters = conn.waiters;
+		conn.waiters = [];
+		for (const waiter of waiters) waiter();
+	}
+	wakeBody(conn) {
+		const waiters = conn.bodyWaiters;
+		conn.bodyWaiters = [];
+		for (const waiter of waiters) waiter();
+	}
+};
+/**
+* Flatten response headers, keeping every `set-cookie` separate (the Headers
+* API folds them into one comma-joined value, which breaks cookie parsing).
+*/
+const collectResponseHeaders = (headers) => {
+	const out = [];
+	headers.forEach((value, name) => {
+		const lower = name.toLowerCase();
+		if (RESPONSE_HEADER_DENYLIST.has(lower) || lower === "set-cookie") return;
+		out.push([name, value]);
+	});
+	const setCookies = headers.getSetCookie?.() ?? [];
+	for (const cookie of setCookies) out.push(["set-cookie", cookie]);
+	return out;
+};
+
 //#endregion
 //#region ../../packages/device-gateway-client/src/client.ts
 const DEFAULT_GATEWAY_URL = "https://device-gateway.lobehub.com";
@@ -250467,6 +251489,7 @@ const noopLogger = {
 };
 var GatewayClient = class extends EventEmitter {
 	ws = null;
+	tunnelHost = null;
 	heartbeatTimer = null;
 	reconnectTimer = null;
 	connectWatchdogTimer = null;
@@ -250502,6 +251525,11 @@ var GatewayClient = class extends EventEmitter {
 		this.logger = options.logger || noopLogger;
 		this.autoReconnect = options.autoReconnect ?? true;
 		this.connectTimeoutMs = options.connectTimeoutMs ?? CONNECT_TIMEOUT;
+		if (options.tunnel !== false) this.tunnelHost = new DeviceTunnelHost({
+			backlog: () => this.ws?.bufferedAmount ?? 0,
+			logger: this.logger,
+			send: (frame) => this.sendMessage(frame)
+		});
 	}
 	get connectionStatus() {
 		return this.status;
@@ -250682,6 +251710,21 @@ var GatewayClient = class extends EventEmitter {
 					this.logger.warn("Received auth_expired from gateway");
 					this.emit("auth_expired");
 					break;
+				case "tunnel_open":
+				case "tunnel_data":
+				case "tunnel_ack":
+				case "tunnel_close":
+				case "tunnel_ws_open":
+				case "tunnel_ws_message":
+				case "tunnel_ws_close":
+					if (this.tunnelHost) this.tunnelHost.handleFrame(message);
+					else if (message.type === "tunnel_open" || message.type === "tunnel_ws_open") this.sendMessage({
+						connId: message.connId,
+						error: "TUNNEL_DISABLED",
+						ok: false,
+						type: message.type === "tunnel_open" ? "tunnel_open_ack" : "tunnel_ws_open_ack"
+					});
+					break;
 				default: this.logger.warn("Unknown message type:", message.type);
 			}
 		} catch (error) {
@@ -250691,6 +251734,7 @@ var GatewayClient = class extends EventEmitter {
 	handleClose = (code, reason) => {
 		this.logger.info(`WebSocket closed: code=${code} reason=${reason.toString()}`);
 		this.stopHeartbeat();
+		this.tunnelHost?.closeAll("DEVICE_DISCONNECTED");
 		this.clearConnectWatchdog();
 		this.ws = null;
 		if (!this.intentionalDisconnect && this.autoReconnect) {
@@ -250781,6 +251825,7 @@ var GatewayClient = class extends EventEmitter {
 		if (this.ws?.readyState === wrapper_default.OPEN) this.ws.send(JSON.stringify(data));
 	}
 	closeWebSocket() {
+		this.tunnelHost?.closeAll("DEVICE_DISCONNECTED");
 		if (!this.ws) return;
 		const ws = this.ws;
 		const suppressCloseError = (error) => {
@@ -250969,6 +252014,31 @@ const parsePiModelCatalog = (stdout) => {
 	return models;
 };
 /**
+* Parse the JSON emitted by `kimi provider list --json`. The `-m` flag accepts
+* the model alias (the `models` table key), so the alias is the catalog id.
+*/
+const parseKimiCodeModelCatalog = (stdout) => {
+	let result;
+	try {
+		result = JSON.parse(stdout);
+	} catch {
+		return [];
+	}
+	if (!isRecord$6(result) || !isRecord$6(result.models)) return [];
+	const models = [];
+	for (const [alias, entry] of Object.entries(result.models)) {
+		if (!alias || !isRecord$6(entry) || typeof entry.model !== "string" || !entry.model) continue;
+		const separatorIndex = alias.indexOf("/");
+		models.push({
+			id: alias,
+			...typeof entry.displayName === "string" && entry.displayName ? { label: entry.displayName } : void 0,
+			modelId: entry.model,
+			providerId: separatorIndex > 0 ? alias.slice(0, separatorIndex) : alias
+		});
+	}
+	return models;
+};
+/**
 * Parse the one-column table emitted by `qodercli --list-models`.
 * Built-in models are selected by name; custom models append their modelID in
 * parentheses and must be selected by that id.
@@ -251050,7 +252120,11 @@ const listHeterogeneousAgentModels = async (params) => {
 			"list",
 			"--format",
 			"json"
-		] : params.type === "grok-build" || params.type === "opencode" ? ["models"] : ["--list-models"];
+		] : params.type === "grok-build" || params.type === "opencode" ? ["models"] : params.type === "kimi-code" ? [
+			"provider",
+			"list",
+			"--json"
+		] : ["--list-models"];
 		const spawnPlan = await resolveCliSpawnPlan(resolved.command, args);
 		const { stderr, stdout } = await execFilePromise(spawnPlan.command, spawnPlan.args, {
 			cwd: params.cwd,
@@ -251077,7 +252151,7 @@ const listHeterogeneousAgentModels = async (params) => {
 			};
 		}
 		return {
-			models: params.type === "cursor" ? parseCursorModelCatalog(String(stdout)) : params.type === "devin" ? parseDevinModelCatalog(String(stdout)) : params.type === "grok-build" ? parseGrokBuildModelCatalog(String(stdout)) : params.type === "pi" ? parsePiModelCatalog(String(stdout)) : params.type === "qoder" ? parseQoderModelCatalog(String(stdout)) : parseOpenCodeModelCatalog(String(stdout)),
+			models: params.type === "cursor" ? parseCursorModelCatalog(String(stdout)) : params.type === "devin" ? parseDevinModelCatalog(String(stdout)) : params.type === "grok-build" ? parseGrokBuildModelCatalog(String(stdout)) : params.type === "kimi-code" ? parseKimiCodeModelCatalog(String(stdout)) : params.type === "pi" ? parsePiModelCatalog(String(stdout)) : params.type === "qoder" ? parseQoderModelCatalog(String(stdout)) : parseOpenCodeModelCatalog(String(stdout)),
 			status: "success",
 			updatedAt
 		};
@@ -286195,7 +287269,7 @@ async function verifyWindowsWfpEgress(opts = {}) {
 	if (!target) {
 		const [lo, hi] = opts.proxyPortRange ?? DEFAULT_WINDOWS_PROXY_PORT_RANGE;
 		for (let i = 0; i < 5; i++) {
-			const s = net.createServer();
+			const s = net$1.createServer();
 			s.listen(0, "127.0.0.1");
 			await once(s, "listening");
 			const p = s.address().port;
@@ -292510,7 +293584,7 @@ async function resolveToken(options) {
 		}
 	}
 	const result = await getValidToken();
-	if (result) {
+	if (result.status === "ok") {
 		log$12.debug("Using stored credentials");
 		const { credentials } = result;
 		const serverUrl = resolveServerUrl();
@@ -292526,7 +293600,8 @@ async function resolveToken(options) {
 			userId
 		};
 	}
-	log$12.error(`No authentication found. Run '${"lh"} login' first, or set ${CLI_API_KEY_ENV}, or provide --token.`);
+	const report = describeTokenLookup(result);
+	log$12.error(report ? `${report.detail} ${report.fix}` : `No authentication found. Run '${"lh"} login' first, or set ${CLI_API_KEY_ENV}, or provide --token.`);
 	process.exit(1);
 }
 
@@ -506431,10 +507506,14 @@ async function probeCredential(ctx) {
 		}
 		if (source.kind === "stored") {
 			const refreshed = await getValidToken();
-			if (!refreshed) return {
-				...base,
-				error: source.token ? "the stored token has expired and could not be refreshed" : "no stored login on this machine"
-			};
+			if (refreshed.status !== "ok") {
+				const report = describeTokenLookup(refreshed);
+				return {
+					...base,
+					error: report?.detail ?? (source.token ? "the stored token has expired and could not be refreshed" : "no stored login on this machine"),
+					fix: report?.fix
+				};
+			}
 			const payload = parseJwtPayload(refreshed.credentials.accessToken);
 			return {
 				...base,
@@ -506545,9 +507624,9 @@ const credentialValidity = {
 			userId: credential.userId
 		};
 		if (credential.error) return {
-			detail: `${credential.origin} cannot be used: ${credential.error}.`,
+			detail: `${credential.origin} cannot be used: ${credential.error.replace(/\.$/, "")}.`,
 			evidence,
-			fix: credential.kind === "env-api-key" ? `Issue a fresh key and re-export ${CLI_API_KEY_ENV}.` : `Run '${"lh"} login' again.`,
+			fix: credential.fix ?? (credential.kind === "env-api-key" ? `Issue a fresh key and re-export ${CLI_API_KEY_ENV}.` : `Run '${"lh"} login' again.`),
 			status: "fail"
 		};
 		if (!credential.userId) return {
@@ -506978,6 +508057,7 @@ const gatewayHandshake = {
 				autoReconnect: false,
 				gatewayUrl,
 				serverUrl: credential.serverUrl,
+				tunnel: false,
 				token: credential.token,
 				tokenType: credential.tokenType,
 				userId: credential.userId
@@ -526172,7 +527252,8 @@ function registerLoginCommand(program) {
 		if (apiKey) try {
 			await getUserIdFromApiKey(apiKey, serverUrl);
 			const existingSettings = loadSettings();
-			saveSettings(existingSettings?.serverUrl === serverUrl ? {
+			const existingServerUrl = existingSettings?.serverUrl || OFFICIAL_SERVER_URL;
+			saveSettings(!!existingSettings && existingServerUrl === serverUrl ? {
 				gatewayUrl: existingSettings.gatewayUrl,
 				serverUrl
 			} : { serverUrl });
@@ -526257,7 +527338,8 @@ function registerLoginCommand(program) {
 						refreshToken: body.refresh_token
 					});
 					const existingSettings = loadSettings();
-					saveSettings(existingSettings?.serverUrl === serverUrl ? {
+					const existingServerUrl = existingSettings?.serverUrl || OFFICIAL_SERVER_URL;
+					saveSettings(!!existingSettings && existingServerUrl === serverUrl ? {
 						gatewayUrl: existingSettings.gatewayUrl,
 						serverUrl
 					} : { serverUrl });
@@ -526489,11 +527571,7 @@ function registerMemoryCommand(program) {
 		const client = await getTrpcClient();
 		const categoriesToFetch = category ? [category] : [...CATEGORIES];
 		const allResults = {};
-		for (const cat of categoriesToFetch) try {
-			allResults[cat] = await fetchCategory(client, cat);
-		} catch {
-			allResults[cat] = [];
-		}
+		for (const cat of categoriesToFetch) allResults[cat] = await fetchCategory(client, cat);
 		if (options.json !== void 0) {
 			const fields = typeof options.json === "string" ? options.json : void 0;
 			outputJson(category ? allResults[category] : allResults, fields);
@@ -528564,6 +529642,7 @@ function registerStatusCommand(program) {
 			gatewayUrl: gatewayUrl || OFFICIAL_GATEWAY_URL,
 			logger: log$12,
 			serverUrl: auth.serverUrl,
+			tunnel: false,
 			token: auth.token,
 			tokenType: auth.tokenType,
 			userId: auth.userId
@@ -530938,8 +532017,70 @@ function ensureAcceptanceDirIgnoredFor(roundDir) {
 //#endregion
 //#region src/utils/skillWiring.ts
 const AGENTS_SKILLS_DIR = path.join(".agents", "skills");
-function detectClaudeHarness(baseDir) {
-	return existsSync(path.join(baseDir, "CLAUDE.md")) || existsSync(path.join(baseDir, ".claude"));
+/**
+* Harness dirs wired onto `.agents/skills`. Two reasons a dir is listed:
+*
+*  - the harness does not scan `.agents/skills` natively (Claude Code's
+*    `.claude/skills`, OpenCode's `.opencode/skill`, Windsurf's
+*    `.windsurf/skills`, Roo Code's `.roo/skills`), or
+*  - another harness compatibility-reads it (Cursor reads `.codex/skills` and
+*    `.claude/skills`, so a repo already carrying `.codex` config gets wired).
+*
+* Codex, Cursor, Gemini CLI, Copilot/VS Code and Amp all read `.agents/skills`
+* directly (Cursor additionally reads its own `.cursor/skills`, wired above).
+* `.github` is deliberately absent: it exists in almost every repo (workflows)
+* and Copilot already reads `.agents/skills`, so wiring it would be pure noise.
+*/
+const HARNESSES = [
+	{
+		dir: ".claude",
+		name: "claude",
+		signals: ["CLAUDE.md", ".claude"],
+		skillsSubdir: "skills"
+	},
+	{
+		dir: ".codex",
+		name: "codex",
+		signals: [".codex"],
+		skillsSubdir: "skills"
+	},
+	{
+		dir: ".cursor",
+		name: "cursor",
+		signals: [".cursor"],
+		skillsSubdir: "skills"
+	},
+	{
+		dir: ".gemini",
+		name: "gemini",
+		signals: [".gemini", "GEMINI.md"],
+		skillsSubdir: "skills"
+	},
+	{
+		dir: ".opencode",
+		name: "opencode",
+		signals: [
+			".opencode",
+			"opencode.json",
+			"opencode.jsonc"
+		],
+		skillsSubdir: "skill"
+	},
+	{
+		dir: ".roo",
+		name: "roo",
+		signals: [".roo"],
+		skillsSubdir: "skills"
+	},
+	{
+		dir: ".windsurf",
+		name: "windsurf",
+		signals: [".windsurf"],
+		skillsSubdir: "skills"
+	}
+];
+function detectHarness(baseDir, harness) {
+	return harness.signals.some((signal) => existsSync(path.join(baseDir, signal)));
 }
 function isSymlink(target) {
 	try {
@@ -530948,18 +532089,13 @@ function isSymlink(target) {
 		return false;
 	}
 }
-/**
-* `.agents/skills` is the single materialized copy; every other harness dir is a
-* symlink onto it, so one install/update reaches all of them.
-*/
-function linkHarnessSkills(baseDir, skillId) {
-	if (!detectClaudeHarness(baseDir)) return { kind: "none" };
-	const claudeDir = path.join(baseDir, ".claude");
-	const link = path.join(claudeDir, "skills");
-	const rel = path.join(".claude", "skills");
+function linkOneHarness(baseDir, skillId, harness) {
+	const harnessDir = path.join(baseDir, harness.dir);
+	const link = path.join(harnessDir, harness.skillsSubdir);
+	const rel = path.join(harness.dir, harness.skillsSubdir);
 	if (isSymlink(link)) {
 		const current = readlinkSync(link);
-		if (path.resolve(claudeDir, current) === path.join(baseDir, AGENTS_SKILLS_DIR)) return {
+		if (path.resolve(harnessDir, current) === path.join(baseDir, AGENTS_SKILLS_DIR)) return {
 			kind: "already",
 			link: rel
 		};
@@ -530969,7 +532105,7 @@ function linkHarnessSkills(baseDir, skillId) {
 			reason: `already a symlink to ${current} — leaving it alone`
 		};
 	}
-	mkdirSync(claudeDir, { recursive: true });
+	mkdirSync(harnessDir, { recursive: true });
 	if (existsSync(link)) {
 		const single = path.join(link, skillId);
 		if (isSymlink(single) || existsSync(single)) return {
@@ -531008,6 +532144,15 @@ function linkHarnessSkills(baseDir, skillId) {
 		target
 	};
 }
+/**
+* `.agents/skills` is the single materialized copy; every detected harness dir
+* is a symlink onto it, so one install/update reaches all of them.
+*/
+function linkHarnessSkills(baseDir, skillId) {
+	const detected = HARNESSES.filter((harness) => detectHarness(baseDir, harness));
+	if (detected.length === 0) return [{ kind: "none" }];
+	return detected.map((harness) => linkOneHarness(baseDir, skillId, harness));
+}
 
 //#endregion
 //#region ../../packages/utils/src/verify/interactionCost.ts
@@ -531832,6 +532977,84 @@ function evidenceDescriptionForFile(description, file) {
 	return description?.trim() || (file ? path.basename(file) : void 0);
 }
 
+//#endregion
+//#region src/commands/acceptanceEvidence.ts
+/** Upload and attach independently: a failed artifact must not discard the report. */
+async function uploadReportEvidence(client, params) {
+	const failedEvidence = [];
+	const types = /* @__PURE__ */ new Set();
+	let count = 0;
+	let inlined = 0;
+	for (const input of reportEvidence(params.evidence)) {
+		const absolutePath = path.resolve(params.dir, input.path);
+		const type = evidenceTypeForFile(absolutePath);
+		const description = evidenceDescriptionForFile(input.description, absolutePath);
+		const metadata = input.comparison ? { comparison: input.comparison } : void 0;
+		let fileId;
+		let missing = false;
+		try {
+			try {
+				await access(absolutePath);
+			} catch (error) {
+				missing = error.code === "ENOENT";
+				throw error;
+			}
+			const content = inlineTextEvidenceForFile(absolutePath, type);
+			if (content === void 0) fileId = (await uploadLocalFile(client, absolutePath)).id;
+			await client.verify.uploadEvidence.mutate({
+				capturedBy: "cli",
+				checkResultId: params.checkResultId,
+				content,
+				description,
+				fileId,
+				metadata,
+				type
+			});
+			types.add(type);
+			count += 1;
+			if (content !== void 0) inlined += 1;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			const reason = missing ? "file_missing" : message.includes("storage_block:") ? "storage_quota" : "upload_failed";
+			const args = [
+				"--check",
+				params.checkResultId,
+				"--type",
+				type,
+				...fileId ? ["--file-id", fileId] : ["--file", absolutePath],
+				"--desc",
+				description,
+				...metadata ? ["--metadata", JSON.stringify(metadata)] : []
+			];
+			const retryCommand = `lh acceptance run evidence upload ${args.map((arg) => `'${arg.replaceAll("'", "'\\''")}'`).join(" ")}`;
+			failedEvidence.push({
+				checkResultId: params.checkResultId,
+				error: message,
+				fileId,
+				path: absolutePath,
+				reason,
+				retryArgs: [
+					"acceptance",
+					"run",
+					"evidence",
+					"upload",
+					...args
+				],
+				retryCommand,
+				retryCommandShell: "posix",
+				type
+			});
+			log$12.warn(`evidence not published: ${path.basename(absolutePath)}: ${message}`);
+		}
+	}
+	return {
+		count,
+		failedEvidence,
+		inlined,
+		types
+	};
+}
+
 //#endregion
 //#region src/commands/acceptanceRun.ts
 const listMaterializedFiles = (directory) => {
@@ -531874,11 +533097,13 @@ async function installAction(options) {
 			removed.push(relativePath.split(path.sep).join("/"));
 		}
 	}
-	const link = linkHarnessSkills(baseDir, bundle.identifier);
+	const links = linkHarnessSkills(baseDir, bundle.identifier);
+	const link = links.find((l) => "link" in l && l.link.startsWith(".claude")) ?? { kind: "none" };
 	const result = {
 		dir: skillDir,
 		ignored: ensureAcceptanceDirIgnored(baseDir),
 		link,
+		links,
 		removed,
 		skill: bundle.identifier,
 		skipped,
@@ -531894,11 +533119,11 @@ async function installAction(options) {
 	console.log(`${import_picocolors.default.green("✓")} ${import_picocolors.default.bold(bundle.name)}${versionLabel} skill → ${import_picocolors.default.dim(path.relative(process.cwd(), skillDir) || skillDir)}`);
 	console.log(`  ${written.length} written${skipped.length ? `, ${skipped.length} skipped` : ""}${removed.length ? `, ${removed.length} stale removed` : ""}`);
 	if (skipped.length > 0) console.log(import_picocolors.default.dim(`  (skipped existing — pass --force to overwrite)`));
-	printWiring(link);
+	printWiring(links);
 }
-function printWiring(link) {
+function printWiring(links) {
 	const arrow = import_picocolors.default.dim("  ↳");
-	switch (link.kind) {
+	for (const link of links) switch (link.kind) {
 		case "linked":
 		case "linked-single":
 			console.log(`${arrow} linked ${link.link} → ${import_picocolors.default.dim(link.target)}`);
@@ -531909,7 +533134,9 @@ function printWiring(link) {
 		case "skipped":
 			console.log(`${arrow} ${import_picocolors.default.yellow(`skipped ${link.link}: ${link.reason}`)}`);
 			break;
-		default: break;
+		default:
+			console.log(`${arrow} ${import_picocolors.default.dim("no harness dirs detected — agents that read .agents/skills pick it up automatically")}`);
+			break;
 	}
 }
 async function runCreateAction(options) {
@@ -532070,12 +533297,17 @@ async function decisionAction(resultId, decision) {
 	console.log(`${import_picocolors.default.green("✓")} Recorded ${import_picocolors.default.bold(decision)} on result ${import_picocolors.default.bold(resultId)}`);
 }
 async function evidenceUploadAction(options) {
-	if (Boolean(options.file) === Boolean(options.content)) {
-		log$12.error("Provide exactly one of --file or --content");
+	if ([
+		options.file,
+		options.content,
+		options.fileId
+	].filter(Boolean).length !== 1) {
+		log$12.error("Provide exactly one of --file, --file-id or --content");
 		process.exit(1);
 	}
+	const metadata = options.metadata ? JSON.parse(options.metadata) : void 0;
 	const client = await getTrpcClient();
-	let fileId;
+	let fileId = options.fileId;
 	let inlineContent = options.content;
 	if (options.file) {
 		inlineContent = inlineTextEvidenceForFile(options.file, options.type);
@@ -532087,6 +533319,7 @@ async function evidenceUploadAction(options) {
 		content: inlineContent,
 		description: evidenceDescriptionForFile(options.desc, options.file),
 		fileId,
+		metadata,
 		type: options.type
 	});
 	if (options.json !== void 0) {
@@ -532243,6 +533476,17 @@ async function ingestReportAction(reportDir, options) {
 	if (requestedAcceptanceId) {
 		const bundle = await client.acceptance.getBundle.query({ id: requestedAcceptanceId });
 		acceptance = bundle.acceptance;
+		const currentWorkspaceId = resolveWorkspaceId();
+		const targetWorkspaceId = acceptance.workspaceId ?? void 0;
+		if (currentWorkspaceId !== targetWorkspaceId) {
+			const current = currentWorkspaceId ? `workspace "${currentWorkspaceId}"` : "personal space";
+			const target = targetWorkspaceId ? `workspace "${targetWorkspaceId}"` : "personal space";
+			const hint = targetWorkspaceId ? `Set LOBEHUB_WORKSPACE_ID=${targetWorkspaceId} for this command and retry.` : "Unset LOBEHUB_WORKSPACE_ID and run 'lh workspace use --personal', then retry.";
+			throw new Error(`Acceptance "${acceptance.id}" belongs to ${target}, but the CLI is using ${current}. ${hint} No run was created.`);
+		}
+		if (targetWorkspaceId) {
+			if ((await client.workspace.getById.query())?.id !== targetWorkspaceId) throw new Error(`The server did not resolve workspace "${targetWorkspaceId}" for this account. Check your access with 'lh workspace list' before retrying. No run was created.`);
+		}
 		plan = plan?.map((item) => ({
 			...item,
 			sourceCriterionId: item.sourceCriterionId ?? bundle.checks?.find((check) => check.id === item.id || check.planItem?.id === item.id)?.planItem?.sourceCriterionId ?? void 0
@@ -532280,6 +533524,7 @@ async function ingestReportAction(reportDir, options) {
 		acceptanceId,
 		verifyRunId: run.id
 	});
+	plan = attached?.plan ?? plan;
 	const runId = attached?.id ?? run.id;
 	if (runId !== run.id) console.log(import_picocolors.default.dim(`Folded into the acceptance's draft round ${attached.roundIndex ?? ""}`));
 	const roundIndex = attached?.roundIndex ?? null;
@@ -532288,11 +533533,14 @@ async function ingestReportAction(reportDir, options) {
 	const seenCheckItemIds = /* @__PURE__ */ new Set();
 	let evidenceCount = 0;
 	let inlined = 0;
+	const failedEvidence = [];
+	const missingEvidence = [];
+	const publishedVerdicts = [];
 	for (const [index, { case: c, checkItemId }] of cases.entries()) {
 		seenCheckItemIds.add(checkItemId);
 		const verdict = toVerdict(c.result ?? c.status ?? c.verdict);
 		const observation = c.keyObservation ?? c.observation ?? c.note;
-		const checkResult = await client.verify.ingestResult.mutate({
+		const checkInput = {
 			checkItemId,
 			checkItemIndex: index,
 			checkItemTitle: c.name ?? c.case ?? c.title ?? checkItemId,
@@ -532303,48 +533551,66 @@ async function ingestReportAction(reportDir, options) {
 			verdict,
 			verifierType: "agent",
 			verifyRunId: runId
+		};
+		const uploaded = await uploadReportEvidence(client, {
+			checkResultId: (await client.verify.ingestResult.mutate(checkInput)).id,
+			dir,
+			evidence: c.evidence
 		});
-		for (const evidenceInput of reportEvidence(c.evidence)) {
-			const rel = evidenceInput.path;
-			const abs = path.isAbsolute(rel) ? rel : path.join(dir, rel);
-			if (!existsSync(abs)) {
-				log$12.warn(`evidence not found, skipping: ${rel}`);
-				continue;
-			}
-			try {
-				const type = evidenceTypeForFile(abs);
-				const inlineContent = inlineTextEvidenceForFile(abs, type);
-				const file = inlineContent === void 0 ? await uploadLocalFile(client, abs) : void 0;
-				await client.verify.uploadEvidence.mutate({
-					capturedBy: "cli",
-					checkResultId: checkResult.id,
-					content: inlineContent,
-					description: evidenceDescriptionForFile(evidenceInput.description, abs),
-					fileId: file?.id,
-					metadata: evidenceInput.comparison ? { comparison: evidenceInput.comparison } : void 0,
-					type
-				});
-				evidenceCount += 1;
-				if (inlineContent !== void 0) inlined += 1;
-			} catch (e) {
-				log$12.warn(`evidence upload failed, skipping ${path.basename(abs)}: ${String(e)}`);
-			}
+		evidenceCount += uploaded.count;
+		inlined += uploaded.inlined;
+		failedEvidence.push(...uploaded.failedEvidence.map((failure) => ({
+			...failure,
+			checkItemId
+		})));
+		const required = (plan?.find((item) => item.id === checkItemId)?.verifierConfig)?.requiredEvidence;
+		const gaps = [...new Set(required?.map((spec) => spec.type) ?? [])].filter((type) => !uploaded.types.has(type));
+		const publishedVerdict = gaps.length > 0 && verdict === "passed" ? "uncertain" : verdict;
+		publishedVerdicts.push(publishedVerdict);
+		if (gaps.length > 0) {
+			missingEvidence.push({
+				checkItemId,
+				types: gaps
+			});
+			const limitation = `Required evidence not published: ${gaps.join(", ")}.`;
+			log$12.warn(`${checkItemId}: ${limitation}`);
+			await client.verify.ingestResult.mutate({
+				...checkInput,
+				toulmin: {
+					...checkInput.toulmin,
+					limitation
+				},
+				verdict: publishedVerdict
+			});
 		}
 	}
+	const unexecuted = plan?.filter((item) => !seenCheckItemIds.has(item.id)) ?? [];
+	for (const item of unexecuted) {
+		const config = item.verifierConfig;
+		const types = [...new Set(config.requiredEvidence?.map((spec) => spec.type) ?? [])];
+		if (types.length === 0) continue;
+		missingEvidence.push({
+			checkItemId: item.id,
+			types
+		});
+		publishedVerdicts.push("uncertain");
+		log$12.warn(`${item.id}: not executed; required evidence not published: ${types.join(", ")}.`);
+	}
 	const conclusion = typeof summary.conclusion === "string" ? summary.conclusion : typeof summary.note === "string" ? summary.note : void 0;
 	const score = typeof summary.score === "number" ? Math.max(0, Math.min(1, summary.score / 100)) : void 0;
-	const recount = cases.length !== allCases.length;
-	const verdicts = cases.map(({ case: c }) => toVerdict(c.result ?? c.status ?? c.verdict));
-	const counted = (verdict) => verdicts.filter((v) => v === verdict).length;
+	const recount = cases.length !== allCases.length || missingEvidence.length > 0;
+	const counted = (verdict) => publishedVerdicts.filter((v) => v === verdict).length;
+	const derivedVerdict = deriveReportVerdict(publishedVerdicts.map((verdict) => ({ verdict })));
+	const reportVerdict = summary.verdict && cases.length === allCases.length ? toVerdict(summary.verdict) : derivedVerdict;
 	await client.verify.upsertReport.mutate({
 		content,
 		failedChecks: recount ? counted("failed") : summary.failed,
 		overallConfidence: score,
 		passedChecks: recount ? counted("passed") : summary.passed,
 		summary: conclusion,
-		totalChecks: recount ? cases.length : summary.total ?? cases.length,
+		totalChecks: recount ? publishedVerdicts.length : summary.total ?? cases.length,
 		uncertainChecks: recount ? counted("uncertain") || void 0 : (summary.blocked ?? 0) + (summary.uncertain ?? 0) || void 0,
-		verdict: summary.verdict && !recount ? toVerdict(summary.verdict) : deriveReportVerdict(cases.map(({ case: c }) => c)),
+		verdict: missingEvidence.length > 0 ? reportVerdict === "failed" || derivedVerdict === "failed" ? "failed" : "uncertain" : reportVerdict,
 		verifyRunId: runId
 	});
 	let proposalPosted = false;
@@ -532362,6 +533628,13 @@ async function ingestReportAction(reportDir, options) {
 		log$12.warn(`proposal not posted to the discussion: ${String(e)}`);
 	}
 	const unplanned = plan?.length ? [...seenCheckItemIds].filter((id) => !plan.some((item) => item.id === id)) : [];
+	const partial = failedEvidence.length > 0 || missingEvidence.length > 0;
+	if (partial) {
+		process.exitCode = 1;
+		log$12.warn("Report saved, but evidence publication is incomplete. Keep the local artifacts; retry only the missing evidence, not the whole ingest. Supplementing evidence does not change recorded verdicts.");
+		if (missingEvidence.some(({ checkItemId }) => !seenCheckItemIds.has(checkItemId))) log$12.warn("Unexecuted checks have no result to attach evidence to. Execute them and publish a new round on the same acceptance; do not re-ingest this unchanged report.");
+		if (failedEvidence.some((failure) => failure.reason === "storage_quota")) log$12.warn("Acceptance evidence uses your personal file storage quota. Free space or upgrade your storage plan, then retry the failed artifacts.");
+	}
 	if (options.json !== void 0) {
 		outputJson({
 			acceptanceId,
@@ -532369,32 +533642,37 @@ async function ingestReportAction(reportDir, options) {
 			cases: cases.length,
 			droppedProgrammaticChecks: droppedLabels,
 			evidence: evidenceCount,
+			failedEvidence,
 			inlined,
+			missingEvidence,
 			origin,
 			planItems: plan?.length ?? 0,
 			proposalPosted,
+			publicationStatus: partial ? "partial" : "complete",
 			pullRequest,
 			roundIndex,
 			roundUrl,
 			scenario,
 			subject: subject.ref,
+			unexecuted: unexecuted.map((item) => item.id),
 			unplanned,
 			verifyRunId: runId
 		}, typeof options.json === "string" ? options.json : void 0);
 		return;
 	}
-	console.log(`${import_picocolors.default.green("✓")} Ingested ${import_picocolors.default.bold(String(cases.length))} case(s), ${import_picocolors.default.bold(String(evidenceCount))} evidence artifact(s)${inlined > 0 ? `, ${import_picocolors.default.bold(String(inlined))} inline` : ""}${droppedLabels.length > 0 ? import_picocolors.default.yellow(` — ${droppedLabels.length} programmatic-test check(s) dropped`) : ""}`);
-	if (plan?.length) {
-		const unexecuted = plan.filter((item) => !seenCheckItemIds.has(item.id));
-		console.log(`${import_picocolors.default.bold("plan")}: ${plan.length} item(s)${unexecuted.length > 0 ? import_picocolors.default.yellow(` — ${unexecuted.length} planned but not executed`) : ""}${unplanned.length > 0 ? import_picocolors.default.dim(` — ${unplanned.length} unplanned case(s)`) : ""}`);
+	console.log(`${partial ? import_picocolors.default.yellow("⚠ Partially published") : import_picocolors.default.green("✓ Ingested")} ${import_picocolors.default.bold(String(cases.length))} case(s), ${import_picocolors.default.bold(String(evidenceCount))} evidence artifact(s)${inlined > 0 ? `, ${import_picocolors.default.bold(String(inlined))} inline` : ""}${droppedLabels.length > 0 ? import_picocolors.default.yellow(` — ${droppedLabels.length} programmatic-test check(s) dropped`) : ""}`);
+	for (const failure of failedEvidence) {
+		console.log(`${import_picocolors.default.yellow("retry (POSIX shell)")}: ${failure.retryCommand}`);
+		console.log(`${import_picocolors.default.dim("retryArgs (lh, shell disabled)")}: ${JSON.stringify(failure.retryArgs)}`);
 	}
+	if (plan?.length) console.log(`${import_picocolors.default.bold("plan")}: ${plan.length} item(s)${unexecuted.length > 0 ? import_picocolors.default.yellow(` — ${unexecuted.length} planned but not executed`) : ""}${unplanned.length > 0 ? import_picocolors.default.dim(` — ${unplanned.length} unplanned case(s)`) : ""}`);
 	if (proposalPosted) console.log(`${import_picocolors.default.bold("proposal")}: posted to the discussion`);
 	if (pullRequest?.url) console.log(`${import_picocolors.default.bold("pr")}: ${pullRequest.url}`);
 	if (origin?.topicId) console.log(`${import_picocolors.default.bold("origin topic")}: ${origin.topicId}`);
 	console.log(`${import_picocolors.default.bold("verifyRunId")}: ${runId} ${import_picocolors.default.dim("(immutable snapshot)")}`);
 	const subjectLabel = subject.ref.subjectType === "standalone" ? "standalone" : `${subject.ref.subjectType}:${subject.ref.subjectId}`;
 	console.log(`${import_picocolors.default.bold("acceptance")}: ${acceptanceId} ${import_picocolors.default.dim(`(${subjectLabel})`)}`);
-	if (options.open) {
+	if (options.open || partial) {
 		console.log(`${import_picocolors.default.bold("open acceptance")}: ${acceptanceUrl}`);
 		if (roundUrl) console.log(`${import_picocolors.default.bold("round snapshot")}: ${roundUrl}`);
 	}
@@ -532418,7 +533696,7 @@ function withSubmitOptions(cmd) {
 	return cmd.option("--run <verifyRunId>", "Target verification session (or use --operation)").option("--operation <operationId>", "Resolve the session from an Agent Run operation id").requiredOption("--item <checkItemId>", "Plan item id (checkItemId)").option("--type <type>", "screenshot|gif|video|text|dom_snapshot|transcript").option("--file <path>", "Local file to upload as the evidence artifact").option("--content <text>", "Inline text payload (instead of a file)").option("--verdict <verdict>", "passed|failed|uncertain").option("--title <text>", "Check item title snapshot").option("--by <capturedBy>", "agent-browser|cdp|cli|program|llm_judge", "cli").option("--desc <text>", "Human-readable caption for the evidence").option("--json [fields]", "Output JSON");
 }
 function withEvidenceUploadOptions(cmd) {
-	return cmd.requiredOption("--check <checkResultId>", "Target check result id").requiredOption("--type <type>", "screenshot|gif|video|text|dom_snapshot|transcript").option("--file <path>", "Local file to upload as the artifact").option("--content <text>", "Inline text payload (instead of a file)").option("--by <capturedBy>", "agent-browser|cdp|cli|program|llm_judge", "cli").option("--desc <text>", "Human-readable caption").option("--json [fields]", "Output JSON");
+	return cmd.requiredOption("--check <checkResultId>", "Target check result id").requiredOption("--type <type>", "screenshot|gif|video|text|dom_snapshot|transcript").option("--file <path>", "Local file to upload as the artifact").option("--file-id <id>", "Attach an already-uploaded file without uploading it again").option("--content <text>", "Inline text payload (instead of a file)").option("--metadata <json>", "Evidence metadata, preserved when retrying an attachment").option("--by <capturedBy>", "agent-browser|cdp|cli|program|llm_judge", "cli").option("--desc <text>", "Human-readable caption").option("--json [fields]", "Output JSON");
 }
 function withReportUpsertOptions(cmd) {
 	return cmd.requiredOption("--run <verifyRunId>", "Target session id").option("--verdict <verdict>", "passed|failed|uncertain").option("--summary <text>", "Short summary").option("--content <markdown>", "Full markdown body").option("--total <n>", "Total checks").option("--passed <n>", "Passed checks").option("--failed <n>", "Failed checks").option("--uncertain <n>", "Uncertain checks").option("--json [fields]", "Output JSON");
@@ -532491,6 +533769,45 @@ function attachDeprecatedVerifyRunAliases(verify) {
 	report.command("get <runId>").description("Deprecated — use `lh acceptance run report get`").option("--json [fields]", "Output JSON").hook("preAction", () => log$12.warn("`lh verify report get` is deprecated — use `lh acceptance run report get`")).action(reportGetAction);
 }
 
+//#endregion
+//#region src/commands/acceptanceCommentFeedback.ts
+/** Discussion lives outside getBundle; its threads are resolved explicitly, not by a new round. */
+const collectCommentFeedback = (items, checks, evidenceLabels) => {
+	const commentsById = new Map(items.map((item) => [item.id, item]));
+	const checksById = new Map(checks.map((check) => [check.id, check]));
+	return items.flatMap((item) => {
+		if (item.kind !== "comment" || item.deletedAt) return [];
+		const root = item.parentCommentId ? commentsById.get(item.parentCommentId) : item;
+		if (!root) return [];
+		const check = root.checkItemId ? checksById.get(root.checkItemId) : void 0;
+		const annotation = root.evidenceId && root.rect ? {
+			comment: item.content,
+			evidenceId: root.evidenceId,
+			rect: root.rect
+		} : void 0;
+		return [{
+			actionable: !root.resolvedAt,
+			annotations: annotation ? [{
+				...annotation,
+				region: formatAnnotationRegion(annotation, evidenceLabels)
+			}] : void 0,
+			attachments: item.attachments,
+			author: item.author,
+			checkId: root.checkItemId ?? void 0,
+			checkSeq: check?.seq,
+			comment: item.content,
+			commentId: item.id,
+			createdAt: item.createdAt.toISOString(),
+			fileIds: item.attachments.map((attachment) => attachment.id),
+			kind: "comment",
+			parentCommentId: item.parentCommentId ?? void 0,
+			roundIndex: item.contextRoundIndex ?? root.contextRoundIndex ?? 0,
+			threadId: root.id,
+			title: check?.title
+		}];
+	});
+};
+
 //#endregion
 //#region src/commands/acceptanceFlow.ts
 /** Agent entry point: author a graph before exercising the product, then append real visits. */
@@ -532720,9 +534037,10 @@ function registerAcceptanceCommands(parent, options) {
 			"CREATED"
 		]);
 	});
-	acceptance.command("feedback <idOrSubject>").description("The user's review feedback — check rejects (with region notes & attachments) plus group-scoped notes").option("--actionable", "Only standing feedback the next repair round must act on").option("--json [fields]", "Output JSON").action(async (idOrSubject, options) => {
+	acceptance.command("feedback <idOrSubject>").description("The user's review feedback — unresolved comments, region notes, attachments and rejection decisions").option("--actionable", "Only standing feedback the next repair round must act on").option("--json [fields]", "Output JSON").action(async (idOrSubject, options) => {
 		const id = await resolveAcceptanceId(idOrSubject);
-		const bundle = await (await getTrpcClient()).acceptance.getBundle.query({ id });
+		const client = await getTrpcClient();
+		const [bundle, comments] = await Promise.all([client.acceptance.getBundle.query({ id }), client.acceptanceComment.list.query({ acceptanceId: id })]);
 		const currentRoundIndex = bundle.rounds.at(-1)?.run.roundIndex ?? 0;
 		const evidenceLabels = /* @__PURE__ */ new Map();
 		for (const check of bundle.checks) {
@@ -532771,9 +534089,17 @@ function registerAcceptanceCommands(parent, options) {
 				});
 			}
 		}
-		for (const round of bundle.rounds) for (const entry of round.run.decisionDetail?.groupFeedback ?? []) {
+		for (const round of bundle.rounds) {
+			const { decisionDetail, userDecision } = round.run;
 			const roundIndex = round.run.roundIndex ?? 0;
-			entries.push({
+			if (userDecision === "reject" && decisionDetail?.comment?.trim()) entries.push({
+				actionable: roundIndex >= currentRoundIndex,
+				comment: decisionDetail.comment,
+				createdAt: decisionDetail.decidedAt,
+				kind: "decision",
+				roundIndex
+			});
+			for (const entry of round.run.decisionDetail?.groupFeedback ?? []) entries.push({
 				actionable: roundIndex >= currentRoundIndex,
 				category: entry.category,
 				comment: entry.comment,
@@ -532783,6 +534109,7 @@ function registerAcceptanceCommands(parent, options) {
 				roundIndex
 			});
 		}
+		entries.push(...collectCommentFeedback(comments.items, bundle.checks, evidenceLabels));
 		entries.sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));
 		const shown = options.actionable ? entries.filter((entry) => entry.actionable) : entries;
 		if (options.json !== void 0) {
@@ -532799,14 +534126,15 @@ function registerAcceptanceCommands(parent, options) {
 		}
 		for (const entry of shown) {
 			const marker = entry.actionable ? import_picocolors.default.red("▶ actionable") : import_picocolors.default.dim("· addressed");
-			const label = entry.kind === "check" ? `C${entry.checkSeq} ${truncate$2(entry.title ?? "", 60)}` : entry.kind === "flow" ? `flow · ${entry.title}` : `group · ${entry.category || "overall"}`;
+			const label = entry.kind === "decision" ? "overall rejection" : entry.kind === "comment" ? `comment ${entry.commentId} · ${entry.checkSeq === void 0 ? "overall" : `C${entry.checkSeq} ${truncate$2(entry.title ?? "", 60)}`}` : entry.kind === "check" ? `C${entry.checkSeq} ${truncate$2(entry.title ?? "", 60)}` : entry.kind === "flow" ? `flow · ${entry.title}` : `group · ${entry.category || "overall"}`;
 			console.log(`${marker} ${label} ${import_picocolors.default.dim(`(r${entry.roundIndex})`)}`);
 			if (entry.comment) console.log(`    ${entry.comment}`);
 			for (const annotation of entry.annotations ?? []) {
-				if (annotation.comment) console.log(`    ${import_picocolors.default.dim("region:")} ${annotation.comment}`);
+				if (annotation.comment && annotation.comment !== entry.comment) console.log(`    ${import_picocolors.default.dim("region:")} ${annotation.comment}`);
 				if (annotation.region) console.log(`      ${import_picocolors.default.dim(`└ ${annotation.region}`)}`);
 			}
 			if (entry.fileIds?.length) console.log(`    ${import_picocolors.default.dim(`attachments: ${entry.fileIds.join(", ")}`)}`);
+			for (const attachment of entry.attachments ?? []) if (attachment.url) console.log(`      ${attachment.name ?? attachment.id}: ${attachment.url}`);
 		}
 	});
 	acceptance.command("accept <idOrSubject>").description("Accept the delivery — the terminal user decision that closes the acceptance").option("--comment <text>", "Optional note recorded with the decision").option("--json [fields]", "Output JSON").action(async (idOrSubject, options) => {
@@ -532832,6 +534160,14 @@ function registerAcceptanceCommands(parent, options) {
 			return;
 		}
 		console.log(`${import_picocolors.default.red("✗")} Delivery rejected (${result.id}) — next round re-opens it`);
+		const dispatch = result.repairDispatch;
+		if (dispatch?.dispatched) console.log(`${import_picocolors.default.green("↻")} Sent back to agent ${dispatch.agentId} in topic ${dispatch.topicId} (operation ${dispatch.operationId})`);
+		else if (dispatch?.reason === "failed") console.log(`${import_picocolors.default.yellow("!")} Repair dispatch failed: ${dispatch.error ?? "unknown error"}`);
+		else if (dispatch?.reason === "goal_coordinator") console.log(import_picocolors.default.dim("Goal task — its coordinator starts the next attempt."));
+		else {
+			const why = dispatch?.reason === "forbidden" ? "Not allowed to run the source agent" : "No source agent to send it back to";
+			console.log(import_picocolors.default.dim(`${why} — hand the repair over with: lh acceptance feedback ${result.id} --actionable`));
+		}
 	});
 	if (!options?.deprecated) attachAcceptanceRunCommands(acceptance);
 }