remote-codex 0.11.17 → 0.11.19

package/apps/supervisor-api/dist/{chunk-ZYCD54EZ.js → chunk-IZBNFCMP.js}

@@ -9,8 +9,8 @@ import Fastify from "fastify";
 import multipart from "@fastify/multipart";
 import websocket from "@fastify/websocket";
 import { spawn as spawn6 } from "child_process";
-import fs26 from "fs";
-import path26 from "path";
+import fs28 from "fs";
+import path28 from "path";
 import { ZodError } from "zod";
 
 // ../../packages/config/src/index.ts
@@ -2318,7 +2318,7 @@ Subquery.prototype.getSQL = function() {
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce(
-    (result2, { path: path27, field }, columnIndex) => {
+    (result2, { path: path29, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -2328,8 +2328,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         decoder = field.sql.decoder;
       }
       let node = result2;
-      for (const [pathChunkIndex, pathChunk] of path27.entries()) {
-        if (pathChunkIndex < path27.length - 1) {
+      for (const [pathChunkIndex, pathChunk] of path29.entries()) {
+        if (pathChunkIndex < path29.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -2337,8 +2337,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) && path27.length === 2) {
-            const objectName = path27[0];
+          if (joinsNotNullableMap && is(field, Column) && path29.length === 2) {
+            const objectName = path29[0];
             if (!(objectName in nullifyMap)) {
               nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
             } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
@@ -6496,6 +6496,7 @@ var threadTurnMetadata = sqliteTable(
     pricingModelKey: text("pricing_model_key"),
     pricingTierKey: text("pricing_tier_key"),
     tokenUsageJson: text("token_usage_json"),
+    displayPrompt: text("display_prompt"),
     createdAt: text("created_at").notNull(),
     updatedAt: text("updated_at").notNull()
   },
@@ -7119,6 +7120,7 @@ function upsertThreadTurnMetadata(db, input) {
       pricingModelKey: input.pricingModelKey !== void 0 ? input.pricingModelKey : existing.pricingModelKey,
       pricingTierKey: input.pricingTierKey !== void 0 ? input.pricingTierKey : existing.pricingTierKey,
       tokenUsageJson: input.tokenUsageJson !== void 0 ? input.tokenUsageJson : existing.tokenUsageJson,
+      displayPrompt: input.displayPrompt !== void 0 ? input.displayPrompt : existing.displayPrompt,
       updatedAt: now
     }).where(eq(threadTurnMetadata.id, existing.id)).run();
     return;
@@ -7133,6 +7135,7 @@ function upsertThreadTurnMetadata(db, input) {
     pricingModelKey: input.pricingModelKey ?? null,
     pricingTierKey: input.pricingTierKey ?? null,
     tokenUsageJson: input.tokenUsageJson ?? null,
+    displayPrompt: input.displayPrompt ?? null,
     createdAt: now,
     updatedAt: now
   }).run();
@@ -9248,7 +9251,7 @@ function extractFileChangeEntries(item) {
       isRecord4(entry.summary) ? entry.summary : null,
       isRecord4(entry.diff) ? entry.diff : null
     ].filter((candidate) => Boolean(candidate));
-    const path27 = uniqueStrings([
+    const path29 = uniqueStrings([
       stringOrNull(valueFromRecords(nestedRecords, ["path", "filePath", "targetPath"])),
       stringOrNull(
         valueFromRecords(nestedRecords, [
@@ -9295,7 +9298,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 = path27 ?? (diffText ? projectRelativePathLabel(extractPathFromDiffText(diffText)) : null);
+    const normalizedPath = path29 ?? (diffText ? projectRelativePathLabel(extractPathFromDiffText(diffText)) : null);
     if (!normalizedPath && additions === 0 && deletions === 0) {
       return null;
     }
@@ -13605,14 +13608,14 @@ function displayPath(pathValue, options) {
   }
   return relativePath;
 }
-function toolIsLowInformationPatch(normalized, state, input, patchText, path27, metadataStats) {
+function toolIsLowInformationPatch(normalized, state, input, patchText, path29, metadataStats) {
   if (normalized !== "applypatch" && normalized !== "patch") {
     return false;
   }
   if (toolStateStatus(state) !== "running") {
     return false;
   }
-  if (path27 || patchText || metadataStats || stringValue2(state.output)) {
+  if (path29 || patchText || metadataStats || stringValue2(state.output)) {
     return false;
   }
   return !isRecord9(input) || Object.keys(input).length === 0;
@@ -13655,7 +13658,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((path27) => Boolean(path27));
+  const paths = files.map((file) => stringValue2(file.filePath) ?? stringValue2(file.path) ?? stringValue2(file.relativePath)).filter((path29) => Boolean(path29));
   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 {
@@ -13803,28 +13806,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 path27 = metadataStats?.path ?? filePathFromInput(input) ?? extractPathFromPatchText(patchText);
-    if (toolIsLowInformationPatch(normalized, state, input, patchText, path27, metadataStats)) {
+    const path29 = metadataStats?.path ?? filePathFromInput(input) ?? extractPathFromPatchText(patchText);
+    if (toolIsLowInformationPatch(normalized, state, input, patchText, path29, metadataStats)) {
       return null;
     }
     const output = stringValue2(state.output);
     const diffStats = countUnifiedDiffStats2(patchText);
-    const displayFilePath = displayPath(path27, options);
+    const displayFilePath = displayPath(path29, 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 ?? (path27 ? 1 : null),
+      changedFiles: metadataStats?.changedFiles ?? (path29 ? 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 path27 = filePathFromInput(input);
-    const text2 = displayPath(path27, options) ?? summary ?? name;
+    const path29 = filePathFromInput(input);
+    const text2 = displayPath(path29, options) ?? summary ?? name;
     return {
       id,
       kind: "fileRead",
@@ -18313,8 +18316,13 @@ function applyLiveAgentMessageOrderingHints(turns, localThreadId, liveState) {
 }
 function buildTurnDto(turn, metadata) {
   const tokenUsage = parseThreadTurnTokenUsageJson(metadata?.tokenUsageJson);
+  const displayPrompt = metadata?.displayPrompt?.trim();
+  const items = displayPrompt && turn.items.some((item) => /\[localImage\]/.test(item.text)) ? turn.items.map(
+    (item) => item.kind === "userMessage" && /\[localImage\]/.test(item.text) ? { ...item, text: displayPrompt } : item
+  ) : turn.items;
   return {
     ...turn,
+    items,
     startedAt: turn.startedAt ?? metadata?.createdAt ?? null,
     model: metadata?.model ?? null,
     reasoningEffort: normalizeReasoningEffort(metadata?.reasoningEffort),
@@ -18824,7 +18832,8 @@ var ThreadPromptTurnCoordinator = class {
         input.effectiveModel
       ),
       pricingModelKey: pricingSnapshot?.pricingModelKey ?? null,
-      pricingTierKey: pricingSnapshot?.pricingTierKey ?? null
+      pricingTierKey: pricingSnapshot?.pricingTierKey ?? null,
+      displayPrompt
     });
     const patch = {
       providerTurnId: turn.providerTurnId,
@@ -19443,7 +19452,8 @@ var ThreadHistoryPersistenceCoordinator = class {
       reasoningEffortAvailable: runtimeMetadata.reasoningEffortAvailable ?? null,
       pricingModelKey: runtimeMetadata.pricingModelKey ?? null,
       pricingTierKey: runtimeMetadata.pricingTierKey ?? null,
-      tokenUsageJson: runtimeMetadata.tokenUsageJson ?? null
+      tokenUsageJson: runtimeMetadata.tokenUsageJson ?? null,
+      displayPrompt: runtimeMetadata.displayPrompt ?? null
     });
     deleteThreadTurnMetadataByThreadAndTurnId(this.db, localThreadId, runtimeTurnId);
   }
@@ -20650,6 +20660,24 @@ function truncateChromeStderr(value) {
   return value.slice(value.length - MAX_CHROME_STDERR_CHARS);
 }
 
+// src/thread-turn-metadata.ts
+function listThreadTurnMetadataMap(db, localThreadId) {
+  return new Map(
+    listThreadTurnMetadataByThreadId(db, localThreadId).map((entry) => [
+      entry.turnId,
+      {
+        model: entry.model ?? null,
+        reasoningEffort: entry.reasoningEffort ?? null,
+        reasoningEffortAvailable: entry.reasoningEffortAvailable ?? null,
+        pricingModelKey: entry.pricingModelKey ?? null,
+        pricingTierKey: normalizePricingTier(entry.pricingTierKey),
+        tokenUsageJson: entry.tokenUsageJson ?? null,
+        createdAt: entry.createdAt ?? null
+      }
+    ])
+  );
+}
+
 // src/thread-export-coordinator.ts
 function userPromptPreviewFromTurn(turn) {
   const prompt = turn.items.find((item) => item.kind === "userMessage")?.text.trim();
@@ -20743,20 +20771,7 @@ var ThreadExportCoordinator = class {
       });
     }
     this.callbacks.requireProviderSessionId(record);
-    const turnMetadataById = new Map(
-      listThreadTurnMetadataByThreadId(this.db, localThreadId).map((entry) => [
-        entry.turnId,
-        {
-          model: entry.model ?? null,
-          reasoningEffort: entry.reasoningEffort ?? null,
-          reasoningEffortAvailable: entry.reasoningEffortAvailable ?? null,
-          pricingModelKey: entry.pricingModelKey ?? null,
-          pricingTierKey: normalizePricingTier(entry.pricingTierKey),
-          tokenUsageJson: entry.tokenUsageJson ?? null,
-          createdAt: entry.createdAt ?? null
-        }
-      ])
-    );
+    const turnMetadataById = listThreadTurnMetadataMap(this.db, localThreadId);
     const cachedDetail = await this.detailAssembler.buildCacheEntry({
       localThreadId,
       record,
@@ -20823,20 +20838,7 @@ var ThreadForkCoordinator = class {
       });
     }
     this.callbacks.requireProviderSessionId(record);
-    const turnMetadataById = new Map(
-      listThreadTurnMetadataByThreadId(this.db, localThreadId).map((entry) => [
-        entry.turnId,
-        {
-          model: entry.model ?? null,
-          reasoningEffort: entry.reasoningEffort ?? null,
-          reasoningEffortAvailable: entry.reasoningEffortAvailable ?? null,
-          pricingModelKey: entry.pricingModelKey ?? null,
-          pricingTierKey: normalizePricingTier(entry.pricingTierKey),
-          tokenUsageJson: entry.tokenUsageJson ?? null,
-          createdAt: entry.createdAt ?? null
-        }
-      ])
-    );
+    const turnMetadataById = listThreadTurnMetadataMap(this.db, localThreadId);
     const cachedDetail = await this.detailAssembler.buildCacheEntry({
       localThreadId,
       record,
@@ -21441,6 +21443,26 @@ var ThreadService = class {
     }
     return record.providerSessionId;
   }
+  requireThreadRecord(localThreadId) {
+    const record = getThreadRecordById(this.db, localThreadId);
+    if (!record) {
+      throw new HttpError(404, {
+        code: "not_found",
+        message: "Thread was not found."
+      });
+    }
+    return record;
+  }
+  requireWorkspaceForThread(record) {
+    const workspace = getWorkspaceRecordById(this.db, record.workspaceId);
+    if (!workspace) {
+      throw new HttpError(404, {
+        code: "not_found",
+        message: "Workspace was not found for this thread."
+      });
+    }
+    return workspace;
+  }
   materializeHiddenRuntimeTurns(localThreadId, turns) {
     for (const turn of this.liveState.hiddenRemoteTurns(localThreadId, turns)) {
       const displayTurnId = this.liveState.displayTurnIdForRuntimeTurn(localThreadId, turn.providerTurnId) ?? turn.providerTurnId;
@@ -21575,37 +21597,12 @@ var ThreadService = class {
     return this.getThreadDetail(localThreadId);
   }
   async getThreadDetail(localThreadId, options = {}) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
-    const workspace = getWorkspaceRecordById(this.db, record.workspaceId);
-    if (!workspace) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Workspace was not found for this thread."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
+    const workspace = this.requireWorkspaceForThread(record);
     this.requireProviderSessionId(record);
     const loadedIds = await this.listLoadedProviderSessionIds(record.provider);
     const workspacePathStatus = await pathExists3(workspace.absPath) ? "present" : "missing";
-    const turnMetadataById = new Map(
-      listThreadTurnMetadataByThreadId(this.db, localThreadId).map((entry) => [
-        entry.turnId,
-        {
-          model: entry.model ?? null,
-          reasoningEffort: entry.reasoningEffort ?? null,
-          reasoningEffortAvailable: entry.reasoningEffortAvailable ?? null,
-          pricingModelKey: entry.pricingModelKey ?? null,
-          pricingTierKey: normalizePricingTier(entry.pricingTierKey),
-          tokenUsageJson: entry.tokenUsageJson ?? null,
-          createdAt: entry.createdAt ?? null
-        }
-      ])
-    );
+    const turnMetadataById = listThreadTurnMetadataMap(this.db, localThreadId);
     const cachedDetail = await this.detailAssembler.buildCacheEntry({
       localThreadId,
       record,
@@ -21663,33 +21660,15 @@ var ThreadService = class {
     return this.exportCoordinator.exportThreadTranscript(localThreadId, input);
   }
   async getThreadGoal(localThreadId) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
     return this.goalCoordinator.getThreadGoal(record);
   }
   async updateThreadGoal(localThreadId, input) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
     return this.goalCoordinator.updateThreadGoal(record, input);
   }
   async clearThreadGoal(localThreadId) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
     return this.goalCoordinator.clearThreadGoal(record);
   }
   async ensureThreadLoadedForProviderOperation(record) {
@@ -21711,28 +21690,9 @@ var ThreadService = class {
     await this.resumeThread(record.id, resumeInput);
   }
   async getThreadHistoryItemDetail(localThreadId, itemId) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
     this.requireProviderSessionId(record);
-    const turnMetadataById = new Map(
-      listThreadTurnMetadataByThreadId(this.db, localThreadId).map((entry) => [
-        entry.turnId,
-        {
-          model: entry.model ?? null,
-          reasoningEffort: entry.reasoningEffort ?? null,
-          reasoningEffortAvailable: entry.reasoningEffortAvailable ?? null,
-          pricingModelKey: entry.pricingModelKey ?? null,
-          pricingTierKey: normalizePricingTier(entry.pricingTierKey),
-          tokenUsageJson: entry.tokenUsageJson ?? null,
-          createdAt: entry.createdAt ?? null
-        }
-      ])
-    );
+    const turnMetadataById = listThreadTurnMetadataMap(this.db, localThreadId);
     const cachedDetail = await this.detailAssembler.buildCacheEntry({
       localThreadId,
       record,
@@ -21763,13 +21723,7 @@ var ThreadService = class {
     return this.getThreadDetail(localThreadId);
   }
   async sendPrompt(localThreadId, input, options = {}) {
-    let record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
+    let record = this.requireThreadRecord(localThreadId);
     await this.importCoordinator.assertImportedThreadReadyForPrompt({
       source: record.source,
       provider: record.provider,
@@ -21869,13 +21823,7 @@ var ThreadService = class {
     });
   }
   async updateThreadSettings(localThreadId, input) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
     const nextSettings = await this.sessionCoordinator.resolveThreadSettings({
       provider: record.provider,
       currentModel: record.model,
@@ -21916,13 +21864,7 @@ var ThreadService = class {
     return this.toThreadDto(updated, loadedIds);
   }
   async updateThreadTitle(localThreadId, title) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
     const normalizedTitle = title.trim();
     if (!normalizedTitle) {
       throw new HttpError(400, {
@@ -21941,13 +21883,7 @@ var ThreadService = class {
     return this.toThreadDto(updated, loadedIds);
   }
   async compactThread(localThreadId) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
     const providerSessionId = this.requireProviderSessionId(record);
     if (record.isConnected === false) {
       throw new HttpError(409, {
@@ -21982,72 +21918,30 @@ var ThreadService = class {
     return this.forkCoordinator.forkThread(localThreadId, input);
   }
   async listThreadSkills(localThreadId) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
-    const workspace = getWorkspaceRecordById(this.db, record.workspaceId);
-    if (!workspace) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Workspace was not found for this thread."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
+    const workspace = this.requireWorkspaceForThread(record);
     return this.managementCoordinator.listThreadSkills({
       provider: record.provider,
       workspacePath: workspace.absPath
     });
   }
   async listThreadMcpServers(localThreadId) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
     return this.managementCoordinator.listThreadMcpServers({
       provider: record.provider
     });
   }
   async listThreadHooks(localThreadId) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
-    const workspace = getWorkspaceRecordById(this.db, record.workspaceId);
-    if (!workspace) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Workspace was not found for this thread."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
+    const workspace = this.requireWorkspaceForThread(record);
     return this.managementCoordinator.listThreadHooks({
       provider: record.provider,
       workspacePath: workspace.absPath
     });
   }
   async createThreadHook(localThreadId, input) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
-    const workspace = getWorkspaceRecordById(this.db, record.workspaceId);
-    if (!workspace) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Workspace was not found for this thread."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
+    const workspace = this.requireWorkspaceForThread(record);
     return this.managementCoordinator.createThreadHook({
       provider: record.provider,
       workspacePath: workspace.absPath,
@@ -22055,20 +21949,8 @@ var ThreadService = class {
     });
   }
   async updateThreadHook(localThreadId, input) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
-    const workspace = getWorkspaceRecordById(this.db, record.workspaceId);
-    if (!workspace) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Workspace was not found for this thread."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
+    const workspace = this.requireWorkspaceForThread(record);
     return this.managementCoordinator.updateThreadHook({
       provider: record.provider,
       workspacePath: workspace.absPath,
@@ -22076,20 +21958,8 @@ var ThreadService = class {
     });
   }
   async trustThreadHook(localThreadId, input) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
-    const workspace = getWorkspaceRecordById(this.db, record.workspaceId);
-    if (!workspace) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Workspace was not found for this thread."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
+    const workspace = this.requireWorkspaceForThread(record);
     return this.managementCoordinator.trustThreadHook({
       provider: record.provider,
       workspacePath: workspace.absPath,
@@ -22097,20 +21967,8 @@ var ThreadService = class {
     });
   }
   async untrustThreadHook(localThreadId, input) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
-    const workspace = getWorkspaceRecordById(this.db, record.workspaceId);
-    if (!workspace) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Workspace was not found for this thread."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
+    const workspace = this.requireWorkspaceForThread(record);
     return this.managementCoordinator.untrustThreadHook({
       provider: record.provider,
       workspacePath: workspace.absPath,
@@ -22118,13 +21976,7 @@ var ThreadService = class {
     });
   }
   async interruptThread(localThreadId, requestedTurnId) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
     const providerSessionId = this.requireProviderSessionId(record);
     const interruptInput = {
       provider: record.provider,
@@ -22152,13 +22004,7 @@ var ThreadService = class {
     return this.deletionCoordinator.deleteThread(localThreadId);
   }
   async respondToRequest(localThreadId, requestId, input) {
-    const record = getThreadRecordById(this.db, localThreadId);
-    if (!record) {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Thread was not found."
-      });
-    }
+    const record = this.requireThreadRecord(localThreadId);
     const requestResponse = this.requestCoordinator.respondToRequest(
       localThreadId,
       requestId,
@@ -22313,20 +22159,7 @@ var ThreadService = class {
     if (!record) {
       return;
     }
-    const turnMetadataById = new Map(
-      listThreadTurnMetadataByThreadId(this.db, localThreadId).map((entry) => [
-        entry.turnId,
-        {
-          model: entry.model ?? null,
-          reasoningEffort: entry.reasoningEffort ?? null,
-          reasoningEffortAvailable: entry.reasoningEffortAvailable ?? null,
-          pricingModelKey: entry.pricingModelKey ?? null,
-          pricingTierKey: normalizePricingTier(entry.pricingTierKey),
-          tokenUsageJson: entry.tokenUsageJson ?? null,
-          createdAt: entry.createdAt ?? null
-        }
-      ])
-    );
+    const turnMetadataById = listThreadTurnMetadataMap(this.db, localThreadId);
     const cachedDetail = await this.detailAssembler.buildCacheEntry({
       localThreadId,
       record,
@@ -24081,68 +23914,143 @@ async function registerThreadRoutes(app) {
 }
 
 // src/routes/workspaces.ts
-import fs18 from "fs/promises";
+import fs20 from "fs/promises";
 import { createReadStream } from "fs";
-import os4 from "os";
-import path19 from "path";
-import { spawn as spawn4 } from "child_process";
+import path21 from "path";
 import { Readable } from "stream";
 import { z as z6 } from "zod";
-var createWorkspaceSchema = z6.union([
-  z6.object({
-    absPath: z6.string().min(1),
-    label: z6.string().min(1).optional()
-  }),
-  z6.object({
-    gitUrl: z6.string().min(1),
-    label: z6.string().min(1).optional()
-  })
-]);
-var updateFavoriteSchema = z6.object({
-  isFavorite: z6.boolean()
-});
-var updateWorkspaceSchema = z6.object({
-  label: z6.string().min(1)
-});
-var workspaceFilePathSchema = z6.string().trim().min(1).max(4096);
-var writeWorkspaceFileSchema = z6.object({
-  path: workspaceFilePathSchema,
-  content: z6.string()
-});
-var moveWorkspaceFileSchema = z6.object({
-  fromPath: workspaceFilePathSchema,
-  toPath: workspaceFilePathSchema,
-  overwrite: z6.boolean().optional()
-});
-var deleteWorkspaceFileSchema = z6.object({
-  path: workspaceFilePathSchema,
-  recursive: z6.boolean().optional()
-});
-var workspaceArtifactIdSchema = z6.string().trim().min(1).max(160).regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/);
-var workspaceArtifactNameSchema = z6.string().trim().min(1).max(255);
-var createWorkspaceArtifactSchema = z6.object({
-  id: workspaceArtifactIdSchema.optional(),
-  name: workspaceArtifactNameSchema,
-  mediaType: z6.string().trim().min(1).max(255).default("application/octet-stream"),
-  contentBase64: z6.string().min(1),
-  metadata: z6.record(z6.string(), z6.unknown()).optional()
-});
-var treeQuerySchema = z6.object({
-  path: z6.string().optional(),
-  showHidden: z6.coerce.boolean().optional()
-});
-var workspaceFileQuerySchema = z6.object({
-  path: z6.string().optional().default("")
-});
-var workspacePreviewQuerySchema = z6.object({
-  path: z6.string().min(1),
-  offset: z6.coerce.number().int().min(0).optional(),
-  limit: z6.coerce.number().int().positive().max(25e4).optional()
-});
+
+// src/workspace-artifact-service.ts
+import fs18 from "fs/promises";
+import path19 from "path";
+function artifactRoot(record) {
+  return path19.join(record.absPath, ".remote-codex", "artifacts");
+}
+function artifactFilePath(record, artifactId) {
+  return path19.join(artifactRoot(record), artifactId, "artifact.bin");
+}
+function artifactMetadataPath(record, artifactId) {
+  return path19.join(artifactRoot(record), artifactId, "metadata.json");
+}
+function safeArtifactFileName(value) {
+  return path19.basename(value).replace(/[^a-zA-Z0-9_. -]/g, "_") || "artifact.bin";
+}
+function artifactIdFromName(name) {
+  const base = path19.basename(name).replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 96);
+  return `${base || "artifact"}-${Date.now().toString(36)}`;
+}
+async function readWorkspaceArtifactMetadata(record, artifactId) {
+  try {
+    const raw = await fs18.readFile(artifactMetadataPath(record, artifactId), "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new HttpError(404, {
+        code: "not_found",
+        message: "Workspace artifact was not found."
+      });
+    }
+    throw error;
+  }
+}
+async function listWorkspaceArtifacts(record) {
+  let entries;
+  try {
+    entries = await fs18.readdir(artifactRoot(record));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  const artifacts = [];
+  for (const entry of entries) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/.test(entry)) {
+      continue;
+    }
+    try {
+      artifacts.push(await readWorkspaceArtifactMetadata(record, entry));
+    } catch (error) {
+      if (!(error instanceof HttpError && error.statusCode === 404)) {
+        throw error;
+      }
+    }
+  }
+  return artifacts.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+}
+async function createWorkspaceArtifact({
+  record,
+  artifactId,
+  name,
+  mediaType,
+  content,
+  metadata
+}) {
+  if (content.length === 0) {
+    throw new HttpError(400, {
+      code: "bad_request",
+      message: "Artifact content must not be empty."
+    });
+  }
+  const dir = path19.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) => {
+    if (error.code === "EEXIST") {
+      throw new HttpError(409, {
+        code: "conflict",
+        message: "Workspace artifact already exists."
+      });
+    }
+    throw error;
+  });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const artifact = {
+    id: artifactId,
+    workspaceId: record.id,
+    name: safeArtifactFileName(name),
+    mediaType,
+    size: content.length,
+    createdAt: now,
+    updatedAt: now,
+    metadata: metadata ?? {}
+  };
+  await fs18.writeFile(artifactMetadataPath(record, artifactId), JSON.stringify(artifact, null, 2));
+  return artifact;
+}
+async function readWorkspaceArtifactContent(record, artifactId) {
+  try {
+    return await fs18.readFile(artifactFilePath(record, artifactId));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new HttpError(404, {
+        code: "not_found",
+        message: "Workspace artifact content was not found."
+      });
+    }
+    throw error;
+  }
+}
+async function deleteWorkspaceArtifact(record, artifactId) {
+  const artifact = await readWorkspaceArtifactMetadata(record, artifactId);
+  await fs18.rm(path19.dirname(artifactFilePath(record, artifactId)), {
+    recursive: true,
+    force: true
+  });
+  return artifact;
+}
+
+// src/workspace-file-service.ts
+import { spawn as spawn4 } from "child_process";
+import fs19 from "fs/promises";
+import os4 from "os";
+import path20 from "path";
 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_DIRECTORY_ENTRY_LIMIT = 400;
+var WORKSPACE_TREE_DIRECTORY_SCAN_LIMIT = 2e3;
 var WORKSPACE_TREE_IGNORED_NAMES = /* @__PURE__ */ new Set([
   ".git",
   "node_modules",
@@ -24172,7 +24080,7 @@ function toWorkspaceFileDto(file) {
   };
 }
 function languageForPath(filePath) {
-  const extension = path19.extname(filePath).slice(1).toLowerCase();
+  const extension = path20.extname(filePath).slice(1).toLowerCase();
   switch (extension) {
     case "js":
     case "jsx":
@@ -24218,18 +24126,18 @@ function languageForPath(filePath) {
   }
 }
 function relativeWorkspacePath(rootPath, absPath) {
-  const relative = path19.relative(rootPath, absPath);
-  return relative === "" ? "" : relative.split(path19.sep).join("/");
+  const relative = path20.relative(rootPath, absPath);
+  return relative === "" ? "" : relative.split(path20.sep).join("/");
 }
 async function resolveWorkspaceItemPath(rootPath, relativePath = "") {
-  const candidate = path19.resolve(rootPath, relativePath || ".");
+  const candidate = path20.resolve(rootPath, relativePath || ".");
   const comparable = await assertPathWithinRoot(rootPath, candidate);
   return comparable;
 }
-async function buildWorkspaceTreeNode(rootPath, absPath, depth = 0) {
-  const stats = await fs18.stat(absPath);
+async function buildWorkspaceTreeNode(rootPath, absPath) {
+  const stats = await fs19.stat(absPath);
   const relativePath = relativeWorkspacePath(rootPath, absPath);
-  const name = relativePath ? path19.basename(absPath) : path19.basename(rootPath);
+  const name = relativePath ? path20.basename(absPath) : path20.basename(rootPath);
   if (!stats.isDirectory()) {
     return {
       name,
@@ -24242,18 +24150,36 @@ async function buildWorkspaceTreeNode(rootPath, absPath, depth = 0) {
     name,
     path: relativePath,
     kind: "directory",
+    childrenLoaded: true,
     children: []
   };
-  if (depth >= 6) {
-    return node;
-  }
-  let entries;
+  const visible = [];
   try {
-    entries = await fs18.readdir(absPath, { withFileTypes: true });
+    const directory = await fs19.opendir(absPath);
+    let scanned = 0;
+    for await (const entry of directory) {
+      scanned += 1;
+      if (scanned > WORKSPACE_TREE_DIRECTORY_SCAN_LIMIT) {
+        node.truncated = true;
+        break;
+      }
+      if (entry.name.startsWith(".") || WORKSPACE_TREE_IGNORED_NAMES.has(entry.name)) {
+        continue;
+      }
+      if (!entry.isDirectory() && !entry.isFile()) {
+        continue;
+      }
+      if (visible.length >= WORKSPACE_TREE_DIRECTORY_ENTRY_LIMIT) {
+        node.truncated = true;
+        break;
+      }
+      visible.push(entry);
+    }
   } catch {
     return node;
   }
-  const visible = entries.filter((entry) => !entry.name.startsWith(".")).filter((entry) => !WORKSPACE_TREE_IGNORED_NAMES.has(entry.name)).sort((left, right) => {
+  node.hasChildren = visible.length > 0;
+  visible.sort((left, right) => {
     if (left.isDirectory() && !right.isDirectory()) {
       return -1;
     }
@@ -24261,15 +24187,28 @@ async function buildWorkspaceTreeNode(rootPath, absPath, depth = 0) {
       return 1;
     }
     return left.name.localeCompare(right.name);
-  }).slice(0, 400);
+  });
   node.children = (await Promise.all(
     visible.map(async (entry) => {
-      const childPath = path19.join(absPath, entry.name);
+      const childPath = path20.join(absPath, entry.name);
       try {
-        if (!entry.isDirectory() && !entry.isFile()) {
-          return null;
+        const childRelativePath = relativeWorkspacePath(rootPath, childPath);
+        if (entry.isDirectory()) {
+          return {
+            name: entry.name,
+            path: childRelativePath,
+            kind: "directory",
+            hasChildren: true,
+            childrenLoaded: false
+          };
         }
-        return await buildWorkspaceTreeNode(rootPath, childPath, depth + 1);
+        const childStats = await fs19.stat(childPath);
+        return {
+          name: entry.name,
+          path: childRelativePath,
+          kind: "file",
+          size: childStats.size
+        };
       } catch {
         return null;
       }
@@ -24277,73 +24216,8 @@ async function buildWorkspaceTreeNode(rootPath, absPath, depth = 0) {
   )).filter((child) => child !== null);
   return node;
 }
-function requireWorkspaceRecord(app, workspaceId) {
-  const record = getWorkspaceRecordById(app.services.database.db, workspaceId);
-  if (!record) {
-    throw new HttpError(404, {
-      code: "not_found",
-      message: "Workspace was not found."
-    });
-  }
-  return record;
-}
-function artifactRoot(record) {
-  return path19.join(record.absPath, ".remote-codex", "artifacts");
-}
-function artifactFilePath(record, artifactId) {
-  return path19.join(artifactRoot(record), artifactId, "artifact.bin");
-}
-function artifactMetadataPath(record, artifactId) {
-  return path19.join(artifactRoot(record), artifactId, "metadata.json");
-}
-function safeArtifactFileName(value) {
-  return path19.basename(value).replace(/[^a-zA-Z0-9_. -]/g, "_") || "artifact.bin";
-}
-function artifactIdFromName(name) {
-  const base = path19.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) {
-  try {
-    const raw = await fs18.readFile(artifactMetadataPath(record, artifactId), "utf8");
-    return JSON.parse(raw);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      throw new HttpError(404, {
-        code: "not_found",
-        message: "Workspace artifact was not found."
-      });
-    }
-    throw error;
-  }
-}
-async function listWorkspaceArtifacts(record) {
-  let entries;
-  try {
-    entries = await fs18.readdir(artifactRoot(record));
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return [];
-    }
-    throw error;
-  }
-  const artifacts = [];
-  for (const entry of entries) {
-    if (!workspaceArtifactIdSchema.safeParse(entry).success) {
-      continue;
-    }
-    try {
-      artifacts.push(await readArtifactMetadata(record, entry));
-    } catch (error) {
-      if (!(error instanceof HttpError && error.statusCode === 404)) {
-        throw error;
-      }
-    }
-  }
-  return artifacts.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
-}
 function contentTypeForPath(filePath) {
-  switch (path19.extname(filePath).slice(1).toLowerCase()) {
+  switch (path20.extname(filePath).slice(1).toLowerCase()) {
     case "png":
       return "image/png";
     case "jpg":
@@ -24373,15 +24247,15 @@ function contentTypeForPath(filePath) {
   }
 }
 async function collectFolderZipEntries(rootPath, folderPath) {
-  const folderName = path19.basename(folderPath) || "workspace-folder";
+  const folderName = path20.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 });
+    const children = await fs19.readdir(current, { withFileTypes: true });
     for (const child of children) {
-      const childPath = await resolveWorkspaceItemPath(rootPath, path19.relative(rootPath, path19.join(current, child.name)));
+      const childPath = await resolveWorkspaceItemPath(rootPath, path20.relative(rootPath, path20.join(current, child.name)));
       if (child.isDirectory()) {
         pending.push(childPath);
         continue;
@@ -24389,7 +24263,7 @@ async function collectFolderZipEntries(rootPath, folderPath) {
       if (!child.isFile()) {
         continue;
       }
-      const stats = await fs18.stat(childPath);
+      const stats = await fs19.stat(childPath);
       totalBytes += stats.size;
       entries.push({
         absPath: childPath,
@@ -24440,8 +24314,8 @@ async function createFolderZipFile(rootPath, folderPath) {
   const centralParts = [];
   let offset = 0;
   for (const entry of entries) {
-    const data = await fs18.readFile(entry.absPath);
-    const name = Buffer.from(entry.archivePath.split(path19.sep).join("/"), "utf8");
+    const data = await fs19.readFile(entry.absPath);
+    const name = Buffer.from(entry.archivePath.split(path20.sep).join("/"), "utf8");
     const checksum = crc32(data);
     const { dosDate, dosTime } = zipDosDateTime(entry.updatedAt);
     const localHeader = Buffer.alloc(30);
@@ -24488,19 +24362,19 @@ async function createFolderZipFile(rootPath, folderPath) {
   endRecord.writeUInt32LE(centralSize, 12);
   endRecord.writeUInt32LE(offset, 16);
   endRecord.writeUInt16LE(0, 20);
-  const tempDir = await fs18.mkdtemp(path19.join(os4.tmpdir(), "remote-codex-folder-download-"));
-  const zipPath = path19.join(tempDir, `${path19.basename(folderPath) || "workspace-folder"}.zip`);
-  await fs18.writeFile(zipPath, Buffer.concat([...localParts, ...centralParts, endRecord]));
+  const tempDir = await fs19.mkdtemp(path20.join(os4.tmpdir(), "remote-codex-folder-download-"));
+  const zipPath = path20.join(tempDir, `${path20.basename(folderPath) || "workspace-folder"}.zip`);
+  await fs19.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);
+    await fs19.rm(zipPath, { force: true }).catch(() => void 0);
+    await fs19.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
   };
 }
 function sanitizeUploadFilename(filename) {
-  const baseName = path19.basename(filename?.trim() || "upload");
+  const baseName = path20.basename(filename?.trim() || "upload");
   if (!baseName || baseName === "." || baseName === "..") {
     return "upload";
   }
@@ -24512,7 +24386,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(path19.sep)) {
+  if (!repoName || repoName === "." || repoName === ".." || repoName.includes(path20.sep)) {
     throw new HttpError(400, {
       code: "bad_request",
       message: "Unable to infer a target directory from the Git URL."
@@ -24522,7 +24396,7 @@ function inferGitRepoName(gitUrl) {
 }
 async function pathExists4(absPath) {
   try {
-    await fs18.stat(absPath);
+    await fs19.stat(absPath);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -24570,6 +24444,69 @@ function cloneRepository(gitUrl, targetPath) {
     });
   });
 }
+
+// src/routes/workspaces.ts
+var createWorkspaceSchema = z6.union([
+  z6.object({
+    absPath: z6.string().min(1),
+    label: z6.string().min(1).optional()
+  }),
+  z6.object({
+    gitUrl: z6.string().min(1),
+    label: z6.string().min(1).optional()
+  })
+]);
+var updateFavoriteSchema = z6.object({
+  isFavorite: z6.boolean()
+});
+var updateWorkspaceSchema = z6.object({
+  label: z6.string().min(1)
+});
+var workspaceFilePathSchema = z6.string().trim().min(1).max(4096);
+var writeWorkspaceFileSchema = z6.object({
+  path: workspaceFilePathSchema,
+  content: z6.string()
+});
+var moveWorkspaceFileSchema = z6.object({
+  fromPath: workspaceFilePathSchema,
+  toPath: workspaceFilePathSchema,
+  overwrite: z6.boolean().optional()
+});
+var deleteWorkspaceFileSchema = z6.object({
+  path: workspaceFilePathSchema,
+  recursive: z6.boolean().optional()
+});
+var workspaceArtifactIdSchema = z6.string().trim().min(1).max(160).regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/);
+var workspaceArtifactNameSchema = z6.string().trim().min(1).max(255);
+var createWorkspaceArtifactSchema = z6.object({
+  id: workspaceArtifactIdSchema.optional(),
+  name: workspaceArtifactNameSchema,
+  mediaType: z6.string().trim().min(1).max(255).default("application/octet-stream"),
+  contentBase64: z6.string().min(1),
+  metadata: z6.record(z6.string(), z6.unknown()).optional()
+});
+var treeQuerySchema = z6.object({
+  path: z6.string().optional(),
+  showHidden: z6.coerce.boolean().optional()
+});
+var workspaceFileQuerySchema = z6.object({
+  path: z6.string().optional().default("")
+});
+var workspacePreviewQuerySchema = z6.object({
+  path: z6.string().min(1),
+  offset: z6.coerce.number().int().min(0).optional(),
+  limit: z6.coerce.number().int().positive().max(25e4).optional()
+});
+function requireWorkspaceRecord(app, workspaceId) {
+  const record = getWorkspaceRecordById(app.services.database.db, workspaceId);
+  if (!record) {
+    throw new HttpError(404, {
+      code: "not_found",
+      message: "Workspace was not found."
+    });
+  }
+  return record;
+}
 async function registerWorkspaceRoutes(app) {
   app.get("/api/workspaces", async () => {
     const records = listWorkspaceRecords(app.services.database.db);
@@ -24577,7 +24514,7 @@ async function registerWorkspaceRoutes(app) {
   });
   app.get("/api/workspaces/tree", async (request) => {
     const query = treeQuerySchema.parse(request.query);
-    const requestedPath = query.path ? path19.resolve(query.path) : app.services.config.workspaceRoot;
+    const requestedPath = query.path ? path21.resolve(query.path) : app.services.config.workspaceRoot;
     const tree = await readWorkspaceTree({
       rootPath: app.services.config.workspaceRoot,
       targetPath: requestedPath,
@@ -24604,7 +24541,7 @@ async function registerWorkspaceRoutes(app) {
     const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
     const query = workspaceFileQuerySchema.parse(request.query);
     const record = requireWorkspaceRecord(app, params.id);
-    const rootPath = await fs18.realpath(record.absPath);
+    const rootPath = await fs20.realpath(record.absPath);
     const targetPath = await resolveWorkspaceItemPath(rootPath, query.path);
     return buildWorkspaceTreeNode(rootPath, targetPath);
   });
@@ -24624,9 +24561,9 @@ async function registerWorkspaceRoutes(app) {
     const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
     const query = workspacePreviewQuerySchema.parse(request.query);
     const record = requireWorkspaceRecord(app, params.id);
-    const rootPath = await fs18.realpath(record.absPath);
+    const rootPath = await fs20.realpath(record.absPath);
     const filePath = await resolveWorkspaceItemPath(rootPath, query.path);
-    const stats = await fs18.stat(filePath);
+    const stats = await fs20.stat(filePath);
     if (!stats.isFile()) {
       throw new HttpError(400, {
         code: "bad_request",
@@ -24635,7 +24572,7 @@ async function registerWorkspaceRoutes(app) {
     }
     const offset = query.offset ?? 0;
     const limit = query.limit ?? PREVIEW_DEFAULT_LIMIT_BYTES;
-    const handle = await fs18.open(filePath, "r");
+    const handle = await fs20.open(filePath, "r");
     try {
       const length = Math.min(limit, Math.max(0, stats.size - offset));
       const buffer = Buffer.alloc(length);
@@ -24643,7 +24580,7 @@ async function registerWorkspaceRoutes(app) {
       const nextOffset = offset + read.bytesRead;
       return {
         path: relativeWorkspacePath(rootPath, filePath),
-        name: path19.basename(filePath),
+        name: path21.basename(filePath),
         content: buffer.subarray(0, read.bytesRead).toString("utf8"),
         language: languageForPath(filePath),
         size: stats.size,
@@ -24658,9 +24595,9 @@ async function registerWorkspaceRoutes(app) {
     const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
     const query = workspacePreviewQuerySchema.pick({ path: true }).parse(request.query);
     const record = requireWorkspaceRecord(app, params.id);
-    const rootPath = await fs18.realpath(record.absPath);
+    const rootPath = await fs20.realpath(record.absPath);
     const filePath = await resolveWorkspaceItemPath(rootPath, query.path);
-    const stats = await fs18.stat(filePath);
+    const stats = await fs20.stat(filePath);
     if (!stats.isFile()) {
       throw new HttpError(400, {
         code: "bad_request",
@@ -24668,18 +24605,18 @@ async function registerWorkspaceRoutes(app) {
       });
     }
     reply.header("content-type", contentTypeForPath(filePath));
-    return reply.send(Readable.from(await fs18.readFile(filePath)));
+    return reply.send(Readable.from(await fs20.readFile(filePath)));
   });
   app.get("/api/workspaces/:id/files/download", async (request, reply) => {
     const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
     const query = workspaceFileQuerySchema.parse(request.query);
     const record = requireWorkspaceRecord(app, params.id);
-    const rootPath = await fs18.realpath(record.absPath);
+    const rootPath = await fs20.realpath(record.absPath);
     const itemPath = await resolveWorkspaceItemPath(rootPath, query.path);
-    const stats = await fs18.stat(itemPath);
+    const stats = await fs20.stat(itemPath);
     if (stats.isDirectory()) {
       const { zipPath, tempDir } = await createFolderZipFile(rootPath, itemPath);
-      const filename2 = `${path19.basename(itemPath) || "workspace-folder"}.zip`;
+      const filename2 = `${path21.basename(itemPath) || "workspace-folder"}.zip`;
       const cleanup = cleanupTemporaryZip(zipPath, tempDir);
       reply.raw.once("finish", () => void cleanup());
       reply.raw.once("close", () => void cleanup());
@@ -24695,18 +24632,18 @@ async function registerWorkspaceRoutes(app) {
         message: "Only file and folder downloads are supported from this endpoint."
       });
     }
-    const filename = path19.basename(itemPath);
+    const filename = path21.basename(itemPath);
     reply.header("content-type", contentTypeForPath(itemPath)).header(
       "content-disposition",
       `attachment; filename="${filename}"; filename*=UTF-8''${encodeURIComponent(filename)}`
     );
-    return reply.send(Readable.from(await fs18.readFile(itemPath)));
+    return reply.send(Readable.from(await fs20.readFile(itemPath)));
   });
   app.post("/api/workspaces/:id/files/upload", async (request) => {
     requireWorkerScope(request, "file:write");
     const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
     const record = requireWorkspaceRecord(app, params.id);
-    const rootPath = await fs18.realpath(record.absPath);
+    const rootPath = await fs20.realpath(record.absPath);
     const uploadRequest = request;
     if (!uploadRequest.isMultipart()) {
       throw new HttpError(400, {
@@ -24761,7 +24698,7 @@ async function registerWorkspaceRoutes(app) {
       kind: "file",
       file: {
         path: file.path,
-        name: path19.basename(file.path),
+        name: path21.basename(file.path),
         size: file.size
       }
     };
@@ -24797,36 +24734,14 @@ async function registerWorkspaceRoutes(app) {
     const record = requireWorkspaceRecord(app, params.id);
     const artifactId = body.id ?? artifactIdFromName(body.name);
     const content = Buffer.from(body.contentBase64, "base64");
-    if (content.length === 0) {
-      throw new HttpError(400, {
-        code: "bad_request",
-        message: "Artifact content must not be empty."
-      });
-    }
-    const dir = path19.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) => {
-      if (error.code === "EEXIST") {
-        throw new HttpError(409, {
-          code: "conflict",
-          message: "Workspace artifact already exists."
-        });
-      }
-      throw error;
-    });
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const artifact = {
-      id: artifactId,
-      workspaceId: record.id,
-      name: safeArtifactFileName(body.name),
+    const artifact = await createWorkspaceArtifact({
+      record,
+      artifactId,
+      name: body.name,
       mediaType: body.mediaType,
-      size: content.length,
-      createdAt: now,
-      updatedAt: now,
-      metadata: body.metadata ?? {}
-    };
-    await fs18.writeFile(artifactMetadataPath(record, artifactId), JSON.stringify(artifact, null, 2));
+      content,
+      ...body.metadata !== void 0 ? { metadata: body.metadata } : {}
+    });
     return { artifact };
   });
   app.get("/api/workspaces/:id/artifacts", async (request) => {
@@ -24839,25 +24754,14 @@ async function registerWorkspaceRoutes(app) {
     requireWorkerScope(request, "artifact:read");
     const params = z6.object({ id: z6.string().uuid(), artifactId: workspaceArtifactIdSchema }).parse(request.params);
     const record = requireWorkspaceRecord(app, params.id);
-    return { artifact: await readArtifactMetadata(record, params.artifactId) };
+    return { artifact: await readWorkspaceArtifactMetadata(record, params.artifactId) };
   });
   app.get("/api/workspaces/:id/artifacts/:artifactId/download", async (request, reply) => {
     requireWorkerScope(request, "artifact:read");
     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);
-    let content;
-    try {
-      content = await fs18.readFile(artifactFilePath(record, params.artifactId));
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        throw new HttpError(404, {
-          code: "not_found",
-          message: "Workspace artifact content was not found."
-        });
-      }
-      throw error;
-    }
+    const artifact = await readWorkspaceArtifactMetadata(record, params.artifactId);
+    const content = await readWorkspaceArtifactContent(record, params.artifactId);
     reply.header("content-type", artifact.mediaType).header("content-length", String(content.length)).header("content-disposition", `attachment; filename="${artifact.name.replace(/"/g, "")}"`);
     return reply.send(content);
   });
@@ -24865,11 +24769,7 @@ async function registerWorkspaceRoutes(app) {
     requireWorkerScope(request, "artifact:write");
     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(path19.dirname(artifactFilePath(record, params.artifactId)), {
-      recursive: true,
-      force: true
-    });
+    const artifact = await deleteWorkspaceArtifact(record, params.artifactId);
     return { deleted: true, artifact };
   });
   app.post("/api/workspaces", async (request) => {
@@ -24881,7 +24781,7 @@ async function registerWorkspaceRoutes(app) {
     let validated;
     if ("gitUrl" in body) {
       const repoName = inferGitRepoName(body.gitUrl);
-      const targetPath = path19.join(settings.devHome, repoName);
+      const targetPath = path21.join(settings.devHome, repoName);
       if (await pathExists4(targetPath)) {
         throw new HttpError(409, {
           code: "conflict",
@@ -25144,8 +25044,8 @@ async function registerAuthRoutes(app) {
 }
 
 // src/provider-host-config-service.ts
-import fs19 from "fs/promises";
-import path20 from "path";
+import fs21 from "fs/promises";
+import path22 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 function providerError(message, statusCode = 404) {
   const error = new Error(message);
@@ -25153,23 +25053,23 @@ function providerError(message, statusCode = 404) {
   return error;
 }
 function resolveProviderHostFilePath(providerHome, name) {
-  return path20.join(providerHome, name);
+  return path22.join(providerHome, name);
 }
 function resolveArchiveRoot(providerHome) {
-  return path20.join(providerHome, "supervisor-config-archives");
+  return path22.join(providerHome, "supervisor-config-archives");
 }
 function resolveArchiveIndexPath(providerHome) {
-  return path20.join(resolveArchiveRoot(providerHome), "index.json");
+  return path22.join(resolveArchiveRoot(providerHome), "index.json");
 }
 function resolveArchivePath(providerHome, archiveId) {
-  return path20.join(resolveArchiveRoot(providerHome), archiveId);
+  return path22.join(resolveArchiveRoot(providerHome), archiveId);
 }
 function defaultArchiveLabel(createdAt) {
   return `Backup ${createdAt.replace("T", " ").replace(/\.\d{3}Z$/, " UTC")}`;
 }
 async function readArchiveIndex(providerHome) {
   try {
-    const raw = await fs19.readFile(resolveArchiveIndexPath(providerHome), "utf8");
+    const raw = await fs21.readFile(resolveArchiveIndexPath(providerHome), "utf8");
     const parsed = JSON.parse(raw);
     return {
       archives: Array.isArray(parsed.archives) ? parsed.archives : []
@@ -25183,8 +25083,8 @@ async function readArchiveIndex(providerHome) {
 }
 async function writeArchiveIndex(providerHome, index) {
   const root = resolveArchiveRoot(providerHome);
-  await fs19.mkdir(root, { recursive: true });
-  await fs19.writeFile(
+  await fs21.mkdir(root, { recursive: true });
+  await fs21.writeFile(
     resolveArchiveIndexPath(providerHome),
     `${JSON.stringify(index, null, 2)}
 `,
@@ -25255,7 +25155,7 @@ var ProviderHostConfigService = class {
     const fileName = this.assertHostFile(provider2, name);
     const filePath = resolveProviderHostFilePath(providerHome, fileName);
     try {
-      const content = await fs19.readFile(filePath, "utf8");
+      const content = await fs21.readFile(filePath, "utf8");
       return {
         name: fileName,
         path: filePath,
@@ -25278,8 +25178,8 @@ var ProviderHostConfigService = class {
     const providerHome = this.providerHome(provider2);
     const fileName = this.assertHostFile(provider2, name);
     const filePath = resolveProviderHostFilePath(providerHome, fileName);
-    await fs19.mkdir(path20.dirname(filePath), { recursive: true });
-    await fs19.writeFile(filePath, input.content, "utf8");
+    await fs21.mkdir(path22.dirname(filePath), { recursive: true });
+    await fs21.writeFile(filePath, input.content, "utf8");
     return this.readFile(provider2, fileName);
   }
   async listArchives(provider2) {
@@ -25305,7 +25205,7 @@ var ProviderHostConfigService = class {
         }
       ])
     );
-    await fs19.mkdir(archivePath, { recursive: true });
+    await fs21.mkdir(archivePath, { recursive: true });
     for (const name of fileNames) {
       const hostFile = await this.readFile(provider2, name);
       files[name] = {
@@ -25313,7 +25213,7 @@ var ProviderHostConfigService = class {
         exists: hostFile.exists
       };
       if (hostFile.exists) {
-        await fs19.writeFile(path20.join(archivePath, name), hostFile.content, "utf8");
+        await fs21.writeFile(path22.join(archivePath, name), hostFile.content, "utf8");
       }
     }
     const archive = {
@@ -25349,14 +25249,14 @@ var ProviderHostConfigService = class {
     const fileNames = this.archiveFileNames(provider2);
     const { archive } = await findArchiveOrThrow(providerHome, id);
     const archivePath = resolveArchivePath(providerHome, archive.id);
-    await fs19.mkdir(providerHome, { recursive: true });
+    await fs21.mkdir(providerHome, { recursive: true });
     for (const name of fileNames) {
       const hostPath = resolveProviderHostFilePath(providerHome, name);
       if (archive.files[name]?.exists) {
-        const content = await fs19.readFile(path20.join(archivePath, name), "utf8");
-        await fs19.writeFile(hostPath, content, "utf8");
+        const content = await fs21.readFile(path22.join(archivePath, name), "utf8");
+        await fs21.writeFile(hostPath, content, "utf8");
       } else {
-        await fs19.rm(hostPath, { force: true });
+        await fs21.rm(hostPath, { force: true });
       }
     }
     await runtime.stop();
@@ -25369,12 +25269,12 @@ var ProviderHostConfigService = class {
 };
 
 // src/shell/shell-session-service.ts
-import fs21 from "fs/promises";
+import fs23 from "fs/promises";
 
 // src/shell/shell-prompt.ts
-import fs20 from "fs/promises";
+import fs22 from "fs/promises";
 import os5 from "os";
-import path21 from "path";
+import path23 from "path";
 function basenameFromPath2(filePath) {
   if (!filePath) {
     return "";
@@ -25383,7 +25283,7 @@ function basenameFromPath2(filePath) {
   if (!normalized) {
     return "";
   }
-  return path21.basename(normalized) || normalized;
+  return path23.basename(normalized) || normalized;
 }
 function isInteractiveShellCommand(command) {
   const normalized = (command ?? "").trim().toLowerCase();
@@ -25544,11 +25444,11 @@ function buildShellPromptInitScriptContents(command) {
 async function ensureShellPromptInitScript(command) {
   const normalized = command.trim().toLowerCase();
   const extension = normalized === "zsh" ? "zsh" : "sh";
-  const filePath = path21.join(
+  const filePath = path23.join(
     os5.tmpdir(),
     `remote-codex-shell-prompt.${extension}`
   );
-  await fs20.writeFile(filePath, buildShellPromptInitScriptContents(command), "utf8");
+  await fs22.writeFile(filePath, buildShellPromptInitScriptContents(command), "utf8");
   return filePath;
 }
 async function buildShellPromptInitCommand(command, options = {}) {
@@ -25564,7 +25464,7 @@ clear
 // src/shell/shell-session-service.ts
 async function pathExists5(filePath) {
   try {
-    await fs21.access(filePath);
+    await fs23.access(filePath);
     return true;
   } catch {
     return false;
@@ -26222,8 +26122,8 @@ var builtinPlugins = [
 ];
 
 // src/plugins/plugin-service.ts
-import fs22 from "fs/promises";
-import path22 from "path";
+import fs24 from "fs/promises";
+import path24 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";
@@ -26235,7 +26135,7 @@ function normalizeManagedCommand(server, repoRoot) {
   if (server.name === "remote_codex_plugins") {
     return {
       command: process.execPath,
-      args: [path22.join(repoRoot, "bin", "remote-codex-plugin-mcp.mjs")]
+      args: [path24.join(repoRoot, "bin", "remote-codex-plugin-mcp.mjs")]
     };
   }
   return {
@@ -26422,10 +26322,10 @@ var PluginService = class {
     if (!input.codexHome) {
       return;
     }
-    const configPath = path22.join(input.codexHome, "config.toml");
+    const configPath = path24.join(input.codexHome, "config.toml");
     let current = "";
     try {
-      current = await fs22.readFile(configPath, "utf8");
+      current = await fs24.readFile(configPath, "utf8");
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -26440,8 +26340,8 @@ var PluginService = class {
     if (next === current) {
       return;
     }
-    await fs22.mkdir(path22.dirname(configPath), { recursive: true });
-    await fs22.writeFile(configPath, next, "utf8");
+    await fs24.mkdir(path24.dirname(configPath), { recursive: true });
+    await fs24.writeFile(configPath, next, "utf8");
   }
   async importPlugin(input) {
     const manifestInput = input.manifest ?? (input.manifestUrl ? await this.fetchManifestUrl(input.manifestUrl) : this.parseManifestJson(input.manifestJson));
@@ -26680,8 +26580,8 @@ var PluginSettingsStore = class {
 };
 
 // src/worker-bootstrap.ts
-import fs23 from "fs/promises";
-import path23 from "path";
+import fs25 from "fs/promises";
+import path25 from "path";
 function trimTrailingSlash(value) {
   return value.replace(/\/+$/, "");
 }
@@ -26692,9 +26592,9 @@ function tomlString(value) {
   return JSON.stringify(value);
 }
 async function writePrivateFile(filePath, content) {
-  await fs23.mkdir(path23.dirname(filePath), { recursive: true, mode: 448 });
-  await fs23.writeFile(filePath, content, { encoding: "utf8", mode: 384 });
-  await fs23.chmod(filePath, 384);
+  await fs25.mkdir(path25.dirname(filePath), { recursive: true, mode: 448 });
+  await fs25.writeFile(filePath, content, { encoding: "utf8", mode: 384 });
+  await fs25.chmod(filePath, 384);
 }
 async function configureWorkerProviderGateway(config) {
   if (config.runtimeRole !== "worker" || !config.llmGatewayBaseUrl || !config.llmGatewayToken) {
@@ -26708,7 +26608,7 @@ async function configureWorkerProviderGateway(config) {
   process.env.ANTHROPIC_BASE_URL = anthropicBaseUrl;
   if (config.agentProviders.codex.enabled) {
     await writePrivateFile(
-      path23.join(config.agentProviders.codex.home, "config.toml"),
+      path25.join(config.agentProviders.codex.home, "config.toml"),
       [
         'model_provider = "sub2api"',
         'forced_login_method = "api"',
@@ -26724,7 +26624,7 @@ async function configureWorkerProviderGateway(config) {
       ].join("\n")
     );
     await writePrivateFile(
-      path23.join(config.agentProviders.codex.home, "auth.json"),
+      path25.join(config.agentProviders.codex.home, "auth.json"),
       `${JSON.stringify(
         {
           OPENAI_API_KEY: config.llmGatewayToken
@@ -26737,7 +26637,7 @@ async function configureWorkerProviderGateway(config) {
   }
   if (config.agentProviders.claude.enabled) {
     await writePrivateFile(
-      path23.join(config.agentProviders.claude.home, "settings.json"),
+      path25.join(config.agentProviders.claude.home, "settings.json"),
       `${JSON.stringify(
         {
           env: {
@@ -26753,7 +26653,7 @@ async function configureWorkerProviderGateway(config) {
   }
   if (config.agentProviders.opencode.enabled) {
     await writePrivateFile(
-      path23.join(config.agentProviders.opencode.home, "opencode.json"),
+      path25.join(config.agentProviders.opencode.home, "opencode.json"),
       `${JSON.stringify(
         {
           provider: {
@@ -26800,27 +26700,27 @@ var BackendPluginHost = class {
 };
 
 // src/shell/pty-shell-backend.ts
-import path24 from "path";
+import path26 from "path";
 import { spawn as spawn5 } from "@homebridge/node-pty-prebuilt-multiarch";
 
 // src/shell/default-shell.ts
-import fs24 from "fs";
+import fs26 from "fs";
 var POSIX_SHELL_CANDIDATES = ["/bin/bash", "/usr/bin/bash", "/bin/sh"];
 function resolveDefaultShell(env = process.env) {
   if (process.platform === "win32") {
     return env.COMSPEC ?? "cmd.exe";
   }
-  if (env.SHELL && fs24.existsSync(env.SHELL)) {
+  if (env.SHELL && fs26.existsSync(env.SHELL)) {
     return env.SHELL;
   }
-  return POSIX_SHELL_CANDIDATES.find((candidate) => fs24.existsSync(candidate)) ?? "/bin/sh";
+  return POSIX_SHELL_CANDIDATES.find((candidate) => fs26.existsSync(candidate)) ?? "/bin/sh";
 }
 
 // src/shell/pty-shell-backend.ts
 var MAX_SCROLLBACK_BYTES = 512 * 1024;
 var ANSI_ESCAPE_PATTERN = new RegExp(String.raw`\u001B\[[0-?]*[ -/]*[@-~]`, "g");
 function shellArgs(shell) {
-  const shellName = path24.basename(shell).toLowerCase();
+  const shellName = path26.basename(shell).toLowerCase();
   if (process.platform === "win32") {
     return [];
   }
@@ -26842,7 +26742,7 @@ function lastVisibleLine(snapshot) {
 }
 function inferRuntime(session) {
   const promptLine = lastVisibleLine(session.scrollback);
-  const shell = path24.basename(session.shell);
+  const shell = path26.basename(session.shell);
   const isCommandRunning = session.exitCode !== null ? false : !/[$#>]\s*$/.test(promptLine.trimEnd());
   return {
     panePid: session.pty.pid,
@@ -26988,8 +26888,8 @@ var PtyShellBackend = class {
 };
 
 // src/shell/tmux-manager.ts
-import fs25 from "fs";
-import path25 from "path";
+import fs27 from "fs";
+import path27 from "path";
 import { spawn as spawnChild } from "child_process";
 async function defaultExecCommand(command, args) {
   return await new Promise((resolve, reject) => {
@@ -27016,17 +26916,17 @@ async function defaultExecCommand(command, args) {
   });
 }
 function resolveExecutablePath(command) {
-  if (command.includes(path25.sep)) {
+  if (command.includes(path27.sep)) {
     return command;
   }
   const searchPath = process.env.PATH ?? "";
-  for (const entry of searchPath.split(path25.delimiter)) {
+  for (const entry of searchPath.split(path27.delimiter)) {
     const trimmed = entry.trim();
     if (!trimmed) {
       continue;
     }
-    const candidate = path25.join(trimmed, command);
-    if (fs25.existsSync(candidate)) {
+    const candidate = path27.join(trimmed, command);
+    if (fs27.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -27787,22 +27687,22 @@ function payloadItems(payload, fields) {
   const record = recordFrom(payload);
   return arrayField(record, fields) ?? (record ? [record] : []);
 }
-function artifactPreviewKind(type, format, path27) {
+function artifactPreviewKind(type, format, path29) {
   const candidates = [
     type,
     format,
-    path27?.split(".").pop() ?? null
+    path29?.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 path27 = stringField3(record, ["path", "filePath", "file_path", "filename", "fileName", "name"]);
+  const path29 = 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"]) ?? path27 ?? "artifact";
+  const title = stringField3(record, ["title", "label", "name", "filename", "fileName"]) ?? path29 ?? "artifact";
   return {
     title,
-    path: path27,
+    path: path29,
     type,
     downloadUrl: stringField3(record, ["downloadUrl", "download_url", "url", "href"])
   };
@@ -27836,21 +27736,21 @@ function normalizeArtifact(module, runId, value) {
   if (!record) {
     return null;
   }
-  const path27 = stringField3(record, ["path", "filePath", "file_path", "filename", "fileName", "name"]);
+  const path29 = 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"]) ?? path27 ?? `${module} artifact`;
+  const title = stringField3(record, ["title", "label", "name", "filename", "fileName"]) ?? path29 ?? `${module} artifact`;
   return {
     module,
     runId,
     title,
-    path: path27,
+    path: path29,
     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, path27)
+    previewKind: artifactPreviewKind(type, format, path29)
   };
 }
 function parseTomlScalar(raw) {
@@ -28080,9 +27980,9 @@ var WorkerHarnessClient = class {
     }
     return { baseUrl, apiKey };
   }
-  async fetchText(path27) {
+  async fetchText(path29) {
     const config = this.requireHarnessConfig();
-    const response = await this.fetchImpl(`${config.baseUrl}${path27}`, {
+    const response = await this.fetchImpl(`${config.baseUrl}${path29}`, {
       headers: {
         "x-api-key": config.apiKey
       }
@@ -28093,11 +27993,11 @@ var WorkerHarnessClient = class {
     }
     return { text: text2 };
   }
-  async fetchPayload(path27, init = {}) {
+  async fetchPayload(path29, 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}${path27}`, {
+    const response = await this.fetchImpl(`${config.baseUrl}${path29}`, {
       ...init,
       headers
     });
@@ -28111,9 +28011,9 @@ var WorkerHarnessClient = class {
       return { text: text2 };
     }
   }
-  async fetchBinary(path27) {
+  async fetchBinary(path29) {
     const config = this.requireHarnessConfig();
-    const response = await this.fetchImpl(`${config.baseUrl}${path27}`, {
+    const response = await this.fetchImpl(`${config.baseUrl}${path29}`, {
       headers: {
         "x-api-key": config.apiKey
       }
@@ -28957,16 +28857,16 @@ var HttpError = class extends Error {
 };
 function findRepoRoot(start = process.cwd()) {
   if (process.env.REMOTE_CODEX_REPO_ROOT) {
-    return path26.resolve(process.env.REMOTE_CODEX_REPO_ROOT);
+    return path28.resolve(process.env.REMOTE_CODEX_REPO_ROOT);
   }
-  let current = path26.resolve(start);
-  while (current !== path26.dirname(current)) {
-    if (fs26.existsSync(path26.join(current, "pnpm-workspace.yaml")) && fs26.existsSync(path26.join(current, "scripts", "service-restart.mjs"))) {
+  let current = path28.resolve(start);
+  while (current !== path28.dirname(current)) {
+    if (fs28.existsSync(path28.join(current, "pnpm-workspace.yaml")) && fs28.existsSync(path28.join(current, "scripts", "service-restart.mjs"))) {
       return current;
     }
-    current = path26.dirname(current);
+    current = path28.dirname(current);
   }
-  return path26.resolve(process.cwd());
+  return path28.resolve(process.cwd());
 }
 function createServiceLifecycle() {
   return {
@@ -28978,8 +28878,8 @@ function createServiceLifecycle() {
         });
       }
       const repoRoot = findRepoRoot();
-      const restartScript = path26.join(repoRoot, "scripts", "service-restart.mjs");
-      if (!fs26.existsSync(restartScript) || !fs26.existsSync(path26.join(repoRoot, "pnpm-workspace.yaml"))) {
+      const restartScript = path28.join(repoRoot, "scripts", "service-restart.mjs");
+      if (!fs28.existsSync(restartScript) || !fs28.existsSync(path28.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."
@@ -29022,7 +28922,7 @@ function buildApp(options = {}) {
   const shellService = options.shellService ?? new ShellSessionService(
     database.db,
     eventBus,
-    createTerminalShellBackend(options.env)
+    options.shellBackend ?? createTerminalShellBackend(options.env)
   );
   const providerHostConfigService = new ProviderHostConfigService(
     agentRuntimes,