remote-codex 0.11.1 → 0.11.3

package/apps/supervisor-api/dist/index.js

@@ -5,15 +5,15 @@ var __export = (target, all) => {
 };
 
 // src/index.ts
-import fs22 from "fs";
+import fs25 from "fs";
 
 // src/app.ts
 import Fastify from "fastify";
 import multipart from "@fastify/multipart";
 import websocket from "@fastify/websocket";
-import { spawn as spawn4 } from "child_process";
-import fs21 from "fs";
-import path21 from "path";
+import { spawn as spawn5 } from "child_process";
+import fs24 from "fs";
+import path23 from "path";
 import { ZodError } from "zod";
 
 // ../../packages/config/src/index.ts
@@ -80,6 +80,7 @@ function truncateAutoThreadTitle(value) {
 // ../../packages/config/src/index.ts
 var envSchema = z.object({
   NODE_ENV: z.enum(["development", "test", "production"]).optional(),
+  REMOTE_CODEX_MODE: z.enum(["local", "server", "relay"]).optional(),
   HOST: z.string().min(1).optional(),
   PORT: z.coerce.number().int().positive().optional(),
   LOG_LEVEL: z.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
@@ -88,6 +89,12 @@ var envSchema = z.object({
   APP_VERSION: z.string().min(1).optional(),
   WORKSPACE_ROOT: z.string().optional(),
   DATABASE_URL: z.string().optional(),
+  REMOTE_CODEX_ADMIN_USERNAME: z.string().min(1).optional(),
+  REMOTE_CODEX_ADMIN_PASSWORD: z.string().min(1).optional(),
+  REMOTE_CODEX_SESSION_SECRET: z.string().min(16).optional(),
+  REMOTE_CODEX_SESSION_TTL_SECONDS: z.coerce.number().int().positive().optional(),
+  REMOTE_CODEX_RELAY_SERVER_URL: z.string().url().optional(),
+  REMOTE_CODEX_RELAY_AGENT_TOKEN: z.string().min(1).optional(),
   CODEX_HOME: z.string().optional(),
   CODEX_COMMAND: z.string().min(1).optional(),
   CODEX_APP_SERVER_START_TIMEOUT_MS: z.coerce.number().int().positive().optional(),
@@ -97,6 +104,31 @@ var envSchema = z.object({
   OPENCODE_COMMAND: z.string().min(1).optional(),
   REMOTE_CODEX_ENABLED_AGENT_PROVIDERS: z.string().optional()
 });
+function optionalNonEmpty(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function normalizeOptionalEnv(env) {
+  return {
+    ...env,
+    WORKSPACE_ROOT: optionalNonEmpty(env.WORKSPACE_ROOT),
+    DATABASE_URL: optionalNonEmpty(env.DATABASE_URL),
+    REMOTE_CODEX_ADMIN_USERNAME: optionalNonEmpty(env.REMOTE_CODEX_ADMIN_USERNAME),
+    REMOTE_CODEX_ADMIN_PASSWORD: optionalNonEmpty(env.REMOTE_CODEX_ADMIN_PASSWORD),
+    REMOTE_CODEX_SESSION_SECRET: optionalNonEmpty(env.REMOTE_CODEX_SESSION_SECRET),
+    REMOTE_CODEX_RELAY_SERVER_URL: optionalNonEmpty(env.REMOTE_CODEX_RELAY_SERVER_URL),
+    REMOTE_CODEX_RELAY_AGENT_TOKEN: optionalNonEmpty(env.REMOTE_CODEX_RELAY_AGENT_TOKEN),
+    CODEX_HOME: optionalNonEmpty(env.CODEX_HOME),
+    CODEX_COMMAND: optionalNonEmpty(env.CODEX_COMMAND),
+    CLAUDE_HOME: optionalNonEmpty(env.CLAUDE_HOME),
+    CLAUDE_COMMAND: optionalNonEmpty(env.CLAUDE_COMMAND),
+    OPENCODE_HOME: optionalNonEmpty(env.OPENCODE_HOME),
+    OPENCODE_COMMAND: optionalNonEmpty(env.OPENCODE_COMMAND),
+    REMOTE_CODEX_ENABLED_AGENT_PROVIDERS: optionalNonEmpty(
+      env.REMOTE_CODEX_ENABLED_AGENT_PROVIDERS
+    )
+  };
+}
 function resolveDatabaseUrl(nodeEnv, value) {
   if (value && value.trim()) {
     return path.resolve(value);
@@ -107,8 +139,9 @@ function resolveDatabaseUrl(nodeEnv, value) {
   return path.resolve(".local", "supervisor-dev.sqlite");
 }
 function loadRuntimeConfig(env = process.env) {
-  const parsed = envSchema.parse(env);
+  const parsed = envSchema.parse(normalizeOptionalEnv(env));
   const nodeEnv = parsed.NODE_ENV ?? "development";
+  const mode = parsed.REMOTE_CODEX_MODE ?? "local";
   const workspaceRoot = parsed.WORKSPACE_ROOT?.trim() ? path.resolve(parsed.WORKSPACE_ROOT) : os.homedir();
   const disableRequestLogging = parsed.DISABLE_REQUEST_LOGGING === void 0 ? nodeEnv === "production" : ["1", "true", "yes", "on"].includes(parsed.DISABLE_REQUEST_LOGGING.toLowerCase());
   const enabledProviders = new Set(
@@ -119,6 +152,7 @@ function loadRuntimeConfig(env = process.env) {
   const opencodeHome = parsed.OPENCODE_HOME?.trim() ? path.resolve(parsed.OPENCODE_HOME) : path.join(os.homedir(), agentBackendMetadata.opencode.defaultHomeDir);
   return {
     nodeEnv,
+    mode,
     host: parsed.HOST ?? "127.0.0.1",
     port: parsed.PORT ?? 8787,
     logLevel: parsed.LOG_LEVEL ?? (nodeEnv === "production" ? "warn" : "info"),
@@ -127,6 +161,16 @@ function loadRuntimeConfig(env = process.env) {
     appVersion: parsed.APP_VERSION ?? "0.1.0",
     workspaceRoot,
     databaseUrl: resolveDatabaseUrl(nodeEnv, parsed.DATABASE_URL),
+    auth: {
+      adminUsername: parsed.REMOTE_CODEX_ADMIN_USERNAME ?? null,
+      adminPassword: parsed.REMOTE_CODEX_ADMIN_PASSWORD ?? null,
+      sessionSecret: parsed.REMOTE_CODEX_SESSION_SECRET ?? null,
+      sessionTtlSeconds: parsed.REMOTE_CODEX_SESSION_TTL_SECONDS ?? 60 * 60 * 24 * 7
+    },
+    relay: {
+      serverUrl: parsed.REMOTE_CODEX_RELAY_SERVER_URL ?? null,
+      agentToken: parsed.REMOTE_CODEX_RELAY_AGENT_TOKEN ?? null
+    },
     agentProviders: {
       codex: {
         provider: "codex",
@@ -564,6 +608,7 @@ var PluginRegistry = class {
 
 // ../../packages/plugin-runtime/src/artifacts.ts
 var artifactFenceLanguages = /* @__PURE__ */ new Set(["artifact", "remote-codex-artifact"]);
+var remoteCodexMoleculeMcpToolName = "remote_codex_render_molecule";
 function stableArtifactId(input) {
   return [
     "artifact",
@@ -634,6 +679,134 @@ function findFencedBlocks(text2, languages) {
   }
   return blocks;
 }
+function readBalancedJsonFragment(text2, startIndex) {
+  const opener = text2[startIndex];
+  const expectedClose = opener === "{" ? "}" : opener === "[" ? "]" : null;
+  if (!expectedClose) {
+    return null;
+  }
+  const stack = [expectedClose];
+  let inString = false;
+  let escaping = false;
+  for (let index = startIndex + 1; index < text2.length; index += 1) {
+    const char = text2[index];
+    if (inString) {
+      if (escaping) {
+        escaping = false;
+      } else if (char === "\\") {
+        escaping = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "{") {
+      stack.push("}");
+      continue;
+    }
+    if (char === "[") {
+      stack.push("]");
+      continue;
+    }
+    if (char === stack.at(-1)) {
+      stack.pop();
+      if (stack.length === 0) {
+        return text2.slice(startIndex, index + 1);
+      }
+    }
+  }
+  return null;
+}
+function containsArtifactFence(text2) {
+  return text2.includes("```artifact") || text2.includes("```remote-codex-artifact") || text2.includes("~~~artifact") || text2.includes("~~~remote-codex-artifact");
+}
+function collectArtifactCandidateStrings(value, output, budget, depth = 0) {
+  if (output.length >= 20 || depth > 12 || budget.nodes <= 0) {
+    return;
+  }
+  budget.nodes -= 1;
+  if (typeof value === "string") {
+    if (containsArtifactFence(value)) {
+      output.push(value);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      collectArtifactCandidateStrings(entry, output, budget, depth + 1);
+      if (output.length >= 20 || budget.nodes <= 0) {
+        break;
+      }
+    }
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const entry of Object.values(value)) {
+      collectArtifactCandidateStrings(entry, output, budget, depth + 1);
+      if (output.length >= 20 || budget.nodes <= 0) {
+        break;
+      }
+    }
+  }
+}
+function parseJsonArtifactCandidateStrings(fragment, output) {
+  try {
+    collectArtifactCandidateStrings(JSON.parse(fragment), output, { nodes: 2e3 });
+  } catch {
+  }
+}
+function findJsonFragmentAt(text2, index) {
+  let startIndex = index;
+  while (startIndex < text2.length && /\s/.test(text2[startIndex] ?? "")) {
+    startIndex += 1;
+  }
+  const char = text2[startIndex];
+  if (char !== "{" && char !== "[") {
+    return null;
+  }
+  return readBalancedJsonFragment(text2, startIndex);
+}
+function extractToolJsonArtifactCandidateStrings(text2) {
+  const values = [];
+  const seenFragments = /* @__PURE__ */ new Set();
+  const addFragment = (fragment) => {
+    if (!fragment || seenFragments.has(fragment)) {
+      return;
+    }
+    seenFragments.add(fragment);
+    parseJsonArtifactCandidateStrings(fragment, values);
+  };
+  addFragment(findJsonFragmentAt(text2, 0));
+  const labelPattern = /(?:^|\n)(?:Arguments|Result)\n/g;
+  for (const match of text2.matchAll(labelPattern)) {
+    addFragment(findJsonFragmentAt(text2, match.index + match[0].length));
+    if (seenFragments.size >= 4 || values.length >= 20) {
+      break;
+    }
+  }
+  return values;
+}
+function extractArtifactCandidateTexts(item, text2) {
+  const values = [text2];
+  if (item.kind !== "toolCall" || ![item.text, item.previewText, text2].some(
+    (value) => typeof value === "string" && value.includes(remoteCodexMoleculeMcpToolName)
+  )) {
+    return values;
+  }
+  const seen = new Set(values);
+  for (const value of extractToolJsonArtifactCandidateStrings(text2)) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    values.push(value);
+  }
+  return values;
+}
 var ManifestArtifactExtractor = class {
   constructor(manifests) {
     this.manifests = manifests;
@@ -650,46 +823,57 @@ var ManifestArtifactExtractor = class {
     return results;
   }
   extractFromItem(turn, item, context) {
-    if (item.kind === "artifact" || !item.text.trim()) {
+    const extractableText = [item.text, item.detailText ?? ""].map((entry) => entry.trim()).filter(Boolean).join("\n\n");
+    if (item.kind === "artifact" || !extractableText) {
       return [];
     }
     const artifacts = [];
-    artifacts.push(...this.extractJsonArtifacts(turn, item, context));
+    artifacts.push(...this.extractJsonArtifacts(turn, item, context, extractableText));
     return artifacts;
   }
-  extractJsonArtifacts(turn, item, context) {
+  extractJsonArtifacts(turn, item, context, text2) {
     const artifacts = [];
-    for (const block of findFencedBlocks(item.text, artifactFenceLanguages)) {
-      if (!block.content) {
-        continue;
-      }
-      let parsed;
-      try {
-        parsed = JSON.parse(block.content);
-      } catch {
-        continue;
-      }
-      const payload = maybeParseArtifactPayload(parsed);
-      if (!payload || !this.hasArtifactType(payload.artifactType)) {
-        continue;
-      }
-      artifacts.push({
-        id: stableArtifactId({
-          turnId: turn.id,
-          itemId: item.id,
+    const extractableTexts = extractArtifactCandidateTexts(item, text2);
+    const seenBlocks = /* @__PURE__ */ new Set();
+    for (const extractableText of extractableTexts) {
+      for (const block of findFencedBlocks(extractableText, artifactFenceLanguages)) {
+        const blockKey = `${block.language}
+${block.content}`;
+        if (seenBlocks.has(blockKey)) {
+          continue;
+        }
+        seenBlocks.add(blockKey);
+        if (!block.content) {
+          continue;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(block.content);
+        } catch {
+          continue;
+        }
+        const payload = maybeParseArtifactPayload(parsed);
+        if (!payload || !this.hasArtifactType(payload.artifactType)) {
+          continue;
+        }
+        artifacts.push({
+          id: stableArtifactId({
+            turnId: turn.id,
+            itemId: item.id,
+            pluginId: this.pluginIdForArtifactType(payload.artifactType) ?? "unknown",
+            artifactType: payload.artifactType,
+            index: artifacts.length
+          }),
           pluginId: this.pluginIdForArtifactType(payload.artifactType) ?? "unknown",
-          artifactType: payload.artifactType,
-          index: artifacts.length
-        }),
-        pluginId: this.pluginIdForArtifactType(payload.artifactType) ?? "unknown",
-        type: payload.artifactType,
-        title: payload.title ?? "Plugin artifact",
-        summaryText: payload.summaryText ?? null,
-        payload: payload.payload,
-        sourceTurnId: turn.id,
-        sourceItemId: item.id,
-        createdAt: context.now
-      });
+          type: payload.artifactType,
+          title: payload.title ?? "Plugin artifact",
+          summaryText: payload.summaryText ?? null,
+          payload: payload.payload,
+          sourceTurnId: turn.id,
+          sourceItemId: item.id,
+          createdAt: context.now
+        });
+      }
     }
     return artifacts;
   }
@@ -760,6 +944,19 @@ function optionalStringArray(value, field) {
   }
   return value;
 }
+function optionalStringRecord(value, field) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord2(value)) {
+    throw new Error(`Plugin manifest field "${field}" must be an object.`);
+  }
+  const entries = Object.entries(value);
+  if (entries.some(([, entry]) => typeof entry !== "string")) {
+    throw new Error(`Plugin manifest field "${field}" must contain string values.`);
+  }
+  return Object.fromEntries(entries);
+}
 function parsePluginManifest(value) {
   if (!isRecord2(value)) {
     throw new Error("Plugin manifest must be an object.");
@@ -788,6 +985,14 @@ function parsePluginManifest(value) {
   if (backend !== void 0 && !isRecord2(backend)) {
     throw new Error('Plugin manifest field "capabilities.backend" must be an object.');
   }
+  const modelHints = capabilities.modelHints;
+  if (modelHints !== void 0 && !Array.isArray(modelHints)) {
+    throw new Error('Plugin manifest field "capabilities.modelHints" must be an array.');
+  }
+  const mcpServers = capabilities.mcpServers;
+  if (mcpServers !== void 0 && !Array.isArray(mcpServers)) {
+    throw new Error('Plugin manifest field "capabilities.mcpServers" must be an array.');
+  }
   return {
     id: assertString(value.id, "id"),
     name: assertString(value.name, "name"),
@@ -824,12 +1029,46 @@ function parsePluginManifest(value) {
         return {
           id: assertString(entry.id, `capabilities.threadPanels[${index}].id`),
           label: assertString(entry.label, `capabilities.threadPanels[${index}].label`),
+          ...typeof entry.kind === "string" ? { kind: entry.kind } : {},
           artifactTypes: optionalStringArray(
             entry.artifactTypes,
             `capabilities.threadPanels[${index}].artifactTypes`
           ) ?? []
         };
       }),
+      modelHints: (modelHints ?? []).map((entry, index) => {
+        if (!isRecord2(entry)) {
+          throw new Error(
+            `Plugin manifest field "capabilities.modelHints[${index}]" must be an object.`
+          );
+        }
+        return {
+          id: assertString(entry.id, `capabilities.modelHints[${index}].id`),
+          text: assertString(entry.text, `capabilities.modelHints[${index}].text`)
+        };
+      }),
+      mcpServers: (mcpServers ?? []).map((entry, index) => {
+        if (!isRecord2(entry)) {
+          throw new Error(
+            `Plugin manifest field "capabilities.mcpServers[${index}]" must be an object.`
+          );
+        }
+        const args = optionalStringArray(
+          entry.args,
+          `capabilities.mcpServers[${index}].args`
+        );
+        const env = optionalStringRecord(
+          entry.env,
+          `capabilities.mcpServers[${index}].env`
+        );
+        return {
+          id: assertString(entry.id, `capabilities.mcpServers[${index}].id`),
+          name: assertString(entry.name, `capabilities.mcpServers[${index}].name`),
+          command: assertString(entry.command, `capabilities.mcpServers[${index}].command`),
+          ...args ? { args } : {},
+          ...env ? { env } : {}
+        };
+      }),
       ...frontend ? {
         frontend: {
           ...typeof frontend.entry === "string" ? { entry: frontend.entry } : {},
@@ -2011,7 +2250,7 @@ Subquery.prototype.getSQL = function() {
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce(
-    (result2, { path: path22, field }, columnIndex) => {
+    (result2, { path: path24, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -2021,8 +2260,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         decoder = field.sql.decoder;
       }
       let node = result2;
-      for (const [pathChunkIndex, pathChunk] of path22.entries()) {
-        if (pathChunkIndex < path22.length - 1) {
+      for (const [pathChunkIndex, pathChunk] of path24.entries()) {
+        if (pathChunkIndex < path24.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -2030,8 +2269,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) && path22.length === 2) {
-            const objectName = path22[0];
+          if (joinsNotNullableMap && is(field, Column) && path24.length === 2) {
+            const objectName = path24[0];
             if (!(objectName in nullifyMap)) {
               nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
             } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
@@ -6132,6 +6371,7 @@ var shellSessions = sqliteTable("shell_sessions", {
   id: text("id").primaryKey(),
   workspaceId: text("workspace_id").notNull(),
   threadId: text("thread_id"),
+  label: text("label"),
   tmuxSessionName: text("tmux_session_name"),
   cwd: text("cwd").notNull(),
   status: text("status"),
@@ -6722,12 +6962,16 @@ function getShellSessionRecordById(db, id) {
 function getShellSessionRecordByThreadId(db, threadId) {
   return db.select().from(shellSessions).where(eq(shellSessions.threadId, threadId)).get();
 }
+function listShellSessionRecordsByThreadId(db, threadId) {
+  return db.select().from(shellSessions).where(eq(shellSessions.threadId, threadId)).orderBy(desc(shellSessions.lastActivityAt), desc(shellSessions.createdAt)).all();
+}
 function createShellSessionRecord(db, input) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const record = {
     id: randomUUID(),
     workspaceId: input.workspaceId,
     threadId: input.threadId,
+    label: input.label ?? null,
     tmuxSessionName: input.tmuxSessionName,
     cwd: input.cwd,
     status: input.status,
@@ -7509,12 +7753,12 @@ var CodexAppServerManager = class extends EventEmitter3 {
       serviceTier: input.serviceTier === void 0 ? void 0 : input.serviceTier,
       effort: input.effort ?? null,
       sandboxPolicy: input.sandboxPolicy ?? null,
-      collaborationMode: input.collaborationMode ? {
-        mode: input.collaborationMode,
+      collaborationMode: input.collaborationMode || input.developerInstructions ? {
+        mode: input.collaborationMode ?? "default",
         settings: {
           model: input.model ?? "",
           reasoning_effort: input.effort ?? null,
-          developer_instructions: null
+          developer_instructions: input.developerInstructions ?? null
         }
       } : null
     });
@@ -8311,7 +8555,7 @@ function extractFileChangeEntries(item) {
       isRecord4(entry.summary) ? entry.summary : null,
       isRecord4(entry.diff) ? entry.diff : null
     ].filter((candidate) => Boolean(candidate));
-    const path22 = uniqueStrings([
+    const path24 = uniqueStrings([
       stringOrNull(valueFromRecords(nestedRecords, ["path", "filePath", "targetPath"])),
       stringOrNull(
         valueFromRecords(nestedRecords, [
@@ -8358,7 +8602,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 = path22 ?? (diffText ? projectRelativePathLabel(extractPathFromDiffText(diffText)) : null);
+    const normalizedPath = path24 ?? (diffText ? projectRelativePathLabel(extractPathFromDiffText(diffText)) : null);
     if (!normalizedPath && additions === 0 && deletions === 0) {
       return null;
     }
@@ -10167,6 +10411,9 @@ var CodexRuntimeAdapter = class extends EventEmitter4 {
     if (input.collaborationMode !== void 0) {
       turnInput.collaborationMode = input.collaborationMode;
     }
+    if (input.developerInstructions !== void 0) {
+      turnInput.developerInstructions = input.developerInstructions;
+    }
     const sandboxPolicy = buildSandboxPolicy(input.sandboxMode, input.workspacePath);
     if (sandboxPolicy !== void 0) {
       turnInput.sandboxPolicy = sandboxPolicy;
@@ -11899,13 +12146,16 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
     const servers = await active.query.mcpServerStatus();
     return servers.map((server) => this.mapMcpServer(server));
   }
-  mapProviderRequest(request, _options) {
+  mapProviderRequest(request, options) {
+    void options;
     return mapClaudeAskUserQuestionRequest(request);
   }
   buildProviderRequestResponse(pending, input) {
     return buildClaudeProviderRequestResponse(pending, input);
   }
-  respondToProviderRequest(_id, _result) {
+  respondToProviderRequest(id, result) {
+    void id;
+    void result;
   }
   async consumeQuery(state) {
     const rawMessages = [];
@@ -12593,14 +12843,14 @@ function displayPath(pathValue, options) {
   }
   return relativePath;
 }
-function toolIsLowInformationPatch(normalized, state, input, patchText, path22, metadataStats) {
+function toolIsLowInformationPatch(normalized, state, input, patchText, path24, metadataStats) {
   if (normalized !== "applypatch" && normalized !== "patch") {
     return false;
   }
   if (toolStateStatus(state) !== "running") {
     return false;
   }
-  if (path22 || patchText || metadataStats || stringValue2(state.output)) {
+  if (path24 || patchText || metadataStats || stringValue2(state.output)) {
     return false;
   }
   return !isRecord9(input) || Object.keys(input).length === 0;
@@ -12643,7 +12893,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((path22) => Boolean(path22));
+  const paths = files.map((file) => stringValue2(file.filePath) ?? stringValue2(file.path) ?? stringValue2(file.relativePath)).filter((path24) => Boolean(path24));
   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 {
@@ -12791,28 +13041,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 path22 = metadataStats?.path ?? filePathFromInput(input) ?? extractPathFromPatchText(patchText);
-    if (toolIsLowInformationPatch(normalized, state, input, patchText, path22, metadataStats)) {
+    const path24 = metadataStats?.path ?? filePathFromInput(input) ?? extractPathFromPatchText(patchText);
+    if (toolIsLowInformationPatch(normalized, state, input, patchText, path24, metadataStats)) {
       return null;
     }
     const output = stringValue2(state.output);
     const diffStats = countUnifiedDiffStats2(patchText);
-    const displayFilePath = displayPath(path22, options);
+    const displayFilePath = displayPath(path24, 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 ?? (path22 ? 1 : null),
+      changedFiles: metadataStats?.changedFiles ?? (path24 ? 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 path22 = filePathFromInput(input);
-    const text2 = displayPath(path22, options) ?? summary ?? name;
+    const path24 = filePathFromInput(input);
+    const text2 = displayPath(path24, options) ?? summary ?? name;
     return {
       id,
       kind: "fileRead",
@@ -14843,7 +15093,7 @@ function shouldPersistLiveHistoryItem(item) {
 function shouldPersistFinalHistoryItem(item) {
   return item.kind === "agentMessage" || shouldPersistLiveHistoryItem(item);
 }
-function shouldPersistRuntimeFinalHistoryItem(item, allItems) {
+function shouldPersistRuntimeFinalHistoryItem(item) {
   if (item.kind === "agentMessage" && isTransientAgentHistoryItem(item)) {
     return false;
   }
@@ -14895,13 +15145,7 @@ function copyPersistedOrderingHints(item, persistedItem) {
   return nextItem;
 }
 function sortHistoryItemsBySequence(items) {
-  if (!items.some(hasHistoryItemSequence)) {
-    return items;
-  }
-  return items.map((item, index) => ({ item, index })).sort((left, right) => {
-    const sequenceDelta = historyItemSequence(left.item) - historyItemSequence(right.item);
-    return sequenceDelta === 0 ? left.index - right.index : sequenceDelta;
-  }).map((entry) => entry.item);
+  return sortTurnItemsByRecordedSequence(items);
 }
 function sortTurnItemsByRecordedSequence(items) {
   const leadingItems = [];
@@ -14914,9 +15158,6 @@ function sortTurnItemsByRecordedSequence(items) {
   if (!trailingItems.some(hasHistoryItemSequence)) {
     return items;
   }
-  if (trailingItems.some((item) => historyItemTranscriptOrder(item) !== null)) {
-    return items;
-  }
   const sequenceValues = trailingItems.map((item) => historyItemSequence(item)).filter(Number.isFinite);
   const maxSequence = sequenceValues.length > 0 ? Math.max(...sequenceValues) : 0;
   const orderedItems2 = [];
@@ -15074,7 +15315,9 @@ function agentTurnToThreadTurnDto(turn, deferredDetails) {
     startedAt: turn.startedAt ?? parseUuidV7Timestamp(turn.providerTurnId),
     status: turn.status,
     error: turn.error?.message ?? null,
-    items: visibleRuntimeTurnItems(turn.items)
+    items: visibleRuntimeTurnItems(turn.items).map(
+      (item, transcriptIndex) => item.transcriptOrder === transcriptIndex ? item : { ...item, transcriptOrder: transcriptIndex }
+    )
   };
   return deferredDetails ? deferLargeHistoryItemDetails(baseTurn, deferredDetails) : baseTurn;
 }
@@ -15113,6 +15356,7 @@ var ThreadLiveStateStore = class {
   threadTurnItemOrder = /* @__PURE__ */ new Map();
   threadNextTurnItemSequence = /* @__PURE__ */ new Map();
   threadMaterializedAgentMessageCounts = /* @__PURE__ */ new Map();
+  threadAgentMessageOrderingHints = /* @__PURE__ */ new Map();
   displayTurnIdForRuntimeTurn(localThreadId, runtimeTurnId) {
     if (!runtimeTurnId) {
       return null;
@@ -15155,6 +15399,7 @@ var ThreadLiveStateStore = class {
     this.threadLivePlans.delete(localThreadId);
     this.threadLiveItems.delete(localThreadId);
     this.threadMaterializedAgentMessageCounts.delete(localThreadId);
+    this.threadAgentMessageOrderingHints.delete(localThreadId);
     this.clearRecordedTurnItemOrders(localThreadId);
     this.runtimeDisplayTurnIds.delete(localThreadId);
     this.hiddenRuntimeTurnIds.delete(localThreadId);
@@ -15179,10 +15424,12 @@ var ThreadLiveStateStore = class {
   resetRecordedTurnItemOrder(localThreadId, turnId) {
     this.threadTurnItemOrder.get(localThreadId)?.delete(turnId);
     this.threadNextTurnItemSequence.get(localThreadId)?.delete(turnId);
+    this.threadAgentMessageOrderingHints.get(localThreadId)?.delete(turnId);
   }
   clearRecordedTurnItemOrders(localThreadId) {
     this.threadTurnItemOrder.delete(localThreadId);
     this.threadNextTurnItemSequence.delete(localThreadId);
+    this.threadAgentMessageOrderingHints.delete(localThreadId);
   }
   recordTurnItemOrder(localThreadId, turnId, itemId) {
     let threadOrders = this.threadTurnItemOrder.get(localThreadId);
@@ -15212,6 +15459,71 @@ var ThreadLiveStateStore = class {
   turnItemOrderSnapshot(localThreadId) {
     return this.threadTurnItemOrder.get(localThreadId) ?? /* @__PURE__ */ new Map();
   }
+  finalTurnAgentMessageOrderingHints(localThreadId, turnId, items, options = {}) {
+    const hints = /* @__PURE__ */ new Map();
+    const turnOrder = this.threadTurnItemOrder.get(localThreadId)?.get(turnId);
+    const liveAgentMessages = [
+      ...this.threadAgentMessageOrderingHints.get(localThreadId)?.get(turnId)?.values() ?? []
+    ].map((item) => ({
+      id: item.id,
+      text: normalizeAgentMessageForMatching(item.text),
+      sequence: item.sequence
+    }));
+    const usedLiveAgentIds = /* @__PURE__ */ new Set();
+    const finalAgentItems = items.filter((item) => item.kind === "agentMessage");
+    for (const item of finalAgentItems) {
+      const existingSequence = turnOrder?.get(item.id);
+      if (existingSequence !== void 0) {
+        hints.set(item.id, existingSequence);
+        const matchingLiveAgent = liveAgentMessages.find(
+          (liveAgent) => liveAgent.id === item.id || liveAgent.sequence === existingSequence
+        );
+        if (matchingLiveAgent) {
+          usedLiveAgentIds.add(matchingLiveAgent.id);
+        }
+        continue;
+      }
+      const text2 = normalizeAgentMessageForMatching(item.text);
+      if (!text2) {
+        continue;
+      }
+      let bestMatch = null;
+      for (const liveAgent of liveAgentMessages) {
+        if (usedLiveAgentIds.has(liveAgent.id) || !liveAgent.text) {
+          continue;
+        }
+        const score = agentMessageMatchScore(text2, liveAgent.text);
+        if (score === 0 || bestMatch && bestMatch.score >= score) {
+          continue;
+        }
+        bestMatch = {
+          id: liveAgent.id,
+          sequence: liveAgent.sequence,
+          score
+        };
+      }
+      if (bestMatch) {
+        usedLiveAgentIds.add(bestMatch.id);
+        hints.set(item.id, bestMatch.sequence);
+      }
+    }
+    if (options.allowUnmatchedFallback ?? true) {
+      const remainingLiveAgents = liveAgentMessages.filter((liveAgent) => !usedLiveAgentIds.has(liveAgent.id)).sort((left, right) => left.sequence - right.sequence);
+      let remainingLiveAgentIndex = 0;
+      for (const item of finalAgentItems) {
+        if (hints.has(item.id) || !normalizeAgentMessageForMatching(item.text)) {
+          continue;
+        }
+        const liveAgent = remainingLiveAgents[remainingLiveAgentIndex];
+        if (!liveAgent) {
+          break;
+        }
+        hints.set(item.id, liveAgent.sequence);
+        remainingLiveAgentIndex += 1;
+      }
+    }
+    return hints;
+  }
   getLiveItems(localThreadId, allTurns, visibleTurns = allTurns) {
     const current = this.threadLiveItems.get(localThreadId);
     if (!current) {
@@ -15227,10 +15539,8 @@ var ThreadLiveStateStore = class {
   upsertLiveItem(localThreadId, turnId, item) {
     const current = this.threadLiveItems.get(localThreadId);
     const currentItems = current?.turnId === turnId ? current.items : [];
-    const nextItems = [
-      ...currentItems.filter((entry) => entry.id !== item.id),
-      item
-    ];
+    const existingIndex = currentItems.findIndex((entry) => entry.id === item.id);
+    const nextItems = existingIndex >= 0 ? currentItems.map((entry, index) => index === existingIndex ? item : entry) : [...currentItems, item];
     this.setLiveItems(localThreadId, {
       turnId,
       items: sortHistoryItemsBySequence(nextItems),
@@ -15251,16 +15561,43 @@ var ThreadLiveStateStore = class {
       text: input.delta,
       sequence: input.sequence
     };
+    this.recordAgentMessageOrderingHint(
+      input.localThreadId,
+      input.turnId,
+      nextItem,
+      input.sequence
+    );
     this.setLiveItems(input.localThreadId, {
       turnId: input.turnId,
-      items: sortHistoryItemsBySequence([
-        ...currentItems.filter((entry) => entry.id !== input.itemId),
-        nextItem
-      ]),
+      items: sortHistoryItemsBySequence(
+        existing ? currentItems.map(
+          (entry) => entry.id === input.itemId ? nextItem : entry
+        ) : [...currentItems, nextItem]
+      ),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     return nextItem;
   }
+  recordAgentMessageOrderingHint(localThreadId, turnId, item, sequence) {
+    if (item.kind !== "agentMessage" || !Number.isFinite(sequence)) {
+      return;
+    }
+    let threadHints = this.threadAgentMessageOrderingHints.get(localThreadId);
+    if (!threadHints) {
+      threadHints = /* @__PURE__ */ new Map();
+      this.threadAgentMessageOrderingHints.set(localThreadId, threadHints);
+    }
+    let turnHints = threadHints.get(turnId);
+    if (!turnHints) {
+      turnHints = /* @__PURE__ */ new Map();
+      threadHints.set(turnId, turnHints);
+    }
+    turnHints.set(item.id, {
+      id: item.id,
+      text: item.text,
+      sequence
+    });
+  }
   reconcileLiveItems(localThreadId, turns) {
     const current = this.threadLiveItems.get(localThreadId);
     if (!current) {
@@ -15312,6 +15649,21 @@ var ThreadLiveStateStore = class {
     return nextLiveItems;
   }
 };
+function normalizeAgentMessageForMatching(text2) {
+  return text2.replace(/\s+/g, " ").trim();
+}
+function agentMessageMatchScore(finalText, liveText) {
+  if (finalText === liveText) {
+    return 3;
+  }
+  if (liveText.length >= 8 && finalText.includes(liveText)) {
+    return 2;
+  }
+  if (finalText.length >= 8 && liveText.includes(finalText)) {
+    return 1;
+  }
+  return 0;
+}
 
 // src/thread-usage-accounting.ts
 var CONTEXT_BASELINE_TOKENS = 12e3;
@@ -15899,9 +16251,10 @@ var ThreadRuntimeEventProjector = class {
           lastError: event.turn.error?.message ?? null,
           lastTurnCompletedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
+        callbacks.persistFinalTurnOrderingHints(record.id, turnId, turnItems);
+        callbacks.persistRuntimeTurnItemsAsDisplayTurn(record.id, rawTurnId, turnId, turnItems);
         liveState.setLivePlan(record.id, null);
         liveState.setLiveItems(record.id, null);
-        callbacks.persistRuntimeTurnItemsAsDisplayTurn(record.id, rawTurnId, turnId, turnItems);
         if (rawTurnId !== turnId) {
           callbacks.deletePersistedHistoryItemsForTurn(record.id, rawTurnId);
           liveState.resetRecordedTurnItemOrder(record.id, rawTurnId);
@@ -16310,34 +16663,82 @@ var ThreadDetailAssembler = class {
   }
   input;
   threadDetailCache = /* @__PURE__ */ new Map();
-  getCache(localThreadId) {
-    const cached = this.threadDetailCache.get(localThreadId);
-    if (!cached) {
+  getCache(localThreadId, options = {}) {
+    const bucket = this.threadDetailCache.get(localThreadId);
+    if (!bucket) {
       return null;
     }
-    if (Date.now() - cached.cachedAt > THREAD_DETAIL_CACHE_TTL_MS) {
-      this.threadDetailCache.delete(localThreadId);
+    const key = cacheKeyForDetailOptions(options);
+    if (key === "uncached") {
       return null;
     }
-    return cached;
+    const cached = key === "full" ? bucket.full : bucket.latestPages.get(key) ?? null;
+    if (cached && !isExpiredThreadDetailCacheEntry(cached)) {
+      return cached;
+    }
+    if (key === "full") {
+      bucket.full = null;
+    } else {
+      bucket.latestPages.delete(key);
+    }
+    if (!bucket.full && bucket.latestPages.size === 0) {
+      this.threadDetailCache.delete(localThreadId);
+    }
+    return null;
   }
-  setCache(localThreadId, entry) {
-    this.threadDetailCache.set(localThreadId, {
+  setCache(localThreadId, options = {}, entry) {
+    const bucket = this.threadDetailCache.get(localThreadId) ?? {
+      full: null,
+      latestPages: /* @__PURE__ */ new Map()
+    };
+    const nextEntry = {
       ...entry,
       cachedAt: Date.now()
-    });
+    };
+    const key = cacheKeyForDetailOptions(options);
+    if (key === "uncached") {
+      return;
+    }
+    if (key === "full") {
+      bucket.full = nextEntry;
+    } else {
+      bucket.latestPages.set(key, nextEntry);
+    }
+    this.threadDetailCache.set(localThreadId, bucket);
   }
   invalidate(localThreadId) {
     this.threadDetailCache.delete(localThreadId);
   }
   cachedTurns(localThreadId) {
-    return this.threadDetailCache.get(localThreadId)?.turns ?? [];
+    const bucket = this.threadDetailCache.get(localThreadId);
+    if (!bucket) {
+      return [];
+    }
+    if (bucket.full && !isExpiredThreadDetailCacheEntry(bucket.full)) {
+      return bucket.full.turns;
+    }
+    let newest = null;
+    for (const [key, entry] of bucket.latestPages.entries()) {
+      if (isExpiredThreadDetailCacheEntry(entry)) {
+        bucket.latestPages.delete(key);
+        continue;
+      }
+      if (!newest || entry.cachedAt > newest.cachedAt) {
+        newest = entry;
+      }
+    }
+    if (!bucket.full && bucket.latestPages.size === 0) {
+      this.threadDetailCache.delete(localThreadId);
+    }
+    return newest?.turns ?? [];
   }
   async buildCacheEntry(input) {
     const options = input.options ?? {};
     const shouldCacheFullDetail = options.limit === void 0 && options.beforeTurnId === void 0;
-    const cached = this.getCache(input.localThreadId);
-    if (cached && shouldCacheFullDetail) {
+    const cacheKey = cacheKeyForDetailOptions(options);
+    const isPaged = !shouldCacheFullDetail;
+    const cached = this.getCache(input.localThreadId, options);
+    if (cached) {
       return cached;
     }
     let remoteSession = await this.input.callbacks.readRemoteSession(
@@ -16347,6 +16748,7 @@ var ThreadDetailAssembler = class {
     if (!remoteSession) {
       return this.buildLocalFallbackEntry({
         ...input,
+        options,
         shouldCacheFullDetail
       });
     }
@@ -16376,13 +16778,18 @@ var ThreadDetailAssembler = class {
       remoteSession.turns
     );
     const visibleTurns = this.input.liveState.visibleRemoteTurns(input.localThreadId, remoteSession.turns).map((turn) => agentTurnToThreadTurnDto(turn, deferredDetails));
-    const resolvedTurnMetadataById = resolveTurnMetadataByVisibleTurnId(
+    const orderedVisibleTurns = applyLiveAgentMessageOrderingHints(
       visibleTurns,
+      input.localThreadId,
+      this.input.liveState
+    );
+    const resolvedTurnMetadataById = resolveTurnMetadataByVisibleTurnId(
+      orderedVisibleTurns,
       input.turnMetadataById
     );
     const turns = mergePersistedHistoryItemsIntoTurns(
       applyRecordedTurnItemOrders(
-        visibleTurns,
+        orderedVisibleTurns,
         this.input.liveState.turnItemOrderSnapshot(input.localThreadId)
       ),
       persistedItemsByTurnId,
@@ -16393,12 +16800,13 @@ var ThreadDetailAssembler = class {
     const entry = {
       cachedAt: Date.now(),
       turns,
-      totalTurnCount: shouldCacheFullDetail ? turns.length : remoteSession.totalTurnCount ?? Math.max(cached?.totalTurnCount ?? 0, turns.length),
-      deferredDetails
+      totalTurnCount: shouldCacheFullDetail ? turns.length : remoteSession.totalTurnCount ?? turns.length,
+      deferredDetails,
+      isPaged
     };
-    if (shouldCacheFullDetail) {
-      this.setCache(input.localThreadId, entry);
-      return this.threadDetailCache.get(input.localThreadId);
+    if (cacheKey !== "uncached") {
+      this.setCache(input.localThreadId, options, entry);
+      return this.getCache(input.localThreadId, options);
     }
     return entry;
   }
@@ -16417,7 +16825,7 @@ var ThreadDetailAssembler = class {
       input.record,
       latestThreadTurnMetadata(input.turnMetadataById)
     );
-    const localTurns = localSession?.turns ?? [...persistedItemsByTurnId.entries()].map(([turnId, items]) => ({
+    const localTurns = localSession?.turns ?? [...persistedItemsByTurnId.keys()].map((turnId) => ({
       id: turnId,
       startedAt: null,
       status: "completed",
@@ -16441,15 +16849,61 @@ var ThreadDetailAssembler = class {
       cachedAt: Date.now(),
       turns,
       totalTurnCount: turns.length,
-      deferredDetails
+      deferredDetails,
+      isPaged: !input.shouldCacheFullDetail
     };
-    if (input.shouldCacheFullDetail) {
-      this.setCache(input.localThreadId, entry);
-      return this.threadDetailCache.get(input.localThreadId);
+    const cacheOptions = input.shouldCacheFullDetail ? {} : input.options;
+    if (cacheKeyForDetailOptions(cacheOptions) !== "uncached") {
+      this.setCache(input.localThreadId, cacheOptions, entry);
+      return this.getCache(input.localThreadId, cacheOptions);
     }
     return entry;
   }
 };
+function isExpiredThreadDetailCacheEntry(entry) {
+  return Date.now() - entry.cachedAt > THREAD_DETAIL_CACHE_TTL_MS;
+}
+function cacheKeyForDetailOptions(options) {
+  if (options.beforeTurnId !== void 0) {
+    return "uncached";
+  }
+  if (options.limit === void 0) {
+    return "full";
+  }
+  return `latest:${options.limit}`;
+}
+function applyLiveAgentMessageOrderingHints(turns, localThreadId, liveState) {
+  return turns.map((turn) => {
+    const orderingHints = liveState.finalTurnAgentMessageOrderingHints(
+      localThreadId,
+      turn.id,
+      turn.items,
+      { allowUnmatchedFallback: false }
+    );
+    if (orderingHints.size === 0) {
+      return turn;
+    }
+    let changed = false;
+    const items = turn.items.map((item) => {
+      if (item.kind !== "agentMessage") {
+        return item;
+      }
+      const sequence = orderingHints.get(item.id);
+      if (sequence === void 0 || item.sequence === sequence) {
+        return item;
+      }
+      changed = true;
+      return {
+        ...item,
+        sequence
+      };
+    });
+    return changed ? {
+      ...turn,
+      items: sortHistoryItemsBySequence(items)
+    } : turn;
+  });
+}
 function buildTurnDto(turn, metadata) {
   const tokenUsage = parseThreadTurnTokenUsageJson(metadata?.tokenUsageJson);
   return {
@@ -16932,7 +17386,8 @@ var ThreadPromptTurnCoordinator = class {
       reasoningEffort: input.normalizedReasoning,
       collaborationMode: input.collaborationMode,
       sandboxMode: input.sandboxMode,
-      workspacePath: input.workspacePath
+      workspacePath: input.workspacePath,
+      developerInstructions: input.developerInstructions ?? null
     };
     if (input.hidden !== void 0) {
       startTurnInput.hidden = input.hidden;
@@ -17049,7 +17504,8 @@ var ThreadPromptTurnCoordinator = class {
       collaborationMode: input.collaborationMode,
       sandboxMode: input.sandboxMode,
       performanceMode: input.performanceMode,
-      workspacePath: input.workspacePath
+      workspacePath: input.workspacePath,
+      developerInstructions: input.developerInstructions ?? null
     });
   }
 };
@@ -17480,12 +17936,38 @@ var ThreadHistoryPersistenceCoordinator = class {
   deletePersistedHistoryItemsForTurn(localThreadId, turnId) {
     deleteThreadHistoryItemRecordsByThreadAndTurnId(this.db, localThreadId, turnId);
   }
+  persistFinalTurnOrderingHints(localThreadId, turnId, items) {
+    const orderingHints = this.liveState.finalTurnAgentMessageOrderingHints(
+      localThreadId,
+      turnId,
+      items
+    );
+    for (const item of items) {
+      if (item.kind !== "agentMessage" || !shouldPersistRuntimeFinalHistoryItem(item)) {
+        continue;
+      }
+      const sequence = orderingHints.get(item.id);
+      if (sequence === void 0) {
+        continue;
+      }
+      upsertThreadHistoryItemRecord(this.db, {
+        threadId: localThreadId,
+        turnId,
+        itemId: item.id,
+        itemJson: JSON.stringify({
+          ...item,
+          sequence,
+          sourceTurnId: turnId
+        })
+      });
+    }
+  }
   persistRuntimeTurnItemsAsDisplayTurn(localThreadId, runtimeTurnId, displayTurnId, items) {
     if (runtimeTurnId === displayTurnId) {
       return;
     }
     for (const item of items) {
-      if (!shouldPersistRuntimeFinalHistoryItem(item, items)) {
+      if (!shouldPersistRuntimeFinalHistoryItem(item)) {
         continue;
       }
       const sequence = this.liveState.recordTurnItemOrder(localThreadId, displayTurnId, item.id);
@@ -19168,6 +19650,16 @@ async function pathExists3(absPath) {
     return false;
   }
 }
+function canUseRuntimePagedTurns(cachedDetail, enrichedTurns, options) {
+  const requestedLimit = options.limit ?? 10;
+  if (enrichedTurns.length > requestedLimit) {
+    return false;
+  }
+  return cachedDetail.totalTurnCount > enrichedTurns.length;
+}
+function pluginDeveloperInstructions(pluginService) {
+  return pluginService?.modelContextPrompt() ?? null;
+}
 var ThreadService = class {
   constructor(db, agentRuntimes, eventBus, localSessionStore, workspaceRoot, providerManagement, pluginService) {
     this.db = db;
@@ -19343,6 +19835,7 @@ var ThreadService = class {
         normalizeReasoningEffort: normalizeReasoningEffort2,
         normalizeThreadGoalStatusForThread: (goal, record) => this.goalCoordinator.normalizeThreadGoalStatusForThread(goal, record),
         persistLiveHistoryItem: (localThreadId, turnId, item) => this.historyPersistence.persistLiveHistoryItem(localThreadId, turnId, item),
+        persistFinalTurnOrderingHints: (localThreadId, turnId, items) => this.historyPersistence.persistFinalTurnOrderingHints(localThreadId, turnId, items),
         persistRuntimeTurnItemsAsDisplayTurn: (localThreadId, runtimeTurnId, displayTurnId, items) => this.historyPersistence.persistRuntimeTurnItemsAsDisplayTurn(
           localThreadId,
           runtimeTurnId,
@@ -19583,9 +20076,13 @@ var ThreadService = class {
     const enrichedTurns = this.pluginService?.enrichTurnsWithArtifacts({
       threadId: updated.id,
       workspacePath: workspace.absPath,
-      turns: cachedDetail.turns
+      turns: cachedDetail.turns,
+      deferredDetails: cachedDetail.deferredDetails
     }) ?? cachedDetail.turns;
-    const pagedTurns = this.detailAssembler.sliceTurns(enrichedTurns, options);
+    const pagedTurns = cachedDetail.isPaged && canUseRuntimePagedTurns(cachedDetail, enrichedTurns, options) ? {
+      turns: enrichedTurns,
+      totalTurnCount: cachedDetail.totalTurnCount
+    } : this.detailAssembler.sliceTurns(enrichedTurns, options);
     this.syncPendingPlanDecisionRequestFromTurns(
       updated.id,
       updated.collaborationMode,
@@ -19776,6 +20273,7 @@ var ThreadService = class {
       ...record,
       providerSessionId
     };
+    const developerInstructions = pluginDeveloperInstructions(this.pluginService);
     if (record.providerTurnId && record.status === "running") {
       if (!turnConfig.supportsRunningTurnInput) {
         throw new HttpError(409, {
@@ -19795,7 +20293,8 @@ var ThreadService = class {
         collaborationMode: turnConfig.collaborationMode,
         sandboxMode: turnConfig.sandboxMode,
         performanceMode: turnConfig.performanceMode,
-        workspacePath: workspace.absPath
+        workspacePath: workspace.absPath,
+        developerInstructions
       });
     }
     return this.promptTurnCoordinator.startPromptTurn(localThreadId, connectedRecord, {
@@ -19806,7 +20305,8 @@ var ThreadService = class {
       collaborationMode: turnConfig.collaborationMode,
       sandboxMode: turnConfig.sandboxMode,
       performanceMode: turnConfig.performanceMode,
-      workspacePath: workspace.absPath
+      workspacePath: workspace.absPath,
+      developerInstructions
     });
   }
   async updateThreadSettings(localThreadId, input) {
@@ -20638,36 +21138,8 @@ function runShellCommand(command, timeoutMs = 0) {
   });
 }
 
-// src/routes/shells.ts
+// src/routes/system.ts
 import { z as z4 } from "zod";
-async function registerShellRoutes(app2) {
-  const threadIdParams = z4.object({ id: z4.string().uuid() });
-  const shellIdParams = z4.object({ id: z4.string().uuid() });
-  const createShellSchema = z4.object({
-    cols: z4.number().int().positive().optional(),
-    rows: z4.number().int().positive().optional()
-  });
-  app2.get("/api/threads/:id/shell", async (request) => {
-    const params = threadIdParams.parse(request.params);
-    return app2.services.shellService.getThreadShellState(params.id);
-  });
-  app2.post("/api/threads/:id/shell", async (request) => {
-    const params = threadIdParams.parse(request.params);
-    const body = createShellSchema.parse(request.body ?? {});
-    const input = {
-      ...body.cols !== void 0 ? { cols: body.cols } : {},
-      ...body.rows !== void 0 ? { rows: body.rows } : {}
-    };
-    return app2.services.shellService.createShellForThread(params.id, input);
-  });
-  app2.post("/api/shells/:id/terminate", async (request) => {
-    const params = shellIdParams.parse(request.params);
-    return app2.services.shellService.terminateShell(params.id);
-  });
-}
-
-// src/routes/system.ts
-import { z as z5 } from "zod";
 
 // src/workspace-settings.ts
 var DEV_HOME_POLICY_KEY = "dev_home";
@@ -20731,27 +21203,27 @@ async function saveWorkspaceSettings(db, workspaceRoot, input) {
 }
 
 // src/routes/system.ts
-var updateProviderHostFileSchema = z5.object({
-  content: z5.string()
+var updateProviderHostFileSchema = z4.object({
+  content: z4.string()
 });
-var archiveIdSchema = z5.string().regex(/^[a-zA-Z0-9_-]+$/);
-var createProviderHostConfigArchiveSchema = z5.object({
-  label: z5.string().trim().min(1).max(120).optional()
+var archiveIdSchema = z4.string().regex(/^[a-zA-Z0-9_-]+$/);
+var createProviderHostConfigArchiveSchema = z4.object({
+  label: z4.string().trim().min(1).max(120).optional()
 });
-var renameProviderHostConfigArchiveSchema = z5.object({
-  label: z5.string().trim().min(1).max(120)
+var renameProviderHostConfigArchiveSchema = z4.object({
+  label: z4.string().trim().min(1).max(120)
 });
-var updateWorkspaceSettingsSchema = z5.object({
-  devHome: z5.string().trim().min(1),
+var updateWorkspaceSettingsSchema = z4.object({
+  devHome: z4.string().trim().min(1),
   defaultBackend: agentBackendIdSchema.optional()
 });
-var providerParamSchema2 = z5.object({
+var providerParamSchema2 = z4.object({
   provider: agentBackendIdSchema
 });
 function parseProviderHostFileParams(params) {
-  return z5.object({
+  return z4.object({
     ...providerParamSchema2.shape,
-    name: z5.string()
+    name: z4.string()
   }).parse(params);
 }
 async function registerSystemRoutes(app2) {
@@ -20779,6 +21251,7 @@ async function registerSystemRoutes(app2) {
     return {
       appName: app2.services.config.appName,
       appVersion: app2.services.config.appVersion,
+      mode: app2.services.config.mode,
       host: app2.services.config.host,
       port: app2.services.config.port,
       workspaceRoot: app2.services.config.workspaceRoot,
@@ -20831,7 +21304,7 @@ async function registerSystemRoutes(app2) {
     return app2.services.providerHostConfigService.createArchive(provider, body);
   });
   app2.patch("/api/config/providers/:provider/archives/:id", async (request) => {
-    const params = z5.object({
+    const params = z4.object({
       ...providerParamSchema2.shape,
       id: archiveIdSchema
     }).parse(request.params);
@@ -20845,7 +21318,7 @@ async function registerSystemRoutes(app2) {
     );
   });
   app2.post("/api/config/providers/:provider/archives/:id/apply", async (request) => {
-    const params = z5.object({
+    const params = z4.object({
       ...providerParamSchema2.shape,
       id: archiveIdSchema
     }).parse(request.params);
@@ -20856,67 +21329,67 @@ async function registerSystemRoutes(app2) {
 // src/routes/threads.ts
 import fs16 from "fs/promises";
 import path16 from "path";
-import { z as z6 } from "zod";
-var createThreadSchema = z6.object({
-  workspaceId: z6.string().uuid(),
-  title: z6.string().optional(),
+import { z as z5 } from "zod";
+var createThreadSchema = z5.object({
+  workspaceId: z5.string().uuid(),
+  title: z5.string().optional(),
   provider: agentBackendIdSchema.optional(),
-  model: z6.string().min(1),
-  approvalMode: z6.enum(["yolo", "guarded"]).default("yolo")
+  model: z5.string().min(1),
+  approvalMode: z5.enum(["yolo", "guarded"]).default("yolo")
 });
-var promptSchema = z6.object({
-  prompt: z6.string().min(1),
-  clientRequestId: z6.string().min(1).optional(),
-  model: z6.string().min(1).optional(),
-  reasoningEffort: z6.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).nullable().optional(),
-  collaborationMode: z6.enum(["default", "plan"]).optional(),
-  sandboxMode: z6.enum(["read-only", "workspace-write", "danger-full-access"]).nullable().optional()
+var promptSchema = z5.object({
+  prompt: z5.string().min(1),
+  clientRequestId: z5.string().min(1).optional(),
+  model: z5.string().min(1).optional(),
+  reasoningEffort: z5.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).nullable().optional(),
+  collaborationMode: z5.enum(["default", "plan"]).optional(),
+  sandboxMode: z5.enum(["read-only", "workspace-write", "danger-full-access"]).nullable().optional()
 });
-var promptAttachmentManifestEntrySchema = z6.object({
-  clientId: z6.string().min(1),
-  kind: z6.enum(["photo", "file"]),
-  originalName: z6.string().optional(),
-  placeholder: z6.string().min(1)
+var promptAttachmentManifestEntrySchema = z5.object({
+  clientId: z5.string().min(1),
+  kind: z5.enum(["photo", "file"]),
+  originalName: z5.string().optional(),
+  placeholder: z5.string().min(1)
 });
-var updateThreadSchema = z6.object({
-  title: z6.string().min(1)
+var updateThreadSchema = z5.object({
+  title: z5.string().min(1)
 });
-var updateThreadSettingsSchema = z6.object({
-  model: z6.string().min(1).optional(),
-  reasoningEffort: z6.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).nullable().optional(),
-  fastMode: z6.boolean().optional(),
-  collaborationMode: z6.enum(["default", "plan"]).optional(),
-  sandboxMode: z6.enum(["read-only", "workspace-write", "danger-full-access"]).nullable().optional()
+var updateThreadSettingsSchema = z5.object({
+  model: z5.string().min(1).optional(),
+  reasoningEffort: z5.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).nullable().optional(),
+  fastMode: z5.boolean().optional(),
+  collaborationMode: z5.enum(["default", "plan"]).optional(),
+  sandboxMode: z5.enum(["read-only", "workspace-write", "danger-full-access"]).nullable().optional()
 }).refine((body) => Object.keys(body).length > 0, {
   message: "At least one thread setting must be provided."
 });
-var updateThreadGoalSchema = z6.object({
-  objective: z6.string().min(1).nullable().optional(),
-  status: z6.enum(["active", "paused", "budgetLimited", "complete", "terminated"]).nullable().optional(),
-  tokenBudget: z6.number().int().positive().nullable().optional()
+var updateThreadGoalSchema = z5.object({
+  objective: z5.string().min(1).nullable().optional(),
+  status: z5.enum(["active", "paused", "budgetLimited", "complete", "terminated"]).nullable().optional(),
+  tokenBudget: z5.number().int().positive().nullable().optional()
 }).refine((body) => Object.keys(body).length > 0, {
   message: "At least one goal field must be provided."
 });
-var interruptSchema = z6.object({
-  turnId: z6.string().optional()
+var interruptSchema = z5.object({
+  turnId: z5.string().optional()
 });
-var importThreadSchema = z6.object({
-  sessionId: z6.string().min(1)
+var importThreadSchema = z5.object({
+  sessionId: z5.string().min(1)
 });
-var resumeThreadSchema = z6.object({
-  model: z6.string().min(1).optional(),
-  sandboxMode: z6.enum(["read-only", "workspace-write", "danger-full-access"]).nullable().optional()
+var resumeThreadSchema = z5.object({
+  model: z5.string().min(1).optional(),
+  sandboxMode: z5.enum(["read-only", "workspace-write", "danger-full-access"]).nullable().optional()
 });
-var forkThreadSchema = z6.discriminatedUnion("mode", [
-  z6.object({
-    mode: z6.literal("latest")
+var forkThreadSchema = z5.discriminatedUnion("mode", [
+  z5.object({
+    mode: z5.literal("latest")
   }),
-  z6.object({
-    mode: z6.literal("turn"),
-    turnId: z6.string().min(1)
+  z5.object({
+    mode: z5.literal("turn"),
+    turnId: z5.string().min(1)
   })
 ]);
-var hookEventNameSchema = z6.enum([
+var hookEventNameSchema = z5.enum([
   "preToolUse",
   "permissionRequest",
   "postToolUse",
@@ -20926,48 +21399,48 @@ var hookEventNameSchema = z6.enum([
   "userPromptSubmit",
   "stop"
 ]);
-var createThreadHookSchema = z6.object({
-  scope: z6.enum(["global", "project"]),
+var createThreadHookSchema = z5.object({
+  scope: z5.enum(["global", "project"]),
   eventName: hookEventNameSchema,
-  matcher: z6.string().nullable().optional(),
-  command: z6.string().trim().min(1),
-  timeoutSec: z6.number().int().positive().max(86400).nullable().optional(),
-  statusMessage: z6.string().nullable().optional()
+  matcher: z5.string().nullable().optional(),
+  command: z5.string().trim().min(1),
+  timeoutSec: z5.number().int().positive().max(86400).nullable().optional(),
+  statusMessage: z5.string().nullable().optional()
 });
 var updateThreadHookSchema = createThreadHookSchema.extend({
   target: createThreadHookSchema
 });
-var trustThreadHookSchema = z6.object({
-  key: z6.string().min(1),
-  currentHash: z6.string().min(1)
+var trustThreadHookSchema = z5.object({
+  key: z5.string().min(1),
+  currentHash: z5.string().min(1)
 });
-var untrustThreadHookSchema = z6.object({
-  key: z6.string().min(1)
+var untrustThreadHookSchema = z5.object({
+  key: z5.string().min(1)
 });
-var respondThreadRequestSchema = z6.object({
-  answers: z6.record(z6.string(), z6.object({
-    answers: z6.array(z6.string())
+var respondThreadRequestSchema = z5.object({
+  answers: z5.record(z5.string(), z5.object({
+    answers: z5.array(z5.string())
   }))
 });
-var threadDetailQuerySchema = z6.object({
-  limit: z6.coerce.number().int().positive().max(100).optional(),
-  beforeTurnId: z6.string().min(1).optional()
+var threadDetailQuerySchema = z5.object({
+  limit: z5.coerce.number().int().positive().max(100).optional(),
+  beforeTurnId: z5.string().min(1).optional()
 });
-var exportThreadPdfSchema = z6.object({
-  format: z6.enum(["pdf", "html"]).optional(),
-  mode: z6.enum(["latest", "selected"]),
-  limit: z6.number().int().positive().max(100).optional(),
-  turnIds: z6.array(z6.string().min(1)).max(100).optional(),
-  profile: z6.enum(["review", "technical"]).optional(),
-  options: z6.object({
-    includeTokenAndPrice: z6.boolean().optional(),
-    includeCommandOutput: z6.boolean().optional(),
-    includeAbsolutePaths: z6.boolean().optional()
+var exportThreadPdfSchema = z5.object({
+  format: z5.enum(["pdf", "html"]).optional(),
+  mode: z5.enum(["latest", "selected"]),
+  limit: z5.number().int().positive().max(100).optional(),
+  turnIds: z5.array(z5.string().min(1)).max(100).optional(),
+  profile: z5.enum(["review", "technical"]).optional(),
+  options: z5.object({
+    includeTokenAndPrice: z5.boolean().optional(),
+    includeCommandOutput: z5.boolean().optional(),
+    includeAbsolutePaths: z5.boolean().optional()
   }).optional()
 }).refine((body) => body.mode !== "selected" || (body.turnIds?.length ?? 0) > 0, {
   message: "turnIds are required for selected exports."
 });
-var queryBooleanSchema = z6.preprocess((value) => {
+var queryBooleanSchema = z5.preprocess((value) => {
   if (value === "true" || value === "1") {
     return true;
   }
@@ -20975,21 +21448,21 @@ var queryBooleanSchema = z6.preprocess((value) => {
     return false;
   }
   return value;
-}, z6.boolean());
-var exportThreadPdfQuerySchema = z6.object({
-  format: z6.enum(["pdf", "html"]).optional(),
-  mode: z6.enum(["latest", "selected"]),
-  limit: z6.coerce.number().int().positive().max(100).optional(),
-  turnIds: z6.string().optional(),
-  profile: z6.enum(["review", "technical"]).optional(),
+}, z5.boolean());
+var exportThreadPdfQuerySchema = z5.object({
+  format: z5.enum(["pdf", "html"]).optional(),
+  mode: z5.enum(["latest", "selected"]),
+  limit: z5.coerce.number().int().positive().max(100).optional(),
+  turnIds: z5.string().optional(),
+  profile: z5.enum(["review", "technical"]).optional(),
   includeTokenAndPrice: queryBooleanSchema.optional(),
   includeCommandOutput: queryBooleanSchema.optional(),
   includeAbsolutePaths: queryBooleanSchema.optional()
 }).refine((query) => query.mode !== "selected" || Boolean(query.turnIds?.trim()), {
   message: "turnIds are required for selected exports."
 });
-var threadImageQuerySchema = z6.object({
-  path: z6.string().min(1)
+var threadImageQuerySchema = z5.object({
+  path: z5.string().min(1)
 });
 async function sendThreadExport(app2, reply, threadId, input) {
   const result = await app2.services.threadService.exportThreadTranscript(threadId, input);
@@ -21089,7 +21562,7 @@ async function parseMultipartPromptRequest(request) {
       message: "attachmentManifest must be valid JSON."
     });
   }
-  const manifest = z6.array(promptAttachmentManifestEntrySchema).max(MAX_PROMPT_ATTACHMENTS).parse(manifestParsed);
+  const manifest = z5.array(promptAttachmentManifestEntrySchema).max(MAX_PROMPT_ATTACHMENTS).parse(manifestParsed);
   if (manifest.length !== uploadedFiles.length) {
     throw new HttpError(400, {
       code: "bad_request",
@@ -21133,7 +21606,7 @@ async function registerThreadRoutes(app2) {
     return app2.services.threadService.importThread(body.sessionId);
   });
   app2.get("/api/threads/:id", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const query = threadDetailQuerySchema.parse(request.query);
     return app2.services.threadService.getThreadDetail(params.id, {
       ...query.limit !== void 0 ? { limit: query.limit } : {},
@@ -21141,11 +21614,11 @@ async function registerThreadRoutes(app2) {
     });
   });
   app2.get("/api/threads/:id/export-turns", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     return app2.services.threadService.listThreadExportTurns(params.id);
   });
   app2.get("/api/threads/:id/exports/pdf", async (request, reply) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const query = exportThreadPdfQuerySchema.parse(request.query);
     const turnIds = query.turnIds?.split(",").map((turnId) => turnId.trim()).filter(Boolean);
     const options = {};
@@ -21169,7 +21642,7 @@ async function registerThreadRoutes(app2) {
     return sendThreadExport(app2, reply, params.id, input);
   });
   app2.post("/api/threads/:id/exports/pdf", async (request, reply) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const parsed = exportThreadPdfSchema.parse(request.body);
     const input = {
       ...parsed.format !== void 0 ? { format: parsed.format } : {},
@@ -21188,9 +21661,9 @@ async function registerThreadRoutes(app2) {
     return sendThreadExport(app2, reply, params.id, input);
   });
   app2.get("/api/threads/:id/items/:itemId/detail", async (request) => {
-    const params = z6.object({
-      id: z6.string().uuid(),
-      itemId: z6.string().min(1)
+    const params = z5.object({
+      id: z5.string().uuid(),
+      itemId: z5.string().min(1)
     }).parse(request.params);
     return app2.services.threadService.getThreadHistoryItemDetail(
       params.id,
@@ -21198,7 +21671,7 @@ async function registerThreadRoutes(app2) {
     );
   });
   app2.get("/api/threads/:id/assets/image", async (request, reply) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const query = threadImageQuerySchema.parse(request.query);
     const record = getThreadRecordById(app2.services.database.db, params.id);
     if (!record) {
@@ -21244,12 +21717,12 @@ async function registerThreadRoutes(app2) {
     return reply.send(await fs16.readFile(requestedPath));
   });
   app2.patch("/api/threads/:id", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const body = updateThreadSchema.parse(request.body);
     return app2.services.threadService.updateThreadTitle(params.id, body.title);
   });
   app2.delete("/api/threads/:id", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const shell = getShellSessionRecordByThreadId(app2.services.database.db, params.id);
     if (shell) {
       if (shell.status !== "exited" && shell.status !== "not_found") {
@@ -21261,7 +21734,7 @@ async function registerThreadRoutes(app2) {
     return app2.services.threadService.deleteThread(params.id);
   });
   app2.patch("/api/threads/:id/settings", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const body = updateThreadSettingsSchema.parse(request.body);
     const input = {
       ...body.model !== void 0 ? { model: body.model } : {},
@@ -21273,15 +21746,15 @@ async function registerThreadRoutes(app2) {
     return app2.services.threadService.updateThreadSettings(params.id, input);
   });
   app2.post("/api/threads/:id/compact", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     return app2.services.threadService.compactThread(params.id);
   });
   app2.get("/api/threads/:id/goal", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     return { goal: await app2.services.threadService.getThreadGoal(params.id) };
   });
   app2.patch("/api/threads/:id/goal", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const parsedBody = updateThreadGoalSchema.parse(request.body);
     const body = {
       ...parsedBody.objective !== void 0 ? { objective: parsedBody.objective } : {},
@@ -21291,32 +21764,32 @@ async function registerThreadRoutes(app2) {
     return { goal: await app2.services.threadService.updateThreadGoal(params.id, body) };
   });
   app2.delete("/api/threads/:id/goal", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     return app2.services.threadService.clearThreadGoal(params.id);
   });
   app2.get("/api/threads/:id/fork-turns", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     return app2.services.threadService.listForkTurnOptions(params.id);
   });
   app2.post("/api/threads/:id/fork", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const body = forkThreadSchema.parse(request.body);
     return app2.services.threadService.forkThread(params.id, body);
   });
   app2.get("/api/threads/:id/skills", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     return app2.services.threadService.listThreadSkills(params.id);
   });
   app2.get("/api/threads/:id/mcp-servers", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     return app2.services.threadService.listThreadMcpServers(params.id);
   });
   app2.get("/api/threads/:id/hooks", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     return app2.services.threadService.listThreadHooks(params.id);
   });
   app2.post("/api/threads/:id/hooks", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const parsedBody = createThreadHookSchema.parse(request.body);
     const body = {
       scope: parsedBody.scope,
@@ -21329,7 +21802,7 @@ async function registerThreadRoutes(app2) {
     return app2.services.threadService.createThreadHook(params.id, body);
   });
   app2.put("/api/threads/:id/hooks", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const parsedBody = updateThreadHookSchema.parse(request.body);
     const body = {
       scope: parsedBody.scope,
@@ -21350,17 +21823,17 @@ async function registerThreadRoutes(app2) {
     return app2.services.threadService.updateThreadHook(params.id, body);
   });
   app2.post("/api/threads/:id/hooks/trust", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const body = trustThreadHookSchema.parse(request.body);
     return app2.services.threadService.trustThreadHook(params.id, body);
   });
   app2.post("/api/threads/:id/hooks/untrust", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const body = untrustThreadHookSchema.parse(request.body);
     return app2.services.threadService.untrustThreadHook(params.id, body);
   });
   app2.post("/api/threads/:id/resume", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const body = resumeThreadSchema.parse(request.body ?? {});
     const input = {
       ...body.model !== void 0 ? { model: body.model } : {},
@@ -21369,13 +21842,13 @@ async function registerThreadRoutes(app2) {
     return app2.services.threadService.resumeThread(params.id, input);
   });
   app2.post("/api/threads/:id/disconnect", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const detail = await app2.services.threadService.disconnectThread(params.id);
     await app2.services.shellService.detachThreadViewers(params.id);
     return detail;
   });
   app2.post("/api/threads/:id/prompt", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const parsed = request.isMultipart() ? await parseMultipartPromptRequest(request) : {
       input: (() => {
         const parsedBody = promptSchema.parse(request.body);
@@ -21400,15 +21873,15 @@ async function registerThreadRoutes(app2) {
     });
   });
   app2.post("/api/threads/:id/requests/:requestId/respond", async (request) => {
-    const params = z6.object({
-      id: z6.string().uuid(),
-      requestId: z6.string().min(1)
+    const params = z5.object({
+      id: z5.string().uuid(),
+      requestId: z5.string().min(1)
     }).parse(request.params);
     const body = respondThreadRequestSchema.parse(request.body);
     return app2.services.threadService.respondToRequest(params.id, params.requestId, body);
   });
   app2.post("/api/threads/:id/interrupt", async (request) => {
-    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
     const body = interruptSchema.parse(request.body ?? {});
     return app2.services.threadService.interruptThread(params.id, body.turnId);
   });
@@ -21418,27 +21891,46 @@ async function registerThreadRoutes(app2) {
 import fs17 from "fs/promises";
 import path17 from "path";
 import { spawn as spawn3 } from "child_process";
-import { z as z7 } from "zod";
-var createWorkspaceSchema = z7.union([
-  z7.object({
-    absPath: z7.string().min(1),
-    label: z7.string().min(1).optional()
+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()
   }),
-  z7.object({
-    gitUrl: z7.string().min(1),
-    label: z7.string().min(1).optional()
+  z6.object({
+    gitUrl: z6.string().min(1),
+    label: z6.string().min(1).optional()
   })
 ]);
-var updateFavoriteSchema = z7.object({
-  isFavorite: z7.boolean()
+var updateFavoriteSchema = z6.object({
+  isFavorite: z6.boolean()
+});
+var updateWorkspaceSchema = z6.object({
+  label: z6.string().min(1)
 });
-var updateWorkspaceSchema = z7.object({
-  label: z7.string().min(1)
+var treeQuerySchema = z6.object({
+  path: z6.string().optional(),
+  showHidden: z6.coerce.boolean().optional()
 });
-var treeQuerySchema = z7.object({
-  path: z7.string().optional(),
-  showHidden: z7.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()
+});
+var PREVIEW_DEFAULT_LIMIT_BYTES = 5e4;
+var WORKSPACE_UPLOAD_MAX_BYTES = 50 * 1024 * 1024;
+var WORKSPACE_TREE_IGNORED_NAMES = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".next",
+  ".turbo",
+  "dist",
+  "build"
+]);
 function toWorkspaceDto2(record) {
   return {
     id: record.id,
@@ -21450,6 +21942,159 @@ function toWorkspaceDto2(record) {
     lastOpenedAt: record.lastOpenedAt
   };
 }
+function languageForPath(filePath) {
+  const extension = path17.extname(filePath).slice(1).toLowerCase();
+  switch (extension) {
+    case "js":
+    case "jsx":
+      return "javascript";
+    case "ts":
+    case "tsx":
+      return extension;
+    case "md":
+    case "markdown":
+      return "markdown";
+    case "yml":
+      return "yaml";
+    case "sh":
+    case "bash":
+      return "bash";
+    case "py":
+      return "python";
+    case "rb":
+      return "ruby";
+    case "rs":
+      return "rust";
+    case "go":
+      return "go";
+    case "c":
+    case "h":
+      return "c";
+    case "cc":
+    case "cpp":
+    case "cxx":
+    case "hpp":
+      return "cpp";
+    case "html":
+    case "css":
+    case "json":
+    case "jsonl":
+    case "toml":
+    case "xml":
+    case "sql":
+    case "txt":
+      return extension;
+    default:
+      return extension || "text";
+  }
+}
+function relativeWorkspacePath(rootPath, absPath) {
+  const relative = path17.relative(rootPath, absPath);
+  return relative === "" ? "" : relative.split(path17.sep).join("/");
+}
+async function resolveWorkspaceItemPath(rootPath, relativePath = "") {
+  const candidate = path17.resolve(rootPath, relativePath || ".");
+  const comparable = await assertPathWithinRoot(rootPath, candidate);
+  return comparable;
+}
+async function buildWorkspaceTreeNode(rootPath, absPath, depth = 0) {
+  const stats = await fs17.stat(absPath);
+  const relativePath = relativeWorkspacePath(rootPath, absPath);
+  const name = relativePath ? path17.basename(absPath) : path17.basename(rootPath);
+  if (!stats.isDirectory()) {
+    return {
+      name,
+      path: relativePath,
+      kind: "file",
+      size: stats.size
+    };
+  }
+  const node = {
+    name,
+    path: relativePath,
+    kind: "directory",
+    children: []
+  };
+  if (depth >= 6) {
+    return node;
+  }
+  let entries;
+  try {
+    entries = await fs17.readdir(absPath, { withFileTypes: true });
+  } catch {
+    return node;
+  }
+  const visible = entries.filter((entry) => !entry.name.startsWith(".")).filter((entry) => !WORKSPACE_TREE_IGNORED_NAMES.has(entry.name)).sort((left, right) => {
+    if (left.isDirectory() && !right.isDirectory()) {
+      return -1;
+    }
+    if (!left.isDirectory() && right.isDirectory()) {
+      return 1;
+    }
+    return left.name.localeCompare(right.name);
+  }).slice(0, 400);
+  node.children = (await Promise.all(
+    visible.map(async (entry) => {
+      const childPath = path17.join(absPath, entry.name);
+      try {
+        if (!entry.isDirectory() && !entry.isFile()) {
+          return null;
+        }
+        return await buildWorkspaceTreeNode(rootPath, childPath, depth + 1);
+      } catch {
+        return null;
+      }
+    })
+  )).filter((child) => child !== null);
+  return node;
+}
+function requireWorkspaceRecord(app2, workspaceId) {
+  const record = getWorkspaceRecordById(app2.services.database.db, workspaceId);
+  if (!record) {
+    throw new HttpError(404, {
+      code: "not_found",
+      message: "Workspace was not found."
+    });
+  }
+  return record;
+}
+function contentTypeForPath(filePath) {
+  switch (path17.extname(filePath).slice(1).toLowerCase()) {
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "gif":
+      return "image/gif";
+    case "webp":
+      return "image/webp";
+    case "svg":
+      return "image/svg+xml";
+    case "pdf":
+      return "application/pdf";
+    case "json":
+      return "application/json; charset=utf-8";
+    case "html":
+      return "text/html; charset=utf-8";
+    case "css":
+      return "text/css; charset=utf-8";
+    case "js":
+    case "mjs":
+    case "ts":
+    case "tsx":
+      return "text/plain; charset=utf-8";
+    default:
+      return "application/octet-stream";
+  }
+}
+function sanitizeUploadFilename(filename) {
+  const baseName = path17.basename(filename?.trim() || "upload");
+  if (!baseName || baseName === "." || baseName === "..") {
+    return "upload";
+  }
+  return baseName;
+}
 function inferGitRepoName(gitUrl) {
   const trimmed = gitUrl.trim();
   const withoutQuery = trimmed.split(/[?#]/)[0] ?? trimmed;
@@ -21534,7 +22179,7 @@ async function registerWorkspaceRoutes(app2) {
     };
   });
   app2.get("/api/workspaces/:id", async (request) => {
-    const params = z7.object({ id: z7.string().uuid() }).parse(request.params);
+    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
     const record = getWorkspaceRecordById(app2.services.database.db, params.id);
     if (!record) {
       throw new HttpError(404, {
@@ -21544,6 +22189,114 @@ async function registerWorkspaceRoutes(app2) {
     }
     return toWorkspaceDto2(record);
   });
+  app2.get("/api/workspaces/:id/files/tree", async (request) => {
+    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const query = workspaceFileQuerySchema.parse(request.query);
+    const record = requireWorkspaceRecord(app2, params.id);
+    const rootPath = await fs17.realpath(record.absPath);
+    const targetPath = await resolveWorkspaceItemPath(rootPath, query.path);
+    return buildWorkspaceTreeNode(rootPath, targetPath);
+  });
+  app2.get("/api/workspaces/:id/files/preview", async (request) => {
+    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const query = workspacePreviewQuerySchema.parse(request.query);
+    const record = requireWorkspaceRecord(app2, params.id);
+    const rootPath = await fs17.realpath(record.absPath);
+    const filePath = await resolveWorkspaceItemPath(rootPath, query.path);
+    const stats = await fs17.stat(filePath);
+    if (!stats.isFile()) {
+      throw new HttpError(400, {
+        code: "bad_request",
+        message: "Workspace preview path must point to a file."
+      });
+    }
+    const offset = query.offset ?? 0;
+    const limit = query.limit ?? PREVIEW_DEFAULT_LIMIT_BYTES;
+    const handle = await fs17.open(filePath, "r");
+    try {
+      const length = Math.min(limit, Math.max(0, stats.size - offset));
+      const buffer = Buffer.alloc(length);
+      const read = await handle.read(buffer, 0, length, offset);
+      const nextOffset = offset + read.bytesRead;
+      return {
+        path: relativeWorkspacePath(rootPath, filePath),
+        name: path17.basename(filePath),
+        content: buffer.subarray(0, read.bytesRead).toString("utf8"),
+        language: languageForPath(filePath),
+        size: stats.size,
+        truncated: nextOffset < stats.size,
+        nextOffset
+      };
+    } finally {
+      await handle.close();
+    }
+  });
+  app2.get("/api/workspaces/:id/files/raw", async (request, reply) => {
+    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const query = workspacePreviewQuerySchema.pick({ path: true }).parse(request.query);
+    const record = requireWorkspaceRecord(app2, params.id);
+    const rootPath = await fs17.realpath(record.absPath);
+    const filePath = await resolveWorkspaceItemPath(rootPath, query.path);
+    const stats = await fs17.stat(filePath);
+    if (!stats.isFile()) {
+      throw new HttpError(400, {
+        code: "bad_request",
+        message: "Raw workspace path must point to a file."
+      });
+    }
+    reply.header("content-type", contentTypeForPath(filePath));
+    return reply.send(Readable.from(await fs17.readFile(filePath)));
+  });
+  app2.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(app2, params.id);
+    const rootPath = await fs17.realpath(record.absPath);
+    const itemPath = await resolveWorkspaceItemPath(rootPath, query.path);
+    const stats = await fs17.stat(itemPath);
+    if (!stats.isFile()) {
+      throw new HttpError(400, {
+        code: "bad_request",
+        message: "Only file downloads are supported from this endpoint."
+      });
+    }
+    const filename = path17.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 fs17.readFile(itemPath)));
+  });
+  app2.post("/api/workspaces/:id/files/upload", async (request) => {
+    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
+    const record = requireWorkspaceRecord(app2, params.id);
+    const rootPath = await fs17.realpath(record.absPath);
+    const part = await request.file();
+    if (!part) {
+      throw new HttpError(400, {
+        code: "bad_request",
+        message: "A file field is required."
+      });
+    }
+    const buffer = await part.toBuffer();
+    if (buffer.byteLength > WORKSPACE_UPLOAD_MAX_BYTES) {
+      throw new HttpError(400, {
+        code: "bad_request",
+        message: "Workspace uploads must be 50 MB or smaller."
+      });
+    }
+    const filename = sanitizeUploadFilename(part.filename);
+    const destination = await resolveWorkspaceItemPath(rootPath, filename);
+    await fs17.writeFile(destination, buffer);
+    return {
+      kind: "file",
+      file: {
+        path: relativeWorkspacePath(rootPath, destination),
+        name: filename,
+        size: buffer.byteLength
+      }
+    };
+  });
   app2.post("/api/workspaces", async (request) => {
     const body = createWorkspaceSchema.parse(request.body);
     const settings = await getWorkspaceSettings(
@@ -21588,7 +22341,7 @@ async function registerWorkspaceRoutes(app2) {
     return toWorkspaceDto2(created);
   });
   app2.patch("/api/workspaces/:id", async (request) => {
-    const params = z7.object({ id: z7.string().uuid() }).parse(request.params);
+    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
     const body = updateWorkspaceSchema.parse(request.body);
     const record = getWorkspaceRecordById(app2.services.database.db, params.id);
     if (!record) {
@@ -21609,7 +22362,7 @@ async function registerWorkspaceRoutes(app2) {
     return toWorkspaceDto2(updated);
   });
   app2.delete("/api/workspaces/:id", async (request) => {
-    const params = z7.object({ id: z7.string().uuid() }).parse(request.params);
+    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
     const record = getWorkspaceRecordById(app2.services.database.db, params.id);
     if (!record) {
       throw new HttpError(404, {
@@ -21633,7 +22386,7 @@ async function registerWorkspaceRoutes(app2) {
     return { id: params.id };
   });
   app2.post("/api/workspaces/:id/favorite", async (request) => {
-    const params = z7.object({ id: z7.string().uuid() }).parse(request.params);
+    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
     const body = updateFavoriteSchema.parse(request.body);
     const record = getWorkspaceRecordById(app2.services.database.db, params.id);
     if (!record) {
@@ -21647,7 +22400,7 @@ async function registerWorkspaceRoutes(app2) {
     return toWorkspaceDto2(updated);
   });
   app2.post("/api/workspaces/:id/open", async (request) => {
-    const params = z7.object({ id: z7.string().uuid() }).parse(request.params);
+    const params = z6.object({ id: z6.string().uuid() }).parse(request.params);
     const record = getWorkspaceRecordById(app2.services.database.db, params.id);
     if (!record) {
       throw new HttpError(404, {
@@ -21662,21 +22415,32 @@ async function registerWorkspaceRoutes(app2) {
 }
 
 // src/routes/plugins.ts
-import { z as z8 } from "zod";
-var pluginParamsSchema = z8.object({
-  pluginId: z8.string().min(1)
+import { z as z7 } from "zod";
+var pluginParamsSchema = z7.object({
+  pluginId: z7.string().min(1)
 });
-var updatePluginSchema = z8.object({
-  enabled: z8.boolean()
+var updatePluginSchema = z7.object({
+  enabled: z7.boolean()
 });
-var importPluginSchema = z8.object({
-  enabled: z8.boolean().optional(),
-  manifestJson: z8.string().optional(),
-  manifest: z8.unknown().optional()
+var importPluginSchema = z7.object({
+  enabled: z7.boolean().optional(),
+  manifestJson: z7.string().optional(),
+  manifest: z7.unknown().optional()
 }).refine((value) => value.manifest !== void 0 || value.manifestJson !== void 0, {
   message: "Plugin import requires manifest or manifestJson."
 });
 async function registerPluginRoutes(app2) {
+  async function syncManagedPluginMcpConfig() {
+    await app2.services.pluginService.syncManagedCodexMcpConfig({
+      codexHome: app2.services.config.agentProviders.codex.home ?? null,
+      repoRoot: app2.services.repoRoot
+    });
+    const codexRuntime = app2.services.agentRuntimes.getOptional("codex");
+    if (codexRuntime) {
+      await codexRuntime.stop();
+      await codexRuntime.start();
+    }
+  }
   app2.get("/api/plugins", async () => {
     return app2.services.pluginService.listPlugins();
   });
@@ -21688,7 +22452,9 @@ async function registerPluginRoutes(app2) {
       ...parsed.manifestJson === void 0 ? {} : { manifestJson: parsed.manifestJson }
     };
     try {
-      return app2.services.pluginService.importPlugin(body);
+      const plugin = app2.services.pluginService.importPlugin(body);
+      await syncManagedPluginMcpConfig();
+      return plugin;
     } catch (error) {
       if (error instanceof SyntaxError) {
         throw new HttpError(400, {
@@ -21717,7 +22483,9 @@ async function registerPluginRoutes(app2) {
     const { pluginId } = pluginParamsSchema.parse(request.params);
     const body = updatePluginSchema.parse(request.body);
     try {
-      return app2.services.pluginService.setPluginEnabled(pluginId, body.enabled);
+      const plugin = app2.services.pluginService.setPluginEnabled(pluginId, body.enabled);
+      await syncManagedPluginMcpConfig();
+      return plugin;
     } catch {
       throw new HttpError(404, {
         code: "not_found",
@@ -21727,6 +22495,46 @@ async function registerPluginRoutes(app2) {
   });
 }
 
+// src/routes/auth.ts
+import { z as z8 } from "zod";
+var loginSchema = z8.object({
+  username: z8.string().min(1),
+  password: z8.string().min(1)
+});
+async function registerAuthRoutes(app2) {
+  app2.get("/api/auth/session", async (request) => {
+    return app2.services.authService.verifyRequest(request);
+  });
+  app2.post("/api/auth/login", async (request, reply) => {
+    const body = loginSchema.parse(request.body ?? {});
+    const login = app2.services.authService.login(body);
+    if (!login) {
+      reply.status(401).send({
+        code: "unauthorized",
+        message: "Invalid username or password."
+      });
+      return;
+    }
+    if (login.token) {
+      app2.services.authService.attachSessionCookie(reply, login.token);
+    }
+    return {
+      token: login.token,
+      session: login.session
+    };
+  });
+  app2.post("/api/auth/logout", async (_request, reply) => {
+    app2.services.authService.clearSessionCookie(reply);
+    return {
+      authenticated: false,
+      username: null,
+      expiresAt: null,
+      mode: app2.services.authService.mode,
+      authRequired: app2.services.authService.required
+    };
+  });
+}
+
 // src/provider-host-config-service.ts
 import fs18 from "fs/promises";
 import path18 from "path";
@@ -21953,28 +22761,12 @@ var ProviderHostConfigService = class {
 };
 
 // src/shell/shell-session-service.ts
+import fs20 from "fs/promises";
+
+// src/shell/shell-prompt.ts
 import fs19 from "fs/promises";
 import os3 from "os";
 import path19 from "path";
-async function pathExists5(filePath) {
-  try {
-    await fs19.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function waitForShellTick(milliseconds) {
-  if (process.env.VITEST) {
-    return Promise.resolve();
-  }
-  return new Promise((resolve) => {
-    setTimeout(resolve, milliseconds);
-  });
-}
 function basenameFromPath2(filePath) {
   if (!filePath) {
     return "";
@@ -22043,9 +22835,6 @@ function resolveEnvironmentPrefix(environmentText) {
   }
   return null;
 }
-function shellSingleQuote(value) {
-  return `'${value.replace(/'/g, `'\\''`)}'`;
-}
 async function resolvePaneEnvironmentPrefix(tmuxManager, sessionName, panePid) {
   const sessionPrefix = await tmuxManager.getSessionEnvironmentVariable(
     sessionName,
@@ -22061,6 +22850,9 @@ async function resolvePaneEnvironmentPrefix(tmuxManager, sessionName, panePid) {
     return null;
   }
 }
+function shellSingleQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
 function buildShellPromptInitScriptContents(command) {
   const normalized = command.trim().toLowerCase();
   if (normalized === "zsh") {
@@ -22160,6 +22952,26 @@ clear
 ` : `${sourceCommand}
 `;
 }
+
+// src/shell/shell-session-service.ts
+async function pathExists5(filePath) {
+  try {
+    await fs20.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function uniqueShellSessionName(baseName, index) {
+  if (index <= 1) {
+    return baseName;
+  }
+  const suffix = `-${index}`;
+  return `${baseName.slice(0, Math.max(1, 64 - suffix.length))}${suffix}`;
+}
 function shellThreadId(shell) {
   if (!shell.threadId) {
     throw new ShellServiceError(
@@ -22220,25 +23032,25 @@ var ShellServiceError = class extends Error {
   code;
 };
 var ShellSessionService = class {
-  constructor(db, eventBus, tmuxManager) {
+  constructor(db, eventBus, shellBackend) {
     this.db = db;
     this.eventBus = eventBus;
-    this.tmuxManager = tmuxManager;
+    this.shellBackend = shellBackend;
   }
   db;
   eventBus;
-  tmuxManager;
+  shellBackend;
   attachments = /* @__PURE__ */ new Map();
   async stop() {
     for (const [shellId, attachment] of this.attachments) {
-      clearInterval(attachment.pollHandle);
+      attachment.backendAttachment.dispose();
       deleteViewerSessionRecord(this.db, attachment.viewerId);
       this.attachments.delete(shellId);
     }
   }
   async syncShellStateOnStartup() {
     const records = listShellSessionRecords(this.db);
-    const sessionNames = new Set(await this.tmuxManager.listSessionNames());
+    const sessionNames = new Set(await this.shellBackend.listSessionNames());
     for (const record of records) {
       const sessionName = record.tmuxSessionName ?? "";
       const nextStatus = sessionNames.has(sessionName) ? "running" : record.status === "exited" ? "exited" : "not_found";
@@ -22261,23 +23073,33 @@ var ShellSessionService = class {
     if (!workspace) {
       throw new ShellServiceError("thread_not_found", "Workspace not found.");
     }
-    const shell = getShellSessionRecordByThreadId(this.db, threadId);
+    const shells = listShellSessionRecordsByThreadId(this.db, threadId);
     const workspacePathStatus = await pathExists5(workspace.absPath) ? "present" : "missing";
-    if (!shell) {
+    if (shells.length === 0) {
       return {
         threadId: thread.id,
         workspaceId: workspace.id,
         workspacePathStatus,
         state: workspacePathStatus === "missing" ? "workspace_missing" : "not_created",
-        shell: null
+        shell: null,
+        shells: [],
+        activeShellId: null
       };
     }
+    const shellDtos = await Promise.all(
+      shells.map((shell) => this.toShellSessionDto(shell.id))
+    );
+    const activeShell = shellDtos.find((shell) => shell.status === "attached") ?? shellDtos.find(
+      (shell) => shell.status !== "exited" && shell.status !== "not_found"
+    ) ?? shellDtos[0] ?? null;
     return {
       threadId: thread.id,
       workspaceId: workspace.id,
       workspacePathStatus,
-      state: await this.resolveShellState(shell.id),
-      shell: await this.toShellSessionDto(shell.id)
+      state: activeShell ? activeShell.status : "not_created",
+      shell: activeShell,
+      shells: shellDtos,
+      activeShellId: activeShell?.id ?? null
     };
   }
   async createShellForThread(threadId, options = {}) {
@@ -22301,26 +23123,21 @@ var ShellSessionService = class {
         "Workspace path is missing on this machine."
       );
     }
-    const tmuxSessionName = this.tmuxManager.sessionNameForThread(thread.id);
-    const existing = getShellSessionRecordByThreadId(this.db, threadId);
-    if (existing) {
-      const canRevive = existing.status === "exited" || existing.status === "not_found";
-      if (!canRevive) {
-        throw new ShellServiceError(
-          "shell_exists",
-          "A durable shell already exists for this thread."
-        );
-      }
-      updateShellSessionRecord(this.db, existing.id, {
-        tmuxSessionName,
-        cwd: workspace.absPath,
-        status: "creating",
-        lastActivityAt: nowIso()
-      });
+    const baseSessionName = this.shellBackend.sessionNameForThread(thread.id);
+    const existingShells = listShellSessionRecordsByThreadId(this.db, threadId);
+    const existingSessionNames = new Set(
+      existingShells.map((shell) => shell.tmuxSessionName).filter((name) => Boolean(name))
+    );
+    let sessionIndex = existingShells.length + 1;
+    let tmuxSessionName = uniqueShellSessionName(baseSessionName, sessionIndex);
+    while (existingSessionNames.has(tmuxSessionName) || await this.shellBackend.hasSession(tmuxSessionName)) {
+      sessionIndex += 1;
+      tmuxSessionName = uniqueShellSessionName(baseSessionName, sessionIndex);
     }
-    const record = existing ?? createShellSessionRecord(this.db, {
+    const record = createShellSessionRecord(this.db, {
       workspaceId: workspace.id,
       threadId: thread.id,
+      label: options.label ?? null,
       tmuxSessionName,
       cwd: workspace.absPath,
       status: "creating"
@@ -22330,27 +23147,15 @@ var ShellSessionService = class {
       state: "creating"
     });
     try {
-      const existingSession = await this.tmuxManager.hasSession(tmuxSessionName);
+      const existingSession = await this.shellBackend.hasSession(tmuxSessionName);
       if (!existingSession) {
-        await this.tmuxManager.createSession({
-          sessionName: tmuxSessionName,
+        await this.shellBackend.createSession({
+          sessionId: tmuxSessionName,
+          threadId: thread.id,
           cwd: workspace.absPath,
           ...options.cols !== void 0 ? { cols: options.cols } : {},
           ...options.rows !== void 0 ? { rows: options.rows } : {}
         });
-        try {
-          const runtime = await this.tmuxManager.getPaneRuntimeInfo(tmuxSessionName);
-          if (isInteractiveShellCommand(runtime.currentCommand)) {
-            await this.tmuxManager.sendInput(
-              tmuxSessionName,
-              await buildShellPromptInitCommand(runtime.currentCommand, {
-                clearScreen: true
-              })
-            );
-            await waitForShellTick(120);
-          }
-        } catch {
-        }
       }
       updateShellSessionRecord(this.db, record.id, {
         status: "running",
@@ -22361,7 +23166,7 @@ var ShellSessionService = class {
         status: "not_found"
       });
       throw new ShellServiceError(
-        "tmux_error",
+        "shell_backend_error",
         error instanceof Error ? error.message : "Unable to start shell."
       );
     }
@@ -22369,7 +23174,32 @@ var ShellSessionService = class {
       threadId: thread.id,
       state: "detached"
     });
-    return this.getThreadShellState(threadId);
+    const state = await this.getThreadShellState(threadId);
+    const createdShell = await this.toShellSessionDto(record.id);
+    return {
+      ...state,
+      state: createdShell.status,
+      shell: createdShell,
+      activeShellId: createdShell.id
+    };
+  }
+  async updateShell(shellId, input) {
+    const shell = getShellSessionRecordById(this.db, shellId);
+    if (!shell) {
+      throw new ShellServiceError("shell_not_found", "Shell not found.");
+    }
+    const updates = {};
+    if ("label" in input) {
+      const label = input.label?.trim() ?? "";
+      updates.label = label.length > 0 ? label : null;
+    }
+    updateShellSessionRecord(this.db, shell.id, updates);
+    const shellDto = await this.toShellSessionDto(shell.id);
+    this.emitShellEvent(shell.id, "shell.status", {
+      threadId: shellThreadId(shell),
+      state: shellDto.status
+    });
+    return shellDto;
   }
   async detachThreadViewers(threadId) {
     const shell = getShellSessionRecordByThreadId(this.db, threadId);
@@ -22381,7 +23211,7 @@ var ShellSessionService = class {
       deleteViewerSessionsByThreadId(this.db, threadId);
       return;
     }
-    clearInterval(attachment.pollHandle);
+    attachment.backendAttachment.dispose();
     deleteViewerSessionRecord(this.db, attachment.viewerId);
     deleteViewerSessionsByThreadId(this.db, threadId);
     this.attachments.delete(shell.id);
@@ -22404,7 +23234,7 @@ var ShellSessionService = class {
     const existingViewer = getViewerSessionRecordByShellId(this.db, shell.id);
     const existingAttachment = this.attachments.get(shell.id);
     if (existingAttachment) {
-      clearInterval(existingAttachment.pollHandle);
+      existingAttachment.backendAttachment.dispose();
       deleteViewerSessionRecord(this.db, existingAttachment.viewerId);
       this.attachments.delete(shell.id);
       this.emitShellEvent(shell.id, "shell.detached", {
@@ -22416,7 +23246,7 @@ var ShellSessionService = class {
     } else if (existingViewer) {
       deleteViewerSessionRecord(this.db, existingViewer.id);
     }
-    const hasSession = await this.tmuxManager.hasSession(shellSessionName(shell));
+    const hasSession = await this.shellBackend.hasSession(shellSessionName(shell));
     if (!hasSession) {
       updateShellSessionRecord(this.db, shell.id, {
         status: "not_found"
@@ -22427,7 +23257,7 @@ var ShellSessionService = class {
       });
       throw new ShellServiceError(
         "shell_not_running",
-        "The durable shell is no longer available."
+        "The terminal is no longer available."
       );
     }
     const viewer = createViewerSessionRecord(this.db, {
@@ -22435,31 +23265,52 @@ var ShellSessionService = class {
       shellId: shell.id,
       activeTab: "shell"
     });
-    await this.tmuxManager.resizeWindow(
-      shellSessionName(shell),
-      options.cols,
-      options.rows
-    );
-    const initialSnapshot = await this.tmuxManager.capturePane(shellSessionName(shell));
-    const initialRuntime = await this.tmuxManager.getPaneRuntimeInfo(
-      shellSessionName(shell)
-    );
+    const attached = await this.shellBackend.attach(shellSessionName(shell), {
+      cols: options.cols,
+      rows: options.rows,
+      onData: (data, session, backendOptions) => {
+        updateShellSessionRecord(this.db, shell.id, {
+          lastActivityAt: nowIso()
+        });
+        updateViewerSessionRecord(this.db, viewer.id, {
+          lastHeartbeatAt: nowIso(),
+          activeTab: "shell"
+        });
+        options.onData(
+          data,
+          shellOutputOptions({
+            replace: backendOptions?.replace === true,
+            cursorX: session.runtime.cursorX,
+            cursorY: session.runtime.cursorY,
+            paneHeight: session.runtime.paneHeight,
+            cwdBaseName: basenameFromPath2(session.runtime.currentPath || shell.cwd),
+            envPrefix: session.runtime.envPrefix ?? void 0,
+            isCommandRunning: session.runtime.isCommandRunning
+          })
+        );
+      },
+      onExit: () => {
+        void this.handleMissingShell(shell, viewer.id);
+      }
+    });
+    const initialSnapshot = attached.session.snapshot;
+    const initialRuntime = attached.session.runtime;
     const initialCwdBaseName = basenameFromPath2(initialRuntime.currentPath || shell.cwd);
-    const initialEnvPrefix = await resolvePaneEnvironmentPrefix(
-      this.tmuxManager,
-      shellSessionName(shell),
-      initialRuntime.panePid
-    );
     const attachment = {
       viewerId: viewer.id,
       onData: options.onData,
-      pollHandle: setInterval(() => {
-        void this.pollAttachment(shell.id);
-      }, 250),
-      lastSnapshot: initialSnapshot,
-      polling: false
+      backendAttachment: attached.attachment
     };
     this.attachments.set(shell.id, attachment);
+    updateShellSessionRecord(this.db, shell.id, {
+      status: "running",
+      lastActivityAt: nowIso()
+    });
+    const shellDto = await this.toShellSessionDto(shell.id);
+    options.onConnected?.({
+      viewerId: viewer.id,
+      shell: shellDto
+    });
     if (initialSnapshot) {
       options.onData(
         initialSnapshot,
@@ -22469,17 +23320,11 @@ var ShellSessionService = class {
           cursorY: initialRuntime.cursorY,
           paneHeight: initialRuntime.paneHeight,
           cwdBaseName: initialCwdBaseName,
-          envPrefix: initialEnvPrefix ?? void 0,
-          isCommandRunning: !isInteractiveShellCommand(
-            initialRuntime.currentCommand
-          )
+          envPrefix: initialRuntime.envPrefix ?? void 0,
+          isCommandRunning: initialRuntime.isCommandRunning
         })
       );
     }
-    updateShellSessionRecord(this.db, shell.id, {
-      status: "running",
-      lastActivityAt: nowIso()
-    });
     this.emitShellEvent(shell.id, "shell.status", {
       threadId,
       state: "attached",
@@ -22487,7 +23332,7 @@ var ShellSessionService = class {
     });
     return {
       viewerId: viewer.id,
-      shell: await this.toShellSessionDto(shell.id)
+      shell: shellDto
     };
   }
   async detachShell(shellId, viewerId) {
@@ -22508,7 +23353,7 @@ var ShellSessionService = class {
         "This browser session does not own the shell attachment."
       );
     }
-    clearInterval(attachment.pollHandle);
+    attachment.backendAttachment.dispose();
     deleteViewerSessionRecord(this.db, viewerId);
     this.attachments.delete(shell.id);
     updateShellSessionRecord(this.db, shell.id, {
@@ -22523,7 +23368,7 @@ var ShellSessionService = class {
   }
   async sendInput(shellId, viewerId, data) {
     const { shell } = this.requireOwnedAttachment(shellId, viewerId);
-    await this.tmuxManager.sendInput(shellSessionName(shell), data);
+    await this.shellBackend.sendInput(shellSessionName(shell), data);
     updateShellSessionRecord(this.db, shellId, {
       lastActivityAt: nowIso()
     });
@@ -22535,10 +23380,7 @@ var ShellSessionService = class {
   async clearShell(shellId, viewerId) {
     const { shell, attachment } = this.requireOwnedAttachment(shellId, viewerId);
     const sessionName = shellSessionName(shell);
-    await this.tmuxManager.sendInput(sessionName, "\f");
-    await waitForShellTick(60);
-    await this.tmuxManager.clearHistory(sessionName);
-    await waitForShellTick(60);
+    const session = await this.shellBackend.clear(sessionName);
     updateShellSessionRecord(this.db, shellId, {
       lastActivityAt: nowIso()
     });
@@ -22546,7 +23388,18 @@ var ShellSessionService = class {
       lastHeartbeatAt: nowIso(),
       activeTab: "shell"
     });
-    await this.pushSnapshot(shell, attachment);
+    attachment.onData(
+      session.snapshot,
+      shellOutputOptions({
+        replace: true,
+        cursorX: session.runtime.cursorX,
+        cursorY: session.runtime.cursorY,
+        paneHeight: session.runtime.paneHeight,
+        cwdBaseName: basenameFromPath2(session.runtime.currentPath || shell.cwd),
+        envPrefix: session.runtime.envPrefix ?? void 0,
+        isCommandRunning: session.runtime.isCommandRunning
+      })
+    );
   }
   async resizeShell(shellId, viewerId, cols, rows) {
     const shell = getShellSessionRecordById(this.db, shellId);
@@ -22566,7 +23419,7 @@ var ShellSessionService = class {
         "This browser session does not own the shell attachment."
       );
     }
-    await this.tmuxManager.resizeWindow(shellSessionName(shell), cols, rows);
+    await this.shellBackend.resize(shellSessionName(shell), cols, rows);
     updateViewerSessionRecord(this.db, viewerId, {
       lastHeartbeatAt: nowIso(),
       activeTab: "shell"
@@ -22579,11 +23432,11 @@ var ShellSessionService = class {
     }
     const attachment = this.attachments.get(shell.id);
     if (attachment) {
-      clearInterval(attachment.pollHandle);
+      attachment.backendAttachment.dispose();
       deleteViewerSessionRecord(this.db, attachment.viewerId);
       this.attachments.delete(shell.id);
     }
-    await this.tmuxManager.killSession(shellSessionName(shell));
+    await this.shellBackend.killSession(shellSessionName(shell));
     updateShellSessionRecord(this.db, shell.id, {
       status: "exited",
       lastActivityAt: nowIso()
@@ -22605,7 +23458,9 @@ var ShellSessionService = class {
       id: shell.id,
       threadId: shellThreadId(shell),
       workspaceId: shell.workspaceId,
+      label: shell.label ?? null,
       tmuxSessionName: shellSessionName(shell),
+      backend: this.shellBackend.kind,
       cwd: shell.cwd,
       status: shellDtoStatus(shell.status, status),
       attachedViewerId: this.attachments.get(shell.id)?.viewerId ?? null,
@@ -22631,31 +23486,7 @@ var ShellSessionService = class {
     const attachment = this.attachments.get(shell.id);
     return attachment ? "attached" : "detached";
   }
-  async pollAttachment(shellId) {
-    const attachment = this.attachments.get(shellId);
-    if (!attachment || attachment.polling) {
-      return;
-    }
-    attachment.polling = true;
-    const shell = getShellSessionRecordById(this.db, shellId);
-    if (!shell) {
-      clearInterval(attachment.pollHandle);
-      this.attachments.delete(shellId);
-      deleteViewerSessionRecord(this.db, attachment.viewerId);
-      return;
-    }
-    try {
-      const hasSession = await this.tmuxManager.hasSession(shellSessionName(shell));
-      if (!hasSession) {
-        await this.handleMissingShell(shell, attachment.viewerId);
-        return;
-      }
-      await this.pushSnapshot(shell, attachment);
-    } finally {
-      attachment.polling = false;
-    }
-  }
-  requireOwnedAttachment(shellId, viewerId) {
+  requireOwnedAttachment(shellId, viewerId) {
     const shell = getShellSessionRecordById(this.db, shellId);
     if (!shell) {
       throw new ShellServiceError("shell_not_found", "Shell not found.");
@@ -22675,42 +23506,10 @@ var ShellSessionService = class {
     }
     return { shell, attachment };
   }
-  async pushSnapshot(shell, attachment) {
-    const sessionName = shellSessionName(shell);
-    const snapshot = await this.tmuxManager.capturePane(sessionName);
-    const runtime = await this.tmuxManager.getPaneRuntimeInfo(sessionName);
-    if (snapshot === attachment.lastSnapshot) {
-      return;
-    }
-    attachment.lastSnapshot = snapshot;
-    updateShellSessionRecord(this.db, shell.id, {
-      lastActivityAt: nowIso()
-    });
-    updateViewerSessionRecord(this.db, attachment.viewerId, {
-      lastHeartbeatAt: nowIso(),
-      activeTab: "shell"
-    });
-    attachment.onData(
-      snapshot,
-      shellOutputOptions({
-        replace: true,
-        cursorX: runtime.cursorX,
-        cursorY: runtime.cursorY,
-        paneHeight: runtime.paneHeight,
-        cwdBaseName: basenameFromPath2(runtime.currentPath || shell.cwd),
-        envPrefix: await resolvePaneEnvironmentPrefix(
-          this.tmuxManager,
-          sessionName,
-          runtime.panePid
-        ) ?? void 0,
-        isCommandRunning: !isInteractiveShellCommand(runtime.currentCommand)
-      })
-    );
-  }
   async handleMissingShell(shell, viewerId) {
     const attachment = this.attachments.get(shell.id);
     if (attachment) {
-      clearInterval(attachment.pollHandle);
+      attachment.backendAttachment.dispose();
       this.attachments.delete(shell.id);
     }
     deleteViewerSessionRecord(this.db, viewerId);
@@ -22733,9 +23532,695 @@ var ShellSessionService = class {
   }
 };
 
+// ../../packages/plugin-terminal/src/manifest.ts
+var TERMINAL_PLUGIN_ID = "remote-codex.terminal";
+var terminalPluginManifest = {
+  id: TERMINAL_PLUGIN_ID,
+  name: "Terminal",
+  version: "0.1.0",
+  description: "Built-in durable terminal panel backed by the supervisor PTY host.",
+  remoteCodex: "^0.11.0",
+  capabilities: {
+    artifactTypes: [],
+    timelineRenderers: [],
+    threadPanels: [
+      {
+        id: "terminal",
+        label: "Terminal",
+        kind: "terminal",
+        artifactTypes: []
+      }
+    ],
+    frontend: {
+      entry: "./dist/index.js"
+    },
+    backend: {
+      entry: "./dist/backend.js"
+    }
+  }
+};
+
+// ../../packages/plugin-xyz-viewer/src/manifest.ts
+var XYZ_MOLECULE_ARTIFACT_TYPE = "chemistry.molecule3d";
+var xyzViewerPluginManifest = {
+  id: "remote-codex.xyz-viewer",
+  name: "XYZ Molecule Viewer",
+  version: "0.1.0",
+  description: "A draft built-in plugin for previewing xyz, extxyz, cif, and pdb molecular structures with 3Dmol.js.",
+  remoteCodex: "^0.11.0",
+  capabilities: {
+    artifactTypes: [
+      {
+        type: XYZ_MOLECULE_ARTIFACT_TYPE,
+        title: "3D Molecule",
+        fileExtensions: ["xyz", "extxyz", "cif", "pdb"]
+      }
+    ],
+    timelineRenderers: [XYZ_MOLECULE_ARTIFACT_TYPE],
+    threadPanels: [
+      {
+        id: "xyz-viewer",
+        label: "Molecules",
+        artifactTypes: [XYZ_MOLECULE_ARTIFACT_TYPE]
+      }
+    ],
+    modelHints: [
+      {
+        id: "render-molecule",
+        text: "XYZ Molecule Viewer is enabled. When outputting a molecular structure, you must call remote_codex_render_molecule; do not output plain xyz, pdb, cif, or extxyz text. Do not invent coordinates unless asked for an example."
+      }
+    ],
+    mcpServers: [
+      {
+        id: "remote-codex-plugin-mcp",
+        name: "remote_codex_plugins",
+        command: "node",
+        args: ["bin/remote-codex-plugin-mcp.mjs"]
+      }
+    ],
+    frontend: {
+      entry: "./dist/index.js",
+      style: "./src/styles.css"
+    }
+  }
+};
+
+// src/plugins/builtin-plugins.ts
+var builtinPlugins = [
+  {
+    manifest: terminalPluginManifest,
+    enabledByDefault: true
+  },
+  {
+    manifest: xyzViewerPluginManifest,
+    enabledByDefault: true
+  }
+];
+
+// src/plugins/plugin-service.ts
+import fs21 from "fs/promises";
+import path20 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";
+function jsonString(value) {
+  return JSON.stringify(value);
+}
+function normalizeManagedCommand(server, repoRoot) {
+  if (server.name === "remote_codex_plugins") {
+    return {
+      command: process.execPath,
+      args: [path20.join(repoRoot, "bin", "remote-codex-plugin-mcp.mjs")]
+    };
+  }
+  return {
+    command: server.command,
+    args: server.args ?? []
+  };
+}
+function stripManagedCodexMcpBlock(content) {
+  const pattern = new RegExp(
+    `\\n?${MANAGED_CODEX_MCP_BEGIN.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${MANAGED_CODEX_MCP_END.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`,
+    "g"
+  );
+  return content.replace(pattern, "\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+}
+function stripCodexMcpServerTables(content, serverNames) {
+  const names = new Set(serverNames);
+  if (names.size === 0) {
+    return content.trimEnd();
+  }
+  const output = [];
+  let current = [];
+  let shouldDropCurrentTable = false;
+  function flushCurrent() {
+    if (!shouldDropCurrentTable) {
+      output.push(...current);
+    }
+    current = [];
+    shouldDropCurrentTable = false;
+  }
+  for (const line of content.split("\n")) {
+    const tableMatch = line.match(/^\s*\[([^\]]+)\]\s*$/);
+    if (tableMatch) {
+      flushCurrent();
+      const tablePath = tableMatch[1] ?? "";
+      shouldDropCurrentTable = [...names].some(
+        (name) => tablePath === `mcp_servers.${name}` || tablePath.startsWith(`mcp_servers.${name}.`)
+      );
+    }
+    current.push(line);
+  }
+  flushCurrent();
+  return output.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+}
+function buildManagedCodexMcpBlock(servers, repoRoot) {
+  if (servers.length === 0) {
+    return "";
+  }
+  const lines = [
+    MANAGED_CODEX_MCP_BEGIN,
+    "# This block is generated from enabled Remote Codex plugins."
+  ];
+  for (const server of servers) {
+    const normalized = normalizeManagedCommand(server, repoRoot);
+    lines.push(
+      "",
+      `[mcp_servers.${server.name}]`,
+      `command = ${jsonString(normalized.command)}`,
+      `args = ${JSON.stringify(normalized.args)}`
+    );
+    const envEntries = Object.entries(server.env ?? {});
+    if (envEntries.length > 0) {
+      lines.push(`[mcp_servers.${server.name}.env]`);
+      for (const [key, value] of envEntries) {
+        lines.push(`${key} = ${jsonString(value)}`);
+      }
+    }
+  }
+  lines.push(MANAGED_CODEX_MCP_END);
+  return lines.join("\n");
+}
+function upsertManagedCodexMcpBlock(content, servers, repoRoot, managedServerNames = servers.map((server) => server.name)) {
+  const stripped = stripCodexMcpServerTables(
+    stripManagedCodexMcpBlock(content),
+    managedServerNames
+  );
+  const managedBlock = buildManagedCodexMcpBlock(servers, repoRoot);
+  if (!managedBlock) {
+    return stripped ? `${stripped}
+` : "";
+  }
+  return `${stripped ? `${stripped}
+
+` : ""}${managedBlock}
+`;
+}
+var PluginService = class {
+  constructor(registry, settingsStore) {
+    this.registry = registry;
+    this.settingsStore = settingsStore;
+    this.loadPersistedSettings();
+  }
+  registry;
+  settingsStore;
+  settings = {
+    enabled: {},
+    imported: []
+  };
+  listPlugins() {
+    return this.registry.list();
+  }
+  getPlugin(pluginId) {
+    return this.registry.get(pluginId);
+  }
+  setPluginEnabled(pluginId, enabled) {
+    const plugin = this.registry.setEnabled(pluginId, enabled);
+    this.settings.enabled[pluginId] = enabled;
+    this.persistSettings();
+    return plugin;
+  }
+  modelContextPrompt() {
+    const hints = this.registry.enabledManifests().flatMap(
+      (manifest) => manifest.capabilities.modelHints ?? []
+    );
+    const text2 = hints.map((hint) => hint.text.trim()).filter(Boolean).join("\n");
+    return text2 || null;
+  }
+  enabledMcpServers() {
+    const byName = /* @__PURE__ */ new Map();
+    for (const manifest of this.registry.enabledManifests()) {
+      for (const server of manifest.capabilities.mcpServers ?? []) {
+        const existing = byName.get(server.name);
+        if (existing) {
+          byName.set(server.name, {
+            ...existing,
+            env: {
+              ...existing.env ?? {},
+              ...server.env ?? {}
+            },
+            pluginIds: [...existing.pluginIds, manifest.id]
+          });
+        } else {
+          byName.set(server.name, {
+            ...server,
+            pluginIds: [manifest.id]
+          });
+        }
+      }
+    }
+    return [...byName.values()].map(({ pluginIds, ...server }) => ({
+      ...server,
+      env: {
+        ...server.env ?? {},
+        REMOTE_CODEX_ENABLED_PLUGIN_IDS: [...new Set(pluginIds)].sort().join(",")
+      }
+    }));
+  }
+  managedMcpServerNames() {
+    return [
+      ...new Set(
+        this.registry.list().flatMap(
+          (plugin) => (plugin.capabilities.mcpServers ?? []).map((server) => server.name)
+        )
+      )
+    ].sort();
+  }
+  async syncManagedCodexMcpConfig(input) {
+    if (!input.codexHome) {
+      return;
+    }
+    const configPath = path20.join(input.codexHome, "config.toml");
+    let current = "";
+    try {
+      current = await fs21.readFile(configPath, "utf8");
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const next = upsertManagedCodexMcpBlock(
+      current,
+      this.enabledMcpServers(),
+      input.repoRoot,
+      this.managedMcpServerNames()
+    );
+    if (next === current) {
+      return;
+    }
+    await fs21.mkdir(path20.dirname(configPath), { recursive: true });
+    await fs21.writeFile(configPath, next, "utf8");
+  }
+  importPlugin(input) {
+    const manifestInput = input.manifest ?? this.parseManifestJson(input.manifestJson);
+    const manifest = parsePluginManifest(manifestInput);
+    const enabled = input.enabled ?? true;
+    const existing = this.registry.getRegistered(manifest.id);
+    if (existing && existing.source !== "imported") {
+      throw new Error(`Built-in plugin cannot be replaced: ${manifest.id}`);
+    }
+    this.registerImportedManifest(manifest, enabled);
+    const existingIndex = this.settings.imported.findIndex(
+      (entry) => entry.id === manifest.id
+    );
+    if (existingIndex >= 0) {
+      this.settings.imported[existingIndex] = manifest;
+    } else {
+      this.settings.imported.push(manifest);
+    }
+    this.settings.enabled[manifest.id] = enabled;
+    this.persistSettings();
+    const plugin = this.registry.get(manifest.id);
+    if (!plugin) {
+      throw new Error(`Plugin import failed: ${manifest.id}`);
+    }
+    return plugin;
+  }
+  enrichTurnsWithArtifacts(input) {
+    const manifests = this.registry.enabledManifests();
+    if (manifests.length === 0) {
+      return input.turns;
+    }
+    const turnsForExtraction = input.deferredDetails ? materializeDeferredDetailsForArtifactExtraction(
+      input.turns,
+      input.deferredDetails
+    ) : input.turns;
+    const enrichedTurns = appendArtifactItemsToTurns(
+      turnsForExtraction,
+      new ManifestArtifactExtractor(manifests),
+      {
+        threadId: input.threadId,
+        workspacePath: input.workspacePath,
+        now: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    );
+    return turnsForExtraction === input.turns ? enrichedTurns : restoreOriginalNonArtifactItems(enrichedTurns, input.turns);
+  }
+  loadPersistedSettings() {
+    if (!this.settingsStore) {
+      return;
+    }
+    this.settings = this.settingsStore.load();
+    for (const manifest of this.settings.imported) {
+      this.registerImportedManifest(
+        manifest,
+        this.settings.enabled[manifest.id] ?? true
+      );
+    }
+    for (const [pluginId, enabled] of Object.entries(this.settings.enabled)) {
+      if (this.registry.get(pluginId)) {
+        this.registry.setEnabled(pluginId, enabled);
+      }
+    }
+  }
+  registerImportedManifest(manifest, enabled) {
+    if (this.registry.get(manifest.id)) {
+      const existing = this.registry.getRegistered(manifest.id);
+      if (existing?.source === "imported") {
+        this.registry.updateImported({
+          manifest,
+          enabledByDefault: enabled,
+          source: "imported"
+        });
+      } else {
+        this.registry.setEnabled(manifest.id, enabled);
+      }
+      return;
+    }
+    this.registry.register({
+      manifest,
+      enabledByDefault: enabled,
+      source: "imported"
+    });
+  }
+  persistSettings() {
+    this.settingsStore?.save(this.settings);
+  }
+  parseManifestJson(manifestJson) {
+    if (!manifestJson?.trim()) {
+      throw new Error("Plugin import requires a manifest object or manifestJson string.");
+    }
+    return JSON.parse(manifestJson);
+  }
+};
+function restoreOriginalNonArtifactItems(enrichedTurns, originalTurns) {
+  const originalItemsByTurnId = new Map(
+    originalTurns.map((turn) => [
+      turn.id,
+      new Map(turn.items.map((item) => [item.id, item]))
+    ])
+  );
+  return enrichedTurns.map((turn) => {
+    const originalItems = originalItemsByTurnId.get(turn.id);
+    if (!originalItems) {
+      return turn;
+    }
+    return {
+      ...turn,
+      items: turn.items.map(
+        (item) => item.kind === "artifact" ? item : originalItems.get(item.id) ?? item
+      )
+    };
+  });
+}
+function materializeDeferredDetailsForArtifactExtraction(turns, deferredDetails) {
+  if (deferredDetails.size === 0) {
+    return turns;
+  }
+  return turns.map((turn) => {
+    let changed = false;
+    const items = turn.items.map((item) => {
+      if (!item.hasDeferredDetail || item.detailText || item.kind !== "toolCall" || ![item.text, item.previewText].some(
+        (value) => typeof value === "string" && value.includes(REMOTE_CODEX_MOLECULE_MCP_TOOL_NAME)
+      )) {
+        return item;
+      }
+      const detail = deferredDetails.get(item.id);
+      if (!detail?.text) {
+        return item;
+      }
+      changed = true;
+      return {
+        ...item,
+        detailText: detail.text
+      };
+    });
+    return changed ? {
+      ...turn,
+      items
+    } : turn;
+  });
+}
+
+// src/plugins/plugin-settings-store.ts
+var PLUGIN_SETTINGS_POLICY_KEY = "plugins";
+function emptySettings() {
+  return {
+    enabled: {},
+    imported: []
+  };
+}
+function parseEnabled(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  const output = {};
+  for (const [key, enabled] of Object.entries(value)) {
+    if (typeof enabled === "boolean") {
+      output[key] = enabled;
+    } else if (enabled && typeof enabled === "object" && !Array.isArray(enabled) && typeof enabled.enabled === "boolean") {
+      output[key] = enabled.enabled;
+    }
+  }
+  return output;
+}
+var PluginSettingsStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  load() {
+    const record = getPolicyRecordByKey(this.db, PLUGIN_SETTINGS_POLICY_KEY);
+    if (!record?.valueJson) {
+      return emptySettings();
+    }
+    try {
+      const parsed = JSON.parse(record.valueJson);
+      return {
+        enabled: parseEnabled(parsed.enabled),
+        imported: Array.isArray(parsed.imported) ? parsed.imported.map((entry) => parsePluginManifest(entry)) : []
+      };
+    } catch {
+      return emptySettings();
+    }
+  }
+  save(settings) {
+    upsertPolicyRecord(
+      this.db,
+      PLUGIN_SETTINGS_POLICY_KEY,
+      JSON.stringify({
+        enabled: settings.enabled,
+        imported: settings.imported
+      })
+    );
+  }
+};
+
+// src/plugins/backend-plugin-host.ts
+var BackendPluginHost = class {
+  constructor(app2) {
+    this.app = app2;
+  }
+  app;
+  socketHandlers = [];
+  registerSocketHandler(handler) {
+    this.socketHandlers.push(handler);
+  }
+  register(contribution) {
+    contribution.registerHttp?.(this.app);
+    contribution.registerSocket?.(this);
+  }
+  async handleSocketMessage(context) {
+    for (const handler of this.socketHandlers) {
+      if (await handler(context)) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/shell/pty-shell-backend.ts
+import path21 from "path";
+import { spawn as spawn4 } from "@homebridge/node-pty-prebuilt-multiarch";
+
+// src/shell/default-shell.ts
+import fs22 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 && fs22.existsSync(env.SHELL)) {
+    return env.SHELL;
+  }
+  return POSIX_SHELL_CANDIDATES.find((candidate) => fs22.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 = path21.basename(shell).toLowerCase();
+  if (process.platform === "win32") {
+    return [];
+  }
+  if (shellName === "bash" || shellName === "zsh" || shellName === "sh") {
+    return ["-l"];
+  }
+  return [];
+}
+function trimScrollback(value) {
+  if (value.length <= MAX_SCROLLBACK_BYTES) {
+    return value;
+  }
+  return value.slice(value.length - MAX_SCROLLBACK_BYTES);
+}
+function lastVisibleLine(snapshot) {
+  const normalized = snapshot.replace(ANSI_ESCAPE_PATTERN, "");
+  const lines = normalized.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  return lines.findLast((line) => line.trim().length > 0) ?? "";
+}
+function inferRuntime(session) {
+  const promptLine = lastVisibleLine(session.scrollback);
+  const shell = path21.basename(session.shell);
+  const isCommandRunning = session.exitCode !== null ? false : !/[$#>]\s*$/.test(promptLine.trimEnd());
+  return {
+    panePid: session.pty.pid,
+    paneWidth: session.pty.cols,
+    paneHeight: session.pty.rows,
+    currentCommand: isCommandRunning ? session.pty.process : shell,
+    currentPath: session.cwd,
+    isCommandRunning
+  };
+}
+var PtyShellBackend = class {
+  kind = "pty";
+  sessions = /* @__PURE__ */ new Map();
+  shell = resolveDefaultShell();
+  sessionNameForThread(threadId) {
+    return `rcx-${threadId.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 28)}`;
+  }
+  async listSessionNames() {
+    return [...this.sessions.keys()];
+  }
+  async hasSession(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  async createSession(input) {
+    if (this.sessions.has(input.sessionId)) {
+      return;
+    }
+    const pty = spawn4(this.shell, shellArgs(this.shell), {
+      name: "xterm-256color",
+      cwd: input.cwd,
+      cols: input.cols ?? 120,
+      rows: input.rows ?? 36,
+      env: {
+        ...process.env,
+        TERM: "xterm-256color",
+        COLORTERM: process.env.COLORTERM ?? "truecolor"
+      },
+      handleFlowControl: true
+    });
+    const session = {
+      id: input.sessionId,
+      cwd: input.cwd,
+      shell: this.shell,
+      pty,
+      scrollback: "",
+      exitCode: null,
+      listeners: /* @__PURE__ */ new Set(),
+      exitListeners: /* @__PURE__ */ new Set(),
+      dataSubscription: { dispose() {
+      } },
+      exitSubscription: { dispose() {
+      } }
+    };
+    session.dataSubscription = pty.onData((data) => {
+      session.scrollback = trimScrollback(session.scrollback + data);
+      for (const listener of session.listeners) {
+        listener(data);
+      }
+    });
+    session.exitSubscription = pty.onExit(() => {
+      session.exitCode = 0;
+      this.sessions.delete(session.id);
+      for (const listener of session.exitListeners) {
+        listener();
+      }
+      session.dataSubscription.dispose();
+      session.exitSubscription.dispose();
+    });
+    this.sessions.set(input.sessionId, session);
+  }
+  async attach(sessionId, options) {
+    const session = this.requireSession(sessionId);
+    this.resizeIfChanged(session, options.cols, options.rows);
+    const onData = (data) => options.onData(data, this.toBackendSession(session));
+    const onExit = () => options.onExit();
+    session.listeners.add(onData);
+    session.exitListeners.add(onExit);
+    return {
+      session: this.toBackendSession(session),
+      attachment: {
+        dispose: () => {
+          session.listeners.delete(onData);
+          session.exitListeners.delete(onExit);
+        }
+      }
+    };
+  }
+  async sendInput(sessionId, data) {
+    this.requireSession(sessionId).pty.write(data);
+  }
+  async clear(sessionId) {
+    const session = this.requireSession(sessionId);
+    session.scrollback = "";
+    session.pty.clear();
+    session.pty.write("\f");
+    return this.toBackendSession(session);
+  }
+  async resize(sessionId, cols, rows) {
+    this.resizeIfChanged(this.requireSession(sessionId), cols, rows);
+  }
+  async snapshot(sessionId) {
+    return this.toBackendSession(this.requireSession(sessionId));
+  }
+  async killSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return;
+    }
+    session.dataSubscription.dispose();
+    session.exitSubscription.dispose();
+    this.sessions.delete(sessionId);
+    try {
+      session.pty.kill();
+    } catch {
+    }
+  }
+  requireSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error("Shell session is no longer available.");
+    }
+    return session;
+  }
+  resizeIfChanged(session, cols, rows) {
+    if (cols <= 0 || rows <= 0) {
+      return;
+    }
+    if (session.pty.cols === cols && session.pty.rows === rows) {
+      return;
+    }
+    session.pty.resize(cols, rows);
+  }
+  toBackendSession(session) {
+    return {
+      id: session.id,
+      cwd: session.cwd,
+      cols: session.pty.cols,
+      rows: session.pty.rows,
+      snapshot: session.scrollback,
+      runtime: inferRuntime(session)
+    };
+  }
+};
+
 // src/shell/tmux-manager.ts
-import fs20 from "fs";
-import path20 from "path";
+import fs23 from "fs";
+import path22 from "path";
 import { spawn as spawnChild } from "child_process";
 async function defaultExecCommand(command, args) {
   return await new Promise((resolve, reject) => {
@@ -22762,17 +24247,17 @@ async function defaultExecCommand(command, args) {
   });
 }
 function resolveExecutablePath(command) {
-  if (command.includes(path20.sep)) {
+  if (command.includes(path22.sep)) {
     return command;
   }
   const searchPath = process.env.PATH ?? "";
-  for (const entry of searchPath.split(path20.delimiter)) {
+  for (const entry of searchPath.split(path22.delimiter)) {
     const trimmed = entry.trim();
     if (!trimmed) {
       continue;
     }
-    const candidate = path20.join(trimmed, command);
-    if (fs20.existsSync(candidate)) {
+    const candidate = path22.join(trimmed, command);
+    if (fs23.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -22784,7 +24269,7 @@ var TmuxManager = class {
   execCommand;
   constructor(options = {}) {
     this.command = resolveExecutablePath(options.command ?? "tmux");
-    this.defaultShell = options.defaultShell ?? process.env.SHELL ?? "/bin/zsh";
+    this.defaultShell = options.defaultShell ?? resolveDefaultShell();
     this.execCommand = options.execCommand ?? defaultExecCommand;
   }
   sessionNameForThread(threadId) {
@@ -23087,215 +24572,740 @@ function tokenizeTmuxInput(data) {
   return tokens;
 }
 
-// ../../packages/plugin-xyz-viewer/src/manifest.ts
-var XYZ_MOLECULE_ARTIFACT_TYPE = "chemistry.molecule3d";
-var xyzViewerPluginManifest = {
-  id: "remote-codex.xyz-viewer",
-  name: "XYZ Molecule Viewer",
-  version: "0.1.0",
-  description: "A draft built-in plugin for previewing xyz, extxyz, cif, and pdb molecular structures with 3Dmol.js.",
-  remoteCodex: "^0.11.0",
-  capabilities: {
-    artifactTypes: [
-      {
-        type: XYZ_MOLECULE_ARTIFACT_TYPE,
-        title: "3D Molecule",
-        fileExtensions: ["xyz", "extxyz", "cif", "pdb"]
-      }
-    ],
-    timelineRenderers: [XYZ_MOLECULE_ARTIFACT_TYPE],
-    threadPanels: [
-      {
-        id: "xyz-viewer",
-        label: "Molecules",
-        artifactTypes: [XYZ_MOLECULE_ARTIFACT_TYPE]
+// src/shell/tmux-shell-backend.ts
+var TmuxShellBackend = class {
+  constructor(tmuxManager = new TmuxManager()) {
+    this.tmuxManager = tmuxManager;
+  }
+  tmuxManager;
+  kind = "tmux";
+  attachments = /* @__PURE__ */ new Map();
+  sessionNameForThread(threadId) {
+    return this.tmuxManager.sessionNameForThread(threadId);
+  }
+  listSessionNames() {
+    return this.tmuxManager.listSessionNames();
+  }
+  hasSession(sessionId) {
+    return this.tmuxManager.hasSession(sessionId);
+  }
+  async createSession(input) {
+    await this.tmuxManager.createSession({
+      sessionName: input.sessionId,
+      cwd: input.cwd,
+      ...input.cols !== void 0 ? { cols: input.cols } : {},
+      ...input.rows !== void 0 ? { rows: input.rows } : {}
+    });
+    try {
+      const runtime = await this.tmuxManager.getPaneRuntimeInfo(input.sessionId);
+      if (isInteractiveShellCommand(runtime.currentCommand)) {
+        await this.tmuxManager.sendInput(
+          input.sessionId,
+          await buildShellPromptInitCommand(runtime.currentCommand, {
+            clearScreen: true
+          })
+        );
       }
-    ],
-    frontend: {
-      entry: "./dist/index.js",
-      style: "./src/styles.css"
+    } catch {
     }
   }
-};
-
-// src/plugins/builtin-plugins.ts
-var builtinPlugins = [
-  {
-    manifest: xyzViewerPluginManifest,
-    enabledByDefault: true
+  async attach(sessionId, options) {
+    const previous = this.attachments.get(sessionId);
+    if (previous) {
+      previous.disposed = true;
+      clearInterval(previous.pollHandle);
+      this.attachments.delete(sessionId);
+    }
+    await this.tmuxManager.resizeWindow(sessionId, options.cols, options.rows);
+    const session = await this.snapshot(sessionId);
+    const attachment = {
+      disposed: false,
+      lastSnapshot: session.snapshot,
+      polling: false,
+      pollHandle: setInterval(() => {
+        void this.poll(sessionId, attachment, options);
+      }, 250)
+    };
+    this.attachments.set(sessionId, attachment);
+    return {
+      session,
+      attachment: {
+        dispose: () => {
+          attachment.disposed = true;
+          clearInterval(attachment.pollHandle);
+          if (this.attachments.get(sessionId) === attachment) {
+            this.attachments.delete(sessionId);
+          }
+        }
+      }
+    };
   }
-];
-
-// src/plugins/plugin-service.ts
-var PluginService = class {
-  constructor(registry, settingsStore) {
-    this.registry = registry;
-    this.settingsStore = settingsStore;
-    this.loadPersistedSettings();
+  sendInput(sessionId, data) {
+    return this.tmuxManager.sendInput(sessionId, data);
   }
-  registry;
-  settingsStore;
-  settings = {
-    enabled: {},
-    imported: []
-  };
-  listPlugins() {
-    return this.registry.list();
+  async clear(sessionId) {
+    await this.tmuxManager.sendInput(sessionId, "\f");
+    await this.tmuxManager.clearHistory(sessionId);
+    const session = await this.snapshot(sessionId);
+    const attachment = this.attachments.get(sessionId);
+    if (attachment) {
+      attachment.lastSnapshot = session.snapshot;
+    }
+    return session;
   }
-  getPlugin(pluginId) {
-    return this.registry.get(pluginId);
+  resize(sessionId, cols, rows) {
+    return this.tmuxManager.resizeWindow(sessionId, cols, rows);
   }
-  setPluginEnabled(pluginId, enabled) {
-    const plugin = this.registry.setEnabled(pluginId, enabled);
-    this.settings.enabled[pluginId] = enabled;
-    this.persistSettings();
-    return plugin;
+  async snapshot(sessionId) {
+    const snapshot = await this.tmuxManager.capturePane(sessionId);
+    const runtime = await this.tmuxManager.getPaneRuntimeInfo(sessionId);
+    const envPrefix = await resolvePaneEnvironmentPrefix(
+      this.tmuxManager,
+      sessionId,
+      runtime.panePid
+    );
+    return {
+      id: sessionId,
+      cwd: runtime.currentPath,
+      cols: runtime.paneWidth,
+      rows: runtime.paneHeight,
+      snapshot,
+      runtime: {
+        cursorX: runtime.cursorX,
+        cursorY: runtime.cursorY,
+        paneWidth: runtime.paneWidth,
+        paneHeight: runtime.paneHeight,
+        panePid: runtime.panePid,
+        currentCommand: runtime.currentCommand,
+        currentPath: runtime.currentPath,
+        envPrefix,
+        isCommandRunning: !isInteractiveShellCommand(runtime.currentCommand)
+      }
+    };
   }
-  importPlugin(input) {
-    const manifestInput = input.manifest ?? this.parseManifestJson(input.manifestJson);
-    const manifest = parsePluginManifest(manifestInput);
-    const enabled = input.enabled ?? true;
-    const existing = this.registry.getRegistered(manifest.id);
-    if (existing && existing.source !== "imported") {
-      throw new Error(`Built-in plugin cannot be replaced: ${manifest.id}`);
+  killSession(sessionId) {
+    const attachment = this.attachments.get(sessionId);
+    if (attachment) {
+      attachment.disposed = true;
+      clearInterval(attachment.pollHandle);
+      this.attachments.delete(sessionId);
     }
-    this.registerImportedManifest(manifest, enabled);
-    const existingIndex = this.settings.imported.findIndex(
-      (entry) => entry.id === manifest.id
+    return this.tmuxManager.killSession(sessionId);
+  }
+  async poll(sessionId, attachment, options) {
+    if (attachment.disposed || attachment.polling) {
+      return;
+    }
+    attachment.polling = true;
+    try {
+      const exists2 = await this.hasSession(sessionId);
+      if (!exists2) {
+        attachment.disposed = true;
+        clearInterval(attachment.pollHandle);
+        this.attachments.delete(sessionId);
+        options.onExit();
+        return;
+      }
+      const session = await this.snapshot(sessionId);
+      if (session.snapshot !== attachment.lastSnapshot) {
+        attachment.lastSnapshot = session.snapshot;
+        options.onData(session.snapshot, session, { replace: true });
+      }
+    } catch {
+      attachment.disposed = true;
+      clearInterval(attachment.pollHandle);
+      this.attachments.delete(sessionId);
+      options.onExit();
+    } finally {
+      attachment.polling = false;
+    }
+  }
+};
+
+// src/routes/shells.ts
+import { z as z9 } from "zod";
+async function registerShellRoutes(app2, options = {}) {
+  const threadIdParams = z9.object({ id: z9.string().uuid() });
+  const shellIdParams = z9.object({ id: z9.string().uuid() });
+  const createShellSchema = z9.object({
+    cols: z9.number().int().positive().optional(),
+    rows: z9.number().int().positive().optional(),
+    label: z9.string().trim().min(1).max(80).optional()
+  });
+  const updateShellSchema = z9.object({
+    label: z9.string().trim().min(1).max(80).nullable().optional()
+  });
+  const routeOptions = options.preHandler ? { preHandler: options.preHandler } : {};
+  app2.get("/api/threads/:id/shell", routeOptions, async (request) => {
+    const params = threadIdParams.parse(request.params);
+    return app2.services.shellService.getThreadShellState(params.id);
+  });
+  app2.post("/api/threads/:id/shell", routeOptions, async (request) => {
+    const params = threadIdParams.parse(request.params);
+    const body = createShellSchema.parse(request.body ?? {});
+    const input = {
+      ...body.cols !== void 0 ? { cols: body.cols } : {},
+      ...body.rows !== void 0 ? { rows: body.rows } : {},
+      ...body.label !== void 0 ? { label: body.label } : {}
+    };
+    return app2.services.shellService.createShellForThread(params.id, input);
+  });
+  app2.post("/api/shells/:id/terminate", routeOptions, async (request) => {
+    const params = shellIdParams.parse(request.params);
+    return app2.services.shellService.terminateShell(params.id);
+  });
+  app2.patch("/api/shells/:id", routeOptions, async (request) => {
+    const params = shellIdParams.parse(request.params);
+    const body = updateShellSchema.parse(request.body ?? {});
+    const input = {
+      ..."label" in body ? { label: body.label ?? null } : {}
+    };
+    return app2.services.shellService.updateShell(params.id, input);
+  });
+}
+
+// src/plugins/terminal-plugin-backend.ts
+function createTerminalShellBackend(env = process.env) {
+  return env.REMOTE_CODEX_SHELL_BACKEND === "tmux" ? new TmuxShellBackend() : new PtyShellBackend();
+}
+function isTerminalPluginEnabled(app2) {
+  return app2.services.pluginService.getPlugin(TERMINAL_PLUGIN_ID)?.enabled === true;
+}
+function requireTerminalPluginEnabled(app2) {
+  if (!isTerminalPluginEnabled(app2)) {
+    throw new ShellServiceError(
+      "plugin_disabled",
+      "The Terminal plugin is disabled."
     );
-    if (existingIndex >= 0) {
-      this.settings.imported[existingIndex] = manifest;
-    } else {
-      this.settings.imported.push(manifest);
+  }
+}
+function registerTerminalPluginBackend(app2) {
+  app2.register(registerShellRoutes, {
+    preHandler: async () => {
+      requireTerminalPluginEnabled(app2);
     }
-    this.settings.enabled[manifest.id] = enabled;
-    this.persistSettings();
-    const plugin = this.registry.get(manifest.id);
-    if (!plugin) {
-      throw new Error(`Plugin import failed: ${manifest.id}`);
+  });
+}
+function createTerminalPluginBackendContribution() {
+  return {
+    pluginId: TERMINAL_PLUGIN_ID,
+    registerHttp: registerTerminalPluginBackend,
+    registerSocket(host2) {
+      host2.registerSocketHandler(createTerminalSocketHandler());
     }
-    return plugin;
+  };
+}
+function createTerminalSocketHandler() {
+  return async (context) => {
+    const { app: app2, message, send } = context;
+    const shellService = app2.services.shellService;
+    const stateKey = `${TERMINAL_PLUGIN_ID}:attached-shell`;
+    const cleanupRegisteredKey = `${TERMINAL_PLUGIN_ID}:cleanup-registered`;
+    const getAttachedShell = () => context.state.get(stateKey);
+    const setAttachedShell = (value) => {
+      if (value) {
+        context.state.set(stateKey, value);
+      } else {
+        context.state.delete(stateKey);
+      }
+    };
+    try {
+      if (message.type === "shell.attach") {
+        requireTerminalPluginEnabled(app2);
+        const attachedShell = getAttachedShell();
+        if (attachedShell && attachedShell.shellId !== message.shellId) {
+          await shellService.detachShell(
+            attachedShell.shellId,
+            attachedShell.viewerId
+          );
+          setAttachedShell(null);
+        }
+        const attachment = await shellService.attachShell(message.shellId, {
+          cols: message.cols,
+          rows: message.rows,
+          onConnected: (connected) => {
+            setAttachedShell({
+              shellId: message.shellId,
+              viewerId: connected.viewerId
+            });
+            send({
+              type: "shell.connected",
+              shellId: message.shellId,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              payload: {
+                viewerId: connected.viewerId
+              }
+            });
+            send({
+              type: "shell.status",
+              shellId: message.shellId,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              payload: {
+                threadId: connected.shell.threadId,
+                state: "attached",
+                viewerId: connected.viewerId
+              }
+            });
+          },
+          onData: (data, options) => {
+            send({
+              type: "shell.output",
+              shellId: message.shellId,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              payload: {
+                data,
+                ...options?.replace ? { replace: true } : {},
+                ...options?.cursorX !== void 0 ? { cursorX: options.cursorX } : {},
+                ...options?.cursorY !== void 0 ? { cursorY: options.cursorY } : {},
+                ...options?.paneHeight !== void 0 ? { paneHeight: options.paneHeight } : {},
+                ...options?.cwdBaseName !== void 0 ? { cwdBaseName: options.cwdBaseName } : {},
+                ...options?.envPrefix !== void 0 ? { envPrefix: options.envPrefix } : {},
+                ...options?.isCommandRunning !== void 0 ? { isCommandRunning: options.isCommandRunning } : {}
+              }
+            });
+          }
+        });
+        if (!getAttachedShell()) {
+          setAttachedShell({
+            shellId: message.shellId,
+            viewerId: attachment.viewerId
+          });
+        }
+        if (context.state.get(cleanupRegisteredKey) !== true) {
+          context.state.set(cleanupRegisteredKey, true);
+          context.onClose(() => {
+            const attached = getAttachedShell();
+            if (attached) {
+              void shellService.detachShell(attached.shellId, attached.viewerId).catch(() => {
+              });
+              setAttachedShell(null);
+            }
+          });
+        }
+        return true;
+      }
+      if (message.type === "shell.detach") {
+        requireTerminalPluginEnabled(app2);
+        await shellService.detachShell(message.shellId, message.viewerId);
+        const attachedShell = getAttachedShell();
+        if (attachedShell?.shellId === message.shellId && attachedShell.viewerId === message.viewerId) {
+          setAttachedShell(null);
+        }
+        return true;
+      }
+      if (message.type === "shell.input") {
+        requireTerminalPluginEnabled(app2);
+        await shellService.sendInput(
+          message.shellId,
+          message.viewerId,
+          message.data
+        );
+        return true;
+      }
+      if (message.type === "shell.resize") {
+        requireTerminalPluginEnabled(app2);
+        await shellService.resizeShell(
+          message.shellId,
+          message.viewerId,
+          message.cols,
+          message.rows
+        );
+        return true;
+      }
+      if (message.type === "shell.clear") {
+        requireTerminalPluginEnabled(app2);
+        await shellService.clearShell(message.shellId, message.viewerId);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      if ("shellId" in message) {
+        send(makeShellErrorEnvelope(message.shellId, error));
+        return true;
+      }
+      throw error;
+    }
+  };
+}
+function makeShellErrorEnvelope(shellId, error) {
+  if (error instanceof ShellServiceError) {
+    return {
+      type: "shell.error",
+      shellId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: {
+        code: error.code,
+        message: error.message
+      }
+    };
   }
-  enrichTurnsWithArtifacts(input) {
-    const manifests = this.registry.enabledManifests();
-    if (manifests.length === 0) {
-      return input.turns;
+  return {
+    type: "shell.error",
+    shellId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    payload: {
+      code: "unknown",
+      message: error instanceof Error ? error.message : "Unexpected shell error."
     }
-    return appendArtifactItemsToTurns(
-      input.turns,
-      new ManifestArtifactExtractor(manifests),
-      {
-        threadId: input.threadId,
-        workspacePath: input.workspacePath,
-        now: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/auth.ts
+import crypto2 from "crypto";
+var AUTH_COOKIE_NAME = "remote_codex_session";
+var AuthService = class {
+  required;
+  mode;
+  username;
+  password;
+  secret;
+  sessionTtlSeconds;
+  constructor(config) {
+    this.mode = config.mode;
+    this.required = config.mode === "server" || config.mode === "relay";
+    this.username = config.auth.adminUsername;
+    this.password = config.auth.adminPassword;
+    this.secret = config.auth.sessionSecret;
+    this.sessionTtlSeconds = config.auth.sessionTtlSeconds;
+    if (this.required) {
+      const missing = [
+        this.username ? null : "REMOTE_CODEX_ADMIN_USERNAME",
+        this.password ? null : "REMOTE_CODEX_ADMIN_PASSWORD",
+        this.secret ? null : "REMOTE_CODEX_SESSION_SECRET"
+      ].filter(Boolean);
+      if (missing.length > 0) {
+        throw new Error(
+          `${config.mode} mode requires auth configuration: ${missing.join(", ")}.`
+        );
       }
-    );
+    }
   }
-  loadPersistedSettings() {
-    if (!this.settingsStore) {
-      return;
+  login(input) {
+    if (!this.required) {
+      return {
+        token: null,
+        session: {
+          authenticated: true,
+          username: null,
+          expiresAt: null,
+          mode: this.mode,
+          authRequired: false
+        }
+      };
     }
-    this.settings = this.settingsStore.load();
-    for (const manifest of this.settings.imported) {
-      this.registerImportedManifest(
-        manifest,
-        this.settings.enabled[manifest.id] ?? true
-      );
+    if (!this.username || !this.password || !this.secret) {
+      return null;
     }
-    for (const [pluginId, enabled] of Object.entries(this.settings.enabled)) {
-      if (this.registry.get(pluginId)) {
-        this.registry.setEnabled(pluginId, enabled);
-      }
+    if (!constantTimeEqual(input.username, this.username) || !constantTimeEqual(input.password, this.password)) {
+      return null;
     }
+    return this.createSession(this.username);
   }
-  registerImportedManifest(manifest, enabled) {
-    if (this.registry.get(manifest.id)) {
-      const existing = this.registry.getRegistered(manifest.id);
-      if (existing?.source === "imported") {
-        this.registry.updateImported({
-          manifest,
-          enabledByDefault: enabled,
-          source: "imported"
-        });
-      } else {
-        this.registry.setEnabled(manifest.id, enabled);
-      }
-      return;
+  verifyRequest(request) {
+    if (!this.required) {
+      return {
+        authenticated: true,
+        username: null,
+        expiresAt: null,
+        mode: this.mode,
+        authRequired: false
+      };
     }
-    this.registry.register({
-      manifest,
-      enabledByDefault: enabled,
-      source: "imported"
-    });
+    const token = readBearerToken(request) ?? readQueryToken(request) ?? readCookieToken(request);
+    if (!token || !this.secret) {
+      return unauthenticatedSession(this.mode);
+    }
+    return this.verifyToken(token);
   }
-  persistSettings() {
-    this.settingsStore?.save(this.settings);
+  attachSessionCookie(reply, token) {
+    reply.header(
+      "set-cookie",
+      `${AUTH_COOKIE_NAME}=${encodeURIComponent(token)}; HttpOnly; SameSite=Lax; Path=/; Max-Age=${this.sessionTtlSeconds}`
+    );
   }
-  parseManifestJson(manifestJson) {
-    if (!manifestJson?.trim()) {
-      throw new Error("Plugin import requires a manifest object or manifestJson string.");
+  clearSessionCookie(reply) {
+    reply.header(
+      "set-cookie",
+      `${AUTH_COOKIE_NAME}=; HttpOnly; SameSite=Lax; Path=/; Max-Age=0`
+    );
+  }
+  createSession(username) {
+    const expiresAtMs = Date.now() + this.sessionTtlSeconds * 1e3;
+    const payload = {
+      username,
+      expiresAt: expiresAtMs,
+      nonce: crypto2.randomBytes(16).toString("base64url")
+    };
+    const payloadText = Buffer.from(JSON.stringify(payload), "utf8").toString(
+      "base64url"
+    );
+    const signature = this.sign(payloadText);
+    return {
+      token: `${payloadText}.${signature}`,
+      session: {
+        authenticated: true,
+        username,
+        expiresAt: new Date(expiresAtMs).toISOString(),
+        mode: this.mode,
+        authRequired: this.required
+      }
+    };
+  }
+  verifyToken(token) {
+    const [payloadText, signature, extra] = token.split(".");
+    if (!payloadText || !signature || extra !== void 0) {
+      return unauthenticatedSession(this.mode);
     }
-    return JSON.parse(manifestJson);
+    if (!constantTimeEqual(signature, this.sign(payloadText))) {
+      return unauthenticatedSession(this.mode);
+    }
+    let payload;
+    try {
+      payload = JSON.parse(
+        Buffer.from(payloadText, "base64url").toString("utf8")
+      );
+    } catch {
+      return unauthenticatedSession(this.mode);
+    }
+    if (!isSessionPayload(payload)) {
+      return unauthenticatedSession(this.mode);
+    }
+    if (payload.expiresAt <= Date.now()) {
+      return unauthenticatedSession(this.mode);
+    }
+    return {
+      authenticated: true,
+      username: payload.username,
+      expiresAt: new Date(payload.expiresAt).toISOString(),
+      mode: this.mode,
+      authRequired: this.required
+    };
+  }
+  sign(payloadText) {
+    return crypto2.createHmac("sha256", this.secret ?? "").update(payloadText).digest("base64url");
   }
 };
-
-// src/plugins/plugin-settings-store.ts
-var PLUGIN_SETTINGS_POLICY_KEY = "plugins";
-function emptySettings() {
+function unauthorizedPayload() {
   return {
-    enabled: {},
-    imported: []
+    code: "unauthorized",
+    message: "Authentication is required."
   };
 }
-function parseEnabled(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return {};
+function readBearerToken(request) {
+  const authorization = request.headers.authorization;
+  if (!authorization) {
+    return null;
   }
-  const output = {};
-  for (const [key, enabled] of Object.entries(value)) {
-    if (typeof enabled === "boolean") {
-      output[key] = enabled;
-    } else if (enabled && typeof enabled === "object" && !Array.isArray(enabled) && typeof enabled.enabled === "boolean") {
-      output[key] = enabled.enabled;
+  const match = /^Bearer\s+(.+)$/i.exec(authorization);
+  return match ? match[1].trim() : null;
+}
+function readCookieToken(request) {
+  const cookie = request.headers.cookie;
+  if (!cookie) {
+    return null;
+  }
+  const entries = cookie.split(";");
+  for (const entry of entries) {
+    const [name, ...valueParts] = entry.trim().split("=");
+    if (name === AUTH_COOKIE_NAME) {
+      return decodeURIComponent(valueParts.join("="));
     }
   }
-  return output;
+  return null;
 }
-var PluginSettingsStore = class {
-  constructor(db) {
-    this.db = db;
+function readQueryToken(request) {
+  const query = request.query;
+  if (!query || typeof query !== "object" || !("token" in query)) {
+    return null;
   }
-  db;
-  load() {
-    const record = getPolicyRecordByKey(this.db, PLUGIN_SETTINGS_POLICY_KEY);
-    if (!record?.valueJson) {
-      return emptySettings();
+  const token = query.token;
+  return typeof token === "string" && token.trim() ? token.trim() : null;
+}
+function unauthenticatedSession(mode) {
+  return {
+    authenticated: false,
+    username: null,
+    expiresAt: null,
+    mode,
+    authRequired: mode === "server" || mode === "relay"
+  };
+}
+function isSessionPayload(value) {
+  return typeof value === "object" && value !== null && "username" in value && typeof value.username === "string" && "expiresAt" in value && typeof value.expiresAt === "number" && "nonce" in value && typeof value.nonce === "string";
+}
+function constantTimeEqual(left, right) {
+  const leftBuffer = Buffer.from(left);
+  const rightBuffer = Buffer.from(right);
+  if (leftBuffer.length !== rightBuffer.length) {
+    return false;
+  }
+  return crypto2.timingSafeEqual(leftBuffer, rightBuffer);
+}
+
+// src/relay-tunnel-client.ts
+var RELAY_HEARTBEAT_INTERVAL_MS = 3e4;
+var RELAY_RECONNECT_INITIAL_DELAY_MS = 1e3;
+var RELAY_RECONNECT_MAX_DELAY_MS = 3e4;
+var RelayTunnelClient = class {
+  constructor(config, handleRequest, handleClientConnected, handleClientMessage) {
+    this.config = config;
+    this.handleRequest = handleRequest;
+    this.handleClientConnected = handleClientConnected;
+    this.handleClientMessage = handleClientMessage;
+  }
+  config;
+  handleRequest;
+  handleClientConnected;
+  handleClientMessage;
+  socket = null;
+  heartbeatHandle = null;
+  reconnectHandle = null;
+  reconnectDelayMs = RELAY_RECONNECT_INITIAL_DELAY_MS;
+  stopped = false;
+  relayClientCleanup = /* @__PURE__ */ new Map();
+  validateConfig() {
+    if (!this.config.serverUrl || !this.config.agentToken) {
+      throw new Error(
+        "Relay mode requires REMOTE_CODEX_RELAY_SERVER_URL and REMOTE_CODEX_RELAY_AGENT_TOKEN."
+      );
+    }
+  }
+  start() {
+    this.validateConfig();
+    this.stopped = false;
+    this.clearReconnect();
+    if (this.socket) {
+      return;
+    }
+    const url = new URL("/supervisor/tunnel", this.config.serverUrl ?? void 0);
+    url.searchParams.set("token", this.config.agentToken ?? "");
+    url.searchParams.set("deviceToken", this.config.agentToken ?? "");
+    this.socket = new WebSocket(url);
+    this.socket.addEventListener("open", () => {
+      this.reconnectDelayMs = RELAY_RECONNECT_INITIAL_DELAY_MS;
+      this.sendHeartbeat();
+      this.heartbeatHandle = setInterval(() => {
+        this.sendHeartbeat();
+      }, RELAY_HEARTBEAT_INTERVAL_MS);
+    });
+    this.socket.addEventListener("close", () => {
+      this.clearHeartbeat();
+      this.cleanupRelayClients();
+      this.socket = null;
+      this.scheduleReconnect();
+    });
+    this.socket.addEventListener("message", (event) => {
+      void this.handleMessage(String(event.data));
+    });
+  }
+  stop() {
+    this.stopped = true;
+    this.clearHeartbeat();
+    this.clearReconnect();
+    this.cleanupRelayClients();
+    this.socket?.close();
+    this.socket = null;
+  }
+  sendHeartbeat() {
+    if (this.socket?.readyState !== WebSocket.OPEN) {
+      return;
     }
+    this.socket.send(
+      JSON.stringify({
+        type: "relay.heartbeat",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
+  async handleMessage(rawMessage) {
+    let parsed;
     try {
-      const parsed = JSON.parse(record.valueJson);
-      return {
-        enabled: parseEnabled(parsed.enabled),
-        imported: Array.isArray(parsed.imported) ? parsed.imported.map((entry) => parsePluginManifest(entry)) : []
-      };
+      parsed = JSON.parse(rawMessage);
     } catch {
-      return emptySettings();
+      return;
+    }
+    if (parsed.type !== "relay.request") {
+      if (parsed.type === "relay.client.connected") {
+        const cleanup = this.handleClientConnected(parsed.clientId, (message) => {
+          this.sendClientMessage(parsed.clientId, message);
+        });
+        this.relayClientCleanup.set(parsed.clientId, cleanup);
+        return;
+      }
+      if (parsed.type === "relay.client.disconnected") {
+        this.relayClientCleanup.get(parsed.clientId)?.();
+        this.relayClientCleanup.delete(parsed.clientId);
+        return;
+      }
+      if (parsed.type === "relay.client.message") {
+        await this.handleClientMessage(parsed.clientId, parsed.payload, (message) => {
+          this.sendClientMessage(parsed.clientId, message);
+        });
+        return;
+      }
+      return;
     }
+    const response = await this.handleRequest(parsed.payload);
+    this.socket?.send(
+      JSON.stringify({
+        type: "relay.response",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId: parsed.requestId,
+        payload: response
+      })
+    );
   }
-  save(settings) {
-    upsertPolicyRecord(
-      this.db,
-      PLUGIN_SETTINGS_POLICY_KEY,
+  sendClientMessage(clientId, message) {
+    if (this.socket?.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    this.socket.send(
       JSON.stringify({
-        enabled: settings.enabled,
-        imported: settings.imported
+        type: "relay.server.message",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        clientId,
+        payload: message
       })
     );
   }
+  clearHeartbeat() {
+    if (this.heartbeatHandle) {
+      clearInterval(this.heartbeatHandle);
+      this.heartbeatHandle = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.stopped || this.reconnectHandle) {
+      return;
+    }
+    const delayMs = this.reconnectDelayMs;
+    this.reconnectDelayMs = Math.min(
+      this.reconnectDelayMs * 2,
+      RELAY_RECONNECT_MAX_DELAY_MS
+    );
+    this.reconnectHandle = setTimeout(() => {
+      this.reconnectHandle = null;
+      this.start();
+    }, delayMs);
+  }
+  clearReconnect() {
+    if (this.reconnectHandle) {
+      clearTimeout(this.reconnectHandle);
+      this.reconnectHandle = null;
+    }
+  }
+  cleanupRelayClients() {
+    for (const [clientId, cleanup] of this.relayClientCleanup) {
+      cleanup();
+      this.relayClientCleanup.delete(clientId);
+    }
+  }
 };
 
 // src/app.ts
 var MAX_PROMPT_ATTACHMENTS2 = 10;
 var MAX_PROMPT_ATTACHMENT_BYTES2 = 25 * 1024 * 1024;
+var RELAY_FORWARD_HEADER = "x-remote-codex-relay-forwarded";
 var HttpError = class extends Error {
   constructor(statusCode, payload) {
     super(payload.message);
@@ -23307,16 +25317,16 @@ var HttpError = class extends Error {
 };
 function findRepoRoot(start = process.cwd()) {
   if (process.env.REMOTE_CODEX_REPO_ROOT) {
-    return path21.resolve(process.env.REMOTE_CODEX_REPO_ROOT);
+    return path23.resolve(process.env.REMOTE_CODEX_REPO_ROOT);
   }
-  let current = path21.resolve(start);
-  while (current !== path21.dirname(current)) {
-    if (fs21.existsSync(path21.join(current, "pnpm-workspace.yaml")) && fs21.existsSync(path21.join(current, "scripts", "service-restart.mjs"))) {
+  let current = path23.resolve(start);
+  while (current !== path23.dirname(current)) {
+    if (fs24.existsSync(path23.join(current, "pnpm-workspace.yaml")) && fs24.existsSync(path23.join(current, "scripts", "service-restart.mjs"))) {
       return current;
     }
-    current = path21.dirname(current);
+    current = path23.dirname(current);
   }
-  return path21.resolve(process.cwd());
+  return path23.resolve(process.cwd());
 }
 function createServiceLifecycle() {
   return {
@@ -23328,14 +25338,14 @@ function createServiceLifecycle() {
         });
       }
       const repoRoot = findRepoRoot();
-      const restartScript = path21.join(repoRoot, "scripts", "service-restart.mjs");
-      if (!fs21.existsSync(restartScript) || !fs21.existsSync(path21.join(repoRoot, "pnpm-workspace.yaml"))) {
+      const restartScript = path23.join(repoRoot, "scripts", "service-restart.mjs");
+      if (!fs24.existsSync(restartScript) || !fs24.existsSync(path23.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."
         });
       }
-      const child = spawn4(process.execPath, [restartScript, "launch"], {
+      const child = spawn5(process.execPath, [restartScript, "launch"], {
         cwd: repoRoot,
         detached: true,
         env: process.env,
@@ -23355,7 +25365,9 @@ function buildApp(options = {}) {
   const pluginRegistry = new PluginRegistry(builtinPlugins);
   const pluginSettingsStore = new PluginSettingsStore(database.db);
   const pluginService = new PluginService(pluginRegistry, pluginSettingsStore);
+  const authService = new AuthService(config);
   const runtimeBootstrap = options.runtimeBootstrap ?? createAgentRuntimeBootstrap(config);
+  const repoRoot = findRepoRoot();
   const agentRuntimes = options.agentRuntimes ?? runtimeBootstrap.agentRuntimes;
   const threadService = new ThreadService(
     database.db,
@@ -23366,7 +25378,11 @@ function buildApp(options = {}) {
     runtimeBootstrap.codexManagement,
     pluginService
   );
-  const shellService = options.shellService ?? new ShellSessionService(database.db, eventBus, new TmuxManager());
+  const shellService = options.shellService ?? new ShellSessionService(
+    database.db,
+    eventBus,
+    createTerminalShellBackend(options.env)
+  );
   const providerHostConfigService = new ProviderHostConfigService(
     agentRuntimes,
     runtimeBootstrap.providerHostHomes
@@ -23383,6 +25399,16 @@ function buildApp(options = {}) {
       fileSize: MAX_PROMPT_ATTACHMENT_BYTES2
     }
   });
+  const backendPluginHost = new BackendPluginHost(app2);
+  backendPluginHost.register(createTerminalPluginBackendContribution());
+  const relaySocketBridge = createRelaySocketBridge(app2, eventBus, backendPluginHost);
+  const relayTunnelClient = config.mode === "relay" ? options.relayTunnelClient ?? new RelayTunnelClient(
+    config.relay,
+    createRelayRequestHandler(app2),
+    relaySocketBridge.handleConnected,
+    relaySocketBridge.handleMessage
+  ) : null;
+  relayTunnelClient?.validateConfig();
   app2.decorate("services", {
     config,
     database,
@@ -23393,7 +25419,29 @@ function buildApp(options = {}) {
     shellService,
     providerHostConfigService,
     pluginRegistry,
-    pluginService
+    pluginService,
+    authService,
+    relayTunnelClient,
+    repoRoot
+  });
+  app2.addHook("onRequest", async (request, reply) => {
+    if (!authService.required) {
+      return;
+    }
+    const requestPath = new URL(request.url, "http://localhost").pathname;
+    if (!requestPath.startsWith("/api/")) {
+      return;
+    }
+    if (requestPath === "/api/auth/login" || requestPath === "/api/auth/logout" || requestPath === "/api/auth/session") {
+      return;
+    }
+    if (config.mode === "relay" && request.headers[RELAY_FORWARD_HEADER] === "1") {
+      return;
+    }
+    const session = authService.verifyRequest(request);
+    if (!session.authenticated) {
+      return reply.status(401).send(unauthorizedPayload());
+    }
   });
   app2.register(async (realtimeApp) => {
     await realtimeApp.register(websocket);
@@ -23406,135 +25454,34 @@ function buildApp(options = {}) {
           message: "Upgrade to websocket is required."
         });
       },
-      wsHandler: (socket) => {
-        let attachedShell = null;
-        function send(message) {
-          if (socket.readyState === 1) {
-            socket.send(JSON.stringify(message));
-          }
+      wsHandler: (socket, request) => {
+        const session = authService.verifyRequest(request);
+        if (!session.authenticated) {
+          socket.close(1008, "Authentication is required.");
+          return;
         }
-        send({
-          type: "supervisor.connected",
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        const unsubscribe = eventBus.onThreadEvent((event) => {
-          send(event);
-        });
-        const unsubscribeShell = eventBus.onShellEvent((event) => {
-          send(event);
-        });
-        socket.on("message", async (rawMessage) => {
-          let parsed;
-          try {
-            parsed = JSON.parse(rawMessage.toString());
-          } catch {
-            return;
-          }
-          try {
-            if (parsed.type === "shell.attach") {
-              if (attachedShell && attachedShell.shellId !== parsed.shellId) {
-                await shellService.detachShell(
-                  attachedShell.shellId,
-                  attachedShell.viewerId
-                );
-                attachedShell = null;
-              }
-              const attachment = await shellService.attachShell(parsed.shellId, {
-                cols: parsed.cols,
-                rows: parsed.rows,
-                onData: (data, options2) => {
-                  send({
-                    type: "shell.output",
-                    shellId: parsed.shellId,
-                    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-                    payload: {
-                      data,
-                      ...options2?.replace ? { replace: true } : {},
-                      ...options2?.cursorX !== void 0 ? { cursorX: options2.cursorX } : {},
-                      ...options2?.cursorY !== void 0 ? { cursorY: options2.cursorY } : {},
-                      ...options2?.paneHeight !== void 0 ? { paneHeight: options2.paneHeight } : {},
-                      ...options2?.cwdBaseName !== void 0 ? { cwdBaseName: options2.cwdBaseName } : {},
-                      ...options2?.envPrefix !== void 0 ? { envPrefix: options2.envPrefix } : {},
-                      ...options2?.isCommandRunning !== void 0 ? { isCommandRunning: options2.isCommandRunning } : {}
-                    }
-                  });
-                }
-              });
-              attachedShell = {
-                shellId: parsed.shellId,
-                viewerId: attachment.viewerId
-              };
-              send({
-                type: "shell.connected",
-                shellId: parsed.shellId,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-                payload: {
-                  viewerId: attachment.viewerId
-                }
-              });
-              return;
-            }
-            if (parsed.type === "supervisor.ping") {
-              send({
-                type: "supervisor.pong",
-                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-                payload: {
-                  requestTimestamp: typeof parsed.timestamp === "string" ? parsed.timestamp : null
-                }
-              });
-              return;
-            }
-            if (parsed.type === "shell.detach") {
-              await shellService.detachShell(parsed.shellId, parsed.viewerId);
-              if (attachedShell?.shellId === parsed.shellId && attachedShell.viewerId === parsed.viewerId) {
-                attachedShell = null;
-              }
-              return;
-            }
-            if (parsed.type === "shell.input") {
-              await shellService.sendInput(
-                parsed.shellId,
-                parsed.viewerId,
-                parsed.data
-              );
-              return;
-            }
-            if (parsed.type === "shell.resize") {
-              await shellService.resizeShell(
-                parsed.shellId,
-                parsed.viewerId,
-                parsed.cols,
-                parsed.rows
-              );
-              return;
-            }
-            if (parsed.type === "shell.clear") {
-              await shellService.clearShell(parsed.shellId, parsed.viewerId);
-            }
-          } catch (error) {
-            if ("shellId" in parsed) {
-              send(makeShellErrorEnvelope(parsed.shellId, error));
+        const supervisorSession = createSupervisorSocketSession({
+          app: app2,
+          eventBus,
+          backendPluginHost,
+          send(message) {
+            if (socket.readyState === 1) {
+              socket.send(JSON.stringify(message));
             }
           }
         });
+        socket.on("message", async (rawMessage) => {
+          await supervisorSession.handleMessage(rawMessage.toString());
+        });
         socket.on("close", () => {
-          if (attachedShell) {
-            void shellService.detachShell(
-              attachedShell.shellId,
-              attachedShell.viewerId
-            ).catch(() => {
-            });
-            attachedShell = null;
-          }
-          unsubscribe();
-          unsubscribeShell();
+          supervisorSession.close();
         });
       }
     });
   });
+  app2.register(registerAuthRoutes);
   app2.register(registerSystemRoutes);
   app2.register(registerAgentRuntimeRoutes);
-  app2.register(registerShellRoutes);
   app2.register(registerPluginRoutes);
   app2.register(registerThreadRoutes);
   app2.register(registerWorkspaceRoutes);
@@ -23576,7 +25523,7 @@ function buildApp(options = {}) {
       return;
     }
     if (error instanceof ShellServiceError) {
-      const statusCode = error.code === "thread_not_found" || error.code === "shell_not_found" ? 404 : error.code === "viewer_conflict" || error.code === "thread_not_connected" || error.code === "shell_exists" || error.code === "workspace_missing" || error.code === "shell_not_running" || error.code === "viewer_not_attached" || error.code === "invalid_viewer" ? 409 : 503;
+      const statusCode = error.code === "thread_not_found" || error.code === "shell_not_found" ? 404 : error.code === "viewer_conflict" || error.code === "thread_not_connected" || error.code === "shell_exists" || error.code === "workspace_missing" || error.code === "shell_not_running" || error.code === "viewer_not_attached" || error.code === "invalid_viewer" || error.code === "plugin_disabled" ? 409 : 503;
       reply.status(statusCode).send({
         code: statusCode === 404 ? "not_found" : statusCode === 409 ? "conflict" : "service_unavailable",
         message: error.message,
@@ -23641,11 +25588,17 @@ function buildApp(options = {}) {
   });
   app2.addHook("onClose", async () => {
     await shellService.stop();
+    relayTunnelClient?.stop();
     await Promise.all(agentRuntimes.all().map((runtime) => runtime.stop()));
     database.sqlite.close();
   });
   app2.addHook("onReady", async () => {
     try {
+      await pluginService.syncManagedCodexMcpConfig({
+        codexHome: runtimeBootstrap.providerHostHomes.codex ?? null,
+        repoRoot
+      });
+      relayTunnelClient?.start();
       await Promise.all(agentRuntimes.all().map((runtime) => runtime.start()));
       await shellService.syncShellStateOnStartup();
     } catch (error) {
@@ -23661,31 +25614,120 @@ function requestLog(app2, error) {
   }
   app2.log.error({ error }, "Non-error value reached Fastify error handler.");
 }
-function makeShellErrorEnvelope(shellId, error) {
-  if (error instanceof ShellServiceError) {
+function createRelayRequestHandler(app2) {
+  return async function handleRelayRequest(request) {
+    const response = await app2.inject({
+      method: request.method,
+      url: request.path,
+      headers: {
+        ...request.headers,
+        [RELAY_FORWARD_HEADER]: "1"
+      },
+      ...request.body !== null ? { payload: request.body } : {}
+    });
     return {
-      type: "shell.error",
-      shellId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      payload: {
-        code: error.code,
-        message: error.message
-      }
+      statusCode: response.statusCode,
+      headers: relayResponseHeaders(response.headers),
+      body: response.body
     };
-  }
+  };
+}
+function createSupervisorSocketSession(input) {
+  const closeHandlers = [];
+  const socketState = /* @__PURE__ */ new Map();
+  const onClose = (handler) => {
+    closeHandlers.push(handler);
+  };
+  input.send({
+    type: "supervisor.connected",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const unsubscribeThread = input.eventBus.onThreadEvent((event) => {
+    input.send(event);
+  });
+  const unsubscribeShell = input.eventBus.onShellEvent((event) => {
+    input.send(event);
+  });
   return {
-    type: "shell.error",
-    shellId,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    payload: {
-      code: "unknown",
-      message: error instanceof Error ? error.message : "Unexpected shell error."
+    async handleMessage(rawMessage) {
+      let parsed;
+      try {
+        parsed = JSON.parse(rawMessage);
+      } catch {
+        return;
+      }
+      try {
+        if (parsed.type === "supervisor.ping") {
+          input.send({
+            type: "supervisor.pong",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            payload: {
+              requestTimestamp: typeof parsed.timestamp === "string" ? parsed.timestamp : null
+            }
+          });
+          return;
+        }
+        await input.backendPluginHost.handleSocketMessage({
+          app: input.app,
+          send: input.send,
+          onClose,
+          state: socketState,
+          message: parsed
+        });
+      } catch {
+        return;
+      }
+    },
+    close() {
+      for (const handler of closeHandlers.splice(0)) {
+        handler();
+      }
+      unsubscribeThread();
+      unsubscribeShell();
+    }
+  };
+}
+function createRelaySocketBridge(app2, eventBus, backendPluginHost) {
+  const sessions = /* @__PURE__ */ new Map();
+  return {
+    handleConnected(clientId, send) {
+      const existing = sessions.get(clientId);
+      existing?.close();
+      const session = createSupervisorSocketSession({
+        app: app2,
+        eventBus,
+        backendPluginHost,
+        send
+      });
+      sessions.set(clientId, session);
+      return () => {
+        session.close();
+        sessions.delete(clientId);
+      };
+    },
+    async handleMessage(clientId, message) {
+      const session = sessions.get(clientId);
+      if (!session) {
+        return;
+      }
+      await session.handleMessage(JSON.stringify(message));
     }
   };
 }
+function relayResponseHeaders(headers) {
+  const output = {};
+  for (const [name, value] of Object.entries(headers)) {
+    if (Array.isArray(value)) {
+      output[name] = value.join(", ");
+    } else if (value !== void 0) {
+      output[name] = String(value);
+    }
+  }
+  return output;
+}
 
 // src/index.ts
-if (fs22.existsSync(".env")) {
+if (fs25.existsSync(".env")) {
   process.loadEnvFile?.(".env");
 }
 var app = buildApp();