remote-codex 0.11.9 → 0.11.11

package/apps/supervisor-api/dist/{chunk-NWZLUCQV.js → chunk-2QAVWDYV.js}

@@ -10,7 +10,7 @@ import multipart from "@fastify/multipart";
 import websocket from "@fastify/websocket";
 import { spawn as spawn5 } from "child_process";
 import fs26 from "fs";
-import path24 from "path";
+import path25 from "path";
 import { ZodError } from "zod";
 
 // ../../packages/config/src/index.ts
@@ -176,7 +176,7 @@ function loadRuntimeConfig(env = process.env) {
     nodeEnv === "production"
   );
   const enabledProviders = new Set(
-    (parsed.REMOTE_CODEX_ENABLED_AGENT_PROVIDERS ?? agentBackendIds.join(",")).split(",").map((provider) => provider.trim().toLowerCase()).filter(Boolean)
+    (parsed.REMOTE_CODEX_ENABLED_AGENT_PROVIDERS ?? agentBackendIds.join(",")).split(",").map((provider2) => provider2.trim().toLowerCase()).filter(Boolean)
   );
   const defaultAgentHomeRoot = runtimeRole === "worker" ? "/home/agent" : os.homedir();
   const codexHome = parsed.CODEX_HOME?.trim() ? path.resolve(parsed.CODEX_HOME) : path.join(defaultAgentHomeRoot, agentBackendMetadata.codex.defaultHomeDir);
@@ -465,15 +465,15 @@ var AgentRuntimeRegistry = class {
   }
   defaultProvider;
   runtimes = /* @__PURE__ */ new Map();
-  get(provider) {
-    const runtime = this.runtimes.get(provider);
+  get(provider2) {
+    const runtime = this.runtimes.get(provider2);
     if (!runtime) {
-      throw new Error(`Agent runtime provider is not configured: ${provider}`);
+      throw new Error(`Agent runtime provider is not configured: ${provider2}`);
     }
     return runtime;
   }
-  getOptional(provider) {
-    return this.runtimes.get(provider) ?? null;
+  getOptional(provider2) {
+    return this.runtimes.get(provider2) ?? null;
   }
   all() {
     return [...this.runtimes.values()];
@@ -501,9 +501,9 @@ var transientAgentHistoryItemSymbol = /* @__PURE__ */ Symbol(
   "remoteCodex.transientAgentHistoryItem"
 );
 var AgentRuntimeError = class extends Error {
-  constructor(message, provider, code = "request_failed", details, cause) {
+  constructor(message, provider2, code = "request_failed", details, cause) {
     super(message);
-    this.provider = provider;
+    this.provider = provider2;
     this.code = code;
     this.details = details;
     this.cause = cause;
@@ -2316,7 +2316,7 @@ Subquery.prototype.getSQL = function() {
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce(
-    (result2, { path: path25, field }, columnIndex) => {
+    (result2, { path: path26, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -2326,8 +2326,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         decoder = field.sql.decoder;
       }
       let node = result2;
-      for (const [pathChunkIndex, pathChunk] of path25.entries()) {
-        if (pathChunkIndex < path25.length - 1) {
+      for (const [pathChunkIndex, pathChunk] of path26.entries()) {
+        if (pathChunkIndex < path26.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -2335,8 +2335,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         } else {
           const rawValue = row[columnIndex];
           const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
-          if (joinsNotNullableMap && is(field, Column) && path25.length === 2) {
-            const objectName = path25[0];
+          if (joinsNotNullableMap && is(field, Column) && path26.length === 2) {
+            const objectName = path26[0];
             if (!(objectName in nullifyMap)) {
               nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
             } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
@@ -7008,10 +7008,10 @@ function listThreadRecordsByWorkspaceId(db, workspaceId) {
 function getThreadRecordById(db, id) {
   return db.select().from(threads).where(eq(threads.id, id)).get();
 }
-function getThreadRecordByProviderSessionId(db, provider, providerSessionId) {
+function getThreadRecordByProviderSessionId(db, provider2, providerSessionId) {
   return db.select().from(threads).where(
     and(
-      eq(threads.provider, provider),
+      eq(threads.provider, provider2),
       eq(threads.providerSessionId, providerSessionId)
     )
   ).get();
@@ -7956,6 +7956,15 @@ function mapTurn(record) {
     items: Array.isArray(record.items) ? record.items : []
   };
 }
+function textOnlyUserInput(prompt) {
+  return [
+    {
+      type: "text",
+      text: prompt,
+      text_elements: []
+    }
+  ];
+}
 function mapModel(record) {
   return {
     id: record.id,
@@ -8279,13 +8288,7 @@ var CodexAppServerManager = class extends EventEmitter3 {
     await this.ensureReady();
     const response = await this.client.request("turn/start", {
       threadId: input.threadId,
-      input: [
-        {
-          type: "text",
-          text: input.prompt,
-          text_elements: []
-        }
-      ],
+      input: input.input ?? textOnlyUserInput(input.prompt),
       model: input.model ?? null,
       serviceTier: input.serviceTier === void 0 ? void 0 : input.serviceTier,
       effort: input.effort ?? null,
@@ -8306,13 +8309,7 @@ var CodexAppServerManager = class extends EventEmitter3 {
     const response = await this.client.request("turn/steer", {
       threadId: input.threadId,
       expectedTurnId: input.turnId,
-      input: [
-        {
-          type: "text",
-          text: input.prompt,
-          text_elements: []
-        }
-      ]
+      input: input.input ?? textOnlyUserInput(input.prompt)
     });
     return response.turn ? mapTurn(response.turn) : null;
   }
@@ -8614,12 +8611,58 @@ ${entryPreview}` : null
 var DEFERRED_COMMAND_DETAIL_TITLE = "Command Output";
 var DEFERRED_TOOL_DETAIL_TITLE = "Tool Call Details";
 var DEFERRED_AGENT_TOOL_DETAIL_TITLE = "Agent Details";
+function parseUuidV7Timestamp(id) {
+  const normalized = id.replace(/-/g, "");
+  if (!/^[0-9a-f]{32}$/i.test(normalized) || normalized[12]?.toLowerCase() !== "7") {
+    return null;
+  }
+  const millis = Number.parseInt(normalized.slice(0, 12), 16);
+  if (!Number.isFinite(millis)) {
+    return null;
+  }
+  return new Date(millis).toISOString();
+}
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringOrNull(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
+function isoTimestampOrNull(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const epochMs = value < 1e10 ? value * 1e3 : value;
+    return new Date(epochMs).toISOString();
+  }
+  const text2 = stringOrNull(value);
+  if (!text2) {
+    return null;
+  }
+  const parsed = Date.parse(text2);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+}
+function codexItemCreatedAt(item) {
+  const candidates = [
+    item.createdAt,
+    item.created_at,
+    item.startedAt,
+    item.started_at,
+    item.completedAt,
+    item.completed_at
+  ];
+  for (const candidate of candidates) {
+    const timestamp = isoTimestampOrNull(candidate);
+    if (timestamp) {
+      return timestamp;
+    }
+  }
+  return parseUuidV7Timestamp(item.id);
+}
+function withCodexItemTimestamp(item, historyItem) {
+  return {
+    ...historyItem,
+    createdAt: historyItem.createdAt ?? codexItemCreatedAt(item)
+  };
+}
 function numberOrNull(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value;
@@ -9108,7 +9151,7 @@ function extractFileChangeEntries(item) {
       isRecord4(entry.summary) ? entry.summary : null,
       isRecord4(entry.diff) ? entry.diff : null
     ].filter((candidate) => Boolean(candidate));
-    const path25 = uniqueStrings([
+    const path26 = uniqueStrings([
       stringOrNull(valueFromRecords(nestedRecords, ["path", "filePath", "targetPath"])),
       stringOrNull(
         valueFromRecords(nestedRecords, [
@@ -9155,7 +9198,7 @@ function extractFileChangeEntries(item) {
     const diffStats = explicitAdditions === 0 && explicitDeletions === 0 && diffText ? countUnifiedDiffStats(diffText) : null;
     const additions = explicitAdditions || diffStats?.additions || 0;
     const deletions = explicitDeletions || diffStats?.deletions || 0;
-    const normalizedPath = path25 ?? (diffText ? projectRelativePathLabel(extractPathFromDiffText(diffText)) : null);
+    const normalizedPath = path26 ?? (diffText ? projectRelativePathLabel(extractPathFromDiffText(diffText)) : null);
     if (!normalizedPath && additions === 0 && deletions === 0) {
       return null;
     }
@@ -9320,7 +9363,7 @@ function itemToHistoryItem(item, deferredDetails) {
   }
 }
 function liveCodexItemToHistoryItem(item, phase) {
-  const historyItem = itemToHistoryItem(item);
+  const historyItem = withCodexItemTimestamp(item, itemToHistoryItem(item));
   if (historyItem.kind !== "commandExecution" && historyItem.kind !== "toolCall" && historyItem.kind !== "agentToolCall" && historyItem.kind !== "skillToolCall" && historyItem.kind !== "fileChange" && historyItem.kind !== "webSearch") {
     return null;
   }
@@ -9335,7 +9378,9 @@ function codexTurnToAgentTurn(turn) {
     rawTurnId: turn.id,
     status: turn.status,
     error: turn.error,
-    items: turn.items.map((item) => itemToHistoryItem(item)),
+    items: turn.items.map(
+      (item) => withCodexItemTimestamp(item, itemToHistoryItem(item))
+    ),
     rawTurn: turn
   };
 }
@@ -9940,8 +9985,8 @@ var CodexManagementService = class {
   isRuntimeRequestError(error) {
     return isCodexRuntimeRequestError(error);
   }
-  canManageHookFiles(provider) {
-    return !provider || provider === "codex";
+  canManageHookFiles(provider2) {
+    return !provider2 || provider2 === "codex";
   }
   isUnsupportedHooksListError(error) {
     return isUnsupportedHooksListError(error);
@@ -10110,6 +10155,7 @@ var CodexManagementService = class {
 
 // ../../packages/codex/src/runtimeAdapter.ts
 import { EventEmitter as EventEmitter4 } from "events";
+import path9 from "path";
 
 // ../../packages/codex/src/requestMapper.ts
 function isRecord6(value) {
@@ -10447,6 +10493,50 @@ function mapCodexProviderRequest(providerRequest, approvalMode) {
 }
 
 // ../../packages/codex/src/runtimeAdapter.ts
+var promptPhotoTokenPattern = /\[PHOTO\s+([^\]]+)\]/g;
+function resolvePromptAssetPath(assetPath, cwd) {
+  if (!assetPath) {
+    return null;
+  }
+  if (path9.isAbsolute(assetPath)) {
+    return path9.normalize(assetPath);
+  }
+  if (!cwd) {
+    return null;
+  }
+  return path9.resolve(cwd, assetPath);
+}
+function codexUserInputFromPrompt(prompt, cwd) {
+  const matches = [...prompt.matchAll(promptPhotoTokenPattern)];
+  if (matches.length === 0) {
+    return void 0;
+  }
+  const input = [];
+  let cursor = 0;
+  let includedImage = false;
+  for (const match of matches) {
+    const token = match[0];
+    const assetPath = match[1]?.trim() ?? "";
+    const start = match.index ?? 0;
+    const precedingText = prompt.slice(cursor, start);
+    if (precedingText) {
+      input.push({ type: "text", text: precedingText, text_elements: [] });
+    }
+    const resolvedPath = resolvePromptAssetPath(assetPath, cwd);
+    if (resolvedPath) {
+      input.push({ type: "localImage", path: resolvedPath });
+      includedImage = true;
+    } else {
+      input.push({ type: "text", text: token, text_elements: [] });
+    }
+    cursor = start + token.length;
+  }
+  const trailingText = prompt.slice(cursor);
+  if (trailingText) {
+    input.push({ type: "text", text: trailingText, text_elements: [] });
+  }
+  return includedImage ? input : void 0;
+}
 var codexCapabilities = {
   sessions: {
     list: true,
@@ -10961,6 +11051,13 @@ var CodexRuntimeAdapter = class extends EventEmitter4 {
       threadId: input.providerSessionId,
       prompt: input.prompt
     };
+    const structuredInput = codexUserInputFromPrompt(
+      input.prompt,
+      input.workspacePath
+    );
+    if (structuredInput) {
+      turnInput.input = structuredInput;
+    }
     if (input.developerInstructions !== void 0) {
       turnInput.developerInstructions = input.developerInstructions;
     }
@@ -10987,11 +11084,17 @@ var CodexRuntimeAdapter = class extends EventEmitter4 {
     return mapTurn2(await codexRuntimeCall(() => this.manager.startTurn(turnInput)));
   }
   async sendInput(input) {
-    const turn = await codexRuntimeCall(() => this.manager.steerTurn({
+    const structuredInput = codexUserInputFromPrompt(
+      input.prompt,
+      input.workspacePath
+    );
+    const steerInput = {
       threadId: input.providerSessionId,
       turnId: input.providerTurnId,
-      prompt: input.prompt
-    }));
+      prompt: input.prompt,
+      ...structuredInput ? { input: structuredInput } : {}
+    };
+    const turn = await codexRuntimeCall(() => this.manager.steerTurn(steerInput));
     return turn ? mapTurn2(turn) : null;
   }
   async interruptTurn(input) {
@@ -11640,13 +11743,13 @@ import { EventEmitter as EventEmitter5 } from "events";
 import { execFile } from "child_process";
 import fs8 from "fs/promises";
 import { createRequire } from "module";
-import path9 from "path";
+import path10 from "path";
 import { pathToFileURL } from "url";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
-var promptPhotoTokenPattern = /\[PHOTO\s+([^\]]+)\]/g;
+var promptPhotoTokenPattern2 = /\[PHOTO\s+([^\]]+)\]/g;
 function mimeTypeForImagePath(filePath) {
-  const extension = path9.extname(filePath).toLowerCase();
+  const extension = path10.extname(filePath).toLowerCase();
   switch (extension) {
     case ".jpg":
     case ".jpeg":
@@ -11676,13 +11779,13 @@ function extensionForImageMediaType(mediaType) {
       return null;
   }
 }
-function resolvePromptAssetPath(assetPath, cwd) {
+function resolvePromptAssetPath2(assetPath, cwd) {
   if (!cwd) {
     return null;
   }
-  const resolvedPath = path9.isAbsolute(assetPath) ? path9.normalize(assetPath) : path9.resolve(cwd, assetPath);
-  const relativePath = path9.relative(cwd, resolvedPath);
-  if (relativePath === "" || !relativePath.startsWith("..") && !path9.isAbsolute(relativePath)) {
+  const resolvedPath = path10.isAbsolute(assetPath) ? path10.normalize(assetPath) : path10.resolve(cwd, assetPath);
+  const relativePath = path10.relative(cwd, resolvedPath);
+  if (relativePath === "" || !relativePath.startsWith("..") && !path10.isAbsolute(relativePath)) {
     return resolvedPath;
   }
   return null;
@@ -11701,7 +11804,7 @@ async function* singleUserMessage(content) {
   };
 }
 async function promptWithImageBlocks(prompt, cwd) {
-  const matches = [...prompt.matchAll(promptPhotoTokenPattern)];
+  const matches = [...prompt.matchAll(promptPhotoTokenPattern2)];
   if (matches.length === 0) {
     return prompt;
   }
@@ -11716,7 +11819,7 @@ async function promptWithImageBlocks(prompt, cwd) {
     if (precedingText) {
       blocks.push({ type: "text", text: precedingText });
     }
-    const resolvedPath = resolvePromptAssetPath(assetPath, cwd);
+    const resolvedPath = resolvePromptAssetPath2(assetPath, cwd);
     const mediaType = resolvedPath ? mimeTypeForImagePath(resolvedPath) : null;
     if (!resolvedPath || !mediaType) {
       blocks.push({ type: "text", text: token });
@@ -13099,13 +13202,13 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       return null;
     }
     const relativePath = `./.temp/threads/${input.localThreadId}/claude-history-${safeAssetFilePart(input.messageId)}-${input.blockIndex}.${extension}`;
-    const targetPath = path9.resolve(input.workspacePath, relativePath);
-    const relativeToWorkspace = path9.relative(input.workspacePath, targetPath);
-    if (relativeToWorkspace === "" || relativeToWorkspace.startsWith("..") || path9.isAbsolute(relativeToWorkspace)) {
+    const targetPath = path10.resolve(input.workspacePath, relativePath);
+    const relativeToWorkspace = path10.relative(input.workspacePath, targetPath);
+    if (relativeToWorkspace === "" || relativeToWorkspace.startsWith("..") || path10.isAbsolute(relativeToWorkspace)) {
       return null;
     }
     try {
-      await fs8.mkdir(path9.dirname(targetPath), { recursive: true });
+      await fs8.mkdir(path10.dirname(targetPath), { recursive: true });
       await fs8.writeFile(targetPath, Buffer.from(data, "base64"));
       return `[PHOTO ${relativePath}]`;
     } catch {
@@ -13264,7 +13367,7 @@ async function importOptionalPackage(specifier) {
       throw localError;
     }
     try {
-      const requireFromGlobal = createRequire(path9.join(globalRoot, "remote-codex-global.cjs"));
+      const requireFromGlobal = createRequire(path10.join(globalRoot, "remote-codex-global.cjs"));
       const resolved = requireFromGlobal.resolve(specifier);
       return await dynamicImport(pathToFileURL(resolved).href);
     } catch {
@@ -13284,7 +13387,7 @@ async function npmGlobalRoot() {
 }
 
 // ../../packages/opencode/src/historyItems.ts
-import path10 from "path";
+import path11 from "path";
 function isRecord9(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -13394,25 +13497,25 @@ function displayPath(pathValue, options) {
   if (!pathValue) {
     return null;
   }
-  if (!path10.isAbsolute(pathValue) || !options.workspacePath) {
+  if (!path11.isAbsolute(pathValue) || !options.workspacePath) {
     return pathValue;
   }
-  const root = path10.resolve(options.workspacePath);
-  const absolutePath = path10.resolve(pathValue);
-  const relativePath = path10.relative(root, absolutePath);
-  if (!relativePath || relativePath.startsWith("..") || path10.isAbsolute(relativePath)) {
+  const root = path11.resolve(options.workspacePath);
+  const absolutePath = path11.resolve(pathValue);
+  const relativePath = path11.relative(root, absolutePath);
+  if (!relativePath || relativePath.startsWith("..") || path11.isAbsolute(relativePath)) {
     return pathValue;
   }
   return relativePath;
 }
-function toolIsLowInformationPatch(normalized, state, input, patchText, path25, metadataStats) {
+function toolIsLowInformationPatch(normalized, state, input, patchText, path26, metadataStats) {
   if (normalized !== "applypatch" && normalized !== "patch") {
     return false;
   }
   if (toolStateStatus(state) !== "running") {
     return false;
   }
-  if (path25 || patchText || metadataStats || stringValue2(state.output)) {
+  if (path26 || patchText || metadataStats || stringValue2(state.output)) {
     return false;
   }
   return !isRecord9(input) || Object.keys(input).length === 0;
@@ -13455,7 +13558,7 @@ function fileChangeStatsFromMetadata(metadata) {
   if (files.length === 0) {
     return null;
   }
-  const paths = files.map((file) => stringValue2(file.filePath) ?? stringValue2(file.path) ?? stringValue2(file.relativePath)).filter((path25) => Boolean(path25));
+  const paths = files.map((file) => stringValue2(file.filePath) ?? stringValue2(file.path) ?? stringValue2(file.relativePath)).filter((path26) => Boolean(path26));
   const addedLines = files.reduce((total, file) => total + (numberValue(file.additions) ?? numberValue(file.addedLines) ?? numberValue(file.added) ?? 0), 0);
   const removedLines = files.reduce((total, file) => total + (numberValue(file.deletions) ?? numberValue(file.removedLines) ?? numberValue(file.removed) ?? 0), 0);
   return {
@@ -13603,28 +13706,28 @@ function mapAssistantTool(messageId2, tool, options) {
   ].includes(normalized)) {
     const metadataStats = fileChangeStatsFromMetadata(state.metadata);
     const patchText = isRecord9(input) ? stringValue2(input.patchText) ?? stringValue2(input.patch) ?? stringValue2(input.diff) : null;
-    const path25 = metadataStats?.path ?? filePathFromInput(input) ?? extractPathFromPatchText(patchText);
-    if (toolIsLowInformationPatch(normalized, state, input, patchText, path25, metadataStats)) {
+    const path26 = metadataStats?.path ?? filePathFromInput(input) ?? extractPathFromPatchText(patchText);
+    if (toolIsLowInformationPatch(normalized, state, input, patchText, path26, metadataStats)) {
       return null;
     }
     const output = stringValue2(state.output);
     const diffStats = countUnifiedDiffStats2(patchText);
-    const displayFilePath = displayPath(path25, options);
+    const displayFilePath = displayPath(path26, options);
     return {
       id,
       kind: "fileChange",
       text: metadataStats ? metadataStats.changedFiles > 1 ? `${metadataStats.changedFiles} changed files` : displayFilePath ?? metadataStats.previewText : displayFilePath ?? output ?? summary ?? name,
       previewText: metadataStats ? metadataStats.changedFiles > 1 ? `${metadataStats.changedFiles} changed files` : displayFilePath ?? metadataStats.previewText : displayFilePath ? `${name}: ${displayFilePath}` : output ?? summary ?? name,
       detailText,
-      changedFiles: metadataStats?.changedFiles ?? (path25 ? 1 : null),
+      changedFiles: metadataStats?.changedFiles ?? (path26 ? 1 : null),
       addedLines: metadataStats?.addedLines ?? diffStats?.addedLines ?? null,
       removedLines: metadataStats?.removedLines ?? diffStats?.removedLines ?? null,
       status: toolStateStatus(state)
     };
   }
   if (["read", "grep", "glob", "list", "ls", "bashoutput"].includes(normalized)) {
-    const path25 = filePathFromInput(input);
-    const text2 = displayPath(path25, options) ?? summary ?? name;
+    const path26 = filePathFromInput(input);
+    const text2 = displayPath(path26, options) ?? summary ?? name;
     return {
       id,
       kind: "fileRead",
@@ -13970,7 +14073,7 @@ import { execFile as execFile2 } from "child_process";
 import fs9 from "fs/promises";
 import net from "net";
 import { createRequire as createRequire2 } from "module";
-import path11 from "path";
+import path12 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile2);
@@ -14102,21 +14205,21 @@ function configuredProviderModelRecords(config) {
   if (!providerConfig) {
     return configured;
   }
-  Object.entries(providerConfig).forEach(([providerID, provider]) => {
-    if (!isRecord10(provider) || !isRecord10(provider.models)) {
+  Object.entries(providerConfig).forEach(([providerID, provider2]) => {
+    if (!isRecord10(provider2) || !isRecord10(provider2.models)) {
       return;
     }
-    Object.entries(provider.models).forEach(([modelID, model]) => {
+    Object.entries(provider2.models).forEach(([modelID, model]) => {
       configured.set(providerModelKey(providerID, modelID), isRecord10(model) ? model : {});
     });
   });
   return configured;
 }
-function mapProviderModel(provider, record, index, configuredRecord) {
-  if (!isRecord10(provider) || !isRecord10(record)) {
+function mapProviderModel(provider2, record, index, configuredRecord) {
+  if (!isRecord10(provider2) || !isRecord10(record)) {
     return null;
   }
-  const providerID = stringValue3(record.providerID) ?? stringValue3(provider.id);
+  const providerID = stringValue3(record.providerID) ?? stringValue3(provider2.id);
   const id = stringValue3(record.id);
   if (!providerID || !id) {
     return null;
@@ -14124,8 +14227,8 @@ function mapProviderModel(provider, record, index, configuredRecord) {
   const name = stringValue3(configuredRecord?.name) ?? stringValue3(record.name) ?? id;
   const variants = configuredRecord ? isRecord10(configuredRecord.variants) ? Object.keys(configuredRecord.variants) : [] : isRecord10(record.variants) ? Object.keys(record.variants) : [];
   const model = providerModelKey(providerID, id);
-  const providerName = stringValue3(provider.name) ?? providerID;
-  const disabled = configuredRecord?.status === "disabled" || record.status === "disabled" || provider.disabled === true;
+  const providerName = stringValue3(provider2.name) ?? providerID;
+  const disabled = configuredRecord?.status === "disabled" || record.status === "disabled" || provider2.disabled === true;
   const reasoningEfforts = variants.map((variant) => ({
     reasoningEffort: variant,
     description: variant === "none" ? "No reasoning" : variant === "xhigh" ? "Maximum reasoning" : `${variant[0]?.toUpperCase() ?? ""}${variant.slice(1)} reasoning`
@@ -14145,15 +14248,15 @@ function providerModels(result, configuredModels) {
   const data = isRecord10(result) && Array.isArray(result.providers) ? result : isRecord10(result) && isRecord10(result.data) && Array.isArray(result.data.providers) ? result.data : null;
   const providers = Array.isArray(data?.providers) ? data.providers : [];
   const models = [];
-  providers.forEach((provider) => {
-    if (!isRecord10(provider) || !isRecord10(provider.models)) {
+  providers.forEach((provider2) => {
+    if (!isRecord10(provider2) || !isRecord10(provider2.models)) {
       return;
     }
-    Object.values(provider.models).forEach((model) => {
+    Object.values(provider2.models).forEach((model) => {
       if (!isRecord10(model)) {
         return;
       }
-      const providerID = stringValue3(model.providerID) ?? stringValue3(provider.id);
+      const providerID = stringValue3(model.providerID) ?? stringValue3(provider2.id);
       const modelID = stringValue3(model.id);
       if (!providerID || !modelID) {
         return;
@@ -14162,7 +14265,7 @@ function providerModels(result, configuredModels) {
       if (configuredModels && configuredModels.size > 0 && !configuredRecord) {
         return;
       }
-      const mapped = mapProviderModel(provider, model, models.length, configuredRecord);
+      const mapped = mapProviderModel(provider2, model, models.length, configuredRecord);
       if (mapped) {
         models.push(mapped);
       }
@@ -15045,7 +15148,7 @@ async function importOptionalPackage2(specifier) {
       throw localError;
     }
     try {
-      const requireFromGlobal = createRequire2(path11.join(globalRoot, "remote-codex-global.cjs"));
+      const requireFromGlobal = createRequire2(path12.join(globalRoot, "remote-codex-global.cjs"));
       const resolved = resolveOptionalPackage(requireFromGlobal, globalRoot, specifier);
       return await dynamicImport(pathToFileURL2(resolved).href);
     } catch {
@@ -15058,7 +15161,7 @@ function resolveOptionalPackage(requireFromGlobal, globalRoot, specifier) {
     return requireFromGlobal.resolve(specifier);
   } catch (error) {
     if (error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED" && specifier === "@opencode-ai/sdk/v2") {
-      return path11.join(globalRoot, "@opencode-ai", "sdk", "dist", "v2", "index.js");
+      return path12.join(globalRoot, "@opencode-ai", "sdk", "dist", "v2", "index.js");
     }
     throw error;
   }
@@ -15074,6 +15177,498 @@ async function npmGlobalRoot2() {
   }
 }
 
+// src/e2e-fake-runtime.ts
+import { EventEmitter as EventEmitter7 } from "events";
+var provider = "claude";
+var firstDelta = "IOS_STREAM_DELTA_READY";
+var secondDelta = " IOS_STREAM_COMPLETED";
+var approvalPromptMarker = "IOS_PENDING_APPROVAL";
+var questionPromptMarker = "IOS_PENDING_QUESTION";
+var planPromptMarker = "IOS_PENDING_PLAN";
+var E2EFakeRuntime = class extends EventEmitter7 {
+  provider = provider;
+  displayName = "E2E Fake Runtime";
+  description = "Deterministic runtime for live iOS and web end-to-end tests.";
+  capabilities = {
+    sessions: { list: true, read: true, resume: true, importLocal: false },
+    turns: { start: true, streamInput: false, steer: false, interrupt: true, compact: false },
+    branching: { fork: false, hardRollback: false, resumeAt: false, rewindFiles: false },
+    controls: {
+      planMode: false,
+      permissionRequests: false,
+      sandboxMode: true,
+      performanceMode: false,
+      goals: false
+    },
+    management: {
+      models: true,
+      mcpStatus: true,
+      skills: false,
+      hooks: false,
+      hookTrust: false,
+      hostConfigFiles: false,
+      providerSettings: false
+    },
+    usage: { contextWindow: true, tokenUsage: true, costUsd: true }
+  };
+  managementSchema = {
+    hostConfigFiles: [],
+    toolboxItems: [],
+    hookCommandTemplates: [],
+    providerConfigFormat: "none",
+    mcpConfigFormat: "none",
+    configArchives: false,
+    buildRestart: false
+  };
+  installation = {
+    packageName: "remote-codex-e2e-fake-runtime",
+    installed: true,
+    installedVersion: "test",
+    latestVersion: null,
+    installCommand: "",
+    updateCommand: "",
+    busy: false,
+    lastError: null
+  };
+  sessions = /* @__PURE__ */ new Map();
+  providerRequests = /* @__PURE__ */ new Map();
+  activeTurnId = null;
+  startedAt = null;
+  getStatus() {
+    return {
+      state: "ready",
+      transport: "none",
+      lastStartedAt: this.startedAt,
+      lastError: null,
+      restartCount: 0
+    };
+  }
+  async start() {
+    this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  async stop() {
+    this.activeTurnId = null;
+  }
+  async listModels() {
+    return [
+      {
+        id: "ios-e2e-stream",
+        model: "ios-e2e-stream",
+        displayName: "iOS E2E Stream",
+        description: "Deterministic streaming test model.",
+        isDefault: true,
+        hidden: false,
+        supportedReasoningEfforts: [
+          { reasoningEffort: "low", description: "Low" },
+          { reasoningEffort: "medium", description: "Medium" },
+          { reasoningEffort: "high", description: "High" }
+        ],
+        defaultReasoningEffort: "medium"
+      }
+    ];
+  }
+  async listSessions() {
+    return [...this.sessions.values()].map((session) => ({
+      provider,
+      providerSessionId: session.providerSessionId,
+      cwd: session.cwd,
+      title: session.title,
+      preview: session.preview,
+      createdAt: session.createdAt,
+      updatedAt: session.updatedAt,
+      status: session.status,
+      rawSession: session
+    }));
+  }
+  async listLoadedSessions() {
+    return [...this.sessions.keys()];
+  }
+  async readSession(providerSessionId) {
+    const session = this.sessions.get(providerSessionId);
+    if (!session) {
+      throw new Error(`E2E fake session missing: ${providerSessionId}`);
+    }
+    return session;
+  }
+  async startSession(input) {
+    const providerSessionId = `e2e-session-${this.sessions.size + 1}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const session = {
+      provider,
+      providerSessionId,
+      cwd: input.cwd,
+      title: null,
+      preview: null,
+      createdAt: now,
+      updatedAt: now,
+      status: "idle",
+      turns: [],
+      totalTurnCount: 0,
+      rawSession: null
+    };
+    this.sessions.set(providerSessionId, session);
+    return {
+      provider,
+      providerSessionId,
+      model: input.model,
+      reasoningEffort: input.reasoningEffort ?? null,
+      sandboxMode: input.sandboxMode ?? null,
+      session,
+      rawSession: session
+    };
+  }
+  async resumeSession(input) {
+    const session = await this.readSession(input.providerSessionId);
+    return {
+      provider,
+      providerSessionId: input.providerSessionId,
+      model: input.model ?? null,
+      reasoningEffort: null,
+      sandboxMode: input.sandboxMode ?? null,
+      session,
+      rawSession: session
+    };
+  }
+  async startTurn(input) {
+    const session = await this.readSession(input.providerSessionId);
+    const providerTurnId = `e2e-turn-${session.turns.length + 1}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const userItem = {
+      id: `${providerTurnId}:user`,
+      createdAt: now,
+      kind: "userMessage",
+      text: input.prompt
+    };
+    const assistantItem = {
+      id: `${providerTurnId}:assistant`,
+      createdAt: now,
+      kind: "agentMessage",
+      text: "",
+      status: "running"
+    };
+    const turn = {
+      providerTurnId,
+      startedAt: now,
+      status: "inProgress",
+      error: null,
+      items: input.hidden ? [] : [userItem],
+      rawTurn: null
+    };
+    session.turns.push(turn);
+    session.totalTurnCount = session.turns.length;
+    session.status = "running";
+    session.updatedAt = now;
+    session.preview = input.prompt;
+    this.activeTurnId = providerTurnId;
+    this.emitRuntimeEvent({
+      type: "turn.started",
+      provider,
+      providerSessionId: input.providerSessionId,
+      turn
+    });
+    if (input.prompt.includes(approvalPromptMarker)) {
+      setTimeout(() => {
+        if (turn.status !== "inProgress") {
+          return;
+        }
+        const requestId = `${providerTurnId}:approval`;
+        this.providerRequests.set(requestId, {
+          providerSessionId: input.providerSessionId,
+          providerTurnId,
+          assistantText: "IOS_PENDING_APPROVAL_RESOLVED"
+        });
+        this.emit("provider-request", {
+          provider,
+          id: requestId,
+          method: "item/commandExecution/requestApproval",
+          params: {
+            providerSessionId: input.providerSessionId,
+            providerTurnId,
+            itemId: `${providerTurnId}:approval-item`,
+            command: "printf ios-e2e-approval",
+            cwd: session.cwd,
+            reason: "iOS E2E approval request."
+          }
+        });
+      }, 250);
+      return turn;
+    }
+    if (input.prompt.includes(questionPromptMarker)) {
+      setTimeout(() => {
+        if (turn.status !== "inProgress") {
+          return;
+        }
+        const requestId = `${providerTurnId}:question`;
+        this.providerRequests.set(requestId, {
+          providerSessionId: input.providerSessionId,
+          providerTurnId,
+          assistantText: "IOS_PENDING_QUESTION_RESOLVED"
+        });
+        this.emit("provider-request", {
+          provider,
+          id: requestId,
+          method: "tool/AskUserQuestion",
+          params: {
+            providerSessionId: input.providerSessionId,
+            providerTurnId,
+            toolUseId: `${providerTurnId}:question-item`
+          }
+        });
+      }, 250);
+      return turn;
+    }
+    if (input.prompt.includes(planPromptMarker)) {
+      const planItem = {
+        id: `${providerTurnId}:plan`,
+        createdAt: now,
+        kind: "plan",
+        text: "1. Verify the iOS pending request path.\n2. Keep plan mode active until the user decides.",
+        status: "completed"
+      };
+      setTimeout(() => {
+        if (turn.status !== "inProgress") {
+          return;
+        }
+        turn.items.push(planItem);
+        this.emitRuntimeEvent({
+          type: "item.started",
+          provider,
+          providerSessionId: input.providerSessionId,
+          providerTurnId,
+          item: { ...planItem }
+        });
+        this.completeTurn(input.providerSessionId, providerTurnId);
+      }, 250);
+      return turn;
+    }
+    setTimeout(() => {
+      if (turn.status !== "inProgress") {
+        return;
+      }
+      assistantItem.text = firstDelta;
+      turn.items.push(assistantItem);
+      this.emitRuntimeEvent({
+        type: "item.started",
+        provider,
+        providerSessionId: input.providerSessionId,
+        providerTurnId,
+        item: { ...assistantItem }
+      });
+      this.emitRuntimeEvent({
+        type: "output.delta",
+        provider,
+        providerSessionId: input.providerSessionId,
+        providerTurnId,
+        itemId: assistantItem.id,
+        delta: firstDelta
+      });
+    }, 250);
+    setTimeout(() => {
+      if (turn.status !== "inProgress") {
+        return;
+      }
+      assistantItem.text = `${firstDelta}${secondDelta}`;
+      assistantItem.status = "completed";
+      turn.status = "completed";
+      session.status = "idle";
+      session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.activeTurnId = null;
+      this.emitRuntimeEvent({
+        type: "output.delta",
+        provider,
+        providerSessionId: input.providerSessionId,
+        providerTurnId,
+        itemId: assistantItem.id,
+        delta: secondDelta
+      });
+      this.emitRuntimeEvent({
+        type: "item.completed",
+        provider,
+        providerSessionId: input.providerSessionId,
+        providerTurnId,
+        item: { ...assistantItem }
+      });
+      this.emitRuntimeEvent({
+        type: "turn.completed",
+        provider,
+        providerSessionId: input.providerSessionId,
+        turn
+      });
+    }, 2e4);
+    return turn;
+  }
+  async interruptTurn(input) {
+    const session = await this.readSession(input.providerSessionId);
+    const turn = session.turns.find((entry) => entry.providerTurnId === input.providerTurnId);
+    if (!turn) {
+      return null;
+    }
+    turn.status = "interrupted";
+    session.status = "interrupted";
+    this.activeTurnId = null;
+    return turn;
+  }
+  async listMcpServers() {
+    return [];
+  }
+  mapProviderRequest(request) {
+    if (request.provider !== provider || !isRecord11(request.params)) {
+      return null;
+    }
+    const providerSessionId = stringValue4(request.params.providerSessionId);
+    const providerTurnId = stringValue4(request.params.providerTurnId);
+    if (!providerSessionId) {
+      return null;
+    }
+    if (request.method === "item/commandExecution/requestApproval") {
+      const requestId = String(request.id);
+      const description = [
+        stringValue4(request.params.reason),
+        stringValue4(request.params.command) ? `Command: ${stringValue4(request.params.command)}` : null,
+        stringValue4(request.params.cwd) ? `CWD: ${stringValue4(request.params.cwd)}` : null
+      ].filter(Boolean).join("\n");
+      return {
+        providerRequestId: request.id,
+        providerSessionId,
+        autoApprovedResult: null,
+        pendingRequest: {
+          providerRequestId: request.id,
+          responseKind: "commandExecutionApproval",
+          request: {
+            id: requestId,
+            kind: "requestUserInput",
+            title: "Command approval required",
+            description: description || "iOS E2E approval request.",
+            turnId: providerTurnId,
+            itemId: stringValue4(request.params.itemId),
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            questions: [
+              {
+                id: "approval",
+                header: "Command approval required",
+                question: description || "iOS E2E approval request.",
+                isOther: false,
+                isSecret: false,
+                options: [
+                  { label: "Allow", description: "Permit this action and continue the current turn." },
+                  { label: "Deny", description: "Decline this action." }
+                ]
+              }
+            ]
+          }
+        }
+      };
+    }
+    if (request.method === "tool/AskUserQuestion") {
+      const requestId = String(request.id);
+      return {
+        providerRequestId: request.id,
+        providerSessionId,
+        autoApprovedResult: null,
+        pendingRequest: {
+          providerRequestId: request.id,
+          responseKind: "askUserQuestion",
+          request: {
+            id: requestId,
+            kind: "requestUserInput",
+            title: "Mode",
+            description: "Which iOS E2E path should continue?",
+            turnId: providerTurnId,
+            itemId: stringValue4(request.params.toolUseId),
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            questions: [
+              {
+                id: "question-1",
+                header: "Mode",
+                question: "Which iOS E2E path should continue?",
+                isOther: true,
+                isSecret: false,
+                options: [
+                  { label: "Short", description: "Keep the response concise." },
+                  { label: "Detailed", description: "Include more context." }
+                ]
+              }
+            ]
+          },
+          responsePayload: {
+            continueAsPrompt: false
+          }
+        }
+      };
+    }
+    return null;
+  }
+  buildProviderRequestResponse(pending, input) {
+    if (pending.responseKind === "commandExecutionApproval") {
+      const answer = input.answers.approval?.answers[0]?.trim().toLowerCase();
+      return { decision: answer === "allow" ? "accept" : "deny" };
+    }
+    return {
+      kind: pending.responseKind,
+      answers: input.answers
+    };
+  }
+  respondToProviderRequest(id, result) {
+    void result;
+    const request = this.providerRequests.get(id);
+    if (!request) {
+      return;
+    }
+    this.providerRequests.delete(id);
+    const session = this.sessions.get(request.providerSessionId);
+    const turn = session?.turns.find((entry) => entry.providerTurnId === request.providerTurnId);
+    if (!session || !turn || turn.status !== "inProgress") {
+      return;
+    }
+    const assistantItem = {
+      id: `${request.providerTurnId}:assistant`,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      kind: "agentMessage",
+      text: request.assistantText,
+      status: "completed"
+    };
+    turn.items.push(assistantItem);
+    this.emitRuntimeEvent({
+      type: "item.started",
+      provider,
+      providerSessionId: request.providerSessionId,
+      providerTurnId: request.providerTurnId,
+      item: { ...assistantItem }
+    });
+    this.completeTurn(request.providerSessionId, request.providerTurnId);
+  }
+  completeTurn(providerSessionId, providerTurnId) {
+    const session = this.sessions.get(providerSessionId);
+    const turn = session?.turns.find((entry) => entry.providerTurnId === providerTurnId);
+    if (!session || !turn || turn.status !== "inProgress") {
+      return;
+    }
+    turn.status = "completed";
+    session.status = "idle";
+    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.activeTurnId = null;
+    this.emitRuntimeEvent({
+      type: "turn.completed",
+      provider,
+      providerSessionId,
+      turn
+    });
+  }
+  emitRuntimeEvent(event) {
+    this.emit("event", event);
+  }
+};
+function isE2EFakeRuntimeEnabled(env = process.env) {
+  const value = env.REMOTE_CODEX_E2E_FAKE_RUNTIME;
+  return value ? ["1", "true", "yes", "on"].includes(value.toLowerCase()) : false;
+}
+function isRecord11(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue4(value) {
+  return typeof value === "string" ? value : null;
+}
+
 // src/agent-runtime-bootstrap.ts
 function createAgentRuntimeBootstrap(config) {
   const runtimes = [];
@@ -15104,6 +15699,10 @@ function createAgentRuntimeBootstrap(config) {
     runtimes.push(createOpenCodeRuntime(config));
     providerHostHomes.opencode = opencodeConfig.home;
   }
+  if (isE2EFakeRuntimeEnabled()) {
+    runtimes.push(new E2EFakeRuntime());
+    providerHostHomes.claude = claudeConfig.home;
+  }
   return {
     agentRuntimes: new AgentRuntimeRegistry(runtimes),
     localCodexSessionStore: new LocalCodexSessionStore(codexConfig.home),
@@ -15137,8 +15736,8 @@ function createOpenCodeRuntime(config) {
 }
 
 // src/event-bus.ts
-import { EventEmitter as EventEmitter7 } from "events";
-var SupervisorEventBus = class extends EventEmitter7 {
+import { EventEmitter as EventEmitter8 } from "events";
+var SupervisorEventBus = class extends EventEmitter8 {
   emitThreadEvent(event) {
     this.emit("thread-event", event);
   }
@@ -15475,8 +16074,8 @@ var ThreadGoalCoordinator = class {
   normalizeThreadGoalStatusForThread(goal, record) {
     return normalizeThreadGoalStatusForThread(goal, record);
   }
-  async ensureGoalsFeatureEnabled(provider) {
-    await this.goalFeatureManagement.ensureGoalsFeatureEnabled(provider);
+  async ensureGoalsFeatureEnabled(provider2) {
+    await this.goalFeatureManagement.ensureGoalsFeatureEnabled(provider2);
   }
 };
 function toIsoFromEpoch2(value) {
@@ -15590,7 +16189,7 @@ var DEFERRED_FILE_CHANGE_DETAIL_TITLE = "File Change Details";
 var DEFERRED_FILE_READ_DETAIL_TITLE = "File Read Details";
 var DEFERRED_WEB_SEARCH_DETAIL_TITLE = "Web Search Details";
 var DEFERRED_HOOK_DETAIL_TITLE = "Hook Details";
-function parseUuidV7Timestamp(id) {
+function parseUuidV7Timestamp2(id) {
   const normalized = id.replace(/-/g, "");
   if (!/^[0-9a-f]{32}$/i.test(normalized) || normalized[12]?.toLowerCase() !== "7") {
     return null;
@@ -15955,7 +16554,7 @@ function mergePersistedHistoryItemsIntoTurns(turns, persistedItemsByTurnId, defe
 function agentTurnToThreadTurnDto(turn, deferredDetails) {
   const baseTurn = {
     id: turn.providerTurnId,
-    startedAt: turn.startedAt ?? parseUuidV7Timestamp(turn.providerTurnId),
+    startedAt: turn.startedAt ?? parseUuidV7Timestamp2(turn.providerTurnId),
     status: turn.status,
     error: turn.error?.message ?? null,
     items: visibleRuntimeTurnItems(turn.items).map(
@@ -16200,6 +16799,7 @@ var ThreadLiveStateStore = class {
       sequence: input.sequence
     } : {
       id: input.itemId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       kind: "agentMessage",
       text: input.delta,
       sequence: input.sequence
@@ -16310,7 +16910,7 @@ function agentMessageMatchScore(finalText, liveText) {
 
 // src/thread-usage-accounting.ts
 var CONTEXT_BASELINE_TOKENS = 12e3;
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function numberOrNull2(value) {
@@ -16358,11 +16958,11 @@ function computeContextRemainingPercent(tokensInContextWindow, contextWindow) {
   return clampPercentage(Math.round(remaining / effectiveWindow * 100));
 }
 function buildThreadContextUsageFromPayload(payload, model = null, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
-  const tokenUsage = isRecord11(payload) ? payload : null;
+  const tokenUsage = isRecord12(payload) ? payload : null;
   const modelContextWindow = numberOrNull2(
     tokenUsage?.modelContextWindow ?? tokenUsage?.model_context_window
   ) ?? contextWindowForModel(model);
-  const lastUsage = isRecord11(tokenUsage?.last) ? tokenUsage.last : null;
+  const lastUsage = isRecord12(tokenUsage?.last) ? tokenUsage.last : null;
   const tokensInContextWindow = numberOrNull2(
     lastUsage?.totalTokens ?? lastUsage?.total_tokens
   );
@@ -16394,7 +16994,7 @@ function shouldResetThreadContextUsageForTurnStart(current) {
   return current?.availability !== "available";
 }
 function buildTurnTokenBreakdown(payload) {
-  const usage = isRecord11(payload) ? payload : null;
+  const usage = isRecord12(payload) ? payload : null;
   const totalTokens2 = numberOrNull2(usage?.totalTokens ?? usage?.total_tokens);
   const inputTokens = numberOrNull2(usage?.inputTokens ?? usage?.input_tokens);
   const cachedInputTokens = numberOrNull2(
@@ -16440,12 +17040,12 @@ function subtractTurnTokenBreakdowns(current, previous) {
   };
 }
 function parseThreadTurnTokenUsage(payload) {
-  const tokenUsage = isRecord11(payload) ? payload : null;
+  const tokenUsage = isRecord12(payload) ? payload : null;
   const total = buildTurnTokenBreakdown(
-    isRecord11(tokenUsage?.total) ? tokenUsage.total : null
+    isRecord12(tokenUsage?.total) ? tokenUsage.total : null
   );
   const last = buildTurnTokenBreakdown(
-    isRecord11(tokenUsage?.last) ? tokenUsage.last : null
+    isRecord12(tokenUsage?.last) ? tokenUsage.last : null
   );
   const modelContextWindow = numberOrNull2(
     tokenUsage?.modelContextWindow ?? tokenUsage?.model_context_window
@@ -16469,7 +17069,7 @@ function parseStoredThreadTurnTokenUsageState(value) {
   try {
     const parsed = JSON.parse(value);
     const baselineTotal = buildTurnTokenBreakdown(
-      isRecord11(parsed?.baselineTotal) ? parsed.baselineTotal : null
+      isRecord12(parsed?.baselineTotal) ? parsed.baselineTotal : null
     );
     return {
       baselineTotal,
@@ -16509,12 +17109,12 @@ function stringifyStoredThreadTurnTokenUsageState(state) {
   });
 }
 function buildThreadTurnTokenUsage(payload, baselineTotal, previous = null) {
-  const tokenUsage = isRecord11(payload) ? payload : null;
+  const tokenUsage = isRecord12(payload) ? payload : null;
   const cumulativeTotal = buildTurnTokenBreakdown(
-    isRecord11(tokenUsage?.total) ? tokenUsage.total : null
+    isRecord12(tokenUsage?.total) ? tokenUsage.total : null
   );
   const last = buildTurnTokenBreakdown(
-    isRecord11(tokenUsage?.last) ? tokenUsage.last : null
+    isRecord12(tokenUsage?.last) ? tokenUsage.last : null
   );
   const modelContextWindow = numberOrNull2(
     tokenUsage?.modelContextWindow ?? tokenUsage?.model_context_window
@@ -16586,7 +17186,7 @@ var ThreadUsageAccounting = class {
       input.localThreadId
     );
     const currentCumulativeTotal = buildTurnTokenBreakdown(
-      isRecord11(input.tokenUsage?.total) ? input.tokenUsage.total : null
+      isRecord12(input.tokenUsage?.total) ? input.tokenUsage.total : null
     );
     if (currentCumulativeTotal) {
       this.threadCumulativeTokenUsage.set(input.localThreadId, currentCumulativeTotal);
@@ -16976,10 +17576,10 @@ var ThreadRuntimeEventProjector = class {
       }
     }
   }
-  findRecordByProviderSessionId(provider, providerSessionId) {
+  findRecordByProviderSessionId(provider2, providerSessionId) {
     return getThreadRecordByProviderSessionId(
       this.input.db,
-      provider ?? "codex",
+      provider2 ?? "codex",
       providerSessionId
     );
   }
@@ -17069,8 +17669,8 @@ var ProviderRequestCoordinator = class {
       dismissedTurnId
     };
   }
-  respondToProviderRequest(provider, pending, input) {
-    const runtime = this.callbacks.runtimeForProvider(provider);
+  respondToProviderRequest(provider2, pending, input) {
+    const runtime = this.callbacks.runtimeForProvider(provider2);
     if (!runtime.buildProviderRequestResponse) {
       throw new HttpError(409, {
         code: "conflict",
@@ -17099,7 +17699,7 @@ var ProviderRequestCoordinator = class {
     const defaultMappedRequest = runtime.mapProviderRequest?.(request, {
       approvalMode: "guarded"
     });
-    const providerSessionIdFromParams = isRecord12(request.params) ? request.params.providerSessionId ?? request.params.threadId ?? request.params.conversationId ?? request.params.sessionId : null;
+    const providerSessionIdFromParams = isRecord13(request.params) ? request.params.providerSessionId ?? request.params.threadId ?? request.params.conversationId ?? request.params.sessionId : null;
     const providerSessionId = defaultMappedRequest?.providerSessionId ?? (typeof providerSessionIdFromParams === "string" ? providerSessionIdFromParams : null);
     const record = providerSessionId ? this.callbacks.findRecordByProviderSessionId(request.provider, providerSessionId) : null;
     if (!record) {
@@ -17312,7 +17912,7 @@ function buildRequestAnswerLines(request, input) {
     return `- ${question.question}: ${answers.join(", ")}`;
   }).filter((line) => Boolean(line));
 }
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -17702,20 +18302,20 @@ var ThreadProviderRuntimeCoordinator = class {
     this.agentRuntimes = agentRuntimes;
   }
   agentRuntimes;
-  normalizeProvider(provider) {
-    if (!provider) {
+  normalizeProvider(provider2) {
+    if (!provider2) {
       return defaultAgentBackendId;
     }
-    if (isAgentBackendId(provider)) {
-      return provider;
+    if (isAgentBackendId(provider2)) {
+      return provider2;
     }
     throw new HttpError(400, {
       code: "bad_request",
-      message: `Unsupported agent runtime provider: ${provider}`
+      message: `Unsupported agent runtime provider: ${provider2}`
     });
   }
-  runtimeForProvider(provider) {
-    const normalizedProvider = this.normalizeProvider(provider);
+  runtimeForProvider(provider2) {
+    const normalizedProvider = this.normalizeProvider(provider2);
     const runtime = this.optionalRuntimeForProvider(normalizedProvider);
     if (!runtime) {
       throw new HttpError(501, {
@@ -17725,8 +18325,8 @@ var ThreadProviderRuntimeCoordinator = class {
     }
     return runtime;
   }
-  optionalRuntimeForProvider(provider) {
-    return this.agentRuntimes.getOptional(this.normalizeProvider(provider)) ?? null;
+  optionalRuntimeForProvider(provider2) {
+    return this.agentRuntimes.getOptional(this.normalizeProvider(provider2)) ?? null;
   }
   allRuntimes() {
     return this.agentRuntimes.all();
@@ -17734,22 +18334,22 @@ var ThreadProviderRuntimeCoordinator = class {
   providerForRecord(record) {
     return this.normalizeProvider(record.provider);
   }
-  isCodexProvider(provider) {
-    return this.providerForRecord({ provider }) === "codex";
+  isCodexProvider(provider2) {
+    return this.providerForRecord({ provider: provider2 }) === "codex";
   }
-  runtimeSupportsFastMode(provider) {
-    return this.optionalRuntimeForProvider(provider)?.capabilities.controls.performanceMode ?? false;
+  runtimeSupportsFastMode(provider2) {
+    return this.optionalRuntimeForProvider(provider2)?.capabilities.controls.performanceMode ?? false;
   }
-  fastModeForProvider(provider, fastMode) {
-    return this.runtimeSupportsFastMode(provider) ? normalizeFastMode(fastMode) : false;
+  fastModeForProvider(provider2, fastMode) {
+    return this.runtimeSupportsFastMode(provider2) ? normalizeFastMode(fastMode) : false;
   }
   performanceModeForRecord(record) {
     return performanceModeForFastMode(
       this.fastModeForProvider(record.provider, record.fastMode)
     );
   }
-  async listLoadedProviderSessionIds(provider = "codex") {
-    const runtime = this.optionalRuntimeForProvider(provider);
+  async listLoadedProviderSessionIds(provider2 = "codex") {
+    const runtime = this.optionalRuntimeForProvider(provider2);
     if (!runtime) {
       return /* @__PURE__ */ new Set();
     }
@@ -17757,11 +18357,11 @@ var ThreadProviderRuntimeCoordinator = class {
       await runtime.listLoadedSessions().catch(() => [])
     );
   }
-  async listProviderModels(provider = "codex") {
-    return this.runtimeForProvider(provider).listModels().catch(() => []);
+  async listProviderModels(provider2 = "codex") {
+    return this.runtimeForProvider(provider2).listModels().catch(() => []);
   }
-  async listProviderModelOptions(provider = "codex") {
-    const models = await this.runtimeForProvider(provider).listModels();
+  async listProviderModelOptions(provider2 = "codex") {
+    const models = await this.runtimeForProvider(provider2).listModels();
     return models.map((model) => this.modelOptionFromAgentModel(model));
   }
   normalizeReasoningForModel(modelRecords, model, requested) {
@@ -17946,15 +18546,15 @@ var ThreadManagementCoordinator = class {
       });
     }
   }
-  assertHookFileManagement(provider) {
-    if (!this.hookFileManagement.canManageHookFiles(provider)) {
+  assertHookFileManagement(provider2) {
+    if (!this.hookFileManagement.canManageHookFiles(provider2)) {
       throw new HttpError(409, {
         code: "conflict",
         message: "This backend does not support hooks file editing."
       });
     }
   }
-  async toThreadHooksDto(provider, workspacePath, entry, fallbackWarnings = []) {
+  async toThreadHooksDto(provider2, workspacePath, entry, fallbackWarnings = []) {
     const { globalHooksPath, projectHooksPath } = this.hookFileManagement.hooksPaths(workspacePath);
     const officialHooks = (entry?.hooks ?? []).map((hook) => ({
       key: hook.key,
@@ -17973,7 +18573,7 @@ var ThreadManagementCoordinator = class {
       currentHash: hook.currentHash,
       trustStatus: hook.trustStatus
     }));
-    const [globalHooks, projectHooks] = this.hookFileManagement.canManageHookFiles(provider) ? await Promise.all([
+    const [globalHooks, projectHooks] = this.hookFileManagement.canManageHookFiles(provider2) ? await Promise.all([
       this.hookFileManagement.readLocalHookDtos({
         hooksPath: globalHooksPath,
         source: "user",
@@ -18125,7 +18725,8 @@ var ThreadPromptTurnCoordinator = class {
         await runtime.sendInput({
           providerSessionId: record.providerSessionId,
           providerTurnId: steerTurnId,
-          prompt: input.prompt
+          prompt: input.prompt,
+          workspacePath: input.workspacePath
         });
         updateThreadRecord(this.db, localThreadId, {
           providerTurnId: steerTurnId,
@@ -18256,9 +18857,9 @@ var ThreadSessionCoordinator = class {
   performanceModeSettings;
   localSessionLookup;
   async startThreadSession(input) {
-    const provider = this.providerRuntime.normalizeProvider(input.threadInput.provider);
+    const provider2 = this.providerRuntime.normalizeProvider(input.threadInput.provider);
     const normalizedTitle = input.threadInput.title?.trim() || input.defaultTitle;
-    const runtime = this.providerRuntime.runtimeForProvider(provider);
+    const runtime = this.providerRuntime.runtimeForProvider(provider2);
     const modelRecords = await runtime.listModels().catch(() => []);
     const reasoningEffort = this.providerRuntime.normalizeReasoningForModel(
       modelRecords,
@@ -18266,8 +18867,8 @@ var ThreadSessionCoordinator = class {
       input.threadInput.reasoningEffort ?? null
     );
     const sandboxMode = defaultSandboxModeForApprovalMode(input.threadInput.approvalMode);
-    const fastMode = this.providerRuntime.runtimeSupportsFastMode(provider) ? this.performanceModeSettings.readFastMode() : false;
-    if (this.providerRuntime.runtimeSupportsFastMode(provider)) {
+    const fastMode = this.providerRuntime.runtimeSupportsFastMode(provider2) ? this.performanceModeSettings.readFastMode() : false;
+    if (this.providerRuntime.runtimeSupportsFastMode(provider2)) {
       ensureFastModeSupported(input.threadInput.model, fastMode, modelRecords);
     }
     const response = await runtime.startSession({
@@ -18279,7 +18880,7 @@ var ThreadSessionCoordinator = class {
       performanceMode: performanceModeForFastMode(fastMode)
     });
     return {
-      provider,
+      provider: provider2,
       normalizedTitle,
       response,
       reasoningEffort,
@@ -18308,30 +18909,30 @@ var ThreadSessionCoordinator = class {
     return this.localSessionLookup.findSession(providerSessionId);
   }
   async resolveLocalImportSession(input) {
-    const provider = normalizeAgentBackendId(input.provider) ?? "codex";
-    if (provider !== "codex") {
-      return this.resolveRuntimeImportSession(provider, input.sessionId);
+    const provider2 = normalizeAgentBackendId(input.provider) ?? "codex";
+    if (provider2 !== "codex") {
+      return this.resolveRuntimeImportSession(provider2, input.sessionId);
     }
     return this.localSessionLookup.findImportSession(input.sessionId, {
       fastMode: this.performanceModeSettings.readFastMode(),
-      provider
+      provider: provider2
     });
   }
-  async resolveRuntimeImportSession(provider, sessionId) {
+  async resolveRuntimeImportSession(provider2, sessionId) {
     try {
-      const session = await this.providerRuntime.runtimeForProvider(provider).readSession(sessionId);
+      const session = await this.providerRuntime.runtimeForProvider(provider2).readSession(sessionId);
       if (!session.cwd) {
         return null;
       }
       return {
-        provider,
+        provider: provider2,
         source: "supervisor",
         sessionId,
         cwd: session.cwd,
         title: session.title?.trim() || session.preview?.trim() || "Untitled imported session",
         model: null,
         summaryText: session.preview,
-        fastMode: this.providerRuntime.runtimeSupportsFastMode(provider) ? this.performanceModeSettings.readFastMode() : false
+        fastMode: this.providerRuntime.runtimeSupportsFastMode(provider2) ? this.performanceModeSettings.readFastMode() : false
       };
     } catch {
       return null;
@@ -18703,9 +19304,9 @@ var ThreadHistoryPersistenceCoordinator = class {
 
 // src/thread-deletion-coordinator.ts
 import fs10 from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 function threadTempDirectoryPath(workspacePath, localThreadId) {
-  return path12.join(workspacePath, ".temp", "threads", localThreadId);
+  return path13.join(workspacePath, ".temp", "threads", localThreadId);
 }
 var ThreadDeletionCoordinator = class {
   constructor(db, requestCoordinator, usageAccounting, liveState, auxiliaryState, callbacks) {
@@ -20102,7 +20703,7 @@ var ThreadForkCoordinator = class {
 // src/thread-attachment-coordinator.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import fs12 from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 async function pathExists(absPath) {
   try {
     await fs12.access(absPath);
@@ -20112,8 +20713,8 @@ async function pathExists(absPath) {
   }
 }
 function sanitizeAttachmentFileName(originalName) {
-  const basename = path13.basename(originalName).trim() || "attachment";
-  const extension = path13.extname(basename).replace(/[^a-zA-Z0-9.]/g, "");
+  const basename = path14.basename(originalName).trim() || "attachment";
+  const extension = path14.extname(basename).replace(/[^a-zA-Z0-9.]/g, "");
   const rawStem = extension ? basename.slice(0, -extension.length) : basename;
   const sanitizedStem = rawStem.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 64);
   const stem = sanitizedStem || "attachment";
@@ -20121,7 +20722,7 @@ function sanitizeAttachmentFileName(originalName) {
   return `${stem}-${randomUUID3().slice(0, 8)}${normalizedExtension}`;
 }
 function threadTempDirectoryPath2(workspacePath, localThreadId) {
-  return path13.join(workspacePath, ".temp", "threads", localThreadId);
+  return path14.join(workspacePath, ".temp", "threads", localThreadId);
 }
 var ThreadAttachmentCoordinator = class {
   constructor(db) {
@@ -20162,7 +20763,7 @@ var ThreadAttachmentCoordinator = class {
       const savedFileName = sanitizeAttachmentFileName(
         attachment.manifest.originalName
       );
-      await fs12.writeFile(path13.join(tempDirectory, savedFileName), attachment.buffer);
+      await fs12.writeFile(path14.join(tempDirectory, savedFileName), attachment.buffer);
       const relativePath = `./.temp/threads/${localThreadId}/${savedFileName}`;
       const replacementToken = attachment.manifest.kind === "photo" ? `[PHOTO ${relativePath}]` : `[FILE ${relativePath}]`;
       rewrittenPrompt = rewrittenPrompt.split(attachment.manifest.placeholder).join(replacementToken);
@@ -20176,7 +20777,7 @@ var ThreadAttachmentCoordinator = class {
 
 // src/thread-import-coordinator.ts
 import fs13 from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 async function pathExists2(absPath) {
   try {
     await fs13.access(absPath);
@@ -20186,19 +20787,19 @@ async function pathExists2(absPath) {
   }
 }
 async function resolveComparablePath2(absPath) {
-  const resolved = path14.resolve(absPath);
+  const resolved = path15.resolve(absPath);
   if (await pathExists2(resolved)) {
     return fs13.realpath(resolved);
   }
-  const parentPath = path14.dirname(resolved);
+  const parentPath = path15.dirname(resolved);
   if (parentPath === resolved) {
     return resolved;
   }
   const resolvedParent = await resolveComparablePath2(parentPath);
-  return path14.join(resolvedParent, path14.basename(resolved));
+  return path15.join(resolvedParent, path15.basename(resolved));
 }
 async function resolveImportedWorkspacePath(workspaceRoot, candidatePath) {
-  if (!path14.isAbsolute(candidatePath)) {
+  if (!path15.isAbsolute(candidatePath)) {
     throw new HttpError(400, {
       code: "bad_request",
       message: "Imported session path must be absolute."
@@ -20206,7 +20807,7 @@ async function resolveImportedWorkspacePath(workspaceRoot, candidatePath) {
   }
   const resolvedRoot = await resolveComparablePath2(workspaceRoot);
   const resolvedCandidate = await resolveComparablePath2(candidatePath);
-  const normalizedRoot = resolvedRoot.endsWith(path14.sep) ? resolvedRoot : `${resolvedRoot}${path14.sep}`;
+  const normalizedRoot = resolvedRoot.endsWith(path15.sep) ? resolvedRoot : `${resolvedRoot}${path15.sep}`;
   if (resolvedCandidate !== resolvedRoot && !resolvedCandidate.startsWith(normalizedRoot)) {
     throw new HttpError(403, {
       code: "forbidden",
@@ -20232,17 +20833,17 @@ var ThreadImportCoordinator = class {
         message: "Session id is required."
       });
     }
-    const provider = normalizeAgentBackendId(input.provider ?? "codex") ?? "codex";
+    const provider2 = normalizeAgentBackendId(input.provider ?? "codex") ?? "codex";
     const existingThread = getThreadRecordByProviderSessionId(
       this.db,
-      provider,
+      provider2,
       normalizedSessionId
     );
     if (existingThread) {
       return existingThread.id;
     }
     const importSession = await this.sessionCoordinator.resolveLocalImportSession({
-      provider,
+      provider: provider2,
       sessionId: normalizedSessionId
     });
     if (!importSession) {
@@ -20259,7 +20860,7 @@ var ThreadImportCoordinator = class {
     if (!workspace) {
       workspace = createWorkspaceRecord(this.db, {
         absPath: importedPath,
-        label: path14.basename(importedPath) || "workspace"
+        label: path15.basename(importedPath) || "workspace"
       });
     }
     const created = createThreadRecord(this.db, {
@@ -20316,8 +20917,8 @@ var ProviderFeatureCoordinator = class {
   mapGoalError(error) {
     this.codexGoalFeatures.mapGoalError(error);
   }
-  async ensureGoalsFeatureEnabled(provider) {
-    if (!this.providerRuntime.isCodexProvider(provider)) {
+  async ensureGoalsFeatureEnabled(provider2) {
+    if (!this.providerRuntime.isCodexProvider(provider2)) {
       return;
     }
     await this.codexGoalFeatures.ensureGoalsFeatureEnabled(
@@ -20382,7 +20983,7 @@ var ThreadService = class {
     this.historyPersistence = new ThreadHistoryPersistenceCoordinator(db, this.liveState);
     this.attachmentCoordinator = new ThreadAttachmentCoordinator(db);
     this.managementCoordinator = new ThreadManagementCoordinator(providerManagement, {
-      runtimeForProvider: (provider) => this.runtimeForProvider(provider)
+      runtimeForProvider: (provider2) => this.runtimeForProvider(provider2)
     });
     this.sessionCoordinator = new ThreadSessionCoordinator(
       this.providerRuntime,
@@ -20408,7 +21009,7 @@ var ThreadService = class {
       this.liveState,
       this.providerRuntime,
       {
-        runtimeForProvider: (provider) => this.runtimeForProvider(provider),
+        runtimeForProvider: (provider2) => this.runtimeForProvider(provider2),
         resetThreadContextUsage: (localThreadId, emitEvent) => this.resetThreadContextUsage(localThreadId, emitEvent),
         getThreadContextUsage: (localThreadId) => this.getThreadContextUsage(localThreadId),
         invalidateThreadDetailCache: (localThreadId) => this.invalidateThreadDetailCache(localThreadId),
@@ -20466,7 +21067,7 @@ var ThreadService = class {
       emitThreadEvent: (type, threadId, payload) => this.emitThreadEvent(type, threadId, payload),
       ensureThreadLoaded: (record) => this.ensureThreadLoadedForProviderOperation(record),
       requireProviderSessionId: (record) => this.requireProviderSessionId(record),
-      runtimeForProvider: (provider) => this.runtimeForProvider(provider)
+      runtimeForProvider: (provider2) => this.runtimeForProvider(provider2)
     });
     this.auxiliaryState = new ThreadAuxiliaryStateStore(db, {
       cachedTurns: (localThreadId) => this.detailAssembler.cachedTurns(localThreadId),
@@ -20478,9 +21079,9 @@ var ThreadService = class {
     });
     this.requestCoordinator = new ProviderRequestCoordinator({
       emitThreadEvent: (type, threadId, payload) => this.emitThreadEvent(type, threadId, payload),
-      findRecordByProviderSessionId: (provider, providerSessionId) => this.findRecordByProviderSessionId(provider, providerSessionId),
+      findRecordByProviderSessionId: (provider2, providerSessionId) => this.findRecordByProviderSessionId(provider2, providerSessionId),
       normalizeCollaborationMode,
-      runtimeForProvider: (provider) => this.runtimeForProvider(provider)
+      runtimeForProvider: (provider2) => this.runtimeForProvider(provider2)
     });
     this.deletionCoordinator = new ThreadDeletionCoordinator(
       db,
@@ -20506,7 +21107,7 @@ var ThreadService = class {
       this.sessionCoordinator,
       {
         buildThreadPatch: (remoteSession, model, reasoningEffort) => buildThreadPatch(remoteSession, model, reasoningEffort),
-        fastModeForProvider: (provider, fastMode) => this.fastModeForProvider(provider, fastMode),
+        fastModeForProvider: (provider2, fastMode) => this.fastModeForProvider(provider2, fastMode),
         getThreadDetail: (localThreadId) => this.getThreadDetail(localThreadId),
         invalidateThreadDetailCache: (localThreadId) => this.invalidateThreadDetailCache(localThreadId),
         normalizeCollaborationMode,
@@ -20540,7 +21141,7 @@ var ThreadService = class {
         deletePersistedHistoryItemsForTurn: (localThreadId, turnId) => this.historyPersistence.deletePersistedHistoryItemsForTurn(localThreadId, turnId),
         dismissPlanDecisionTurn: (localThreadId) => this.requestCoordinator.dismissPlanDecisionTurn(localThreadId),
         emitThreadEvent: (type, threadId, payload) => this.emitThreadEvent(type, threadId, payload),
-        fastModeForProvider: (provider, fastMode) => this.fastModeForProvider(provider, fastMode),
+        fastModeForProvider: (provider2, fastMode) => this.fastModeForProvider(provider2, fastMode),
         hasPendingAskUserQuestion: (localThreadId) => this.hasPendingAskUserQuestion(localThreadId),
         invalidateThreadDetailCache: (localThreadId) => this.invalidateThreadDetailCache(localThreadId),
         listThreadGoalHistory: (localThreadId) => this.goalCoordinator.listThreadGoalHistory(localThreadId),
@@ -20595,14 +21196,14 @@ var ThreadService = class {
   forkCoordinator;
   attachmentCoordinator;
   importCoordinator;
-  normalizeProvider(provider) {
-    return this.providerRuntime.normalizeProvider(provider);
+  normalizeProvider(provider2) {
+    return this.providerRuntime.normalizeProvider(provider2);
   }
-  runtimeForProvider(provider) {
-    return this.providerRuntime.runtimeForProvider(provider);
+  runtimeForProvider(provider2) {
+    return this.providerRuntime.runtimeForProvider(provider2);
   }
-  optionalRuntimeForProvider(provider) {
-    return this.providerRuntime.optionalRuntimeForProvider(provider);
+  optionalRuntimeForProvider(provider2) {
+    return this.providerRuntime.optionalRuntimeForProvider(provider2);
   }
   providerForRecord(record) {
     return this.providerRuntime.providerForRecord(record);
@@ -20634,18 +21235,18 @@ var ThreadService = class {
       );
     }
   }
-  findRecordByProviderSessionId(provider, providerSessionId) {
+  findRecordByProviderSessionId(provider2, providerSessionId) {
     return getThreadRecordByProviderSessionId(
       this.db,
-      this.providerForRecord({ provider }),
+      this.providerForRecord({ provider: provider2 }),
       providerSessionId
     );
   }
-  runtimeSupportsFastMode(provider) {
-    return this.providerRuntime.runtimeSupportsFastMode(provider);
+  runtimeSupportsFastMode(provider2) {
+    return this.providerRuntime.runtimeSupportsFastMode(provider2);
   }
-  fastModeForProvider(provider, fastMode) {
-    return this.providerRuntime.fastModeForProvider(provider, fastMode);
+  fastModeForProvider(provider2, fastMode) {
+    return this.providerRuntime.fastModeForProvider(provider2, fastMode);
   }
   performanceModeForRecord(record) {
     return this.providerRuntime.performanceModeForRecord(record);
@@ -20653,11 +21254,11 @@ var ThreadService = class {
   async handleProviderRequest(request) {
     await this.handleProviderRuntimeRequest(request);
   }
-  async listLoadedProviderSessionIds(provider = "codex") {
-    return this.providerRuntime.listLoadedProviderSessionIds(provider);
+  async listLoadedProviderSessionIds(provider2 = "codex") {
+    return this.providerRuntime.listLoadedProviderSessionIds(provider2);
   }
-  async listProviderModels(provider = "codex") {
-    return this.providerRuntime.listProviderModels(provider);
+  async listProviderModels(provider2 = "codex") {
+    return this.providerRuntime.listProviderModels(provider2);
   }
   invalidateThreadDetailCache(localThreadId) {
     this.detailAssembler.invalidate(localThreadId);
@@ -20938,19 +21539,18 @@ var ThreadService = class {
     return this.getThreadDetail(localThreadId);
   }
   async sendPrompt(localThreadId, input, options = {}) {
-    const record = getThreadRecordById(this.db, localThreadId);
+    let record = getThreadRecordById(this.db, localThreadId);
     if (!record) {
       throw new HttpError(404, {
         code: "not_found",
         message: "Thread was not found."
       });
     }
-    const providerSessionId = this.requireProviderSessionId(record);
     await this.importCoordinator.assertImportedThreadReadyForPrompt({
       source: record.source,
       provider: record.provider,
-      providerSessionId,
-      listLoadedProviderSessionIds: (provider) => this.listLoadedProviderSessionIds(provider)
+      providerSessionId: this.requireProviderSessionId(record),
+      listLoadedProviderSessionIds: (provider2) => this.listLoadedProviderSessionIds(provider2)
     });
     if (record.isConnected === false) {
       throw new HttpError(409, {
@@ -20958,6 +21558,23 @@ var ThreadService = class {
         message: "Connect this thread before sending a new prompt."
       });
     }
+    if (this.providerForRecord(record) === "codex") {
+      const providerSessionId2 = this.requireProviderSessionId(record);
+      const loadedIds = await this.listLoadedProviderSessionIds(record.provider);
+      if (!loadedIds.has(providerSessionId2)) {
+        await this.ensureThreadLoadedForProviderOperation(record);
+        record = getThreadRecordById(this.db, localThreadId);
+        const resumedProviderSessionId = this.requireProviderSessionId(record);
+        const refreshedLoadedIds = await this.listLoadedProviderSessionIds(record.provider);
+        if (!refreshedLoadedIds.has(resumedProviderSessionId)) {
+          throw new HttpError(409, {
+            code: "conflict",
+            message: "Connect this thread before sending a new prompt."
+          });
+        }
+      }
+    }
+    const providerSessionId = this.requireProviderSessionId(record);
     const prompt = input.prompt.trim();
     const displayPrompt = options.displayPrompt?.trim() || prompt;
     if (!prompt) {
@@ -21381,7 +21998,7 @@ var ThreadService = class {
         provider: record.provider,
         providerSessionId: this.requireProviderSessionId(record),
         model: record.model,
-        listLoadedProviderSessionIds: (provider) => this.listLoadedProviderSessionIds(provider),
+        listLoadedProviderSessionIds: (provider2) => this.listLoadedProviderSessionIds(provider2),
         resumeThread: (input2) => this.resumeThread(localThreadId, input2)
       });
       await this.updateThreadSettings(localThreadId, {
@@ -21407,7 +22024,7 @@ var ThreadService = class {
   }
   toThreadDto(record, loadedIds) {
     return toThreadDto(record, loadedIds, {
-      fastModeForProvider: (provider, fastMode) => this.fastModeForProvider(provider, fastMode),
+      fastModeForProvider: (provider2, fastMode) => this.fastModeForProvider(provider2, fastMode),
       getThreadContextUsage: (localThreadId) => this.getThreadContextUsage(localThreadId)
     });
   }
@@ -21502,7 +22119,7 @@ var ThreadService = class {
 // src/routes/agent-runtimes.ts
 import fs15 from "fs/promises";
 import { spawn as spawn2 } from "child_process";
-import path15 from "path";
+import path16 from "path";
 import { z as z3 } from "zod";
 
 // src/provider-schemas.ts
@@ -21521,15 +22138,15 @@ var npmManagedPackageNames = {
   claude: ["@anthropic-ai/claude-code", "@anthropic-ai/claude-agent-sdk"],
   opencode: ["opencode-ai", "@opencode-ai/sdk"]
 };
-function providerNotConfigured(provider) {
-  const error = new Error(`Agent runtime provider is not configured: ${provider}`);
+function providerNotConfigured(provider2) {
+  const error = new Error(`Agent runtime provider is not configured: ${provider2}`);
   error.statusCode = 404;
   return error;
 }
-function runtimeDto(app, provider) {
-  const runtime = app.services.agentRuntimes.getOptional(provider);
+function runtimeDto(app, provider2) {
+  const runtime = app.services.agentRuntimes.getOptional(provider2);
   if (!runtime) {
-    throw providerNotConfigured(provider);
+    throw providerNotConfigured(provider2);
   }
   const installation = {
     ...runtime.installation
@@ -21539,7 +22156,7 @@ function runtimeDto(app, provider) {
     displayName: runtime.displayName,
     description: runtime.description,
     enabled: isAgentRuntimeEnabled({ ...runtime, installation }),
-    isDefault: provider === defaultAgentBackendId,
+    isDefault: provider2 === defaultAgentBackendId,
     status: runtime.getStatus(),
     capabilities: runtime.capabilities,
     managementSchema: runtime.managementSchema,
@@ -21559,18 +22176,18 @@ async function registerAgentRuntimeRoutes(app) {
     });
   });
   app.get("/api/agent-runtimes/:provider/status", async (request) => {
-    const { provider } = providerParamSchema.parse(request.params);
-    return runtimeDto(app, provider);
+    const { provider: provider2 } = providerParamSchema.parse(request.params);
+    return runtimeDto(app, provider2);
   });
   app.post("/api/agent-runtimes/:provider/restart", async (request) => {
-    const { provider } = providerParamSchema.parse(request.params);
-    const runtime = app.services.agentRuntimes.getOptional(provider);
+    const { provider: provider2 } = providerParamSchema.parse(request.params);
+    const runtime = app.services.agentRuntimes.getOptional(provider2);
     if (!runtime) {
-      throw providerNotConfigured(provider);
+      throw providerNotConfigured(provider2);
     }
     await runtime.stop();
     await runtime.start();
-    return runtimeDto(app, provider);
+    return runtimeDto(app, provider2);
   });
   app.post("/api/agent-runtimes/:provider/install", async (request) => {
     if (!app.services.config.agentRuntimeManagementEnabled) {
@@ -21579,11 +22196,11 @@ async function registerAgentRuntimeRoutes(app) {
         message: "Agent runtime install and update are disabled for this worker."
       });
     }
-    const { provider } = providerParamSchema.parse(request.params);
+    const { provider: provider2 } = providerParamSchema.parse(request.params);
     const { action } = installActionSchema.parse(request.body ?? {});
-    const runtime = app.services.agentRuntimes.getOptional(provider);
+    const runtime = app.services.agentRuntimes.getOptional(provider2);
     if (!runtime) {
-      throw providerNotConfigured(provider);
+      throw providerNotConfigured(provider2);
     }
     const command = action === "install" ? runtime.installation.installCommand : runtime.installation.updateCommand;
     if (!command) {
@@ -21616,16 +22233,16 @@ async function registerAgentRuntimeRoutes(app) {
       if (updateWarning) {
         runtime.installation.lastError = updateWarning;
       }
-      return runtimeDto(app, provider);
+      return runtimeDto(app, provider2);
     } finally {
       runtime.installation.busy = false;
     }
   });
   app.get("/api/agent-runtimes/:provider/models", async (request) => {
-    const { provider } = providerParamSchema.parse(request.params);
-    const runtime = app.services.agentRuntimes.getOptional(provider);
+    const { provider: provider2 } = providerParamSchema.parse(request.params);
+    const runtime = app.services.agentRuntimes.getOptional(provider2);
     if (!runtime) {
-      throw providerNotConfigured(provider);
+      throw providerNotConfigured(provider2);
     }
     return (await runtime.listModels()).map((model) => ({
       id: model.id,
@@ -21649,10 +22266,10 @@ async function registerAgentRuntimeRoutes(app) {
         message: "Build restart is disabled for this worker."
       });
     }
-    const { provider } = providerParamSchema.parse(request.params);
-    const runtime = app.services.agentRuntimes.getOptional(provider);
+    const { provider: provider2 } = providerParamSchema.parse(request.params);
+    const runtime = app.services.agentRuntimes.getOptional(provider2);
     if (!runtime) {
-      throw providerNotConfigured(provider);
+      throw providerNotConfigured(provider2);
     }
     if (!runtime.managementSchema.buildRestart) {
       const error = new Error("This backend does not support build and restart.");
@@ -21723,7 +22340,7 @@ async function refreshBackendInstallation(app, runtime) {
 async function installedPackageVersion(packageName) {
   const globalRoot = await npmGlobalRoot3();
   if (globalRoot) {
-    const global = await packageVersionFromPath(path15.join(globalRoot, packageName, "package.json"));
+    const global = await packageVersionFromPath(path16.join(globalRoot, packageName, "package.json"));
     if (global) {
       return global;
     }
@@ -21760,8 +22377,8 @@ async function updatePathWarning(app, runtime, before, command) {
     `Command: ${command}`
   ].filter(Boolean).join(" ");
 }
-function runtimeCommand(app, provider) {
-  switch (provider) {
+function runtimeCommand(app, provider2) {
+  switch (provider2) {
     case "codex":
       return app.services.config.agentProviders.codex.command;
     case "claude":
@@ -21774,7 +22391,7 @@ function versionStringContains(installedVersion, latestVersion) {
   return Boolean(installedVersion && latestVersion && installedVersion.includes(latestVersion));
 }
 async function packageVersionFromNode(packageName) {
-  return packageVersionFromPath(path15.resolve("node_modules", packageName, "package.json"));
+  return packageVersionFromPath(path16.resolve("node_modules", packageName, "package.json"));
 }
 async function packageVersionFromPath(packageJsonPath) {
   try {
@@ -21801,14 +22418,14 @@ async function npmGlobalBin() {
     return firstLine(result.stdout);
   }
   const prefix = await npmGlobalPrefix();
-  return prefix ? path15.join(prefix, "bin") : null;
+  return prefix ? path16.join(prefix, "bin") : null;
 }
 async function npmGlobalPrefix() {
   const result = await runShellCommand("npm prefix -g", 3e3);
   return result.code === 0 ? firstLine(result.stdout) : null;
 }
 async function commandPathFor(command) {
-  if (path15.isAbsolute(command)) {
+  if (path16.isAbsolute(command)) {
     return command;
   }
   const result = await runShellCommand(`command -v ${shellQuote(command)}`, 3e3);
@@ -22415,8 +23032,8 @@ async function registerSystemRoutes(app) {
         message: "Provider config archives are disabled for this worker."
       });
     }
-    const { provider } = providerParamSchema2.parse(request.params);
-    return app.services.providerHostConfigService.listArchives(provider);
+    const { provider: provider2 } = providerParamSchema2.parse(request.params);
+    return app.services.providerHostConfigService.listArchives(provider2);
   });
   app.post("/api/config/providers/:provider/archives", async (request) => {
     if (!app.services.config.managementRoutesEnabled) {
@@ -22425,13 +23042,13 @@ async function registerSystemRoutes(app) {
         message: "Provider config archives are disabled for this worker."
       });
     }
-    const { provider } = providerParamSchema2.parse(request.params);
+    const { provider: provider2 } = providerParamSchema2.parse(request.params);
     const body = {};
     const parsedBody = createProviderHostConfigArchiveSchema.parse(request.body ?? {});
     if (parsedBody.label !== void 0) {
       body.label = parsedBody.label;
     }
-    return app.services.providerHostConfigService.createArchive(provider, body);
+    return app.services.providerHostConfigService.createArchive(provider2, body);
   });
   app.patch("/api/config/providers/:provider/archives/:id", async (request) => {
     if (!app.services.config.managementRoutesEnabled) {
@@ -22480,7 +23097,7 @@ async function registerSystemRoutes(app) {
 
 // src/routes/threads.ts
 import fs17 from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 import { z as z5 } from "zod";
 
 // src/worker-identity.ts
@@ -22952,7 +23569,7 @@ async function registerThreadRoutes(app) {
         message: "Workspace was not found for this thread."
       });
     }
-    const candidatePath = path16.isAbsolute(query.path) ? query.path : path16.resolve(workspace.absPath, query.path);
+    const candidatePath = path17.isAbsolute(query.path) ? query.path : path17.resolve(workspace.absPath, query.path);
     const requestedPath = await fs17.realpath(candidatePath).catch(() => null);
     if (!requestedPath) {
       throw new HttpError(404, {
@@ -22960,8 +23577,8 @@ async function registerThreadRoutes(app) {
         message: "Image file was not found."
       });
     }
-    const resolvedWorkspaceRoot = await fs17.realpath(app.services.config.workspaceRoot).catch(() => path16.resolve(app.services.config.workspaceRoot));
-    const workspacePrefix = resolvedWorkspaceRoot.endsWith(path16.sep) ? resolvedWorkspaceRoot : `${resolvedWorkspaceRoot}${path16.sep}`;
+    const resolvedWorkspaceRoot = await fs17.realpath(app.services.config.workspaceRoot).catch(() => path17.resolve(app.services.config.workspaceRoot));
+    const workspacePrefix = resolvedWorkspaceRoot.endsWith(path17.sep) ? resolvedWorkspaceRoot : `${resolvedWorkspaceRoot}${path17.sep}`;
     if (requestedPath !== resolvedWorkspaceRoot && !requestedPath.startsWith(workspacePrefix)) {
       throw new HttpError(403, {
         code: "forbidden",
@@ -23157,7 +23774,9 @@ async function registerThreadRoutes(app) {
 
 // src/routes/workspaces.ts
 import fs18 from "fs/promises";
-import path17 from "path";
+import { createReadStream } from "fs";
+import os3 from "os";
+import path18 from "path";
 import { spawn as spawn3 } from "child_process";
 import { Readable } from "stream";
 import { z as z6 } from "zod";
@@ -23214,6 +23833,8 @@ var workspacePreviewQuerySchema = z6.object({
 });
 var PREVIEW_DEFAULT_LIMIT_BYTES = 5e4;
 var WORKSPACE_UPLOAD_MAX_BYTES = 50 * 1024 * 1024;
+var WORKSPACE_FOLDER_DOWNLOAD_MAX_BYTES = 100 * 1024 * 1024;
+var WORKSPACE_FOLDER_DOWNLOAD_MAX_FILES = 300;
 var WORKSPACE_TREE_IGNORED_NAMES = /* @__PURE__ */ new Set([
   ".git",
   "node_modules",
@@ -23243,7 +23864,7 @@ function toWorkspaceFileDto(file) {
   };
 }
 function languageForPath(filePath) {
-  const extension = path17.extname(filePath).slice(1).toLowerCase();
+  const extension = path18.extname(filePath).slice(1).toLowerCase();
   switch (extension) {
     case "js":
     case "jsx":
@@ -23289,18 +23910,18 @@ function languageForPath(filePath) {
   }
 }
 function relativeWorkspacePath(rootPath, absPath) {
-  const relative = path17.relative(rootPath, absPath);
-  return relative === "" ? "" : relative.split(path17.sep).join("/");
+  const relative = path18.relative(rootPath, absPath);
+  return relative === "" ? "" : relative.split(path18.sep).join("/");
 }
 async function resolveWorkspaceItemPath(rootPath, relativePath = "") {
-  const candidate = path17.resolve(rootPath, relativePath || ".");
+  const candidate = path18.resolve(rootPath, relativePath || ".");
   const comparable = await assertPathWithinRoot(rootPath, candidate);
   return comparable;
 }
 async function buildWorkspaceTreeNode(rootPath, absPath, depth = 0) {
   const stats = await fs18.stat(absPath);
   const relativePath = relativeWorkspacePath(rootPath, absPath);
-  const name = relativePath ? path17.basename(absPath) : path17.basename(rootPath);
+  const name = relativePath ? path18.basename(absPath) : path18.basename(rootPath);
   if (!stats.isDirectory()) {
     return {
       name,
@@ -23335,7 +23956,7 @@ async function buildWorkspaceTreeNode(rootPath, absPath, depth = 0) {
   }).slice(0, 400);
   node.children = (await Promise.all(
     visible.map(async (entry) => {
-      const childPath = path17.join(absPath, entry.name);
+      const childPath = path18.join(absPath, entry.name);
       try {
         if (!entry.isDirectory() && !entry.isFile()) {
           return null;
@@ -23359,19 +23980,19 @@ function requireWorkspaceRecord(app, workspaceId) {
   return record;
 }
 function artifactRoot(record) {
-  return path17.join(record.absPath, ".remote-codex", "artifacts");
+  return path18.join(record.absPath, ".remote-codex", "artifacts");
 }
 function artifactFilePath(record, artifactId) {
-  return path17.join(artifactRoot(record), artifactId, "artifact.bin");
+  return path18.join(artifactRoot(record), artifactId, "artifact.bin");
 }
 function artifactMetadataPath(record, artifactId) {
-  return path17.join(artifactRoot(record), artifactId, "metadata.json");
+  return path18.join(artifactRoot(record), artifactId, "metadata.json");
 }
 function safeArtifactFileName(value) {
-  return path17.basename(value).replace(/[^a-zA-Z0-9_. -]/g, "_") || "artifact.bin";
+  return path18.basename(value).replace(/[^a-zA-Z0-9_. -]/g, "_") || "artifact.bin";
 }
 function artifactIdFromName(name) {
-  const base = path17.basename(name).replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 96);
+  const base = path18.basename(name).replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 96);
   return `${base || "artifact"}-${Date.now().toString(36)}`;
 }
 async function readArtifactMetadata(record, artifactId) {
@@ -23414,7 +24035,7 @@ async function listWorkspaceArtifacts(record) {
   return artifacts.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
 }
 function contentTypeForPath(filePath) {
-  switch (path17.extname(filePath).slice(1).toLowerCase()) {
+  switch (path18.extname(filePath).slice(1).toLowerCase()) {
     case "png":
       return "image/png";
     case "jpg":
@@ -23443,8 +24064,135 @@ function contentTypeForPath(filePath) {
       return "application/octet-stream";
   }
 }
+async function collectFolderZipEntries(rootPath, folderPath) {
+  const folderName = path18.basename(folderPath) || "workspace-folder";
+  const entries = [];
+  let totalBytes = 0;
+  const pending = [folderPath];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    const children = await fs18.readdir(current, { withFileTypes: true });
+    for (const child of children) {
+      const childPath = await resolveWorkspaceItemPath(rootPath, path18.relative(rootPath, path18.join(current, child.name)));
+      if (child.isDirectory()) {
+        pending.push(childPath);
+        continue;
+      }
+      if (!child.isFile()) {
+        continue;
+      }
+      const stats = await fs18.stat(childPath);
+      totalBytes += stats.size;
+      entries.push({
+        absPath: childPath,
+        archivePath: `${folderName}/${relativeWorkspacePath(folderPath, childPath)}`,
+        size: stats.size,
+        updatedAt: stats.mtime
+      });
+      if (entries.length >= WORKSPACE_FOLDER_DOWNLOAD_MAX_FILES) {
+        throw new HttpError(400, {
+          code: "bad_request",
+          message: "Folder downloads must contain fewer than 300 files."
+        });
+      }
+      if (totalBytes >= WORKSPACE_FOLDER_DOWNLOAD_MAX_BYTES) {
+        throw new HttpError(400, {
+          code: "bad_request",
+          message: "Folder downloads must be smaller than 100 MB."
+        });
+      }
+    }
+  }
+  return entries.sort((left, right) => left.archivePath.localeCompare(right.archivePath));
+}
+var crc32Table = new Uint32Array(256);
+for (let index = 0; index < 256; index += 1) {
+  let value = index;
+  for (let bit = 0; bit < 8; bit += 1) {
+    value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+  }
+  crc32Table[index] = value >>> 0;
+}
+function crc32(buffer) {
+  let value = 4294967295;
+  for (const byte of buffer) {
+    value = crc32Table[(value ^ byte) & 255] ^ value >>> 8;
+  }
+  return (value ^ 4294967295) >>> 0;
+}
+function zipDosDateTime(updatedAt) {
+  const year = Math.max(1980, updatedAt.getFullYear());
+  const dosTime = updatedAt.getHours() << 11 | updatedAt.getMinutes() << 5 | Math.floor(updatedAt.getSeconds() / 2);
+  const dosDate = year - 1980 << 9 | updatedAt.getMonth() + 1 << 5 | updatedAt.getDate();
+  return { dosDate, dosTime };
+}
+async function createFolderZipFile(rootPath, folderPath) {
+  const entries = await collectFolderZipEntries(rootPath, folderPath);
+  const localParts = [];
+  const centralParts = [];
+  let offset = 0;
+  for (const entry of entries) {
+    const data = await fs18.readFile(entry.absPath);
+    const name = Buffer.from(entry.archivePath.split(path18.sep).join("/"), "utf8");
+    const checksum = crc32(data);
+    const { dosDate, dosTime } = zipDosDateTime(entry.updatedAt);
+    const localHeader = Buffer.alloc(30);
+    localHeader.writeUInt32LE(67324752, 0);
+    localHeader.writeUInt16LE(20, 4);
+    localHeader.writeUInt16LE(0, 6);
+    localHeader.writeUInt16LE(0, 8);
+    localHeader.writeUInt16LE(dosTime, 10);
+    localHeader.writeUInt16LE(dosDate, 12);
+    localHeader.writeUInt32LE(checksum, 14);
+    localHeader.writeUInt32LE(data.length, 18);
+    localHeader.writeUInt32LE(data.length, 22);
+    localHeader.writeUInt16LE(name.length, 26);
+    localHeader.writeUInt16LE(0, 28);
+    localParts.push(localHeader, name, data);
+    const centralHeader = Buffer.alloc(46);
+    centralHeader.writeUInt32LE(33639248, 0);
+    centralHeader.writeUInt16LE(20, 4);
+    centralHeader.writeUInt16LE(20, 6);
+    centralHeader.writeUInt16LE(0, 8);
+    centralHeader.writeUInt16LE(0, 10);
+    centralHeader.writeUInt16LE(dosTime, 12);
+    centralHeader.writeUInt16LE(dosDate, 14);
+    centralHeader.writeUInt32LE(checksum, 16);
+    centralHeader.writeUInt32LE(data.length, 20);
+    centralHeader.writeUInt32LE(data.length, 24);
+    centralHeader.writeUInt16LE(name.length, 28);
+    centralHeader.writeUInt16LE(0, 30);
+    centralHeader.writeUInt16LE(0, 32);
+    centralHeader.writeUInt16LE(0, 34);
+    centralHeader.writeUInt16LE(0, 36);
+    centralHeader.writeUInt32LE(0, 38);
+    centralHeader.writeUInt32LE(offset, 42);
+    centralParts.push(centralHeader, name);
+    offset += localHeader.length + name.length + data.length;
+  }
+  const centralSize = centralParts.reduce((sum, part) => sum + part.length, 0);
+  const endRecord = Buffer.alloc(22);
+  endRecord.writeUInt32LE(101010256, 0);
+  endRecord.writeUInt16LE(0, 4);
+  endRecord.writeUInt16LE(0, 6);
+  endRecord.writeUInt16LE(entries.length, 8);
+  endRecord.writeUInt16LE(entries.length, 10);
+  endRecord.writeUInt32LE(centralSize, 12);
+  endRecord.writeUInt32LE(offset, 16);
+  endRecord.writeUInt16LE(0, 20);
+  const tempDir = await fs18.mkdtemp(path18.join(os3.tmpdir(), "remote-codex-folder-download-"));
+  const zipPath = path18.join(tempDir, `${path18.basename(folderPath) || "workspace-folder"}.zip`);
+  await fs18.writeFile(zipPath, Buffer.concat([...localParts, ...centralParts, endRecord]));
+  return { zipPath, tempDir };
+}
+function cleanupTemporaryZip(zipPath, tempDir) {
+  return async () => {
+    await fs18.rm(zipPath, { force: true }).catch(() => void 0);
+    await fs18.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
+  };
+}
 function sanitizeUploadFilename(filename) {
-  const baseName = path17.basename(filename?.trim() || "upload");
+  const baseName = path18.basename(filename?.trim() || "upload");
   if (!baseName || baseName === "." || baseName === "..") {
     return "upload";
   }
@@ -23456,7 +24204,7 @@ function inferGitRepoName(gitUrl) {
   const normalized = withoutQuery.replace(/[\\/]+$/, "");
   const rawName = normalized.split(/[/:]/).filter(Boolean).at(-1) ?? "";
   const repoName = rawName.endsWith(".git") ? rawName.slice(0, -4) : rawName;
-  if (!repoName || repoName === "." || repoName === ".." || repoName.includes(path17.sep)) {
+  if (!repoName || repoName === "." || repoName === ".." || repoName.includes(path18.sep)) {
     throw new HttpError(400, {
       code: "bad_request",
       message: "Unable to infer a target directory from the Git URL."
@@ -23521,7 +24269,7 @@ async function registerWorkspaceRoutes(app) {
   });
   app.get("/api/workspaces/tree", async (request) => {
     const query = treeQuerySchema.parse(request.query);
-    const requestedPath = query.path ? path17.resolve(query.path) : app.services.config.workspaceRoot;
+    const requestedPath = query.path ? path18.resolve(query.path) : app.services.config.workspaceRoot;
     const tree = await readWorkspaceTree({
       rootPath: app.services.config.workspaceRoot,
       targetPath: requestedPath,
@@ -23587,7 +24335,7 @@ async function registerWorkspaceRoutes(app) {
       const nextOffset = offset + read.bytesRead;
       return {
         path: relativeWorkspacePath(rootPath, filePath),
-        name: path17.basename(filePath),
+        name: path18.basename(filePath),
         content: buffer.subarray(0, read.bytesRead).toString("utf8"),
         language: languageForPath(filePath),
         size: stats.size,
@@ -23621,13 +24369,25 @@ async function registerWorkspaceRoutes(app) {
     const rootPath = await fs18.realpath(record.absPath);
     const itemPath = await resolveWorkspaceItemPath(rootPath, query.path);
     const stats = await fs18.stat(itemPath);
+    if (stats.isDirectory()) {
+      const { zipPath, tempDir } = await createFolderZipFile(rootPath, itemPath);
+      const filename2 = `${path18.basename(itemPath) || "workspace-folder"}.zip`;
+      const cleanup = cleanupTemporaryZip(zipPath, tempDir);
+      reply.raw.once("finish", () => void cleanup());
+      reply.raw.once("close", () => void cleanup());
+      reply.header("content-type", "application/zip").header(
+        "content-disposition",
+        `attachment; filename="${filename2}"; filename*=UTF-8''${encodeURIComponent(filename2)}`
+      );
+      return reply.send(createReadStream(zipPath));
+    }
     if (!stats.isFile()) {
       throw new HttpError(400, {
         code: "bad_request",
-        message: "Only file downloads are supported from this endpoint."
+        message: "Only file and folder downloads are supported from this endpoint."
       });
     }
-    const filename = path17.basename(itemPath);
+    const filename = path18.basename(itemPath);
     reply.header("content-type", contentTypeForPath(itemPath)).header(
       "content-disposition",
       `attachment; filename="${filename}"; filename*=UTF-8''${encodeURIComponent(filename)}`
@@ -23693,7 +24453,7 @@ async function registerWorkspaceRoutes(app) {
       kind: "file",
       file: {
         path: file.path,
-        name: path17.basename(file.path),
+        name: path18.basename(file.path),
         size: file.size
       }
     };
@@ -23735,7 +24495,7 @@ async function registerWorkspaceRoutes(app) {
         message: "Artifact content must not be empty."
       });
     }
-    const dir = path17.dirname(artifactFilePath(record, artifactId));
+    const dir = path18.dirname(artifactFilePath(record, artifactId));
     await fs18.mkdir(dir, { recursive: true, mode: 448 });
     const filePath = artifactFilePath(record, artifactId);
     await fs18.writeFile(filePath, content, { flag: "wx" }).catch((error) => {
@@ -23798,7 +24558,7 @@ async function registerWorkspaceRoutes(app) {
     const params = z6.object({ id: z6.string().uuid(), artifactId: workspaceArtifactIdSchema }).parse(request.params);
     const record = requireWorkspaceRecord(app, params.id);
     const artifact = await readArtifactMetadata(record, params.artifactId);
-    await fs18.rm(path17.dirname(artifactFilePath(record, params.artifactId)), {
+    await fs18.rm(path18.dirname(artifactFilePath(record, params.artifactId)), {
       recursive: true,
       force: true
     });
@@ -23813,7 +24573,7 @@ async function registerWorkspaceRoutes(app) {
     let validated;
     if ("gitUrl" in body) {
       const repoName = inferGitRepoName(body.gitUrl);
-      const targetPath = path17.join(settings.devHome, repoName);
+      const targetPath = path18.join(settings.devHome, repoName);
       if (await pathExists4(targetPath)) {
         throw new HttpError(409, {
           code: "conflict",
@@ -24077,7 +24837,7 @@ async function registerAuthRoutes(app) {
 
 // src/provider-host-config-service.ts
 import fs19 from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 function providerError(message, statusCode = 404) {
   const error = new Error(message);
@@ -24085,16 +24845,16 @@ function providerError(message, statusCode = 404) {
   return error;
 }
 function resolveProviderHostFilePath(providerHome, name) {
-  return path18.join(providerHome, name);
+  return path19.join(providerHome, name);
 }
 function resolveArchiveRoot(providerHome) {
-  return path18.join(providerHome, "supervisor-config-archives");
+  return path19.join(providerHome, "supervisor-config-archives");
 }
 function resolveArchiveIndexPath(providerHome) {
-  return path18.join(resolveArchiveRoot(providerHome), "index.json");
+  return path19.join(resolveArchiveRoot(providerHome), "index.json");
 }
 function resolveArchivePath(providerHome, archiveId) {
-  return path18.join(resolveArchiveRoot(providerHome), archiveId);
+  return path19.join(resolveArchiveRoot(providerHome), archiveId);
 }
 function defaultArchiveLabel(createdAt) {
   return `Backup ${createdAt.replace("T", " ").replace(/\.\d{3}Z$/, " UTC")}`;
@@ -24147,44 +24907,44 @@ var ProviderHostConfigService = class {
   }
   agentRuntimes;
   providerHomes;
-  runtime(provider) {
-    const runtime = this.agentRuntimes.getOptional(provider);
+  runtime(provider2) {
+    const runtime = this.agentRuntimes.getOptional(provider2);
     if (!runtime) {
-      throw providerError(`Agent runtime provider is not configured: ${provider}`);
+      throw providerError(`Agent runtime provider is not configured: ${provider2}`);
     }
     return runtime;
   }
-  providerHome(provider) {
-    const home = this.providerHomes[provider];
+  providerHome(provider2) {
+    const home = this.providerHomes[provider2];
     if (!home) {
       throw providerError("This backend does not expose host config files.");
     }
     return home;
   }
-  hostFileNames(provider) {
-    const runtime = this.runtime(provider);
+  hostFileNames(provider2) {
+    const runtime = this.runtime(provider2);
     if (!runtime.capabilities.management.hostConfigFiles) {
       throw providerError("This backend does not expose host config files.");
     }
     return runtime.managementSchema.hostConfigFiles.map((file) => file.name);
   }
-  assertHostFile(provider, name) {
-    const fileNames = this.hostFileNames(provider);
+  assertHostFile(provider2, name) {
+    const fileNames = this.hostFileNames(provider2);
     if (!fileNames.includes(name)) {
       throw providerError("Host config file is not exposed by this backend.", 400);
     }
     return name;
   }
-  archiveFileNames(provider) {
-    const runtime = this.runtime(provider);
+  archiveFileNames(provider2) {
+    const runtime = this.runtime(provider2);
     if (!runtime.managementSchema.configArchives) {
       throw providerError("This backend does not support config archives.");
     }
-    return this.hostFileNames(provider);
+    return this.hostFileNames(provider2);
   }
-  async readFile(provider, name) {
-    const providerHome = this.providerHome(provider);
-    const fileName = this.assertHostFile(provider, name);
+  async readFile(provider2, name) {
+    const providerHome = this.providerHome(provider2);
+    const fileName = this.assertHostFile(provider2, name);
     const filePath = resolveProviderHostFilePath(providerHome, fileName);
     try {
       const content = await fs19.readFile(filePath, "utf8");
@@ -24206,25 +24966,25 @@ var ProviderHostConfigService = class {
       };
     }
   }
-  async updateFile(provider, name, input) {
-    const providerHome = this.providerHome(provider);
-    const fileName = this.assertHostFile(provider, name);
+  async updateFile(provider2, name, input) {
+    const providerHome = this.providerHome(provider2);
+    const fileName = this.assertHostFile(provider2, name);
     const filePath = resolveProviderHostFilePath(providerHome, fileName);
-    await fs19.mkdir(path18.dirname(filePath), { recursive: true });
+    await fs19.mkdir(path19.dirname(filePath), { recursive: true });
     await fs19.writeFile(filePath, input.content, "utf8");
-    return this.readFile(provider, fileName);
+    return this.readFile(provider2, fileName);
   }
-  async listArchives(provider) {
-    const runtime = this.runtime(provider);
+  async listArchives(provider2) {
+    const runtime = this.runtime(provider2);
     if (!runtime.managementSchema.configArchives) {
       return [];
     }
-    const index = await readArchiveIndex(this.providerHome(provider));
+    const index = await readArchiveIndex(this.providerHome(provider2));
     return index.archives;
   }
-  async createArchive(provider, input) {
-    const providerHome = this.providerHome(provider);
-    const fileNames = this.archiveFileNames(provider);
+  async createArchive(provider2, input) {
+    const providerHome = this.providerHome(provider2);
+    const fileNames = this.archiveFileNames(provider2);
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
     const id = `${createdAt.replace(/[-:.TZ]/g, "").slice(0, 14)}-${randomUUID4().slice(0, 8)}`;
     const archivePath = resolveArchivePath(providerHome, id);
@@ -24239,13 +24999,13 @@ var ProviderHostConfigService = class {
     );
     await fs19.mkdir(archivePath, { recursive: true });
     for (const name of fileNames) {
-      const hostFile = await this.readFile(provider, name);
+      const hostFile = await this.readFile(provider2, name);
       files[name] = {
         name,
         exists: hostFile.exists
       };
       if (hostFile.exists) {
-        await fs19.writeFile(path18.join(archivePath, name), hostFile.content, "utf8");
+        await fs19.writeFile(path19.join(archivePath, name), hostFile.content, "utf8");
       }
     }
     const archive = {
@@ -24261,9 +25021,9 @@ var ProviderHostConfigService = class {
     });
     return archive;
   }
-  async renameArchive(provider, id, input) {
-    const providerHome = this.providerHome(provider);
-    this.archiveFileNames(provider);
+  async renameArchive(provider2, id, input) {
+    const providerHome = this.providerHome(provider2);
+    this.archiveFileNames(provider2);
     const { index, archive } = await findArchiveOrThrow(providerHome, id);
     const updated = {
       ...archive,
@@ -24275,17 +25035,17 @@ var ProviderHostConfigService = class {
     });
     return updated;
   }
-  async applyArchive(provider, id) {
-    const runtime = this.runtime(provider);
-    const providerHome = this.providerHome(provider);
-    const fileNames = this.archiveFileNames(provider);
+  async applyArchive(provider2, id) {
+    const runtime = this.runtime(provider2);
+    const providerHome = this.providerHome(provider2);
+    const fileNames = this.archiveFileNames(provider2);
     const { archive } = await findArchiveOrThrow(providerHome, id);
     const archivePath = resolveArchivePath(providerHome, archive.id);
     await fs19.mkdir(providerHome, { recursive: true });
     for (const name of fileNames) {
       const hostPath = resolveProviderHostFilePath(providerHome, name);
       if (archive.files[name]?.exists) {
-        const content = await fs19.readFile(path18.join(archivePath, name), "utf8");
+        const content = await fs19.readFile(path19.join(archivePath, name), "utf8");
         await fs19.writeFile(hostPath, content, "utf8");
       } else {
         await fs19.rm(hostPath, { force: true });
@@ -24305,8 +25065,8 @@ import fs21 from "fs/promises";
 
 // src/shell/shell-prompt.ts
 import fs20 from "fs/promises";
-import os3 from "os";
-import path19 from "path";
+import os4 from "os";
+import path20 from "path";
 function basenameFromPath2(filePath) {
   if (!filePath) {
     return "";
@@ -24315,7 +25075,7 @@ function basenameFromPath2(filePath) {
   if (!normalized) {
     return "";
   }
-  return path19.basename(normalized) || normalized;
+  return path20.basename(normalized) || normalized;
 }
 function isInteractiveShellCommand(command) {
   const normalized = (command ?? "").trim().toLowerCase();
@@ -24476,8 +25236,8 @@ function buildShellPromptInitScriptContents(command) {
 async function ensureShellPromptInitScript(command) {
   const normalized = command.trim().toLowerCase();
   const extension = normalized === "zsh" ? "zsh" : "sh";
-  const filePath = path19.join(
-    os3.tmpdir(),
+  const filePath = path20.join(
+    os4.tmpdir(),
     `remote-codex-shell-prompt.${extension}`
   );
   await fs20.writeFile(filePath, buildShellPromptInitScriptContents(command), "utf8");
@@ -25100,7 +25860,7 @@ var terminalPluginManifest = {
   }
 };
 
-// ../../packages/plugin-xyz-viewer/src/manifest.ts
+// ../../node_modules/.pnpm/@remote-codex+plugin-xyz-viewer@file+..+remote-codex-thread-ui+packages+plugin-xyz-view_5227bf80a742872b523d08ba646669ff/node_modules/@remote-codex/plugin-xyz-viewer/dist/chunk-6FS7BLJV.js
 var XYZ_MOLECULE_ARTIFACT_TYPE = "chemistry.molecule3d";
 var xyzViewerPluginManifest = {
   id: "remote-codex.xyz-viewer",
@@ -25159,7 +25919,7 @@ var builtinPlugins = [
 
 // src/plugins/plugin-service.ts
 import fs22 from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 var MANAGED_CODEX_MCP_BEGIN = "# BEGIN remote-codex managed plugin MCP servers";
 var MANAGED_CODEX_MCP_END = "# END remote-codex managed plugin MCP servers";
 var REMOTE_CODEX_MOLECULE_MCP_TOOL_NAME = "remote_codex_render_molecule";
@@ -25171,7 +25931,7 @@ function normalizeManagedCommand(server, repoRoot) {
   if (server.name === "remote_codex_plugins") {
     return {
       command: process.execPath,
-      args: [path20.join(repoRoot, "bin", "remote-codex-plugin-mcp.mjs")]
+      args: [path21.join(repoRoot, "bin", "remote-codex-plugin-mcp.mjs")]
     };
   }
   return {
@@ -25358,7 +26118,7 @@ var PluginService = class {
     if (!input.codexHome) {
       return;
     }
-    const configPath = path20.join(input.codexHome, "config.toml");
+    const configPath = path21.join(input.codexHome, "config.toml");
     let current = "";
     try {
       current = await fs22.readFile(configPath, "utf8");
@@ -25376,7 +26136,7 @@ var PluginService = class {
     if (next === current) {
       return;
     }
-    await fs22.mkdir(path20.dirname(configPath), { recursive: true });
+    await fs22.mkdir(path21.dirname(configPath), { recursive: true });
     await fs22.writeFile(configPath, next, "utf8");
   }
   async importPlugin(input) {
@@ -25617,7 +26377,7 @@ var PluginSettingsStore = class {
 
 // src/worker-bootstrap.ts
 import fs23 from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 function trimTrailingSlash(value) {
   return value.replace(/\/+$/, "");
 }
@@ -25628,7 +26388,7 @@ function tomlString(value) {
   return JSON.stringify(value);
 }
 async function writePrivateFile(filePath, content) {
-  await fs23.mkdir(path21.dirname(filePath), { recursive: true, mode: 448 });
+  await fs23.mkdir(path22.dirname(filePath), { recursive: true, mode: 448 });
   await fs23.writeFile(filePath, content, { encoding: "utf8", mode: 384 });
   await fs23.chmod(filePath, 384);
 }
@@ -25644,7 +26404,7 @@ async function configureWorkerProviderGateway(config) {
   process.env.ANTHROPIC_BASE_URL = anthropicBaseUrl;
   if (config.agentProviders.codex.enabled) {
     await writePrivateFile(
-      path21.join(config.agentProviders.codex.home, "config.toml"),
+      path22.join(config.agentProviders.codex.home, "config.toml"),
       [
         'model_provider = "sub2api"',
         'forced_login_method = "api"',
@@ -25660,7 +26420,7 @@ async function configureWorkerProviderGateway(config) {
       ].join("\n")
     );
     await writePrivateFile(
-      path21.join(config.agentProviders.codex.home, "auth.json"),
+      path22.join(config.agentProviders.codex.home, "auth.json"),
       `${JSON.stringify(
         {
           OPENAI_API_KEY: config.llmGatewayToken
@@ -25673,7 +26433,7 @@ async function configureWorkerProviderGateway(config) {
   }
   if (config.agentProviders.claude.enabled) {
     await writePrivateFile(
-      path21.join(config.agentProviders.claude.home, "settings.json"),
+      path22.join(config.agentProviders.claude.home, "settings.json"),
       `${JSON.stringify(
         {
           env: {
@@ -25689,7 +26449,7 @@ async function configureWorkerProviderGateway(config) {
   }
   if (config.agentProviders.opencode.enabled) {
     await writePrivateFile(
-      path21.join(config.agentProviders.opencode.home, "opencode.json"),
+      path22.join(config.agentProviders.opencode.home, "opencode.json"),
       `${JSON.stringify(
         {
           provider: {
@@ -25736,7 +26496,7 @@ var BackendPluginHost = class {
 };
 
 // src/shell/pty-shell-backend.ts
-import path22 from "path";
+import path23 from "path";
 import { spawn as spawn4 } from "@homebridge/node-pty-prebuilt-multiarch";
 
 // src/shell/default-shell.ts
@@ -25756,7 +26516,7 @@ function resolveDefaultShell(env = process.env) {
 var MAX_SCROLLBACK_BYTES = 512 * 1024;
 var ANSI_ESCAPE_PATTERN = new RegExp(String.raw`\u001B\[[0-?]*[ -/]*[@-~]`, "g");
 function shellArgs(shell) {
-  const shellName = path22.basename(shell).toLowerCase();
+  const shellName = path23.basename(shell).toLowerCase();
   if (process.platform === "win32") {
     return [];
   }
@@ -25778,7 +26538,7 @@ function lastVisibleLine(snapshot) {
 }
 function inferRuntime(session) {
   const promptLine = lastVisibleLine(session.scrollback);
-  const shell = path22.basename(session.shell);
+  const shell = path23.basename(session.shell);
   const isCommandRunning = session.exitCode !== null ? false : !/[$#>]\s*$/.test(promptLine.trimEnd());
   return {
     panePid: session.pty.pid,
@@ -25925,7 +26685,7 @@ var PtyShellBackend = class {
 
 // src/shell/tmux-manager.ts
 import fs25 from "fs";
-import path23 from "path";
+import path24 from "path";
 import { spawn as spawnChild } from "child_process";
 async function defaultExecCommand(command, args) {
   return await new Promise((resolve, reject) => {
@@ -25952,16 +26712,16 @@ async function defaultExecCommand(command, args) {
   });
 }
 function resolveExecutablePath(command) {
-  if (command.includes(path23.sep)) {
+  if (command.includes(path24.sep)) {
     return command;
   }
   const searchPath = process.env.PATH ?? "";
-  for (const entry of searchPath.split(path23.delimiter)) {
+  for (const entry of searchPath.split(path24.delimiter)) {
     const trimmed = entry.trim();
     if (!trimmed) {
       continue;
     }
-    const candidate = path23.join(trimmed, command);
+    const candidate = path24.join(trimmed, command);
     if (fs25.existsSync(candidate)) {
       return candidate;
     }
@@ -26720,22 +27480,22 @@ function payloadItems(payload, fields) {
   const record = recordFrom(payload);
   return arrayField(record, fields) ?? (record ? [record] : []);
 }
-function artifactPreviewKind(type, format, path25) {
+function artifactPreviewKind(type, format, path26) {
   const candidates = [
     type,
     format,
-    path25?.split(".").pop() ?? null
+    path26?.split(".").pop() ?? null
   ].map((value) => value?.trim().toLowerCase()).filter(Boolean);
   return candidates.some((value) => MOLECULE_ARTIFACT_TYPES.has(value)) ? "molecule" : "file";
 }
 function normalizeArtifactRef(value) {
   const record = recordFrom(value);
-  const path25 = stringField3(record, ["path", "filePath", "file_path", "filename", "fileName", "name"]);
+  const path26 = stringField3(record, ["path", "filePath", "file_path", "filename", "fileName", "name"]);
   const type = stringField3(record, ["type", "artifactType", "artifact_type", "format", "extension"]);
-  const title = stringField3(record, ["title", "label", "name", "filename", "fileName"]) ?? path25 ?? "artifact";
+  const title = stringField3(record, ["title", "label", "name", "filename", "fileName"]) ?? path26 ?? "artifact";
   return {
     title,
-    path: path25,
+    path: path26,
     type,
     downloadUrl: stringField3(record, ["downloadUrl", "download_url", "url", "href"])
   };
@@ -26769,21 +27529,21 @@ function normalizeArtifact(module, runId, value) {
   if (!record) {
     return null;
   }
-  const path25 = stringField3(record, ["path", "filePath", "file_path", "filename", "fileName", "name"]);
+  const path26 = stringField3(record, ["path", "filePath", "file_path", "filename", "fileName", "name"]);
   const type = stringField3(record, ["type", "artifactType", "artifact_type"]);
   const format = stringField3(record, ["format", "fileFormat", "file_format", "extension"]) ?? type;
-  const title = stringField3(record, ["title", "label", "name", "filename", "fileName"]) ?? path25 ?? `${module} artifact`;
+  const title = stringField3(record, ["title", "label", "name", "filename", "fileName"]) ?? path26 ?? `${module} artifact`;
   return {
     module,
     runId,
     title,
-    path: path25,
+    path: path26,
     type,
     format,
     mimeType: stringField3(record, ["mimeType", "mime_type", "contentType", "content_type"]),
     sizeBytes: numberField2(record, ["sizeBytes", "size_bytes", "bytes"]),
     downloadUrl: stringField3(record, ["downloadUrl", "download_url", "url", "href"]),
-    previewKind: artifactPreviewKind(type, format, path25)
+    previewKind: artifactPreviewKind(type, format, path26)
   };
 }
 function normalizeRuns(module, result) {
@@ -26910,9 +27670,9 @@ var WorkerHarnessClient = class {
     }
     return { baseUrl, apiKey };
   }
-  async fetchText(path25) {
+  async fetchText(path26) {
     const config = this.requireHarnessConfig();
-    const response = await this.fetchImpl(`${config.baseUrl}${path25}`, {
+    const response = await this.fetchImpl(`${config.baseUrl}${path26}`, {
       headers: {
         "x-api-key": config.apiKey
       }
@@ -26923,11 +27683,11 @@ var WorkerHarnessClient = class {
     }
     return { text: text2 };
   }
-  async fetchPayload(path25, init = {}) {
+  async fetchPayload(path26, init = {}) {
     const config = this.requireHarnessConfig();
     const headers = new Headers(init.headers);
     headers.set("x-api-key", config.apiKey);
-    const response = await this.fetchImpl(`${config.baseUrl}${path25}`, {
+    const response = await this.fetchImpl(`${config.baseUrl}${path26}`, {
       ...init,
       headers
     });
@@ -26941,9 +27701,9 @@ var WorkerHarnessClient = class {
       return { text: text2 };
     }
   }
-  async fetchBinary(path25) {
+  async fetchBinary(path26) {
     const config = this.requireHarnessConfig();
-    const response = await this.fetchImpl(`${config.baseUrl}${path25}`, {
+    const response = await this.fetchImpl(`${config.baseUrl}${path26}`, {
       headers: {
         "x-api-key": config.apiKey
       }
@@ -27488,16 +28248,16 @@ var HttpError = class extends Error {
 };
 function findRepoRoot(start = process.cwd()) {
   if (process.env.REMOTE_CODEX_REPO_ROOT) {
-    return path24.resolve(process.env.REMOTE_CODEX_REPO_ROOT);
+    return path25.resolve(process.env.REMOTE_CODEX_REPO_ROOT);
   }
-  let current = path24.resolve(start);
-  while (current !== path24.dirname(current)) {
-    if (fs26.existsSync(path24.join(current, "pnpm-workspace.yaml")) && fs26.existsSync(path24.join(current, "scripts", "service-restart.mjs"))) {
+  let current = path25.resolve(start);
+  while (current !== path25.dirname(current)) {
+    if (fs26.existsSync(path25.join(current, "pnpm-workspace.yaml")) && fs26.existsSync(path25.join(current, "scripts", "service-restart.mjs"))) {
       return current;
     }
-    current = path24.dirname(current);
+    current = path25.dirname(current);
   }
-  return path24.resolve(process.cwd());
+  return path25.resolve(process.cwd());
 }
 function createServiceLifecycle() {
   return {
@@ -27509,8 +28269,8 @@ function createServiceLifecycle() {
         });
       }
       const repoRoot = findRepoRoot();
-      const restartScript = path24.join(repoRoot, "scripts", "service-restart.mjs");
-      if (!fs26.existsSync(restartScript) || !fs26.existsSync(path24.join(repoRoot, "pnpm-workspace.yaml"))) {
+      const restartScript = path25.join(repoRoot, "scripts", "service-restart.mjs");
+      if (!fs26.existsSync(restartScript) || !fs26.existsSync(path25.join(repoRoot, "pnpm-workspace.yaml"))) {
         throw new HttpError(503, {
           code: "service_unavailable",
           message: "Build and restart requires a Remote Codex source checkout. Set REMOTE_CODEX_REPO_ROOT to the checkout path, or update the npm package with npm install -g remote-codex@latest."
@@ -27652,9 +28412,10 @@ function buildApp(options = {}) {
         });
       },
       wsHandler: (socket, request) => {
+        const supervisorSocket = socket;
         const session = authService.verifyRequest(request);
         if (!session.authenticated) {
-          socket.close(1008, "Authentication is required.");
+          supervisorSocket.close(1008, "Authentication is required.");
           return;
         }
         const supervisorSession = createSupervisorSocketSession({
@@ -27662,15 +28423,15 @@ function buildApp(options = {}) {
           eventBus,
           backendPluginHost,
           send(message) {
-            if (socket.readyState === 1) {
-              socket.send(JSON.stringify(message));
+            if (supervisorSocket.readyState === 1) {
+              supervisorSocket.send(JSON.stringify(message));
             }
           }
         });
-        socket.on("message", async (rawMessage) => {
+        supervisorSocket.on("message", async (rawMessage) => {
           await supervisorSession.handleMessage(rawMessage.toString());
         });
-        socket.on("close", () => {
+        supervisorSocket.on("close", () => {
           supervisorSession.close();
         });
       }
@@ -27819,6 +28580,7 @@ function requestLog(app, error) {
 }
 function createRelayRequestHandler(app) {
   return async function handleRelayRequest(request) {
+    const payload = request.body === null ? void 0 : request.bodyEncoding === "base64" ? Buffer.from(request.body, "base64") : request.body;
     const response = await app.inject({
       method: request.method,
       url: request.path,
@@ -27826,15 +28588,41 @@ function createRelayRequestHandler(app) {
         ...request.headers,
         [RELAY_FORWARD_HEADER]: "1"
       },
-      ...request.body !== null ? { payload: request.body } : {}
+      ...payload !== void 0 ? { payload } : {}
     });
+    const responseBody = relayResponseBody(response);
     return {
       statusCode: response.statusCode,
       headers: relayResponseHeaders(response.headers),
-      body: response.body
+      body: responseBody.body,
+      ...responseBody.bodyEncoding ? { bodyEncoding: responseBody.bodyEncoding } : {}
     };
   };
 }
+function relayResponseBody(response) {
+  const contentType = responseHeader(response.headers, "content-type");
+  if (isTextRelayResponse(contentType)) {
+    return { body: response.body };
+  }
+  return {
+    body: response.rawPayload.toString("base64"),
+    bodyEncoding: "base64"
+  };
+}
+function responseHeader(headers, name) {
+  const lowerName = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== lowerName || value === void 0) {
+      continue;
+    }
+    return Array.isArray(value) ? value.join(", ") : String(value);
+  }
+  return "";
+}
+function isTextRelayResponse(contentType) {
+  const lower = contentType.toLowerCase();
+  return lower.startsWith("text/") || lower.includes("application/json") || lower.includes("+json") || lower.includes("application/javascript") || lower.includes("application/xml") || lower.includes("+xml") || lower.includes("image/svg+xml");
+}
 function createSupervisorSocketSession(input) {
   const closeHandlers = [];
   const socketState = /* @__PURE__ */ new Map();