dsh-codex-subscription 3.0.0-beta.3 → 3.0.0-beta.4

package/lib/index.js

@@ -9,9 +9,9 @@ import { promisify } from "node:util";
 import { HttpsProxyAgent } from "https-proxy-agent";
 import WebSocket from "ws";
 import { clientRequestSchema } from "@deepseek-ai/dsh-client-connection";
-import { lstat, mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
-import { constants, readFileSync, statSync } from "node:fs";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+import { lstat, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { constants, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import { LlmError, createUserMessage } from "@deepseek-ai/dsh-llm";
@@ -845,6 +845,17 @@ function createCodexNetworkTransport(options = {}) {
 }
 //#endregion
 //#region src/subscription-connection.js
+/**
+* Who a bearer token belongs to, stable across refreshes: the ChatGPT account id inside the token, so a
+* refreshed token keeps the same prompt-cache key and socket. A token without one falls back to itself.
+*/
+function tokenScope(apiKey) {
+	try {
+		const account = JSON.parse(Buffer.from(String(apiKey).split(".")[1], "base64url").toString("utf8"))?.["https://api.openai.com/auth"]?.chatgpt_account_id;
+		if (typeof account === "string" && account.length > 0 && account.length <= 128) return `account:${account}`;
+	} catch {}
+	return `token:${apiKey}`;
+}
 function createSubscriptionConnection({ resolveMode = () => "sse", resolveProxy = resolveCodexOAuthProxy } = {}) {
 	const namespace = randomUUID();
 	const sessions = /* @__PURE__ */ new Set();
@@ -873,7 +884,7 @@ function createSubscriptionConnection({ resolveMode = () => "sse", resolveProxy
 			const sessionId = options.sessionId && `dsh-${createHash("sha256").update(JSON.stringify([
 				namespace,
 				options.sessionId,
-				options.apiKey,
+				tokenScope(options.apiKey),
 				proxy
 			])).digest("hex").slice(0, 56)}`;
 			if (sessionId) sessions.add(sessionId);
@@ -1124,6 +1135,8 @@ const RPC_ENDPOINTS = Object.freeze([
 	"remote/enable",
 	"remote/disable",
 	"remote/pair",
+	"remote/clients",
+	"remote/revoke",
 	"reset-credit/inspect",
 	"reset-credit/prepare",
 	"reset-credit/consume",
@@ -2062,7 +2075,7 @@ function inheritedOriginalImageRef(session, assetId) {
 }
 //#endregion
 //#region src/version.js
-const PACKAGE_VERSION = "3.0.0-beta.3";
+const PACKAGE_VERSION = "3.0.0-beta.4";
 const USER_AGENT = `dsh-codex-subscription/${PACKAGE_VERSION}`;
 //#endregion
 //#region src/codex-images.js
@@ -2260,7 +2273,7 @@ function imageContent(value) {
 	const label = typeof value.size === "string" && value.size.length > 0 ? `Generated a ${value.size} image.` : "Generated an image.";
 	return [{
 		type: "text",
-		text: value.localPath === void 0 ? label : `${label}\nOriginal PNG saved on the DSH host at: ${JSON.stringify(value.localPath)}. Read this file or copy it to the workspace with a .png extension; this host path is not a browser URL.`
+		text: value.localPath === void 0 ? label : `${label}\nOriginal PNG saved on the DSH host at: ${JSON.stringify(value.localPath)}. Read this file or copy it to the workspace with a .png extension; this host path is not a browser URL. The image is already shown to the user, so do not embed it again; copy it rather than move it, and leave the original in place unless the user asks you to delete it.`
 	}, {
 		type: "image",
 		attachment: imageReference(value.image)
@@ -2364,6 +2377,41 @@ function imageOutputSchema() {
 		}
 	};
 }
+const SUPPORT_ID = /^[A-Za-z0-9._-]{1,80}$/u;
+/** The request id Codex returns for an image call, kept on failures so a report can be traced. */
+function supportId(response) {
+	const id = response.headers?.get?.("x-codex-imagegen-request-id");
+	return typeof id === "string" && SUPPORT_ID.test(id) ? ` (request ${id})` : "";
+}
+/** What a 429 from the image endpoint says: when the limit resets, when the response tells us. */
+async function limitMessage(response, now = Date.now()) {
+	const fallback = "Codex image generation quota is unavailable";
+	let error;
+	try {
+		error = JSON.parse(await readTextWithin(response, 16 * 1024))?.error;
+	} catch {
+		return fallback;
+	}
+	if (!record$4(error)) return fallback;
+	const at = Number.isSafeInteger(error.resets_at) && error.resets_at > 0 ? error.resets_at * 1e3 : Number.isSafeInteger(error.resets_in_seconds) && error.resets_in_seconds > 0 ? now + error.resets_in_seconds * 1e3 : void 0;
+	if (at === void 0) return fallback;
+	const minutes = Math.max(1, Math.ceil((at - now) / 6e4));
+	return `Codex image generation limit reached; it resets in about ${minutes >= 120 ? `${Math.round(minutes / 60)} hours` : `${minutes} minutes`}`;
+}
+async function readTextWithin(response, maximumBytes) {
+	if (response.body === null || response.body === void 0) return "";
+	const reader = response.body.getReader();
+	const chunks = [];
+	let bytes = 0;
+	while (bytes < maximumBytes) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		bytes += value.byteLength;
+		chunks.push(value);
+	}
+	await reader.cancel().catch(() => {});
+	return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))).toString("utf8").slice(0, maximumBytes);
+}
 function responseMetadata(value) {
 	const data = Array.isArray(value?.data) ? value.data[0] : void 0;
 	const encoded = record$4(data) ? data.b64_json : void 0;
@@ -2533,8 +2581,9 @@ function createCodexImageTool(options) {
 			}
 			if (!response.ok) {
 				if (response.status === 401 || response.status === 403) throw new Error("ChatGPT sign-in needs to be renewed");
-				if (response.status === 429) throw new Error("Codex image generation quota is unavailable");
-				throw new Error(`Codex image ${editing ? "edit" : "generation"} failed (HTTP ${response.status})`);
+				const requestId = supportId(response);
+				if (response.status === 429) throw new Error(`${await limitMessage(response)}${requestId}`);
+				throw new Error(`Codex image ${editing ? "edit" : "generation"} failed (HTTP ${response.status})${requestId}`);
 			}
 			const metadata = responseMetadata(await readJsonWithin(response, encodedLimit(maximumBytes) + RESPONSE_ENVELOPE_BYTES));
 			const data = decodeCodexPng(metadata.encoded, maximumBytes);
@@ -2896,6 +2945,21 @@ const CONFLICT_RENEW_MS = 15 * 6e4;
 const MAX_RECONNECT_MS = 3e4;
 const REQUEST_TIMEOUT_MS = 3e4;
 const REFRESH_MARGIN_MS = 5 * 6e4;
+const PING_MS = 1e4;
+const PONG_TIMEOUT_MS = 6e4;
+const STABLE_MS = 6e4;
+const MAX_BUFFERED_ITEMS = 2e3;
+const MAX_BUFFERED_BYTES = 32 * 1024 * 1024;
+const BUFFER_IDLE_MS = 30 * 6e4;
+const RETRY_AFTER_JITTER_MS = 3e4;
+/** Milliseconds a server asked us to wait (Retry-After as seconds or a date), when it did. */
+function retryAfterMs$1(value, at = Date.now()) {
+	if (typeof value !== "string" || value.trim() === "") return void 0;
+	const seconds = Number(value);
+	if (Number.isFinite(seconds)) return Math.max(0, Math.round(seconds * 1e3));
+	const date = Date.parse(value);
+	return Number.isNaN(date) ? void 0 : Math.max(0, date - at);
+}
 var RemoteControlError = class extends Error {
 	constructor(code, message) {
 		super(message);
@@ -2919,6 +2983,7 @@ function remoteControlEndpoints(base = REMOTE_CONTROL_BASE_URL) {
 		enroll: at("wham/remote/control/server/enroll"),
 		refresh: at("wham/remote/control/server/refresh"),
 		pair: at("wham/remote/control/server/pair"),
+		clients: (environment) => at(`wham/remote/control/environments/${encodeURIComponent(environment)}/clients`),
 		websocket
 	});
 }
@@ -2969,6 +3034,8 @@ function createRemoteControlRelay(options) {
 	const clients = /* @__PURE__ */ new Map();
 	const assemblies = /* @__PURE__ */ new Map();
 	const sequences = /* @__PURE__ */ new Map();
+	const outbound = /* @__PURE__ */ new Map();
+	const lastInbound = /* @__PURE__ */ new Map();
 	const state = {
 		status: "stopped",
 		connectedAt: void 0,
@@ -2981,9 +3048,19 @@ function createRemoteControlRelay(options) {
 			redirect: "error",
 			signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]) : AbortSignal.timeout(REQUEST_TIMEOUT_MS)
 		});
-		if (!response.ok) throw new RemoteControlError(response.status === 401 || response.status === 403 ? "unauthorized" : "http-error", `Remote Control request failed (HTTP ${response.status})`);
+		if (!response.ok) {
+			const error = new RemoteControlError(response.status === 401 || response.status === 403 ? "unauthorized" : "http-error", `Remote Control request failed (HTTP ${response.status})`);
+			if (response.status === 429 || response.status >= 500) error.retryAfterMs = retryAfterMs$1(response.headers?.get?.("retry-after"), now());
+			throw error;
+		}
 		return response.json();
 	};
+	const accountHeaders = (access, accountId) => ({
+		authorization: `Bearer ${access}`,
+		"chatgpt-account-id": accountId,
+		accept: "application/json",
+		"user-agent": options.userAgent
+	});
 	const ensureEnrollment = async (signal) => {
 		if (enrolled && enrolled.expiresAt > now() + REFRESH_MARGIN_MS) return enrolled;
 		const { access, accountId } = await options.credentials(signal);
@@ -3036,45 +3113,134 @@ function createRemoteControlRelay(options) {
 			expiresAt
 		};
 	};
+	/** The phones paired with this host, from the same account endpoint Codex uses. */
+	const listClients = async (signal) => {
+		const current = await ensureEnrollment(signal);
+		const { access, accountId } = await options.credentials(signal);
+		if (!access || !accountId) throw new RemoteControlError("not-signed-in", "ChatGPT subscription is not signed in");
+		const value = await request(endpoints.clients(current.environmentId), {
+			method: "GET",
+			headers: accountHeaders(access, accountId)
+		}, signal);
+		return (Array.isArray(value?.items) ? value.items : []).filter((item) => text(item?.client_id)).map((item) => ({
+			clientId: item.client_id,
+			name: text(item.display_name) ?? text(item.device_model) ?? null,
+			platform: text(item.platform) ?? null,
+			osVersion: text(item.os_version) ?? null,
+			appVersion: text(item.app_version) ?? null,
+			lastSeenAt: Number.isFinite(Date.parse(item.last_seen_at)) ? Date.parse(item.last_seen_at) : null
+		}));
+	};
+	/** Remove one paired phone; it has to be paired again to come back. */
+	const revokeClient = async (clientId, signal) => {
+		if (typeof clientId !== "string" || clientId === "" || clientId.length > 200) throw new RemoteControlError("bad-request", "A client id is required");
+		const current = await ensureEnrollment(signal);
+		const { access, accountId } = await options.credentials(signal);
+		if (!access || !accountId) throw new RemoteControlError("not-signed-in", "ChatGPT subscription is not signed in");
+		const target = new URL(`${endpoints.clients(current.environmentId).href}/${encodeURIComponent(clientId)}`);
+		const response = await doFetch(target, {
+			method: "DELETE",
+			headers: accountHeaders(access, accountId),
+			redirect: "error",
+			signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]) : AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+		});
+		if (!response.ok) throw new RemoteControlError(response.status === 401 || response.status === 403 ? "unauthorized" : "http-error", `Remote Control request failed (HTTP ${response.status})`);
+		closeClient(clientId);
+	};
 	const sendEnvelope = async (envelope) => {
 		if (socket?.readyState !== 1) throw new RemoteControlError("not-connected", "Remote Control is not connected");
 		await new Promise((resolve, reject) => socket.send(JSON.stringify(envelope), (error) => error ? reject(error) : resolve()));
 	};
+	const remember = (key, sequence, segment, encoded) => {
+		const stream = outbound.get(key) ?? {
+			items: [],
+			bytes: 0,
+			touched: now()
+		};
+		outbound.set(key, stream);
+		stream.items.push({
+			sequence,
+			segment,
+			encoded
+		});
+		stream.bytes += encoded.length;
+		stream.touched = now();
+		while (stream.items.length > MAX_BUFFERED_ITEMS || stream.bytes > MAX_BUFFERED_BYTES) stream.bytes -= stream.items.shift().encoded.length;
+	};
+	const acknowledge = (key, sequence, segment) => {
+		const stream = outbound.get(key);
+		if (!stream) return;
+		stream.items = stream.items.filter((item) => !(item.sequence < sequence || item.sequence === sequence && (segment === void 0 || (item.segment ?? 0) <= segment)));
+		stream.bytes = stream.items.reduce((total, item) => total + item.encoded.length, 0);
+		if (stream.items.length === 0) outbound.delete(key);
+	};
+	const replay = (ws) => {
+		for (const [key, stream] of outbound) {
+			if (now() - stream.touched > BUFFER_IDLE_MS) {
+				outbound.delete(key);
+				continue;
+			}
+			for (const item of stream.items) ws.send(item.encoded, () => {});
+		}
+	};
 	const sendServerMessage = async (clientId, streamId, message) => {
 		const key = `${clientId}\u0000${streamId}`;
+		const isRequest = message?.method !== void 0 && message?.id !== void 0;
+		if (isRequest && socket?.readyState !== 1) throw new RemoteControlError("not-connected", "Remote Control is not connected");
 		const sequence = sequences.get(key) ?? 1;
 		sequences.set(key, sequence + 1);
-		const envelope = {
+		const encoded = JSON.stringify({
 			client_id: clientId,
 			message,
 			seq_id: sequence,
 			stream_id: streamId,
 			type: "server_message"
+		});
+		const put = async (text) => {
+			if (isRequest) return new Promise((resolve, reject) => socket.send(text, (error) => error ? reject(error) : resolve()));
+			remember(key, sequence, void 0, text);
+			if (socket?.readyState === 1) await new Promise((resolve) => socket.send(text, () => resolve()));
 		};
-		const encoded = JSON.stringify(envelope);
-		if (Buffer.byteLength(encoded) <= MAX_SEGMENT_BYTES) return sendEnvelope(envelope);
+		if (Buffer.byteLength(encoded) <= MAX_SEGMENT_BYTES) return put(encoded);
 		const bytes = Buffer.from(JSON.stringify(message));
 		if (bytes.byteLength > MAX_MESSAGE_BYTES) throw new RemoteControlError("too-large", "Remote Control message is too large");
 		const chunks = [];
 		for (let offset = 0; offset < bytes.byteLength; offset += TARGET_SEGMENT_BYTES) chunks.push(bytes.subarray(offset, offset + TARGET_SEGMENT_BYTES).toString("base64"));
-		await Promise.all(chunks.map((chunk, segmentId) => sendEnvelope({
-			client_id: clientId,
-			message_chunk_base64: chunk,
-			message_size_bytes: bytes.byteLength,
-			segment_count: chunks.length,
-			segment_id: segmentId,
-			seq_id: sequence,
-			stream_id: streamId,
-			type: "server_message_chunk"
-		})));
+		for (const [segmentId, chunk] of chunks.entries()) {
+			const text = JSON.stringify({
+				client_id: clientId,
+				message_chunk_base64: chunk,
+				message_size_bytes: bytes.byteLength,
+				segment_count: chunks.length,
+				segment_id: segmentId,
+				seq_id: sequence,
+				stream_id: streamId,
+				type: "server_message_chunk"
+			});
+			if (isRequest) await put(text);
+			else {
+				remember(key, sequence, segmentId, text);
+				if (socket?.readyState === 1) await new Promise((resolve) => socket.send(text, () => resolve()));
+			}
+		}
 	};
 	const closeClient = (clientId, streamId) => {
 		for (const [key, client] of clients) if (key.startsWith(`${clientId}\u0000`) && (streamId === void 0 || key === `${clientId}\u0000${streamId}`)) {
 			clients.delete(key);
 			sequences.delete(key);
+			outbound.delete(key);
+			lastInbound.delete(key);
 			client.close();
 		}
 	};
+	const resetStreams = () => {
+		for (const [, client] of clients) client.close();
+		clients.clear();
+		sequences.clear();
+		outbound.clear();
+		lastInbound.clear();
+		assemblies.clear();
+	};
 	const deliver = async (envelope) => {
 		const streamId = envelope.stream_id ?? randomUUID();
 		const key = `${envelope.client_id}\u0000${streamId}`;
@@ -3099,7 +3265,10 @@ function createRemoteControlRelay(options) {
 			};
 			clients.set(key, client);
 		}
-		client.receive(envelope.message);
+		if (!(Number.isInteger(envelope.seq_id) && (lastInbound.get(key) ?? -1) >= envelope.seq_id)) {
+			if (Number.isInteger(envelope.seq_id)) lastInbound.set(key, envelope.seq_id);
+			client.receive(envelope.message);
+		}
 		if (Number.isInteger(envelope.seq_id)) await sendEnvelope({
 			client_id: envelope.client_id,
 			seq_id: envelope.seq_id,
@@ -3144,6 +3313,8 @@ function createRemoteControlRelay(options) {
 		else if (envelope.type === "client_message_chunk") {
 			const message = receiveChunk(envelope);
 			if (message) await deliver(message);
+		} else if (envelope.type === "ack") {
+			if (typeof envelope.stream_id === "string" && Number.isInteger(envelope.seq_id)) acknowledge(`${envelope.client_id}\u0000${envelope.stream_id}`, envelope.seq_id, Number.isInteger(envelope.segment_id) ? envelope.segment_id : void 0);
 		} else if (envelope.type === "client_closed") closeClient(envelope.client_id, envelope.stream_id);
 		else if (envelope.type === "ping") await sendEnvelope({
 			client_id: envelope.client_id,
@@ -3168,25 +3339,60 @@ function createRemoteControlRelay(options) {
 			let queue = Promise.resolve();
 			const onAbort = () => ws.close();
 			signal.addEventListener("abort", onAbort, { once: true });
+			let ping;
+			let silent;
+			const hearFrom = () => {
+				clearTimeout(silent);
+				silent = setTimeout(() => {
+					state.lastError = "timeout";
+					try {
+						(ws.terminate ?? ws.close).call(ws);
+					} catch {}
+				}, options.pongTimeoutMs ?? PONG_TIMEOUT_MS);
+			};
+			const stopBeat = () => {
+				clearInterval(ping);
+				clearTimeout(silent);
+			};
 			ws.on("open", () => {
 				state.status = "connected";
 				state.connectedAt = now();
 				state.lastError = void 0;
+				replay(ws);
+				if (typeof ws.ping === "function") {
+					hearFrom();
+					ping = setInterval(() => {
+						try {
+							ws.ping();
+						} catch {}
+					}, options.pingMs ?? PING_MS);
+				}
+			});
+			ws.on("pong", hearFrom);
+			ws.on("unexpected-response", (request, response) => {
+				stopBeat();
+				const error = new RemoteControlError("socket", `Unexpected server response: ${response?.statusCode}`);
+				if (response?.statusCode === 429 || response?.statusCode >= 500) error.retryAfterMs = retryAfterMs$1(String(response.headers?.["retry-after"] ?? ""), now());
+				try {
+					request?.destroy?.();
+				} catch {}
+				reject(error);
 			});
 			ws.on("message", (data) => {
 				queue = queue.then(() => receive(String(data))).catch((error) => {
 					state.lastError = error?.code ?? "protocol";
 				});
 			});
-			ws.on("error", (error) => reject(new RemoteControlError("socket", error?.message ?? "socket error")));
+			ws.on("error", (error) => {
+				stopBeat();
+				reject(new RemoteControlError("socket", error?.message ?? "socket error"));
+			});
 			ws.on("close", () => {
+				stopBeat();
 				signal.removeEventListener("abort", onAbort);
 				resolve();
 			});
 		});
-		for (const [, client] of clients) client.close();
-		clients.clear();
-		sequences.clear();
 		assemblies.clear();
 		socket = void 0;
 	};
@@ -3194,12 +3400,15 @@ function createRemoteControlRelay(options) {
 		let delay = INITIAL_RECONNECT_MS;
 		let conflicts = 0;
 		let conflictSince = 0;
+		let asked;
 		while (!signal.aborted) {
 			state.status = "connecting";
 			try {
+				state.connectedAt = void 0;
 				await connectOnce(signal);
-				delay = INITIAL_RECONNECT_MS;
+				if (state.connectedAt !== void 0 && now() - state.connectedAt >= STABLE_MS) delay = INITIAL_RECONNECT_MS;
 			} catch (error) {
+				asked = error?.retryAfterMs;
 				state.lastError = error?.code ?? "network";
 				if (options.debug) state.detail = String(error?.message ?? error).slice(0, 160);
 				state.status = "error";
@@ -3210,6 +3419,7 @@ function createRemoteControlRelay(options) {
 					installation = await options.renewInstallation();
 					enrolled = void 0;
 					conflicts = 0;
+					resetStreams();
 				}
 				if (error?.code === "not-signed-in") {
 					state.status = "stopped";
@@ -3218,12 +3428,16 @@ function createRemoteControlRelay(options) {
 			}
 			if (signal.aborted) break;
 			state.reconnects += 1;
-			await wait(delay, signal);
+			const spread = Math.round(delay * (.5 + (options.random ?? Math.random)() / 2));
+			await wait(asked === void 0 ? spread : Math.max(spread, asked + Math.round((options.random ?? Math.random)() * RETRY_AFTER_JITTER_MS)), signal);
+			asked = void 0;
 			delay = Math.min(delay * 2, MAX_RECONNECT_MS);
 		}
 	};
 	return Object.freeze({
 		pair,
+		listClients,
+		revokeClient,
 		status: () => ({
 			...state,
 			enrolled: enrolled !== void 0,
@@ -3244,6 +3458,7 @@ function createRemoteControlRelay(options) {
 			stop?.abort();
 			socket?.close();
 			await running;
+			resetStreams();
 			state.status = "stopped";
 		}
 	});
@@ -3322,6 +3537,13 @@ function createRemoteControl(options) {
 		async pair(signal) {
 			return (await ensureRelay()).pair(signal);
 		},
+		async clients(signal) {
+			return (await ensureRelay()).listClients(signal);
+		},
+		async revoke(clientId, signal) {
+			await (await ensureRelay()).revokeClient(clientId, signal);
+			return this.clients(signal);
+		},
 		status() {
 			return {
 				...relay?.status() ?? {
@@ -3338,6 +3560,212 @@ function createRemoteControl(options) {
 	});
 }
 //#endregion
+//#region src/remote-control-git.js
+const DEFAULT_TIMEOUT_MS$2 = 15e3;
+const MAX_TIMEOUT_MS = 3e4;
+const DEFAULT_OUTPUT_BYTES = 1024 * 1024;
+const MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
+const READ_ONLY = /* @__PURE__ */ new Set([
+	"status",
+	"diff",
+	"rev-parse",
+	"ls-files",
+	"show",
+	"log",
+	"rev-list",
+	"merge-base",
+	"diff-tree",
+	"ls-tree",
+	"cat-file",
+	"describe",
+	"shortlog",
+	"blame",
+	"diff-files",
+	"diff-index",
+	"for-each-ref",
+	"count-objects"
+]);
+const EXACT = [
+	["branch", "--show-current"],
+	["remote"],
+	["remote", "-v"],
+	["symbolic-ref", "HEAD"],
+	[
+		"symbolic-ref",
+		"--short",
+		"HEAD"
+	],
+	[
+		"symbolic-ref",
+		"-q",
+		"HEAD"
+	]
+];
+const FORBIDDEN = /^(?:-o$|--output(?:=|$)|--ext-diff|--textconv|--exec|--upload-pack|--receive-pack|--git-dir|--work-tree|--namespace|--super-prefix|--open-files-in-pager|-O|--paginate|-c$|-C$|--config)/u;
+const TEXTUAL = /* @__PURE__ */ new Set([
+	"diff",
+	"show",
+	"log",
+	"blame",
+	"diff-tree",
+	"diff-files",
+	"diff-index"
+]);
+/** The argv to run for a phone request, or a reason it is refused. */
+function gitArguments(command) {
+	if (!Array.isArray(command) || command.length < 2 || command.some((part) => typeof part !== "string" || part.length > 4096 || part.includes("\0"))) return { error: "not a git command" };
+	if (!/^git(?:\.exe)?$/iu.test(basename(command[0]))) return { error: "only git is available" };
+	let rest = command.slice(1);
+	if (rest[0] === "--no-pager") rest = rest.slice(1);
+	const [subcommand, ...args] = rest;
+	if (subcommand === void 0) return { error: "no git subcommand" };
+	if (args.some((arg) => FORBIDDEN.test(arg))) return { error: `option not allowed with git ${subcommand}` };
+	const exact = EXACT.some((form) => form.length === rest.length && form.every((part, index) => part === rest[index]));
+	if (!READ_ONLY.has(subcommand) && !exact) return { error: `git ${subcommand} is not available` };
+	return { argv: [
+		"-c",
+		"core.fsmonitor=false",
+		"-c",
+		"core.pager=cat",
+		"-c",
+		"diff.external=",
+		"--no-pager",
+		subcommand,
+		...TEXTUAL.has(subcommand) ? ["--no-ext-diff", "--no-textconv"] : [],
+		...args
+	] };
+}
+const inside = (folder, root) => {
+	const path = relative(resolve(root), resolve(folder));
+	return path === "" || !path.startsWith("..") && !path.startsWith(`..${sep}`) && !/^[A-Za-z]:/u.test(path);
+};
+/**
+* @param {{ command: string[], cwd?: string, timeoutMs?: number, outputBytesCap?: number, tty?: boolean, streamStdin?: boolean, streamStdoutStderr?: boolean }} params
+* @param {{ folders: string[], run?: typeof execFile }} options folders: the conversation folders git may run in
+*/
+function runGit(params, { folders, run = execFile }) {
+	const parsed = gitArguments(params?.command);
+	if (parsed.error) return Promise.reject(Object.assign(new Error(parsed.error), { code: "not-allowed" }));
+	if (params.tty || params.streamStdin || params.streamStdoutStderr) return Promise.reject(Object.assign(/* @__PURE__ */ new Error("streaming is not available"), { code: "not-allowed" }));
+	const cwd = localFolder(params.cwd);
+	if (!cwd || !folders.some((root) => inside(cwd, root))) return Promise.reject(Object.assign(/* @__PURE__ */ new Error("git only runs in a DSH conversation folder"), { code: "not-allowed" }));
+	const timeout = Math.min(Number.isFinite(params.timeoutMs) && params.timeoutMs > 0 ? params.timeoutMs : DEFAULT_TIMEOUT_MS$2, MAX_TIMEOUT_MS);
+	const cap = Math.min(Number.isInteger(params.outputBytesCap) && params.outputBytesCap > 0 ? params.outputBytesCap : DEFAULT_OUTPUT_BYTES, MAX_OUTPUT_BYTES);
+	const env = {
+		...process.env,
+		GIT_OPTIONAL_LOCKS: "0",
+		GIT_TERMINAL_PROMPT: "0",
+		GIT_PAGER: "cat",
+		GIT_EXTERNAL_DIFF: "",
+		GIT_ASKPASS: "",
+		GCM_INTERACTIVE: "never"
+	};
+	return new Promise((resolvePromise) => {
+		run("git", parsed.argv, {
+			cwd,
+			env,
+			timeout,
+			maxBuffer: cap,
+			windowsHide: true,
+			encoding: "utf8"
+		}, (error, stdout, stderr) => {
+			resolvePromise({
+				exitCode: error ? typeof error.code === "number" ? error.code : 1 : 0,
+				stdout: String(stdout ?? "").slice(0, cap),
+				stderr: error && typeof error.code !== "number" ? String(error.message).slice(0, 500) : String(stderr ?? "").slice(0, cap)
+			});
+		});
+	});
+}
+//#endregion
+//#region src/remote-control-files.js
+const SKIP = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	".hg",
+	".svn",
+	"dist",
+	"build",
+	"target",
+	"__pycache__",
+	".venv",
+	"venv",
+	".next",
+	".cache",
+	"coverage"
+]);
+const MAX_ENTRIES = 3e4;
+const MAX_DEPTH = 8;
+const BUDGET_MS = 2e3;
+const RESULTS = 50;
+/** Subsequence match with a bonus for runs, word starts and the file name; undefined when the query is not in the text. */
+function fuzzyScore(query, text) {
+	const needle = query.toLowerCase();
+	const hay = text.toLowerCase();
+	const indices = [];
+	let from = 0;
+	let score = 0;
+	let previous = -2;
+	const nameStart = hay.lastIndexOf("/") + 1;
+	for (const char of needle) {
+		const at = hay.indexOf(char, from);
+		if (at < 0) return void 0;
+		indices.push(at);
+		score += 1 + (at === previous + 1 ? 5 : 0) + (at === 0 || "/_-. ".includes(hay[at - 1]) ? 4 : 0) + (at >= nameStart ? 2 : 0);
+		previous = at;
+		from = at + 1;
+	}
+	return {
+		score: score * 10 - Math.floor(Math.min(text.length, 200) / 10),
+		indices
+	};
+}
+const within = (folder, target) => {
+	const path = relative(resolve(folder), resolve(target));
+	return path === "" || !path.startsWith("..") && !/^[A-Za-z]:/u.test(path);
+};
+/** Matches for `query` under each root; roots outside `folders` are ignored. */
+async function searchFiles({ roots, query, folders, now = Date.now }) {
+	const found = [];
+	const started = now();
+	let seen = 0;
+	for (const given of roots) {
+		const root = localFolder(given);
+		if (!root || !folders.some((folder) => within(folder, root))) continue;
+		const queue = [[root, 0]];
+		while (queue.length > 0 && seen < MAX_ENTRIES && now() - started < BUDGET_MS) {
+			const [folder, depth] = queue.shift();
+			let entries;
+			try {
+				entries = await readdir(folder, { withFileTypes: true });
+			} catch {
+				continue;
+			}
+			for (const entry of entries) {
+				if (entry.name.startsWith(".") && entry.name !== ".github") continue;
+				const directory = entry.isDirectory();
+				if (!directory && !entry.isFile()) continue;
+				seen += 1;
+				const path = relative(root, join(folder, entry.name)).split(sep).join("/");
+				const match = query === "" ? {
+					score: 0,
+					indices: []
+				} : fuzzyScore(query, path);
+				if (match) found.push({
+					root,
+					path,
+					match_type: directory ? "directory" : "file",
+					file_name: entry.name,
+					score: match.score,
+					indices: match.indices
+				});
+				if (directory && !SKIP.has(entry.name) && depth < MAX_DEPTH) queue.push([join(folder, entry.name), depth + 1]);
+			}
+		}
+	}
+	return found.sort((a, b) => b.score - a.score || a.path.length - b.path.length).slice(0, RESULTS);
+}
+//#endregion
 //#region src/remote-control-dsh.js
 /** A folder the phone named, only when it is an existing absolute folder on this machine. */
 function localFolder(value) {
@@ -3349,6 +3777,84 @@ function localFolder(value) {
 		return;
 	}
 }
+/** One image the phone attached, sent inline as a data URL (its own file paths mean nothing on this machine). */
+function dataImage(url) {
+	const match = typeof url === "string" ? /^data:(image\/[A-Za-z0-9.+-]+);base64,([A-Za-z0-9+/=\s]+)$/u.exec(url) : null;
+	return match ? {
+		mediaType: match[1].toLowerCase(),
+		data: new Uint8Array(Buffer.from(match[2], "base64"))
+	} : void 0;
+}
+const inputImages = (input) => (Array.isArray(input) ? input : []).filter((part) => part?.type === "image" && typeof part.url === "string");
+const MAX_PHONE_IMAGES = 8;
+/** Facts about a real local file or folder the phone asks about, so its folder picker shows what is on this machine. */
+function realMetadata(value) {
+	if (typeof value !== "string" || !isAbsolute(value)) return void 0;
+	try {
+		const stat = statSync(value);
+		return {
+			isDirectory: stat.isDirectory(),
+			isFile: stat.isFile(),
+			isSymlink: false,
+			createdAtMs: Math.floor(stat.birthtimeMs),
+			modifiedAtMs: Math.floor(stat.mtimeMs)
+		};
+	} catch {
+		return;
+	}
+}
+/** Names inside a real local folder (folders first, hidden ones left out, bounded); nothing for anything else. */
+function readFolder(value) {
+	const folder = localFolder(value);
+	if (!folder) return [];
+	try {
+		return readdirSync(folder, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".") && (entry.isDirectory() || entry.isFile())).map((entry) => ({
+			fileName: entry.name,
+			isDirectory: entry.isDirectory(),
+			isFile: entry.isFile()
+		})).sort((a, b) => Number(b.isDirectory) - Number(a.isDirectory) || a.fileName.localeCompare(b.fileName)).slice(0, 500);
+	} catch {
+		return [];
+	}
+}
+/** Offset paging over a full list, the way the phone asks for it (cursor is the next offset). */
+function page(list, params) {
+	const start = Number.isInteger(Number(params?.cursor)) ? Math.max(0, Number(params.cursor)) : 0;
+	const limit = Number.isInteger(params?.limit) && params.limit > 0 ? params.limit : list.length;
+	return {
+		data: list.slice(start, start + limit),
+		nextCursor: start + limit < list.length ? String(start + limit) : null,
+		backwardsCursor: null
+	};
+}
+/** Codex usage as the phone's rate-limit snapshot (primary and secondary windows of the main limit). */
+function rateLimits(read) {
+	const toWindow = (entry) => entry && {
+		usedPercent: Math.round(entry.usedPercent),
+		windowDurationMins: Math.round(entry.windowSeconds / 60),
+		resetsAt: entry.resetsAt ?? null
+	};
+	const snapshot = (limit) => ({
+		limitId: limit?.id ?? "codex",
+		limitName: limit?.name ?? null,
+		normalModelSlug: null,
+		primary: toWindow(limit?.windows?.[0]) ?? null,
+		secondary: toWindow(limit?.windows?.[1]) ?? null,
+		credits: null,
+		individualLimit: null,
+		spendControlReached: read?.spendControlReached ?? null,
+		planType: read?.planType ?? null,
+		rateLimitReachedType: read?.rateLimitReachedType ?? null
+	});
+	return {
+		ordinaryUsageAllowed: null,
+		rateLimits: snapshot(read?.rateLimits?.find((limit) => limit.id === "codex") ?? read?.rateLimits?.[0]),
+		rateLimitsByLimitId: read ? Object.fromEntries((read.rateLimits ?? []).map((limit) => [limit.id, snapshot(limit)])) : null,
+		rateLimitResetCredits: null,
+		accountId: null,
+		rateLimitUpsell: null
+	};
+}
 const seconds = (value) => Math.floor((Number.isFinite(value) ? value : Date.now()) / 1e3);
 const emptyTurn = () => ({
 	id: randomUUID(),
@@ -3362,6 +3868,8 @@ const emptyTurn = () => ({
 });
 const textOf = (content) => (content ?? []).map((block) => block?.type === "text" ? block.text : "").filter(Boolean).join("\n");
 const inputText = (input) => (Array.isArray(input) ? input : []).map((part) => part?.type === "text" ? part.text : "").filter(Boolean).join("\n");
+/** Skills the phone picked, written the way DSH invokes a skill: a /name gesture ahead of the text. */
+const skillGestures = (input) => (Array.isArray(input) ? input : []).filter((part) => part?.type === "skill" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(String(part.name))).map((part) => `/${part.name}`);
 const notFound = (id) => new RpcError(-32602, `Thread not found: ${String(id).slice(0, 80)}`);
 const modelKey = (selection) => `${encodeURIComponent(selection.provider)}/${encodeURIComponent(selection.model)}`;
 function parseModelKey(value) {
@@ -3388,8 +3896,98 @@ function parseArguments(value) {
 const visibleText = (content) => textOf(content).replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gu, "").trim();
 /** Text of a user-role message the person wrote; DSH's own injected ones (runtime context, notices) carry another source kind. */
 const typedText = (message) => message.role === "user" && (message.source === void 0 || message.source?.kind === "user") ? visibleText(message.content) : "";
+const lines = (text) => String(text ?? "").split("\n");
+const added = (text) => lines(text).map((line) => `+${line}`).join("\n");
+const removed = (text) => lines(text).map((line) => `-${line}`).join("\n");
+/**
+* How a DSH tool call looks on the phone: shell commands and file edits use the phone's own
+* command and diff views; everything else stays a generic tool call.
+*/
+function toolItem(block, cwd) {
+	const args = parseArguments(block.arguments);
+	const base = {
+		id: block.id,
+		status: "inProgress"
+	};
+	if (/^(bash|pwsh)(_persistent)?$/u.test(block.name) && typeof args?.command === "string") return {
+		type: "commandExecution",
+		...base,
+		command: args.command,
+		cwd: typeof args.workdir === "string" ? args.workdir : cwd ?? "",
+		processId: null,
+		source: "agent",
+		commandActions: [],
+		aggregatedOutput: null,
+		exitCode: null,
+		durationMs: null
+	};
+	if (block.name === "edit" && typeof args?.file_path === "string") return {
+		type: "fileChange",
+		...base,
+		changes: [{
+			path: args.file_path,
+			kind: {
+				type: "update",
+				move_path: null
+			},
+			diff: `@@\n${removed(args.old_string)}\n${added(args.new_string)}`
+		}]
+	};
+	if (block.name === "write" && typeof args?.file_path === "string") return {
+		type: "fileChange",
+		...base,
+		changes: [{
+			path: args.file_path,
+			kind: { type: "add" },
+			diff: added(args.content)
+		}]
+	};
+	if (block.name === "codex_image_generate") return {
+		type: "imageGeneration",
+		...base,
+		revisedPrompt: typeof args?.prompt === "string" ? args.prompt : null,
+		result: ""
+	};
+	return {
+		type: "dynamicToolCall",
+		...base,
+		namespace: null,
+		tool: block.name,
+		arguments: args,
+		contentItems: null,
+		success: null,
+		durationMs: null
+	};
+}
+/** Record a tool's result on the item that showed the call. */
+function finishTool(item, message, imageUrls) {
+	const failed = Boolean(message.isError);
+	item.status = failed ? "failed" : "completed";
+	if (item.type === "commandExecution") {
+		item.aggregatedOutput = textOf(message.content);
+		item.exitCode = failed ? 1 : 0;
+	} else if (item.type === "imageGeneration") {
+		const url = imageBlocks(message).map((block) => imageUrls.get(block.attachment.attachmentId)).find(Boolean);
+		item.result = url ? url.slice(url.indexOf(",") + 1) : "";
+		if (!url) item.status = "failed";
+	} else if (item.type === "dynamicToolCall") {
+		item.contentItems = toolOutput(message, imageUrls);
+		item.success = !failed;
+	}
+}
+const imageBlocks = (message) => (message.content ?? []).filter((block) => block?.type === "image" && block.attachment);
+const toolOutput = (message, imageUrls) => [{
+	type: "inputText",
+	text: textOf(message.content)
+}, ...imageBlocks(message).map((block) => imageUrls.get(block.attachment.attachmentId)).filter(Boolean).map((imageUrl) => ({
+	type: "inputImage",
+	imageUrl
+}))];
 /** One user message starts a turn; assistant blocks and tool results fill it. */
-function projectTurns(messages, at = Date.now()) {
+/** Images the person attached to a message of their own. */
+const typedImages = (message) => message.role === "user" && (message.source === void 0 || message.source?.kind === "user") ? (message.content ?? []).filter((block) => block?.type === "image" && block.attachment) : [];
+/** `imageUrls` maps an attachment id to a data URL the phone can show; images without one are left out. */
+function projectTurns(messages, at = Date.now(), imageUrls = /* @__PURE__ */ new Map(), cwd = void 0) {
 	const turns = [];
 	let turn;
 	const calls = /* @__PURE__ */ new Map();
@@ -3403,7 +4001,8 @@ function projectTurns(messages, at = Date.now()) {
 	};
 	for (const message of messages) if (message.role === "user") {
 		const text = typedText(message);
-		if (text === "") continue;
+		const pictures = typedImages(message).map((block) => imageUrls.get(block.attachment.attachmentId)).filter(Boolean);
+		if (text === "" && pictures.length === 0) continue;
 		close();
 		turn = {
 			...emptyTurn(),
@@ -3414,11 +4013,14 @@ function projectTurns(messages, at = Date.now()) {
 			type: "userMessage",
 			id: message.id,
 			clientId: null,
-			content: [{
+			content: [...text === "" ? [] : [{
 				type: "text",
 				text,
 				text_elements: []
-			}]
+			}], ...pictures.map((url) => ({
+				type: "image",
+				url
+			}))]
 		});
 	} else if (message.role === "assistant") {
 		turn ??= {
@@ -3442,36 +4044,19 @@ function projectTurns(messages, at = Date.now()) {
 				content: [block.text]
 			});
 			else if (block.type === "tool-call") {
-				const item = {
-					type: "dynamicToolCall",
-					id: block.id,
-					namespace: null,
-					tool: block.name,
-					arguments: parseArguments(block.arguments),
-					status: "inProgress",
-					contentItems: null,
-					success: null,
-					durationMs: null
-				};
+				const item = toolItem(block, cwd);
 				calls.set(block.id, item);
 				turn.items.push(item);
 			}
 		}
 	} else if (message.role === "tool") {
 		const item = calls.get(message.toolCallId);
-		if (item) {
-			item.contentItems = [{
-				type: "inputText",
-				text: textOf(message.content)
-			}];
-			item.status = message.isError ? "failed" : "completed";
-			item.success = !message.isError;
-		}
+		if (item) finishTool(item, message, imageUrls);
 	}
 	close();
 	return turns;
 }
-function thread({ id, title, preview, cwd, createdAt, updatedAt, running, turns = [] }) {
+function thread({ id, title, preview, cwd, createdAt, updatedAt, running, turns = [], projectId = null }) {
 	return {
 		id,
 		sessionId: id,
@@ -3500,7 +4085,7 @@ function thread({ id, title, preview, cwd, createdAt, updatedAt, running, turns
 		historyMode: "legacy",
 		section: null,
 		sectionEnteredAt: null,
-		projectId: null,
+		projectId,
 		canAcceptDirectInput: true,
 		extra: null
 	};
@@ -3509,7 +4094,7 @@ function thread({ id, title, preview, cwd, createdAt, updatedAt, running, turns
 * @param {{ controller: () => any, agents: () => any, permissions?: () => any, userAgent: string }} options
 */
 const PHONE_RETURN_MS = 12e4;
-function createDshRemoteControl({ controller, agents, permissions = () => void 0, workspaces = () => void 0, trace = () => {}, phoneReturnMs = PHONE_RETURN_MS, userAgent }) {
+function createDshRemoteControl({ controller, agents, permissions = () => void 0, workspaces = () => void 0, attachments = () => void 0, usage = () => void 0, projections = () => void 0, skills = () => void 0, llm = () => void 0, trace = () => {}, phoneReturnMs = PHONE_RETURN_MS, userAgent }) {
 	const subscribers = /* @__PURE__ */ new Map();
 	const active = /* @__PURE__ */ new Map();
 	const queues = /* @__PURE__ */ new Map();
@@ -3581,6 +4166,69 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 			turnsBackwardsCursor: null
 		};
 	};
+	const searches = /* @__PURE__ */ new Map();
+	/** Folders of DSH workspaces and conversations: the only places the phone may search or run git. */
+	const conversationFolders = async () => {
+		const items = (await service().list({}).catch(() => ({ items: [] }))).items ?? [];
+		return [...workspaceList().map((entry) => entry.path), ...items.map((item) => item.cwd)].filter((folder) => typeof folder === "string" && folder !== "");
+	};
+	/** DSH's token and context-window projections as the phone's token-usage ring. */
+	const tokenUsage = (session) => {
+		try {
+			const values = projections()?.snapshot?.(session, ["tokenUsage", "contextPressure"])?.values;
+			const used = values?.tokenUsage;
+			if (!used) return void 0;
+			const breakdown = (total, input, cached, output) => ({
+				totalTokens: total,
+				inputTokens: input,
+				cachedInputTokens: cached,
+				cacheWriteInputTokens: 0,
+				outputTokens: output,
+				reasoningOutputTokens: 0
+			});
+			const input = (used.uncachedInputTokens ?? 0) + (used.cacheReadTokens ?? 0) + (used.cacheWriteTokens ?? 0);
+			const pressure = values.contextPressure?.pressureTokens ?? 0;
+			return {
+				total: breakdown(input + (used.outputTokens ?? 0), input, used.cacheReadTokens ?? 0, used.outputTokens ?? 0),
+				last: breakdown(pressure, pressure, 0, 0),
+				modelContextWindow: values.contextPressure?.contextWindow ?? null
+			};
+		} catch {
+			return;
+		}
+	};
+	const workspaceList = () => {
+		try {
+			return workspaces()?.list?.() ?? [];
+		} catch {
+			return [];
+		}
+	};
+	const projectIdOf = (sessionId) => workspaceList().find((entry) => entry.sessionIds?.includes(sessionId))?.id ?? null;
+	const projectOf = (entry, position) => ({
+		id: String(entry.id),
+		name: entry.title || String(entry.path).split(/[\/]/u).filter(Boolean).at(-1) || "Workspace",
+		roots: [{ path: entry.path }],
+		metadata: {},
+		position,
+		createdAt: seconds(entry.createdAt),
+		updatedAt: seconds(entry.updatedAt),
+		recencyAt: entry.sessionIds?.length ? seconds(entry.updatedAt) : null
+	});
+	/** Data URLs for the images in a conversation (newest first, bounded), so the phone can show them. */
+	const imageUrlsOf = async (messages) => {
+		const urls = /* @__PURE__ */ new Map();
+		const store = attachments();
+		if (!store) return urls;
+		const wanted = messages.flatMap((message) => message.role === "tool" || typedImages(message).length > 0 ? imageBlocks(message) : []).toReversed().slice(0, 12);
+		await Promise.all(wanted.map(async (block) => {
+			try {
+				const stored = await store.readImage(block.attachment, AbortSignal.timeout(1e4));
+				urls.set(block.attachment.attachmentId, `data:${stored.ref.mediaType};base64,${Buffer.from(stored.data).toString("base64")}`);
+			} catch {}
+		}));
+		return urls;
+	};
 	const openThread = async (id, notify) => {
 		const agent = await agentFor(id);
 		if (notify) subscribe(id, notify);
@@ -3588,6 +4236,7 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 		const session = agent.session;
 		const messages = session.deriveMessages();
 		const first = messages.find((message) => typedText(message) !== "");
+		const imageUrls = await imageUrlsOf(messages);
 		return {
 			agent,
 			thread: thread({
@@ -3595,8 +4244,9 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 				cwd: session.meta?.cwd,
 				createdAt: session.meta?.createdAt,
 				running: active.has(id),
+				projectId: projectIdOf(id),
 				preview: first ? visibleText(first.content).slice(0, 200) : "",
-				turns: projectTurns(messages, session.meta?.createdAt)
+				turns: projectTurns(messages, session.meta?.createdAt, imageUrls, session.meta?.cwd)
 			})
 		};
 	};
@@ -3703,9 +4353,33 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 			completedAt: null
 		} };
 	};
+	/** Message content for DSH from what the phone sent: its text plus any inline images (DSH admits and stores them itself). */
+	const contentOf = (input) => {
+		const text = [...skillGestures(input), inputText(input)].filter(Boolean).join(" ");
+		const pictures = inputImages(input);
+		if (text === "" && pictures.length === 0) throw invalidParams("Send some text or an image");
+		if (pictures.length > MAX_PHONE_IMAGES) throw invalidParams(`At most ${MAX_PHONE_IMAGES} images per message`);
+		const images = pictures.map((picture) => {
+			const image = dataImage(picture.url);
+			if (!image) throw invalidParams("Only images sent inline are supported");
+			return {
+				type: "image",
+				data: Buffer.from(image.data).toString("base64"),
+				mediaType: image.mediaType,
+				name: "phone-image"
+			};
+		});
+		return {
+			text,
+			pictures,
+			content: [...text === "" ? [] : [{
+				type: "text",
+				text
+			}], ...images]
+		};
+	};
 	async function startTurn(params, notify) {
-		const text = inputText(params?.input);
-		if (text === "") throw invalidParams("Only text input is supported");
+		const { text, pictures, content } = contentOf(params?.input);
 		lastPrompt.text = text;
 		const id = params?.threadId;
 		const agent = await agentFor(id);
@@ -3722,16 +4396,26 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 			type: "userMessage",
 			id: randomUUID(),
 			clientId: params.clientUserMessageId ?? null,
-			content: [{
+			content: [...text === "" ? [] : [{
 				type: "text",
 				text,
 				text_elements: []
-			}]
+			}], ...pictures.map((picture) => ({
+				type: "image",
+				url: picture.url
+			}))]
 		};
 		emit(id, "turn/started", {
 			threadId: id,
 			turn
 		});
+		emit(id, "thread/status/changed", {
+			threadId: id,
+			status: {
+				type: "active",
+				activeFlags: []
+			}
+		});
 		emit(id, "item/started", {
 			threadId: id,
 			turnId: turn.id,
@@ -3749,10 +4433,7 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 				requestId: randomUUID(),
 				sessionId: id,
 				mode: "queue",
-				content: [{
-					type: "text",
-					text
-				}]
+				content
 			}, AbortSignal.timeout(3e4));
 		} catch (error) {
 			active.delete(id);
@@ -3777,10 +4458,20 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 			}
 			turn.completedAt = seconds(Date.now());
 			active.delete(id);
+			const usageNow = tokenUsage(agent.session);
+			if (usageNow) emit(id, "thread/tokenUsage/updated", {
+				threadId: id,
+				turnId: turn.id,
+				tokenUsage: usageNow
+			});
 			emit(id, "turn/completed", {
 				threadId: id,
 				turn
 			});
+			emit(id, "thread/status/changed", {
+				threadId: id,
+				status: { type: "idle" }
+			});
 			const [next, ...rest] = queues.get(id) ?? [];
 			if (next) {
 				queues.set(id, rest);
@@ -3804,11 +4495,11 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 			}[process.platform] ?? process.platform,
 			userAgent
 		}),
-		"account/read": () => ({
+		"account/read": async () => ({
 			account: {
 				type: "chatgpt",
 				email: null,
-				planType: "unknown"
+				planType: (await usage()?.read?.().catch(() => void 0))?.planType ?? "unknown"
 			},
 			requiresOpenaiAuth: false
 		}),
@@ -3821,36 +4512,42 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 			const value = await loadCatalog();
 			const defaultKey = value.default ? modelKey(value.default) : void 0;
 			const data = [];
-			for (const group of value.groups ?? []) for (const model of group.models ?? []) {
-				const key = modelKey({
-					provider: group.id,
-					model: model.id
-				});
-				const efforts = (model.reasoning?.efforts ?? []).map((effort) => ({
-					reasoningEffort: effort.id,
-					description: effort.name ?? effort.id
-				}));
-				const supported = efforts.length > 0 ? efforts : [{
-					reasoningEffort: "medium",
-					description: "Default"
-				}];
-				data.push({
-					id: key,
-					model: key,
-					displayName: model.name ?? model.id,
-					description: group.name ?? "",
-					hidden: false,
-					isDefault: key === defaultKey,
-					supportedReasoningEfforts: supported,
-					defaultReasoningEffort: model.reasoning?.defaultEffort ?? supported[0].reasoningEffort,
-					inputModalities: ["text"],
-					supportsPersonality: false,
-					additionalSpeedTiers: [],
-					upgrade: null,
-					upgradeInfo: null,
-					availabilityNux: null,
-					serviceTiers: []
-				});
+			for (const group of value.groups ?? []) {
+				const modalities = new Map(await Promise.all((group.models ?? []).map(async (model) => {
+					const info = await Promise.resolve(llm()?.resolveModelInfo?.(group.id, model.id)).catch(() => void 0);
+					return [model.id, (Array.isArray(info?.inputModalities) ? info.inputModalities : ["text"]).filter((kind) => kind === "text" || kind === "image")];
+				})));
+				for (const model of group.models ?? []) {
+					const key = modelKey({
+						provider: group.id,
+						model: model.id
+					});
+					const efforts = (model.reasoning?.efforts ?? []).map((effort) => ({
+						reasoningEffort: effort.id,
+						description: effort.name ?? effort.id
+					}));
+					const supported = efforts.length > 0 ? efforts : [{
+						reasoningEffort: "medium",
+						description: "Default"
+					}];
+					data.push({
+						id: key,
+						model: key,
+						displayName: model.name ?? model.id,
+						description: group.name ?? "",
+						hidden: false,
+						isDefault: key === defaultKey,
+						supportedReasoningEfforts: supported,
+						defaultReasoningEffort: model.reasoning?.defaultEffort ?? supported[0].reasoningEffort,
+						inputModalities: modalities.get(model.id)?.length ? modalities.get(model.id) : ["text"],
+						supportsPersonality: false,
+						additionalSpeedTiers: [],
+						upgrade: null,
+						upgradeInfo: null,
+						availabilityNux: null,
+						serviceTiers: []
+					});
+				}
 			}
 			return {
 				data,
@@ -3878,22 +4575,32 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 			filePath: process.platform === "win32" ? "C:dshconfig.toml" : "/dsh/config.toml",
 			overriddenMetadata: null
 		}),
-		"command/exec": () => {
-			throw new RpcError(-32600, "Running commands directly is not available on a DSH host; ask in the conversation instead");
+		"command/exec": async (params) => {
+			const folders = await conversationFolders();
+			try {
+				return await runGit(params, { folders });
+			} catch (error) {
+				trace({
+					method: "command/exec:refused",
+					reason: String(error?.message).slice(0, 80),
+					command: Array.isArray(params?.command) ? params.command.slice(0, 3).map((part) => String(part).slice(0, 40)) : null
+				});
+				throw new RpcError(-32600, error?.code === "not-allowed" ? `Not available on a DSH host: ${error.message}` : "Could not run the command");
+			}
 		},
 		"plugin/installed": () => ({
 			marketplaceLoadErrors: [],
 			marketplaces: []
 		}),
 		"fs/createDirectory": () => ({}),
-		"fs/getMetadata": () => ({
+		"fs/getMetadata": (params) => realMetadata(params?.path) ?? {
 			isDirectory: true,
 			isFile: false,
 			isSymlink: false,
 			createdAtMs: Date.now(),
 			modifiedAtMs: Date.now()
-		}),
-		"fs/readDirectory": () => ({ entries: [] }),
+		},
+		"fs/readDirectory": (params) => ({ entries: readFolder(params?.path) }),
 		"collaborationMode/list": () => ({ data: [] }),
 		"permissionProfile/list": () => ({
 			data: [],
@@ -3908,7 +4615,6 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 			data: [],
 			nextCursor: null
 		}),
-		"skills/list": () => ({ data: [] }),
 		"config/read": () => ({
 			config: {},
 			origins: {},
@@ -3923,19 +4629,114 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 			const value = await service().list({}, signal);
 			const archived = new Set(workspaces()?.archivedSessionIds ?? []);
 			const wantArchived = params?.archived === true;
+			const excluded = new Set(Array.isArray(params?.excludedThreadIds) ? params.excludedThreadIds : []);
+			const folders = [params?.cwd].flat().filter((entry) => typeof entry === "string");
+			const members = typeof params?.projectId === "string" ? new Set(workspaceList().find((entry) => String(entry.id) === params.projectId)?.sessionIds ?? []) : void 0;
+			const needle = params?.searchTerm ? String(params.searchTerm).toLocaleLowerCase() : "";
+			return page((value.items ?? []).filter((item) => item.origin !== "subagent" && !item.blank && archived.has(item.sessionId) === wantArchived && !excluded.has(item.sessionId) && (folders.length === 0 || folders.includes(item.cwd)) && (members === void 0 || members.has(item.sessionId))).map((item) => thread({
+				id: item.sessionId,
+				cwd: item.cwd,
+				createdAt: item.updatedAt,
+				updatedAt: item.updatedAt,
+				projectId: projectIdOf(item.sessionId),
+				running: item.running,
+				title: item.projections?.values?.title ?? null
+			})).filter((entry) => !needle || `${entry.name ?? ""} ${entry.preview}`.toLocaleLowerCase().includes(needle)), params);
+		},
+		"project/list": (params) => page(workspaceList().map(projectOf), params),
+		"project/read": async (params) => {
+			const list = workspaceList();
+			const index = list.findIndex((entry) => String(entry.id) === params?.projectId);
+			if (index < 0) throw new RpcError(-32602, `Project not found: ${String(params?.projectId).slice(0, 80)}`);
+			return { project: projectOf(list[index], index) };
+		},
+		"account/rateLimits/read": async () => rateLimits(await usage()?.read?.().catch(() => void 0)),
+		"thread/turns/list": async (params) => {
+			const { thread: value } = await openThread(params?.threadId);
+			const ordered = params?.sortDirection === "asc" ? value.turns : value.turns.toReversed();
+			return {
+				...page(ordered, params),
+				backwardsCursor: ordered.length ? String(0) : null
+			};
+		},
+		"thread/fork": async (params, { notify }) => {
+			const forked = await service().fork({ sessionId: params?.threadId });
+			const agent = await agentFor(forked.sessionId);
+			await applySelection(agent, forked.sessionId, params);
+			const { thread: value } = await openThread(forked.sessionId, notify);
+			emit(forked.sessionId, "thread/started", { thread: value });
 			return {
-				data: (value.items ?? []).filter((item) => item.origin !== "subagent" && !item.blank && archived.has(item.sessionId) === wantArchived).map((item) => thread({
-					id: item.sessionId,
-					cwd: item.cwd,
-					createdAt: item.updatedAt,
-					updatedAt: item.updatedAt,
-					running: item.running,
-					title: item.projections?.values?.title ?? null
-				})).filter((entry) => !params?.searchTerm || `${entry.name ?? ""} ${entry.preview}`.toLocaleLowerCase().includes(String(params.searchTerm).toLocaleLowerCase())),
-				nextCursor: null,
-				backwardsCursor: null
+				...settings(agent, value.cwd),
+				thread: value
 			};
 		},
+		"thread/readState/update": () => ({}),
+		fuzzyFileSearch: async (params) => ({ files: await searchFiles({
+			roots: params?.roots ?? [],
+			query: String(params?.query ?? ""),
+			folders: await conversationFolders()
+		}) }),
+		"fuzzyFileSearch/sessionStart": (params, { notify }) => {
+			searches.set(params?.sessionId, {
+				roots: params?.roots ?? [],
+				notify
+			});
+			return {};
+		},
+		"fuzzyFileSearch/sessionUpdate": async (params) => {
+			const search = searches.get(params?.sessionId);
+			if (search) {
+				const query = String(params?.query ?? "");
+				const files = await searchFiles({
+					roots: search.roots,
+					query,
+					folders: await conversationFolders()
+				});
+				search.notify("fuzzyFileSearch/sessionUpdated", {
+					sessionId: params.sessionId,
+					query,
+					files
+				}).catch(() => {});
+				search.notify("fuzzyFileSearch/sessionCompleted", { sessionId: params.sessionId }).catch(() => {});
+			}
+			return {};
+		},
+		"fuzzyFileSearch/sessionStop": (params) => {
+			searches.delete(params?.sessionId);
+			return {};
+		},
+		"skills/list": async (params, { signal }) => {
+			const registry = skills();
+			const folders = Array.isArray(params?.cwds) && params.cwds.length > 0 ? params.cwds : [workspaceList()[0]?.path ?? ""];
+			return { data: await Promise.all(folders.map(async (cwd) => {
+				try {
+					return {
+						cwd,
+						errors: [],
+						skills: (await registry?.list?.({
+							cwd: cwd || void 0,
+							signal
+						}) ?? []).filter((skill) => skill?.invocation?.userInvocable !== false).map((skill) => ({
+							name: skill.name,
+							description: skill.description ?? "",
+							shortDescription: null,
+							interface: null,
+							dependencies: null,
+							path: skill.path ?? skill.name,
+							scope: "user",
+							enabled: true,
+							pluginId: null
+						}))
+					};
+				} catch {
+					return {
+						cwd,
+						skills: [],
+						errors: []
+					};
+				}
+			})) };
+		},
 		"thread/archive": async (params) => {
 			const registry = workspaces();
 			if (!registry) throw new RpcError(-32603, "DSH archive is unavailable in this profile");
@@ -3964,7 +4765,8 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 		"thread/start": async (params, { notify }) => {
 			if (params?.ephemeral === true) return titleThread(params);
 			const cwd = localFolder(params?.cwd);
-			const created = await service().create(cwd ? { cwd } : {});
+			const project = typeof params?.projectId === "string" ? workspaceList().find((entry) => String(entry.id) === params.projectId) : void 0;
+			const created = await service().create(project ? { workspaceId: project.id } : cwd ? { cwd } : {});
 			const agent = await agentFor(created.sessionId);
 			await applySelection(agent, created.sessionId, params);
 			const { thread: value } = await openThread(created.sessionId, notify);
@@ -3980,16 +4782,12 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 			return {};
 		},
 		"turn/steer": async (params) => {
-			const text = inputText(params?.input);
-			if (text === "") throw invalidParams("Only text input is supported");
+			const { content } = contentOf(params?.input);
 			await service().prompt({
 				requestId: randomUUID(),
 				sessionId: params?.threadId,
 				mode: "steer",
-				content: [{
-					type: "text",
-					text
-				}]
+				content
 			}, AbortSignal.timeout(3e4));
 			return { turnId: params?.expectedTurnId ?? active.get(params?.threadId)?.turn.id ?? "" };
 		},
@@ -4087,6 +4885,26 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 	*/
 	const askPhone = async (request, method, params) => {
 		const sessionId = request.agent.session.id;
+		emit(sessionId, "thread/status/changed", {
+			threadId: sessionId,
+			status: {
+				type: "active",
+				activeFlags: [method === "item/tool/requestUserInput" ? "waitingOnUserInput" : "waitingOnApproval"]
+			}
+		});
+		try {
+			return await asked(request, method, params, sessionId);
+		} finally {
+			if (active.has(sessionId)) emit(sessionId, "thread/status/changed", {
+				threadId: sessionId,
+				status: {
+					type: "active",
+					activeFlags: []
+				}
+			});
+		}
+	};
+	const asked = async (request, method, params, sessionId) => {
 		for (;;) {
 			const phone = phoneFor(request)?.phone;
 			if (!phone) throw new RpcError(-32800, "No phone");
@@ -4117,6 +4935,7 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 			threadId: session.id,
 			turnId: running.turn.id,
 			itemId: request.wait?.callId ?? randomUUID(),
+			isBlocking: true,
 			questions: request.questions.map((question) => ({
 				id: question.id,
 				header: question.header ?? "",
@@ -4149,21 +4968,30 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 		});
 		if (!found) return next();
 		const { session, running } = found;
-		return askPhone(request, "item/commandExecution/requestApproval", {
+		const call = request.callId ? callOf(session, request.callId) : void 0;
+		const reason = request.displayReason?.en ?? request.reason ?? null;
+		const common = {
 			threadId: session.id,
 			turnId: running.turn.id,
 			itemId: request.callId ?? randomUUID(),
-			startedAtMs: Date.now(),
+			startedAtMs: Date.now()
+		};
+		return (call && (call.name === "edit" || call.name === "write") ? askPhone(request, "item/fileChange/requestApproval", {
+			...common,
+			reason,
+			grantRoot: null
+		}) : askPhone(request, "item/commandExecution/requestApproval", {
+			...common,
 			command: commandText(session, request),
 			cwd: session.meta?.cwd ?? null,
-			reason: request.displayReason?.en ?? request.reason ?? null,
+			reason,
 			commandActions: [],
 			availableDecisions: [
 				"accept",
 				"decline",
 				"cancel"
 			]
-		}).then((answer) => {
+		})).then((answer) => {
 			const decision = typeof answer?.decision === "string" ? answer.decision : "";
 			return decision === "accept" || decision === "acceptForSession" ? "allowed-once" : decision === "cancel" ? "cancelled" : "rejected";
 		}, () => next());
@@ -4225,6 +5053,10 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 	};
 	/** Forward committed assistant and tool events of a phone-started turn as items. */
 	const onSessionEvent = (session, event) => {
+		if (event.type === "session/title" && typeof event.data?.title === "string" && subscribers.has(session.id)) emit(session.id, "thread/name/updated", {
+			threadId: session.id,
+			threadName: event.data.title
+		});
 		const running = active.get(session.id);
 		if (!running || !subscribers.has(session.id)) return;
 		if (event.type === "turn/end") {
@@ -4234,20 +5066,19 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 		if (event.type !== "assistant/message" && event.type !== "tool/result") return;
 		const message = session.deriveMessages().at(-1);
 		if (message?.role === "tool") {
-			const item = running.turn.items.find((entry) => entry.type === "dynamicToolCall" && entry.id === message.toolCallId);
+			const item = running.turn.items.find((entry) => entry.id === message.toolCallId && entry.type !== "agentMessage");
 			if (item) {
-				item.contentItems = [{
-					type: "inputText",
-					text: textOf(message.content)
-				}];
-				item.status = message.isError ? "failed" : "completed";
-				item.success = !message.isError;
-				emit(session.id, "item/completed", {
-					threadId: session.id,
-					turnId: running.turn.id,
-					item,
-					completedAtMs: Date.now()
-				});
+				const finish = (imageUrls) => {
+					finishTool(item, message, imageUrls);
+					emit(session.id, "item/completed", {
+						threadId: session.id,
+						turnId: running.turn.id,
+						item,
+						completedAtMs: Date.now()
+					});
+				};
+				if (imageBlocks(message).length > 0) imageUrlsOf([message]).then(finish, () => finish(/* @__PURE__ */ new Map()));
+				else finish(/* @__PURE__ */ new Map());
 			}
 			return;
 		}
@@ -4259,10 +5090,29 @@ function createDshRemoteControl({ controller, agents, permissions = () => void 0
 				type: "text",
 				text: "x"
 			}]
-		}, message]).flatMap((turn) => turn.items.slice(1));
+		}, message], void 0, void 0, session.meta?.cwd).flatMap((turn) => turn.items.slice(1));
 		const stream = streams.get(session.id);
 		streams.delete(session.id);
 		let reuse = stream?.item;
+		for (const block of message.content) {
+			if (block.type !== "tool-call" || block.name !== "todo_write") continue;
+			const todos = parseArguments(block.arguments)?.todos;
+			if (!Array.isArray(todos)) continue;
+			const status = {
+				pending: "pending",
+				in_progress: "inProgress",
+				completed: "completed"
+			};
+			emit(session.id, "turn/plan/updated", {
+				threadId: session.id,
+				turnId: running.turn.id,
+				explanation: null,
+				plan: todos.filter((todo) => typeof todo?.content === "string").map((todo) => ({
+					step: todo.content,
+					status: status[todo.status] ?? "pending"
+				}))
+			});
+		}
 		for (const item of items) {
 			if (reuse && item.type === "agentMessage") {
 				const shown = reuse;
@@ -6570,21 +7420,35 @@ function creditExpiry({ planType, balance, apiExpiresAt }, now = Date.now()) {
 	};
 }
 //#endregion
+//#region src/quota-cadence.js
+/** Milliseconds until the next quota read, from the highest used percentage of the windows that matter. */
+function quotaRefreshMs(percent) {
+	if (!Number.isFinite(percent)) return 6e4;
+	if (percent >= 99) return 5e3;
+	if (percent >= 90) return 15e3;
+	if (percent >= 75) return 3e4;
+	return 6e4;
+}
+/** Highest used percentage among windows (objects with usedPercent), or undefined when there are none. */
+function highestUsed(windows) {
+	const values = (Array.isArray(windows) ? windows : []).map((window) => window?.usedPercent).filter(Number.isFinite);
+	return values.length === 0 ? void 0 : Math.max(...values);
+}
+//#endregion
 //#region src/usage.js
 const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
-const DEFAULT_TTL_MS = 6e4;
 const DEFAULT_TIMEOUT_MS$1 = 15e3;
 const DEFAULT_FAILURE_TTL_MS = 5e3;
 const DEFAULT_MAX_RETRY_AFTER_MS = 5 * 6e4;
 const record$1 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-function windowOf(value) {
+function windowOf(value, nowSeconds) {
 	if (value === void 0 || value === null) return void 0;
 	if (!record$1(value)) throw new Error("Codex returned a malformed rate-limit window");
 	const used = value.used_percent;
 	const seconds = value.limit_window_seconds;
 	if (!Number.isFinite(used) || used < 0 || used > 100) throw new Error("Codex returned an invalid used percentage");
 	if (!Number.isInteger(seconds) || seconds <= 0) throw new Error("Codex returned an invalid window duration");
-	const resetsAt = epochSeconds(value.reset_at, "rate-limit reset time");
+	const resetsAt = epochSeconds(value.reset_at, "rate-limit reset time") ?? (Number.isInteger(value.reset_after_seconds) && value.reset_after_seconds > 0 && Number.isFinite(nowSeconds) ? nowSeconds + value.reset_after_seconds : void 0);
 	return {
 		usedPercent: used,
 		remainingPercent: 100 - used,
@@ -6592,10 +7456,10 @@ function windowOf(value) {
 		...resetsAt === void 0 ? {} : { resetsAt }
 	};
 }
-function limitOf(id, name, value) {
+function limitOf(id, name, value, nowSeconds) {
 	if (value === void 0 || value === null) return void 0;
 	if (!record$1(value)) throw new Error("Codex returned malformed rate-limit details");
-	const windows = [windowOf(value.primary_window), windowOf(value.secondary_window)].filter(Boolean);
+	const windows = [windowOf(value.primary_window, nowSeconds), windowOf(value.secondary_window, nowSeconds)].filter(Boolean);
 	return windows.length === 0 ? void 0 : {
 		id,
 		...name ? { name } : {},
@@ -6695,7 +7559,8 @@ function resetCreditsOf(value) {
 	};
 }
 /** Reduce the provider payload to a browser-safe quota projection. */
-function parseCodexUsage(value) {
+function parseCodexUsage(value, nowMs = Date.now()) {
+	const nowSeconds = Math.floor(nowMs / 1e3);
 	if (!record$1(value)) throw new Error("Codex returned a malformed usage response");
 	const rateLimits = [];
 	const seenLimitIds = /* @__PURE__ */ new Set();
@@ -6704,21 +7569,27 @@ function parseCodexUsage(value) {
 		seenLimitIds.add(limit.id);
 		rateLimits.push(limit);
 	};
-	addLimit(limitOf("codex", "Codex", value.rate_limit));
+	addLimit(limitOf("codex", "Codex", value.rate_limit, nowSeconds));
 	if (value.additional_rate_limits !== void 0 && value.additional_rate_limits !== null && !Array.isArray(value.additional_rate_limits)) throw new Error("Codex returned malformed additional rate limits");
 	for (const entry of value.additional_rate_limits ?? []) {
 		if (!record$1(entry) || typeof entry.metered_feature !== "string" || entry.metered_feature.length === 0) throw new Error("Codex returned a malformed additional rate limit");
 		if (entry.limit_name !== void 0 && entry.limit_name !== null && typeof entry.limit_name !== "string") throw new Error("Codex returned an invalid additional rate-limit name");
-		addLimit(limitOf(entry.metered_feature, entry.limit_name || void 0, entry.rate_limit));
+		addLimit(limitOf(entry.metered_feature, entry.limit_name || void 0, entry.rate_limit, nowSeconds));
 	}
-	addLimit(limitOf("code_review", "Code review", value.code_review_rate_limit));
+	addLimit(limitOf("code_review", "Code review", value.code_review_rate_limit, nowSeconds));
 	const chatPass = chatPassOf(value.chatpass);
 	const credits = creditsOf(value.credits, typeof value.plan_type === "string" ? value.plan_type : void 0);
 	const individualLimit = individualOf(value.spend_control);
 	const spendControlReached = spendControlReachedOf(value.spend_control);
 	const resetCredits = resetCreditsOf(value.rate_limit_reset_credits);
+	const planType = typeof value.plan_type === "string" && /^[a-z][a-z_]{0,31}$/u.test(value.plan_type) ? value.plan_type : void 0;
+	const reached = value.rate_limit_reached_type;
+	const reachedRaw = typeof reached === "string" ? reached : record$1(reached) ? reached.type : void 0;
+	const rateLimitReachedType = typeof reachedRaw === "string" && /^[a-z][a-z_]{0,63}$/u.test(reachedRaw) ? reachedRaw : void 0;
 	return {
 		rateLimits,
+		...rateLimitReachedType === void 0 ? {} : { rateLimitReachedType },
+		...planType === void 0 ? {} : { planType },
 		...chatPass === void 0 ? {} : { chatPass },
 		...credits === void 0 ? {} : { credits },
 		...individualLimit === void 0 ? {} : { individualLimit },
@@ -6749,7 +7620,7 @@ function createCodexUsageReader(options) {
 	const readCredential = options.readCredential;
 	const fetchUsage = options.fetch ?? fetch;
 	const now = options.now ?? Date.now;
-	const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+	const ttlFor = (value) => options.ttlMs ?? quotaRefreshMs(highestUsed(value?.rateLimits?.find((limit) => limit.id === "codex")?.windows));
 	const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS$1;
 	const failureTtlMs = options.failureTtlMs ?? DEFAULT_FAILURE_TTL_MS;
 	const maxRetryAfterMs = options.maxRetryAfterMs ?? DEFAULT_MAX_RETRY_AFTER_MS;
@@ -6784,14 +7655,14 @@ function createCodexUsageReader(options) {
 			throw new Error("ChatGPT returned an unreadable usage response");
 		}
 		return {
-			...parseCodexUsage(value),
+			...parseCodexUsage(value, now()),
 			fetchedAt: now()
 		};
 	};
 	return Object.freeze({
 		read({ force = false, signal } = {}) {
 			if (failed !== void 0 && now() < failed.retryAt) return Promise.reject(new Error(failed.message));
-			if (!force && cached !== void 0 && now() - cached.fetchedAt < ttlMs) return Promise.resolve(structuredClone(cached));
+			if (!force && cached !== void 0 && now() - cached.fetchedAt < ttlFor(cached)) return Promise.resolve(structuredClone(cached));
 			if (inFlight !== void 0) return inFlight.then(structuredClone);
 			const currentGeneration = generation;
 			const current = load(signal).then((value) => {
@@ -6875,6 +7746,7 @@ function createWakeSignal() {
 	};
 }
 function shortResetDelay(usage, nowMs, maxWaitMs, resetMarginMs) {
+	if (typeof usage?.rateLimitReachedType === "string" && /^(?:workspace_|.*credits_depleted)/u.test(usage.rateLimitReachedType)) return void 0;
 	let latestDelayMs;
 	for (const limit of usage?.rateLimits ?? []) {
 		if (limit?.id !== "codex") continue;
@@ -7709,14 +8581,16 @@ function createSubscriptionRpcHandler({ authHandler, usageReader, resetCreditSer
 			"remote/status",
 			"remote/enable",
 			"remote/disable",
-			"remote/pair"
+			"remote/pair",
+			"remote/clients",
+			"remote/revoke"
 		].includes(endpoint)) try {
 			signal.throwIfAborted();
 			if (!remoteControl) return publicError("unavailable", "Remote Control is unavailable");
 			const action = endpoint.split("/")[1];
 			return {
 				ok: true,
-				value: action === "status" ? remoteControl.status() : action === "enable" ? await remoteControl.enable() : action === "disable" ? await remoteControl.disable() : await remoteControl.pair(signal)
+				value: action === "status" ? remoteControl.status() : action === "enable" ? await remoteControl.enable() : action === "disable" ? await remoteControl.disable() : action === "clients" ? await remoteControl.clients(signal) : action === "revoke" ? await remoteControl.revoke(payload?.clientId, signal) : await remoteControl.pair(signal)
 			};
 		} catch (error) {
 			if (signal.aborted) throw error;
@@ -8249,6 +9123,11 @@ function apply(ctx, config = {}) {
 		agents: () => ctx.get?.("agents"),
 		permissions: () => ctx.get?.("permissionPresets"),
 		workspaces: () => ctx.get?.("workspaceRegistry"),
+		attachments: () => ctx.attachments,
+		usage: () => usageReader,
+		projections: () => ctx.get?.("sessionProjections"),
+		skills: () => ctx.get?.("skills"),
+		llm: () => ctx.llm,
 		trace: (entry) => {
 			try {
 				remoteControl.host.note(entry);
@@ -8266,6 +9145,7 @@ function apply(ctx, config = {}) {
 		stateFile: dshHomePath("state", "codex-subscription", "remote-control.json"),
 		hostName: `DSH (${hostname()})`,
 		userAgent: USER_AGENT,
+		base: process.env.DSH_CODEX_REMOTE_BASE || void 0,
 		methods: remoteBridge.methods,
 		onClose: (_client, notify) => remoteBridge.forget(notify)
 	});