remote-codex 0.11.49 → 0.11.51

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

@@ -5,15 +5,15 @@ var __export = (target, all) => {
 };
 
 // src/index.ts
-import fs31 from "fs";
+import fs33 from "fs";
 
 // src/app.ts
 import Fastify from "fastify";
 import multipart from "@fastify/multipart";
 import websocket from "@fastify/websocket";
 import { spawn } from "child_process";
-import fs29 from "fs";
-import path31 from "path";
+import fs31 from "fs";
+import path33 from "path";
 import { ZodError } from "zod";
 
 // ../../packages/config/src/index.ts
@@ -176,7 +176,7 @@ function loadRuntimeConfig(env = process.env, platform = process.platform) {
     nodeEnv === "production"
   );
   const enabledProviders = new Set(
-    (parsed.REMOTE_CODEX_ENABLED_AGENT_PROVIDERS ?? (platform === "win32" ? "codex" : "codex,claude,opencode")).split(",").map((provider2) => provider2.trim().toLowerCase()).filter(Boolean)
+    (parsed.REMOTE_CODEX_ENABLED_AGENT_PROVIDERS ?? (platform === "win32" ? "codex,acp" : "codex,claude,opencode,acp")).split(",").map((provider2) => provider2.trim().toLowerCase()).filter(Boolean)
   );
   const defaultAgentHomeRoot = os.homedir();
   const codexHome = parsed.CODEX_HOME?.trim() ? path.resolve(parsed.CODEX_HOME) : path.join(defaultAgentHomeRoot, agentBackendMetadata.codex.defaultHomeDir);
@@ -2336,7 +2336,7 @@ Subquery.prototype.getSQL = function() {
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce(
-    (result2, { path: path33, field }, columnIndex) => {
+    (result2, { path: path35, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -2346,8 +2346,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         decoder = field.sql.decoder;
       }
       let node = result2;
-      for (const [pathChunkIndex, pathChunk] of path33.entries()) {
-        if (pathChunkIndex < path33.length - 1) {
+      for (const [pathChunkIndex, pathChunk] of path35.entries()) {
+        if (pathChunkIndex < path35.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -2355,8 +2355,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) && path33.length === 2) {
-            const objectName = path33[0];
+          if (joinsNotNullableMap && is(field, Column) && path35.length === 2) {
+            const objectName = path35[0];
             if (!(objectName in nullifyMap)) {
               nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
             } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
@@ -6846,7 +6846,7 @@ function upsertThreadTurnMetadata(db, input) {
     pricingTierKey: input.pricingTierKey ?? null,
     tokenUsageJson: input.tokenUsageJson ?? null,
     displayPrompt: input.displayPrompt ?? null,
-    createdAt: now,
+    createdAt: input.createdAt ?? now,
     updatedAt: now
   }).run();
 }
@@ -9139,7 +9139,7 @@ function extractFileChangeEntries(item) {
       isRecord4(entry.summary) ? entry.summary : null,
       isRecord4(entry.diff) ? entry.diff : null
     ].filter((candidate) => Boolean(candidate));
-    const path33 = uniqueStrings([
+    const path35 = uniqueStrings([
       stringOrNull(valueFromRecords(nestedRecords, ["path", "filePath", "targetPath"])),
       stringOrNull(
         valueFromRecords(nestedRecords, [
@@ -9186,7 +9186,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 = path33 ?? (diffText ? projectRelativePathLabel(extractPathFromDiffText(diffText)) : null);
+    const normalizedPath = path35 ?? (diffText ? projectRelativePathLabel(extractPathFromDiffText(diffText)) : null);
     if (!normalizedPath && additions === 0 && deletions === 0) {
       return null;
     }
@@ -14187,14 +14187,14 @@ function displayPath(pathValue, options) {
   }
   return relativePath.split(path12.sep).join("/");
 }
-function toolIsLowInformationPatch(normalized, state, input, patchText, path33, metadataStats) {
+function toolIsLowInformationPatch(normalized, state, input, patchText, path35, metadataStats) {
   if (normalized !== "applypatch" && normalized !== "patch") {
     return false;
   }
   if (toolStateStatus(state) !== "running") {
     return false;
   }
-  if (path33 || patchText || metadataStats || stringValue2(state.output)) {
+  if (path35 || patchText || metadataStats || stringValue2(state.output)) {
     return false;
   }
   return !isRecord9(input) || Object.keys(input).length === 0;
@@ -14237,7 +14237,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((path33) => Boolean(path33));
+  const paths = files.map((file) => stringValue2(file.filePath) ?? stringValue2(file.path) ?? stringValue2(file.relativePath)).filter((path35) => Boolean(path35));
   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 {
@@ -14356,8 +14356,8 @@ function normalizeLegacyMessage(message) {
     finish: stringValue2(info.finish) ?? void 0
   };
 }
-function mapAssistantTool(messageId2, tool, options) {
-  const id = stringValue2(tool.id) ?? `${messageId2}:tool`;
+function mapAssistantTool(messageId3, tool, options) {
+  const id = stringValue2(tool.id) ?? `${messageId3}:tool`;
   const name = stringValue2(tool.name) ?? stringValue2(tool.tool) ?? "Tool";
   const state = isRecord9(tool.state) ? tool.state : {};
   const input = state.input;
@@ -14385,28 +14385,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 path33 = metadataStats?.path ?? filePathFromInput(input) ?? extractPathFromPatchText(patchText);
-    if (toolIsLowInformationPatch(normalized, state, input, patchText, path33, metadataStats)) {
+    const path35 = metadataStats?.path ?? filePathFromInput(input) ?? extractPathFromPatchText(patchText);
+    if (toolIsLowInformationPatch(normalized, state, input, patchText, path35, metadataStats)) {
       return null;
     }
     const output = stringValue2(state.output);
     const diffStats = countUnifiedDiffStats2(patchText);
-    const displayFilePath = displayPath(path33, options);
+    const displayFilePath = displayPath(path35, 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 ?? (path33 ? 1 : null),
+      changedFiles: metadataStats?.changedFiles ?? (path35 ? 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 path33 = filePathFromInput(input);
-    const text2 = displayPath(path33, options) ?? summary ?? name;
+    const path35 = filePathFromInput(input);
+    const text2 = displayPath(path35, options) ?? summary ?? name;
     return {
       id,
       kind: "fileRead",
@@ -14485,13 +14485,13 @@ function openCodeMessagesToPlanUpdate(messages) {
   }
   return null;
 }
-function mapAssistantPart(messageId2, part, index, options) {
-  const partId = stringValue2(part.id) ?? `${messageId2}:${stringValue2(part.type) ?? "part"}:${index}`;
+function mapAssistantPart(messageId3, part, index, options) {
+  const partId = stringValue2(part.id) ?? `${messageId3}:${stringValue2(part.type) ?? "part"}:${index}`;
   const partType = stringValue2(part.type);
   if (partType === "text") {
     const text2 = stringValue2(part.text);
     return text2 ? {
-      id: `${messageId2}:text:${index}`,
+      id: `${messageId3}:text:${index}`,
       kind: "agentMessage",
       text: text2
     } : null;
@@ -14505,7 +14505,7 @@ function mapAssistantPart(messageId2, part, index, options) {
     } : null;
   }
   if (partType === "tool") {
-    return mapAssistantTool(messageId2, part, options);
+    return mapAssistantTool(messageId3, part, options);
   }
   if (partType === "file") {
     const sourcePath = isRecord9(part.source) ? stringValue2(part.source.path) : null;
@@ -15935,7 +15935,8 @@ var builtinAcpAgents = [
     baseProbeCommand: "opencode --version",
     serverCommand: "opencode acp",
     serverProbeCommand: "opencode acp --help",
-    installCommand: null
+    installCommand: null,
+    modelListCommand: "opencode models"
   },
   {
     id: "deepseek",
@@ -16079,7 +16080,7 @@ var AcpAgentCatalog = class {
 ${result.stderr}`;
     const defaultModel = output.match(/^Default model:\s*(\S+)/m)?.[1] ?? null;
     const models = output.split(/\r?\n/).flatMap((line) => {
-      const match = line.match(/^\s*[-*]\s+(\S+?)(?:\s+\(default\))?\s*$/);
+      const match = line.match(/^\s*[-*]\s+(\S+?)(?:\s+\(default\))?\s*$/) ?? line.match(/^\s*([A-Za-z0-9._-]+\/[A-Za-z0-9._:/-]+)\s*$/);
       if (!match?.[1]) {
         return [];
       }
@@ -16162,13 +16163,125 @@ function acpAgentMetadata(entry) {
   };
 }
 
+// ../../packages/acp/src/extensions.ts
+var REMOTE_CODEX_HARNESS_EXTENSION_META_KEY = "remoteCodex.harnessExtensions";
+var REMOTE_CODEX_HARNESS_EXTENSION_PROTOCOL = "remote-codex.harness-extension/v1";
+var REMOTE_CODEX_HARNESS_EXTENSION_EVENT_METHOD = "remoteCodex/harness-extension/event";
+var extensionSegmentPattern = /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/;
+function assertExtensionSegment(value, label) {
+  if (!extensionSegmentPattern.test(value)) {
+    throw new Error(`${label} must be a lowercase extension identifier.`);
+  }
+}
+function harnessExtensionMethodName(extensionId, version2, method) {
+  assertExtensionSegment(extensionId, "Extension id");
+  assertExtensionSegment(method, "Extension method");
+  if (!Number.isInteger(version2) || version2 < 1) {
+    throw new Error("Extension version must be a positive integer.");
+  }
+  return `remoteCodex/${extensionId}/v${version2}/${method}`;
+}
+function createHarnessExtensionCall(input) {
+  harnessExtensionMethodName(
+    input.extensionId,
+    input.extensionVersion,
+    input.method
+  );
+  if (!input.operationId.trim()) {
+    throw new Error("Extension operation id is required.");
+  }
+  if (!input.idempotencyKey.trim()) {
+    throw new Error("Extension idempotency key is required.");
+  }
+  return {
+    protocol: REMOTE_CODEX_HARNESS_EXTENSION_PROTOCOL,
+    extensionId: input.extensionId,
+    extensionVersion: input.extensionVersion,
+    method: input.method,
+    operationId: input.operationId,
+    idempotencyKey: input.idempotencyKey,
+    params: input.params
+  };
+}
+
+// ../../packages/acp/src/capabilities.ts
+function isRecord11(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue4(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function harnessExtensions(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((candidate) => {
+    if (!isRecord11(candidate)) {
+      return [];
+    }
+    const id = stringValue4(candidate.id);
+    const version2 = candidate.version;
+    const stability = candidate.stability;
+    const methods2 = Array.isArray(candidate.methods) ? candidate.methods.filter((item) => typeof item === "string") : [];
+    const events = Array.isArray(candidate.events) ? candidate.events.filter((item) => typeof item === "string") : [];
+    if (!id || !Number.isInteger(version2) || Number(version2) < 1 || stability !== "experimental" && stability !== "stable") {
+      return [];
+    }
+    return [{
+      id,
+      version: Number(version2),
+      stability,
+      methods: methods2,
+      events
+    }];
+  });
+}
+function legacyExtensions(meta) {
+  const steering = isRecord11(meta.steering) ? { supported: meta.steering.supported === true } : null;
+  const goal = isRecord11(meta.goal) ? {
+    version: typeof meta.goal.version === "string" || typeof meta.goal.version === "number" ? meta.goal.version : null,
+    controlMethod: stringValue4(meta.goal.controlMethod),
+    actions: Array.isArray(meta.goal.actions) ? meta.goal.actions.filter((item) => typeof item === "string") : []
+  } : null;
+  return { steering, goal };
+}
+function snapshotAcpInitializeResponse(response) {
+  if (!response) {
+    return null;
+  }
+  const meta = isRecord11(response._meta) ? response._meta : {};
+  return {
+    protocolVersion: response.protocolVersion,
+    agentInfo: response.agentInfo ? {
+      name: response.agentInfo.name,
+      title: response.agentInfo.title ?? null,
+      version: response.agentInfo.version ?? null
+    } : null,
+    agentCapabilities: structuredClone(response.agentCapabilities ?? {}),
+    harnessExtensions: harnessExtensions(
+      meta[REMOTE_CODEX_HARNESS_EXTENSION_META_KEY]
+    ),
+    legacyExtensions: legacyExtensions(meta)
+  };
+}
+function snapshotAcpAgentCapabilities(input) {
+  const ready = input.availability === "ready";
+  return {
+    provider: "acp",
+    agentId: input.agentId,
+    availability: input.availability,
+    negotiated: ready ? input.negotiated ?? null : null,
+    effectiveCapabilities: ready ? structuredClone(input.effectiveCapabilities) : null
+  };
+}
+
 // ../../packages/acp/src/catalog-runtime.ts
-import { EventEmitter as EventEmitter8 } from "events";
+import { EventEmitter as EventEmitter9 } from "events";
 
 // ../../packages/acp/src/runtimeAdapter.ts
-import { EventEmitter as EventEmitter7 } from "events";
-import fs11 from "fs/promises";
-import path14 from "path";
+import { EventEmitter as EventEmitter8 } from "events";
+import fs13 from "fs/promises";
+import path16 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 import { Readable, Writable } from "stream";
 
@@ -17919,17 +18032,17 @@ function isResponseMessage(value) {
 function isNotificationMessage(value) {
   return isJsonRpcEnvelope(value) && !("id" in value) && typeof value["method"] === "string";
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null;
 }
 function isJsonRpcEnvelope(value) {
-  return isRecord11(value) && value["jsonrpc"] === "2.0";
+  return isRecord12(value) && value["jsonrpc"] === "2.0";
 }
 function isJsonRpcId(value) {
   return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
 }
 function isResponseShapedMessage(value) {
-  return isRecord11(value) && !("method" in value) && ("id" in value || "result" in value || "error" in value);
+  return isRecord12(value) && !("method" in value) && ("id" in value || "result" in value || "error" in value);
 }
 function isResponseBatch(batch) {
   let hasValidCall = false;
@@ -17939,7 +18052,7 @@ function isResponseBatch(batch) {
   for (const entry of batch) {
     hasValidCall ||= isRequestMessage(entry) || isNotificationMessage(entry);
     hasValidResponse ||= isResponseMessage(entry);
-    if (!isRecord11(entry)) {
+    if (!isRecord12(entry)) {
       continue;
     }
     hasCallShape ||= "method" in entry;
@@ -17954,13 +18067,13 @@ function isResponseBatch(batch) {
   return hasResponseShape && !hasCallShape;
 }
 function cancelRequestId(params) {
-  if (!isRecord11(params) || !isJsonRpcId(params["requestId"])) {
+  if (!isRecord12(params) || !isJsonRpcId(params["requestId"])) {
     return void 0;
   }
   return params["requestId"];
 }
 function isErrorResponse(value) {
-  return isRecord11(value) && typeof value["code"] === "number" && Number.isInteger(value["code"]) && typeof value["message"] === "string";
+  return isRecord12(value) && typeof value["code"] === "number" && Number.isInteger(value["code"]) && typeof value["message"] === "string";
 }
 var Handled = {
   /**
@@ -18505,7 +18618,7 @@ var Connection = class {
     if (this.abortController.signal.aborted) {
       return Promise.resolve();
     }
-    if (!isRecord11(message)) {
+    if (!isRecord12(message)) {
       console.error("Invalid message", { message });
       return Promise.resolve();
     }
@@ -18908,7 +19021,7 @@ function ndJsonStream(output, input) {
           await writeJson(protocolErrorResponse(RequestError.parseError()));
           return;
         }
-        if (isRecord11(message) || Array.isArray(message)) {
+        if (isRecord12(message) || Array.isArray(message)) {
           controller.enqueue(message);
         } else {
           await writeJson(protocolErrorResponse(RequestError.invalidRequest(message)));
@@ -20063,13 +20176,15 @@ function mappedPlan(entries) {
   };
 }
 var AcpTurnItemMapper = class {
-  constructor(turnId, initialItems = []) {
+  constructor(turnId, initialItems = [], mode = "live") {
     this.turnId = turnId;
+    this.mode = mode;
     for (const item of initialItems) {
       this.upsert(item);
     }
   }
   turnId;
+  mode;
   items = /* @__PURE__ */ new Map();
   order = [];
   tools = /* @__PURE__ */ new Map();
@@ -20077,6 +20192,16 @@ var AcpTurnItemMapper = class {
   thoughtIndex = 0;
   currentAgentMessageId = null;
   currentThoughtId = null;
+  appendUserMessage(content, itemId) {
+    const current = this.items.get(itemId);
+    const item = {
+      ...current ?? { id: itemId, kind: "userMessage" },
+      text: `${current?.text ?? ""}${acpContentBlockText(content)}`,
+      status: modeStatus(this.mode)
+    };
+    this.upsert(item);
+    return item;
+  }
   turn(status = "inProgress", error = null) {
     return {
       providerTurnId: this.turnId,
@@ -20099,7 +20224,7 @@ var AcpTurnItemMapper = class {
       case "agent_message_chunk": {
         result.itemUpdates.push(...this.finishThought());
         const delta = acpContentBlockText(update.content);
-        const itemId = this.currentAgentMessageId ?? `${this.turnId}:agent:${++this.agentMessageIndex}`;
+        const itemId = this.currentAgentMessageId ?? messageId2(update) ?? `${this.turnId}:agent:${++this.agentMessageIndex}`;
         this.currentAgentMessageId = itemId;
         const current = this.items.get(itemId);
         const item = {
@@ -20114,7 +20239,7 @@ var AcpTurnItemMapper = class {
       case "agent_thought_chunk": {
         result.itemUpdates.push(...this.finishAgentMessage());
         const delta = acpContentBlockText(update.content);
-        const itemId = this.currentThoughtId ?? `${this.turnId}:thought:${++this.thoughtIndex}`;
+        const itemId = this.currentThoughtId ?? messageId2(update) ?? `${this.turnId}:thought:${++this.thoughtIndex}`;
         this.currentThoughtId = itemId;
         const current = this.items.get(itemId);
         const item = {
@@ -20298,6 +20423,449 @@ var AcpTurnItemMapper = class {
     return [...this.finishAgentMessage(), ...this.finishThought()];
   }
 };
+function messageId2(update) {
+  return typeof update.messageId === "string" && update.messageId.trim() ? update.messageId.trim() : null;
+}
+function modeStatus(mode) {
+  return mode === "hydrate" ? "completed" : "running";
+}
+
+// ../../packages/acp/src/prompt-content.ts
+import fs12 from "fs/promises";
+import path15 from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+
+// ../../packages/acp/src/workspace-boundary.ts
+import fs11 from "fs/promises";
+import path14 from "path";
+function isInside(root, candidate) {
+  const relative = path14.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path14.sep}`) && !path14.isAbsolute(relative);
+}
+async function resolveAcpWorkspacePath(workspacePath, candidatePath) {
+  if (!path14.isAbsolute(candidatePath)) {
+    throw new Error("ACP workspace paths must be absolute.");
+  }
+  const rootPath = path14.resolve(workspacePath);
+  const requestedPath = path14.resolve(candidatePath);
+  if (!isInside(rootPath, requestedPath)) {
+    throw new Error("ACP path must stay inside the session workspace.");
+  }
+  const rootRealPath = await fs11.realpath(rootPath);
+  let existingPath = requestedPath;
+  const missingSegments = [];
+  while (true) {
+    try {
+      const existingRealPath = await fs11.realpath(existingPath);
+      if (!isInside(rootRealPath, existingRealPath)) {
+        throw new Error("ACP path resolves outside the session workspace.");
+      }
+      return path14.join(existingRealPath, ...missingSegments);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+      const parent = path14.dirname(existingPath);
+      if (parent === existingPath) {
+        throw new Error("ACP workspace path has no existing parent.");
+      }
+      missingSegments.unshift(path14.basename(existingPath));
+      existingPath = parent;
+    }
+  }
+}
+
+// ../../packages/acp/src/prompt-content.ts
+var attachmentTokenPattern = /\[(PHOTO|FILE)\s+([^\]]+)\]/g;
+var maxEmbeddedImageBytes = 20 * 1024 * 1024;
+function imageMimeType(filePath) {
+  switch (path15.extname(filePath).toLowerCase()) {
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".gif":
+      return "image/gif";
+    case ".webp":
+      return "image/webp";
+    case ".png":
+    default:
+      return "image/png";
+  }
+}
+async function buildAcpPromptContent(input) {
+  if (input.content) {
+    return input.content.map((block) => {
+      if (block.type === "image" && input.promptCapabilities?.image !== true) {
+        throw new Error("The selected ACP agent does not support image prompts.");
+      }
+      if (block.type === "audio" && input.promptCapabilities?.audio !== true) {
+        throw new Error("The selected ACP agent does not support audio prompts.");
+      }
+      if (block.type === "resource" && input.promptCapabilities?.embeddedContext !== true) {
+        throw new Error("The selected ACP agent does not support embedded context.");
+      }
+      return structuredClone(block);
+    });
+  }
+  const matches = [...input.prompt.matchAll(attachmentTokenPattern)];
+  if (matches.length === 0) {
+    return [{ type: "text", text: input.prompt }];
+  }
+  const blocks = [];
+  let cursor = 0;
+  for (const match of matches) {
+    const start = match.index ?? 0;
+    const preceding = input.prompt.slice(cursor, start);
+    if (preceding) {
+      blocks.push({ type: "text", text: preceding });
+    }
+    const kind = match[1];
+    const requestedPath = match[2]?.trim() ?? "";
+    const requestedAssetPath = path15.isAbsolute(requestedPath) ? requestedPath : path15.resolve(input.workspacePath, requestedPath);
+    const assetPath = await resolveAcpWorkspacePath(
+      input.workspacePath,
+      requestedAssetPath
+    );
+    const uri = pathToFileURL3(assetPath).toString();
+    if (kind === "PHOTO") {
+      if (input.promptCapabilities?.image !== true) {
+        throw new Error("The selected ACP agent does not support image prompts.");
+      }
+      const stat = await fs12.stat(assetPath);
+      if (!stat.isFile() || stat.size > maxEmbeddedImageBytes) {
+        throw new Error("ACP image attachment is missing or exceeds 20 MiB.");
+      }
+      blocks.push({
+        type: "image",
+        data: (await fs12.readFile(assetPath)).toString("base64"),
+        mimeType: imageMimeType(assetPath),
+        uri
+      });
+    } else {
+      await fs12.access(assetPath);
+      blocks.push({
+        type: "resource_link",
+        name: path15.basename(assetPath),
+        uri
+      });
+    }
+    cursor = start + match[0].length;
+  }
+  const trailing = input.prompt.slice(cursor);
+  if (trailing) {
+    blocks.push({ type: "text", text: trailing });
+  }
+  return blocks;
+}
+
+// ../../packages/acp/src/extension-registry.ts
+import { EventEmitter as EventEmitter7 } from "events";
+var HarnessExtensionInvocationError = class extends Error {
+  constructor(payload) {
+    super(payload.message);
+    this.payload = payload;
+    this.name = "HarnessExtensionInvocationError";
+  }
+  payload;
+};
+function extensionKey(extensionId, version2) {
+  return `${extensionId}@${version2}`;
+}
+function operationFingerprint(input) {
+  return JSON.stringify(input);
+}
+var HarnessExtensionRegistry = class extends EventEmitter7 {
+  extensions = /* @__PURE__ */ new Map();
+  operations = /* @__PURE__ */ new Map();
+  eventSequences = /* @__PURE__ */ new Set();
+  register(input) {
+    const key = extensionKey(input.descriptor.id, input.descriptor.version);
+    const existing = this.extensions.get(key);
+    if (existing && existing.ownerId !== input.ownerId) {
+      throw new Error(
+        `Harness extension ${key} is already owned by ${existing.ownerId}.`
+      );
+    }
+    if (new Set(input.descriptor.methods).size !== input.descriptor.methods.length) {
+      throw new Error(`Harness extension ${key} declares duplicate methods.`);
+    }
+    if (new Set(input.descriptor.events).size !== input.descriptor.events.length) {
+      throw new Error(`Harness extension ${key} declares duplicate events.`);
+    }
+    this.extensions.set(key, {
+      ownerId: input.ownerId,
+      descriptor: structuredClone(input.descriptor),
+      transport: input.transport,
+      wireMethods: { ...input.wireMethods ?? {} },
+      capabilityPatch: input.capabilityPatch ? structuredClone(input.capabilityPatch) : null,
+      paramMappers: { ...input.paramMappers ?? {} }
+    });
+  }
+  unregisterOwner(ownerId) {
+    for (const [key, extension] of this.extensions) {
+      if (extension.ownerId === ownerId) {
+        this.extensions.delete(key);
+      }
+    }
+  }
+  list() {
+    return [...this.extensions.values()].map((extension) => ({
+      ownerId: extension.ownerId,
+      descriptor: structuredClone(extension.descriptor)
+    }));
+  }
+  supports(extensionId, version2, method) {
+    return this.extensions.get(extensionKey(extensionId, version2))?.descriptor.methods.includes(method) ?? false;
+  }
+  effectiveCapabilities(base) {
+    const effective = structuredClone(base);
+    for (const extension of this.extensions.values()) {
+      if (!extension.capabilityPatch) continue;
+      for (const [section, patch] of Object.entries(extension.capabilityPatch)) {
+        Object.assign(
+          effective[section],
+          patch
+        );
+      }
+    }
+    return effective;
+  }
+  invoke(input) {
+    const key = extensionKey(input.extensionId, input.extensionVersion);
+    const extension = this.extensions.get(key);
+    if (!extension || !extension.descriptor.methods.includes(input.method)) {
+      return Promise.reject(this.error(input, {
+        code: "extension_method_unavailable",
+        message: `Harness extension method is unavailable: ${key}/${input.method}`,
+        retryable: false
+      }));
+    }
+    if (input.signal?.aborted) {
+      return Promise.reject(this.error(input, {
+        code: "extension_cancelled",
+        message: "Harness extension request was cancelled before dispatch.",
+        retryable: true
+      }));
+    }
+    const fingerprint = operationFingerprint(input);
+    const cached = this.operations.get(input.idempotencyKey);
+    if (cached) {
+      if (cached.fingerprint !== fingerprint) {
+        return Promise.reject(this.error(input, {
+          code: "idempotency_conflict",
+          message: "Harness extension idempotency key was reused for another operation.",
+          retryable: false
+        }));
+      }
+      return cached.promise;
+    }
+    const envelope = createHarnessExtensionCall(input);
+    const controller = new AbortController();
+    const timeoutMs = input.timeoutMs ?? 3e4;
+    let timer = null;
+    let abort = null;
+    const request = new Promise((resolve, reject) => {
+      abort = () => {
+        controller.abort(input.signal?.reason);
+        reject(this.error(input, {
+          code: "extension_cancelled",
+          message: "Harness extension request was cancelled.",
+          retryable: true
+        }));
+      };
+      input.signal?.addEventListener("abort", abort, { once: true });
+      timer = setTimeout(() => {
+        controller.abort(new Error("Harness extension request timed out."));
+        reject(this.error(input, {
+          code: "extension_timeout",
+          message: `Harness extension request timed out after ${timeoutMs}ms.`,
+          retryable: true
+        }));
+      }, timeoutMs);
+      void Promise.resolve().then(() => extension.transport.request(
+        extension.wireMethods[input.method] ?? harnessExtensionMethodName(
+          input.extensionId,
+          input.extensionVersion,
+          input.method
+        ),
+        extension.paramMappers[input.method]?.(envelope) ?? envelope,
+        controller.signal
+      )).then((value) => resolve(value), (cause) => reject(
+        cause instanceof HarnessExtensionInvocationError ? cause : this.error(input, {
+          code: "extension_request_failed",
+          message: cause instanceof Error ? cause.message : String(cause),
+          retryable: false
+        })
+      ));
+    }).finally(() => {
+      if (timer) clearTimeout(timer);
+      if (abort) input.signal?.removeEventListener("abort", abort);
+    });
+    this.operations.set(input.idempotencyKey, { fingerprint, promise: request });
+    request.catch(() => {
+      if (this.operations.get(input.idempotencyKey)?.promise === request) {
+        this.operations.delete(input.idempotencyKey);
+      }
+    });
+    while (this.operations.size > 256) {
+      this.operations.delete(this.operations.keys().next().value);
+    }
+    return request;
+  }
+  handleEvent(ownerId, event) {
+    if (event.protocol !== REMOTE_CODEX_HARNESS_EXTENSION_PROTOCOL) {
+      throw new Error("Harness extension event protocol is unsupported.");
+    }
+    const extension = this.extensions.get(
+      extensionKey(event.extensionId, event.extensionVersion)
+    );
+    if (!extension || extension.ownerId !== ownerId) {
+      throw new Error("Harness extension event owner does not match registration.");
+    }
+    if (!extension.descriptor.events.includes(event.event)) {
+      throw new Error(`Harness extension event is not declared: ${event.event}`);
+    }
+    if (event.sequence !== null) {
+      const sequenceKey = [
+        ownerId,
+        event.extensionId,
+        event.extensionVersion,
+        event.providerSessionId,
+        event.event,
+        event.sequence
+      ].join("\0");
+      if (this.eventSequences.has(sequenceKey)) {
+        return false;
+      }
+      this.eventSequences.add(sequenceKey);
+    }
+    this.emit("event", structuredClone(event));
+    return true;
+  }
+  error(input, error) {
+    return new HarnessExtensionInvocationError({
+      protocol: REMOTE_CODEX_HARNESS_EXTENSION_PROTOCOL,
+      extensionId: input.extensionId,
+      extensionVersion: input.extensionVersion,
+      method: input.method,
+      operationId: input.operationId,
+      ...error
+    });
+  }
+};
+
+// ../../packages/acp/src/session-hydrator.ts
+function updateMessageId(update) {
+  return typeof update.messageId === "string" && update.messageId.trim() ? update.messageId.trim() : null;
+}
+var AcpSessionHydrator = class {
+  constructor(providerSessionId) {
+    this.providerSessionId = providerSessionId;
+  }
+  providerSessionId;
+  turns = [];
+  leadingUpdates = [];
+  current = null;
+  turnIndex = 0;
+  providerIdentifiedTurnCount = 0;
+  receivedAt = Date.now();
+  apply(update) {
+    if (update.sessionUpdate === "user_message_chunk") {
+      this.applyUserMessage(update);
+      return;
+    }
+    if (update.sessionUpdate === "config_option_update" || update.sessionUpdate === "current_mode_update" || update.sessionUpdate === "available_commands_update" || update.sessionUpdate === "session_info_update" || update.sessionUpdate === "usage_update") {
+      return;
+    }
+    if (!this.current) {
+      this.leadingUpdates.push(update);
+      return;
+    }
+    const current = this.current;
+    this.flushLeadingUpdates(current);
+    current.sawNonUserUpdate = true;
+    current.mapper.apply(update);
+  }
+  complete() {
+    this.finishCurrent();
+    return [...this.turns];
+  }
+  coverage() {
+    this.finishCurrent();
+    return {
+      source: "providerReplay",
+      // ACP v1 has no authoritative history total; absence cannot prove completeness.
+      completeness: "unknown",
+      replayedTurnCount: this.turns.length,
+      replayedItemCount: this.turns.reduce(
+        (count, turn) => count + turn.items.length,
+        0
+      ),
+      providerIdentifiedTurnCount: this.providerIdentifiedTurnCount
+    };
+  }
+  applyUserMessage(update) {
+    const messageId3 = updateMessageId(update);
+    const shouldStartTurn = !this.current || this.current.sawNonUserUpdate || Boolean(
+      messageId3 && this.current.userMessageId && messageId3 !== this.current.userMessageId
+    );
+    if (shouldStartTurn) {
+      if (this.current) {
+        this.finishCurrent();
+      }
+      this.startTurn(messageId3);
+    }
+    const current = this.current;
+    if (messageId3 && !current.userMessageId) {
+      current.userMessageId = messageId3;
+    }
+    current.mapper.appendUserMessage(
+      update.content,
+      current.userMessageId ?? `${current.mapper.turnId}:user`
+    );
+  }
+  startTurn(userMessageId) {
+    const index = this.turnIndex++;
+    const stableSource = userMessageId ?? `${this.providerSessionId}:${index}`;
+    const builder = {
+      userMessageId,
+      mapper: new AcpTurnItemMapper(
+        `acp-hydrated:${stableSource}`,
+        [],
+        "hydrate"
+      ),
+      startedAt: new Date(this.receivedAt + index).toISOString(),
+      sawNonUserUpdate: false
+    };
+    if (userMessageId) {
+      this.providerIdentifiedTurnCount += 1;
+    }
+    this.current = builder;
+    return builder;
+  }
+  finishCurrent() {
+    if (!this.current && this.leadingUpdates.length > 0) {
+      this.startTurn(null);
+    }
+    if (!this.current) {
+      return;
+    }
+    this.flushLeadingUpdates(this.current);
+    const completed = this.current.mapper.complete("completed").turn;
+    if (completed.items.length > 0) {
+      this.turns.push({
+        ...completed,
+        startedAt: this.current.startedAt
+      });
+    }
+    this.current = null;
+  }
+  flushLeadingUpdates(current) {
+    for (const update of this.leadingUpdates.splice(0)) {
+      current.mapper.apply(update);
+    }
+  }
+};
 
 // ../../packages/acp/src/terminal-service.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -20317,14 +20885,28 @@ function retainedOutput(state) {
   };
 }
 var AcpTerminalService = class {
-  constructor(sessionCwd) {
+  constructor(sessionCwd, onOperation = () => void 0) {
     this.sessionCwd = sessionCwd;
+    this.onOperation = onOperation;
   }
   sessionCwd;
+  onOperation;
   terminals = /* @__PURE__ */ new Map();
-  create(params) {
+  async create(params) {
     const terminalId = randomUUID3();
-    const cwd = params.cwd ?? this.sessionCwd(params.sessionId) ?? process.cwd();
+    const sessionCwd = this.sessionCwd(params.sessionId);
+    if (!sessionCwd) {
+      throw new Error(`ACP session workspace not found: ${params.sessionId}`);
+    }
+    const cwd = await resolveAcpWorkspacePath(
+      sessionCwd,
+      params.cwd ?? sessionCwd
+    );
+    this.onOperation({
+      operation: "terminal.create",
+      sessionId: params.sessionId,
+      path: cwd
+    });
     const parsed = params.args && params.args.length > 0 ? { command: params.command, args: params.args } : parseCommandLine(params.command);
     const child = spawnProcess({
       command: parsed.command,
@@ -20412,10 +20994,13 @@ var AcpTerminalService = class {
 // ../../packages/acp/src/runtimeAdapter.ts
 var acpCapabilities = {
   sessions: {
-    list: true,
+    list: false,
     read: true,
-    resume: true,
-    importLocal: false
+    resume: false,
+    importLocal: false,
+    load: false,
+    close: false,
+    delete: false
   },
   turns: {
     start: true,
@@ -20467,7 +21052,19 @@ function errorMessage3(error) {
 function cloneCapabilities() {
   return structuredClone(acpCapabilities);
 }
-function isRecord12(value) {
+function applyNegotiatedAcpCapabilities(target, capabilities) {
+  target.sessions.list = Boolean(capabilities?.sessionCapabilities?.list);
+  target.sessions.load = capabilities?.loadSession === true;
+  target.sessions.resume = Boolean(
+    capabilities?.loadSession || capabilities?.sessionCapabilities?.resume
+  );
+  target.sessions.close = Boolean(capabilities?.sessionCapabilities?.close);
+  target.sessions.delete = Boolean(capabilities?.sessionCapabilities?.delete);
+  target.sessions.importLocal = false;
+  target.branching.fork = Boolean(capabilities?.sessionCapabilities?.fork);
+  return target;
+}
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function allSelectOptions(option) {
@@ -20563,8 +21160,12 @@ function sessionDetail(state) {
     createdAt: state.createdAt,
     updatedAt: state.updatedAt,
     status: state.status,
-    turns: state.turns,
-    totalTurnCount: state.turns.length
+    turns: state.turns.map((turn) => ({
+      ...turn,
+      items: turn.items.map((item) => ({ ...item }))
+    })),
+    totalTurnCount: state.turns.length,
+    ...state.hydrationCoverage ? { historyCoverage: { ...state.hydrationCoverage } } : {}
   };
 }
 function sessionSummaryFromInfo2(info) {
@@ -20580,12 +21181,29 @@ function sessionSummaryFromInfo2(info) {
     rawSession: info
   };
 }
-var AcpRuntimeAdapter = class extends EventEmitter7 {
+var AcpRuntimeAdapter = class extends EventEmitter8 {
   constructor(options) {
     super();
     this.options = options;
+    this.extensionRegistry.on(
+      "event",
+      (event) => this.emitRuntimeEvent({
+        type: "harness.extension",
+        provider: "acp",
+        providerSessionId: event.providerSessionId,
+        providerTurnId: event.providerTurnId,
+        providerItemId: event.providerItemId,
+        extensionId: event.extensionId,
+        extensionVersion: event.extensionVersion,
+        event: event.event,
+        operationId: event.operationId,
+        sequence: event.sequence,
+        payload: event.payload
+      })
+    );
     this.terminalService = new AcpTerminalService(
-      (sessionId) => this.sessions.get(sessionId)?.cwd ?? null
+      (sessionId) => this.sessions.get(sessionId)?.cwd ?? null,
+      (operation) => this.emit("fs-operation", operation)
     );
   }
   options;
@@ -20607,6 +21225,8 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
   sessions = /* @__PURE__ */ new Map();
   knownSessions = /* @__PURE__ */ new Map();
   pendingPermissions = /* @__PURE__ */ new Map();
+  hydrators = /* @__PURE__ */ new Map();
+  extensionRegistry = new HarnessExtensionRegistry();
   terminalService;
   child = null;
   connection = null;
@@ -20625,6 +21245,9 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
   getStatus() {
     return { ...this.status };
   }
+  getProtocolSnapshot() {
+    return snapshotAcpInitializeResponse(this.initializeResponse);
+  }
   async start() {
     if (this.status.state === "ready") {
       return;
@@ -20675,7 +21298,16 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
         Writable.toWeb(child.stdin),
         Readable.toWeb(child.stdout)
       );
-      const app2 = client({ name: this.options.clientInfo?.name ?? "remote-codex-supervisor" }).onRequest(methods.client.session.requestPermission, (request) => this.requestPermission(request.params)).onNotification(methods.client.session.update, (notification) => this.handleSessionUpdate(notification.params)).onRequest(methods.client.fs.readTextFile, (request) => this.readTextFile(request.params)).onRequest(methods.client.fs.writeTextFile, (request) => this.writeTextFile(request.params)).onRequest(methods.client.terminal.create, (request) => this.terminalService.create(request.params)).onRequest(methods.client.terminal.output, (request) => this.terminalService.output(request.params)).onRequest(methods.client.terminal.waitForExit, (request) => this.terminalService.waitForExit(request.params)).onRequest(methods.client.terminal.kill, (request) => this.terminalService.kill(request.params)).onRequest(methods.client.terminal.release, (request) => this.terminalService.release(request.params));
+      const app2 = client({ name: this.options.clientInfo?.name ?? "remote-codex-supervisor" }).onRequest(methods.client.session.requestPermission, (request) => this.requestPermission(request.params)).onNotification(methods.client.session.update, (notification) => this.handleSessionUpdate(notification.params)).onNotification(
+        REMOTE_CODEX_HARNESS_EXTENSION_EVENT_METHOD,
+        (params) => params,
+        (notification) => {
+          this.extensionRegistry.handleEvent(
+            "acp-agent",
+            notification.params
+          );
+        }
+      ).onRequest(methods.client.fs.readTextFile, (request) => this.readTextFile(request.params)).onRequest(methods.client.fs.writeTextFile, (request) => this.writeTextFile(request.params)).onRequest(methods.client.terminal.create, (request) => this.terminalService.create(request.params)).onRequest(methods.client.terminal.output, (request) => this.terminalService.output(request.params)).onRequest(methods.client.terminal.waitForExit, (request) => this.terminalService.waitForExit(request.params)).onRequest(methods.client.terminal.kill, (request) => this.terminalService.kill(request.params)).onRequest(methods.client.terminal.release, (request) => this.terminalService.release(request.params));
       this.connection = app2.connect(stream);
       this.context = this.connection.agent;
       const initialize = this.context.request(methods.agent.initialize, {
@@ -20697,7 +21329,9 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
       });
       const initializeResponse = await this.withStartupTimeout(initialize);
       this.initializeResponse = initializeResponse;
+      this.resetCapabilities();
       this.applyAgentCapabilities(initializeResponse.agentCapabilities);
+      this.registerNegotiatedExtensions(initializeResponse);
       this.status = {
         ...this.status,
         state: "ready",
@@ -20727,11 +21361,11 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
   async stop() {
     this.stopping = true;
     this.terminalService.stop();
-    for (const [id, permission] of this.pendingPermissions) {
-      clearTimeout(permission.timer);
-      permission.resolve(cancelledPermission());
-      this.pendingPermissions.delete(id);
-    }
+    this.settleActiveTurns("interrupted", "ACP runtime stopped.");
+    this.cancelPendingPermissions();
+    this.hydrators.clear();
+    await this.closeLoadedSessionsBeforeStop();
+    this.extensionRegistry.unregisterOwner("acp-agent");
     this.connection?.close();
     this.child?.kill("SIGTERM");
     this.connection = null;
@@ -20746,6 +21380,21 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
     };
     this.emit("status", this.getStatus());
   }
+  async closeLoadedSessionsBeforeStop() {
+    if (!this.context || !this.initializeResponse?.agentCapabilities?.sessionCapabilities?.close) {
+      return;
+    }
+    const sessionIds = [...this.sessions.keys()];
+    const results = await Promise.allSettled(sessionIds.map((sessionId) => this.context.request(methods.agent.session.close, { sessionId })));
+    results.forEach((result, index) => {
+      if (result.status === "rejected") {
+        this.emit(
+          "warning",
+          `Unable to close ACP session ${sessionIds[index] ?? "unknown"} before stop: ${errorMessage3(result.reason)}`
+        );
+      }
+    });
+  }
   async listModels() {
     return [{
       id: "default",
@@ -20759,13 +21408,21 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
     }];
   }
   async inspectModelOptions(cwd) {
+    const sessionCapabilities = this.initializeResponse?.agentCapabilities?.sessionCapabilities;
+    if (!sessionCapabilities?.delete) {
+      return this.listModels();
+    }
     const context = await this.requireContext();
     const response = await context.request(methods.agent.session.new, {
-      cwd: path14.resolve(cwd),
+      cwd: path16.resolve(cwd),
       mcpServers: [],
       _meta: { yoloMode: false, remoteCodexCapabilityProbe: true }
     });
     let configOptions = response.configOptions ?? [];
+    this.updateCapabilitiesFromConfigOptions(configOptions);
+    const supportsPerformanceMode = configOptions.some(
+      (option) => option.id === "fast-mode" || option.category === "model_config"
+    );
     try {
       const modelOption = configOptionByCategory(configOptions, "model");
       if (!modelOption || modelOption.type !== "select") {
@@ -20777,6 +21434,7 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
           description: "Use the model configured by the ACP agent.",
           isDefault: true,
           hidden: false,
+          supportsPerformanceMode,
           supportedReasoningEfforts: reasoning.efforts,
           defaultReasoningEffort: reasoning.defaultEffort,
           selectionKind: "model"
@@ -20804,6 +21462,7 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
           description: option.description ?? "",
           isDefault: option.value === modelOption.currentValue,
           hidden: false,
+          supportsPerformanceMode,
           supportedReasoningEfforts: reasoning.efforts,
           defaultReasoningEffort: reasoning.defaultEffort,
           selectionKind: "model"
@@ -20811,11 +21470,9 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
       }
       return models;
     } finally {
-      if (this.initializeResponse?.agentCapabilities?.sessionCapabilities?.close) {
-        await context.request(methods.agent.session.close, {
-          sessionId: response.sessionId
-        }).catch(() => void 0);
-      }
+      await context.request(methods.agent.session.delete, {
+        sessionId: response.sessionId
+      }).catch(() => void 0);
     }
   }
   async listSessions() {
@@ -20847,22 +21504,170 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
   async listLoadedSessions() {
     return [...this.sessions.keys()];
   }
-  async readSession(providerSessionId) {
-    const state = this.sessions.get(providerSessionId);
-    if (state) {
-      return sessionDetail(state);
+  async closeSession(providerSessionId) {
+    if (!this.initializeResponse?.agentCapabilities?.sessionCapabilities?.close) {
+      throw new AgentRuntimeError(
+        "ACP agent does not support session/close.",
+        "acp",
+        "request_failed"
+      );
     }
-    throw new AgentRuntimeError(
-      "ACP session history is owned by the Remote Codex supervisor and is not materialized in this runtime process.",
-      "acp",
-      "request_failed",
-      { historyUnavailable: true, providerSessionId }
+    await (await this.requireContext()).request(methods.agent.session.close, {
+      sessionId: providerSessionId
+    });
+    this.sessions.delete(providerSessionId);
+  }
+  async deleteSession(providerSessionId) {
+    if (!this.initializeResponse?.agentCapabilities?.sessionCapabilities?.delete) {
+      throw new AgentRuntimeError(
+        "ACP agent does not support session/delete.",
+        "acp",
+        "request_failed"
+      );
+    }
+    await (await this.requireContext()).request(methods.agent.session.delete, {
+      sessionId: providerSessionId
+    });
+    this.sessions.delete(providerSessionId);
+    this.knownSessions.delete(providerSessionId);
+  }
+  async sendInput(input) {
+    const state = this.sessions.get(input.providerSessionId);
+    if (!state?.activeMapper || state.activeMapper.turnId !== input.providerTurnId) {
+      return null;
+    }
+    if (!this.extensionRegistry.supports("acp.steering", 1, "steer")) {
+      throw new AgentRuntimeError(
+        "The selected ACP agent does not support running-turn steering.",
+        "acp",
+        "request_failed"
+      );
+    }
+    const prompt = await buildAcpPromptContent({
+      prompt: input.prompt,
+      workspacePath: input.workspacePath ?? state.cwd,
+      promptCapabilities: this.initializeResponse?.agentCapabilities?.promptCapabilities
+    });
+    const operationId = randomUUID4();
+    await this.extensionRegistry.invoke({
+      extensionId: "acp.steering",
+      extensionVersion: 1,
+      method: "steer",
+      operationId,
+      idempotencyKey: `${input.providerSessionId}:${input.providerTurnId}:steer:${operationId}`,
+      params: {
+        providerSessionId: input.providerSessionId,
+        prompt
+      }
+    });
+    return state.activeMapper.turn();
+  }
+  async compactSession(providerSessionId) {
+    const operationId = randomUUID4();
+    await this.extensionRegistry.invoke({
+      extensionId: "codex.control",
+      extensionVersion: 1,
+      method: "compact",
+      operationId,
+      idempotencyKey: `${providerSessionId}:compact:${operationId}`,
+      params: { providerSessionId },
+      timeoutMs: 18e4
+    });
+  }
+  async forkSession(input) {
+    if (!this.initializeResponse?.agentCapabilities?.sessionCapabilities?.fork) {
+      throw new AgentRuntimeError(
+        "The selected ACP agent does not support session/fork.",
+        "acp",
+        "request_failed"
+      );
+    }
+    const source = this.sessions.get(input.providerSessionId) ?? await this.restoreSession(input.providerSessionId);
+    const response = await (await this.requireContext()).request(
+      methods.agent.session.fork,
+      {
+        sessionId: source.providerSessionId,
+        cwd: source.cwd,
+        mcpServers: []
+      }
     );
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.knownSessions.set(response.sessionId, {
+      provider: "acp",
+      providerSessionId: response.sessionId,
+      cwd: source.cwd,
+      title: source.title,
+      preview: source.turns.at(-1)?.items.filter((item) => item.kind === "agentMessage").map((item) => item.text).join("\n") || null,
+      createdAt: now,
+      updatedAt: now,
+      status: "not_loaded"
+    });
+    const forked = await this.restoreSession(response.sessionId);
+    if (forked.turns.length === 0 && source.turns.length > 0) {
+      forked.turns = structuredClone(source.turns);
+      forked.hydrationCoverage = null;
+    }
+    forked.modes = response.modes ?? forked.modes;
+    forked.configOptions = response.configOptions ?? forked.configOptions;
+    this.syncStateFromConfigOptions(forked);
+    return sessionDetail(forked);
+  }
+  async getGoal(providerSessionId) {
+    return this.sessions.get(providerSessionId)?.goal ?? null;
+  }
+  async setGoal(input) {
+    const state = this.sessions.get(input.providerSessionId);
+    if (!state) {
+      throw new AgentRuntimeError("ACP session is not loaded.", "acp", "request_failed");
+    }
+    if (input.tokenBudget !== void 0 && input.tokenBudget !== null) {
+      throw new AgentRuntimeError(
+        "Codex ACP goal control does not expose token budgets.",
+        "acp",
+        "request_failed"
+      );
+    }
+    const action = input.objective?.trim() ? { action: "set", objective: input.objective.trim() } : input.status === "paused" ? { action: "pause" } : input.status === "active" ? { action: "resume" } : null;
+    if (!action) {
+      throw new AgentRuntimeError(
+        "Codex ACP goal update requires an objective, pause, or resume action.",
+        "acp",
+        "request_failed"
+      );
+    }
+    await this.invokeAcpGoal(input.providerSessionId, action);
+    if (!state.goal) {
+      throw new AgentRuntimeError(
+        "Codex ACP completed goal control without publishing a goal snapshot.",
+        "acp",
+        "invalid_response"
+      );
+    }
+    return state.goal;
+  }
+  async clearGoal(providerSessionId) {
+    const state = this.sessions.get(providerSessionId);
+    if (!state) {
+      return false;
+    }
+    const existed = Boolean(state.goal);
+    await this.invokeAcpGoal(providerSessionId, { action: "clear" });
+    return existed;
+  }
+  listHarnessExtensions() {
+    return this.extensionRegistry.list();
+  }
+  invokeHarnessExtension(input) {
+    return this.extensionRegistry.invoke(input);
+  }
+  async readSession(providerSessionId) {
+    const state = this.sessions.get(providerSessionId) ?? await this.restoreSession(providerSessionId);
+    return sessionDetail(state);
   }
   async startSession(input) {
     const context = await this.requireContext();
     const response = await context.request(methods.agent.session.new, {
-      cwd: path14.resolve(input.cwd),
+      cwd: path16.resolve(input.cwd),
       mcpServers: [],
       _meta: {
         yoloMode: input.approvalMode === "yolo"
@@ -20871,23 +21676,33 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const state = {
       providerSessionId: response.sessionId,
-      cwd: path14.resolve(input.cwd),
+      cwd: path16.resolve(input.cwd),
       title: null,
       createdAt: now,
       updatedAt: now,
-      model: input.model === "default" ? null : input.model,
-      reasoningEffort: input.reasoningEffort ?? null,
+      model: null,
+      reasoningEffort: null,
       sandboxMode: input.sandboxMode ?? null,
       status: "idle",
       turns: [],
       activeMapper: null,
       modes: response.modes ?? null,
       configOptions: response.configOptions ?? [],
-      availableCommands: []
+      availableCommands: [],
+      hydrationCoverage: null,
+      goal: null
     };
     this.sessions.set(state.providerSessionId, state);
+    this.syncStateFromConfigOptions(state);
     this.knownSessions.set(state.providerSessionId, sessionDetail(state));
-    await this.applySessionSettings(state, input.model, input.reasoningEffort, input.sandboxMode);
+    await this.applySessionSettings(
+      state,
+      input.model,
+      input.reasoningEffort,
+      input.sandboxMode,
+      void 0,
+      input.performanceMode
+    );
     const session = sessionDetail(state);
     return {
       provider: "acp",
@@ -20903,7 +21718,14 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
   async resumeSession(input) {
     const existing = this.sessions.get(input.providerSessionId);
     const state = existing ?? await this.restoreSession(input.providerSessionId);
-    await this.applySessionSettings(state, input.model, void 0, input.sandboxMode);
+    await this.applySessionSettings(
+      state,
+      input.model,
+      void 0,
+      input.sandboxMode,
+      void 0,
+      input.performanceMode
+    );
     state.status = "idle";
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     const session = sessionDetail(state);
@@ -20933,7 +21755,8 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
       input.model,
       input.reasoningEffort,
       input.sandboxMode,
-      input.collaborationMode
+      input.collaborationMode,
+      input.performanceMode
     );
     const turnId = input.displayTurnId ?? randomUUID4();
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -20955,13 +21778,21 @@ var AcpRuntimeAdapter = class extends EventEmitter7 {
       providerSessionId: state.providerSessionId,
       turn: startedTurn
     });
-    const prompt = input.developerInstructions?.trim() ? `${input.developerInstructions.trim()}
+    const prompt = await buildAcpPromptContent({
+      prompt: input.prompt,
+      workspacePath: input.workspacePath ?? state.cwd,
+      promptCapabilities: this.initializeResponse?.agentCapabilities?.promptCapabilities,
+      ...input.content ? { content: input.content } : {}
+    });
+    if (input.developerInstructions?.trim()) {
+      prompt.unshift({ type: "text", text: `${input.developerInstructions.trim()}
 
-${input.prompt}` : input.prompt;
+` });
+    }
     const context = await this.requireContext();
     void context.request(methods.agent.session.prompt, {
       sessionId: state.providerSessionId,
-      prompt: [{ type: "text", text: prompt }]
+      prompt
     }).then(
       (response) => this.completePrompt(state, mapper, response),
       (error) => this.failPrompt(state, mapper, error)
@@ -20980,7 +21811,7 @@ ${input.prompt}` : input.prompt;
     return state.activeMapper.turn("interrupted");
   }
   mapProviderRequest(request, options) {
-    if (request.method !== methods.client.session.requestPermission || !isRecord12(request.params)) {
+    if (request.method !== methods.client.session.requestPermission || !isRecord13(request.params)) {
       return null;
     }
     const params = request.params;
@@ -21027,7 +21858,7 @@ ${input.prompt}` : input.prompt;
     };
   }
   buildProviderRequestResponse(pending, input) {
-    const options = Array.isArray(pending.responsePayload?.options) ? pending.responsePayload.options.filter(isRecord12) : [];
+    const options = Array.isArray(pending.responsePayload?.options) ? pending.responsePayload.options.filter(isRecord13) : [];
     const answer = Object.values(input.answers).flatMap((entry) => entry.answers)[0] ?? "";
     const selected = options.find((option) => option.name === answer || option.id === answer);
     return selected && typeof selected.id === "string" ? selectedPermission(selected.id) : cancelledPermission();
@@ -21072,19 +21903,30 @@ ${input.prompt}` : input.prompt;
       activeMapper: null,
       modes: null,
       configOptions: [],
-      availableCommands: []
+      availableCommands: [],
+      hydrationCoverage: null,
+      goal: null
     };
     this.sessions.set(providerSessionId, state);
     try {
       const capabilities = this.initializeResponse?.agentCapabilities;
       if (capabilities?.loadSession) {
-        const response = await context.request(methods.agent.session.load, {
-          sessionId: providerSessionId,
-          cwd: summary.cwd,
-          mcpServers: []
-        });
-        state.modes = response.modes ?? null;
-        state.configOptions = response.configOptions ?? [];
+        const hydrator = new AcpSessionHydrator(providerSessionId);
+        this.hydrators.set(providerSessionId, hydrator);
+        try {
+          const response = await context.request(methods.agent.session.load, {
+            sessionId: providerSessionId,
+            cwd: summary.cwd,
+            mcpServers: []
+          });
+          state.modes = response.modes ?? null;
+          state.configOptions = response.configOptions ?? [];
+          state.turns = hydrator.complete();
+          state.hydrationCoverage = hydrator.coverage();
+          this.syncStateFromConfigOptions(state);
+        } finally {
+          this.hydrators.delete(providerSessionId);
+        }
       } else if (capabilities?.sessionCapabilities?.resume) {
         const response = await context.request(methods.agent.session.resume, {
           sessionId: providerSessionId,
@@ -21093,6 +21935,7 @@ ${input.prompt}` : input.prompt;
         });
         state.modes = response.modes ?? null;
         state.configOptions = response.configOptions ?? [];
+        this.syncStateFromConfigOptions(state);
       } else {
         throw new Error("ACP agent does not support session/load or session/resume.");
       }
@@ -21109,18 +21952,24 @@ ${input.prompt}` : input.prompt;
       );
     }
   }
-  async applySessionSettings(state, model, reasoningEffort, sandboxMode, collaborationMode) {
+  async applySessionSettings(state, model, reasoningEffort, sandboxMode, collaborationMode, performanceMode) {
     if (model && model !== "default") {
-      await this.setConfigOption(state, "model", model);
-      state.model = model;
+      state.model = await this.setConfigOption(state, "model", model);
     }
     if (reasoningEffort) {
-      await this.setConfigOption(state, "thought_level", reasoningEffort);
-      state.reasoningEffort = reasoningEffort;
+      const applied = await this.setConfigOption(
+        state,
+        "thought_level",
+        reasoningEffort
+      );
+      state.reasoningEffort = normalizeAcpEffort(applied);
     }
     if (sandboxMode !== void 0) {
       state.sandboxMode = sandboxMode;
     }
+    if (performanceMode) {
+      await this.setFastMode(state, performanceMode === "fast");
+    }
     const modes = state.modes?.availableModes ?? [];
     if (modes.length === 0) {
       return;
@@ -21146,16 +21995,27 @@ ${input.prompt}` : input.prompt;
         sessionId: state.providerSessionId,
         modelId: value
       });
-      return;
+      return value;
     }
     if (!option || option.type !== "select") {
-      return;
+      throw new AgentRuntimeError(
+        `ACP agent does not expose a ${category} config option.`,
+        "acp",
+        "request_failed"
+      );
     }
     const selected = allSelectOptions(option).find(
       (candidate) => candidate.value === value || candidate.name.toLowerCase() === value.toLowerCase()
     );
-    if (!selected || selected.value === option.currentValue) {
-      return;
+    if (!selected) {
+      throw new AgentRuntimeError(
+        `ACP agent rejected unknown ${category} option: ${value}`,
+        "acp",
+        "request_failed"
+      );
+    }
+    if (selected.value === option.currentValue) {
+      return selected.value;
     }
     const context = await this.requireContext();
     const response = await context.request(methods.agent.session.setConfigOption, {
@@ -21164,6 +22024,60 @@ ${input.prompt}` : input.prompt;
       value: selected.value
     });
     state.configOptions = response.configOptions;
+    return selected.value;
+  }
+  syncStateFromConfigOptions(state) {
+    this.updateCapabilitiesFromConfigOptions(state.configOptions);
+    const modelOption = configOptionByCategory(state.configOptions, "model");
+    if (modelOption?.type === "select") {
+      state.model = modelOption.currentValue;
+    }
+    const thoughtOption = configOptionByCategory(
+      state.configOptions,
+      "thought_level"
+    );
+    if (thoughtOption?.type === "select") {
+      state.reasoningEffort = normalizeAcpEffort(thoughtOption.currentValue);
+    }
+  }
+  updateCapabilitiesFromConfigOptions(configOptions) {
+    this.capabilities.management.models ||= Boolean(
+      configOptionByCategory(configOptions, "model")
+    );
+    this.capabilities.controls.performanceMode ||= configOptions.some(
+      (option) => option.id === "fast-mode" || option.category === "model_config"
+    );
+  }
+  async setFastMode(state, enabled) {
+    const option = state.configOptions.find(
+      (candidate) => candidate.id === "fast-mode" || candidate.category === "model_config"
+    );
+    if (!option) {
+      throw new AgentRuntimeError(
+        "The selected ACP agent does not expose fast mode.",
+        "acp",
+        "request_failed"
+      );
+    }
+    const value = option.type === "boolean" ? enabled : allSelectOptions(option).find((candidate) => enabled ? ["on", "true", "fast"].includes(candidate.value.toLowerCase()) : ["off", "false", "standard"].includes(candidate.value.toLowerCase()))?.value;
+    if (value === void 0 || value === option.currentValue) {
+      return;
+    }
+    const response = await (await this.requireContext()).request(
+      methods.agent.session.setConfigOption,
+      option.type === "boolean" ? {
+        sessionId: state.providerSessionId,
+        configId: option.id,
+        type: "boolean",
+        value
+      } : {
+        sessionId: state.providerSessionId,
+        configId: option.id,
+        value
+      }
+    );
+    state.configOptions = response.configOptions;
+    this.updateCapabilitiesFromConfigOptions(state.configOptions);
   }
   handleSessionUpdate(notification) {
     const state = this.sessions.get(notification.sessionId);
@@ -21172,8 +22086,10 @@ ${input.prompt}` : input.prompt;
     }
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     const update = notification.update;
+    const hydrator = this.hydrators.get(notification.sessionId);
     if (update.sessionUpdate === "config_option_update") {
       state.configOptions = update.configOptions;
+      this.syncStateFromConfigOptions(state);
     } else if (update.sessionUpdate === "current_mode_update" && state.modes) {
       state.modes = { ...state.modes, currentModeId: update.currentModeId };
     } else if (update.sessionUpdate === "available_commands_update") {
@@ -21181,7 +22097,7 @@ ${input.prompt}` : input.prompt;
     } else if (update.sessionUpdate === "session_info_update") {
       if (update.title !== void 0) {
         state.title = update.title;
-        if (update.title) {
+        if (update.title && !hydrator) {
           this.emitRuntimeEvent({
             type: "session.title.updated",
             provider: "acp",
@@ -21190,6 +22106,30 @@ ${input.prompt}` : input.prompt;
           });
         }
       }
+      const goal = this.goalFromSessionInfoUpdate(
+        state.providerSessionId,
+        update
+      );
+      if (goal !== void 0) {
+        state.goal = goal;
+        if (!hydrator) {
+          this.emitRuntimeEvent(goal ? {
+            type: "goal.updated",
+            provider: "acp",
+            providerSessionId: state.providerSessionId,
+            providerTurnId: state.activeMapper?.turnId ?? null,
+            goal
+          } : {
+            type: "goal.cleared",
+            provider: "acp",
+            providerSessionId: state.providerSessionId
+          });
+        }
+      }
+    }
+    if (hydrator) {
+      hydrator.apply(update);
+      return;
     }
     const mapper = state.activeMapper;
     if (!mapper) {
@@ -21328,10 +22268,17 @@ ${input.prompt}` : input.prompt;
     });
   }
   async readTextFile(params) {
-    if (!path14.isAbsolute(params.path)) {
-      throw new Error("ACP file paths must be absolute.");
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`ACP session workspace not found: ${params.sessionId}`);
     }
-    const content = await fs11.readFile(params.path, "utf8");
+    const filePath = await resolveAcpWorkspacePath(session.cwd, params.path);
+    this.emit("fs-operation", {
+      operation: "fs.readTextFile",
+      sessionId: params.sessionId,
+      path: filePath
+    });
+    const content = await fs13.readFile(filePath, "utf8");
     if (params.line === void 0 && params.limit === void 0) {
       return { content };
     }
@@ -21341,11 +22288,18 @@ ${input.prompt}` : input.prompt;
     return { content: lines.slice(start, end).join("\n") };
   }
   async writeTextFile(params) {
-    if (!path14.isAbsolute(params.path)) {
-      throw new Error("ACP file paths must be absolute.");
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`ACP session workspace not found: ${params.sessionId}`);
     }
-    await fs11.mkdir(path14.dirname(params.path), { recursive: true });
-    await fs11.writeFile(params.path, params.content, "utf8");
+    const filePath = await resolveAcpWorkspacePath(session.cwd, params.path);
+    this.emit("fs-operation", {
+      operation: "fs.writeTextFile",
+      sessionId: params.sessionId,
+      path: filePath
+    });
+    await fs13.mkdir(path16.dirname(filePath), { recursive: true });
+    await fs13.writeFile(filePath, params.content, "utf8");
     return {};
   }
   async requireContext() {
@@ -21356,9 +22310,207 @@ ${input.prompt}` : input.prompt;
     return this.context;
   }
   applyAgentCapabilities(capabilities) {
-    this.capabilities.sessions.list = Boolean(capabilities?.sessionCapabilities?.list);
-    this.capabilities.sessions.importLocal = false;
-    this.capabilities.branching.fork = false;
+    applyNegotiatedAcpCapabilities(this.capabilities, capabilities);
+  }
+  resetCapabilities() {
+    const baseline = cloneCapabilities();
+    for (const section of Object.keys(baseline)) {
+      Object.assign(this.capabilities[section], baseline[section]);
+    }
+  }
+  goalFromSessionInfoUpdate(providerSessionId, update) {
+    const meta = isRecord13(update._meta) ? update._meta : null;
+    if (!meta || !Object.hasOwn(meta, "goal")) {
+      return void 0;
+    }
+    if (meta.goal === null) {
+      return null;
+    }
+    if (!isRecord13(meta.goal)) {
+      return void 0;
+    }
+    const objective = typeof meta.goal.objective === "string" ? meta.goal.objective.trim() : "";
+    if (!objective) {
+      return void 0;
+    }
+    return {
+      providerSessionId,
+      objective,
+      status: typeof meta.goal.status === "string" ? meta.goal.status : "active",
+      tokenBudget: typeof meta.goal.tokenBudget === "number" ? meta.goal.tokenBudget : null,
+      tokensUsed: typeof meta.goal.tokensUsed === "number" ? meta.goal.tokensUsed : 0,
+      timeUsedSeconds: typeof meta.goal.timeUsedSeconds === "number" ? meta.goal.timeUsedSeconds : 0,
+      createdAt: typeof meta.goal.createdAt === "number" ? meta.goal.createdAt : Date.now(),
+      updatedAt: typeof meta.goal.updatedAt === "number" ? meta.goal.updatedAt : Date.now(),
+      rawGoal: structuredClone(meta.goal)
+    };
+  }
+  async invokeAcpGoal(providerSessionId, action) {
+    if (!this.extensionRegistry.supports("acp.goal", 1, action.action)) {
+      throw new AgentRuntimeError(
+        "The selected ACP agent does not expose goal control.",
+        "acp",
+        "request_failed"
+      );
+    }
+    const operationId = randomUUID4();
+    await this.extensionRegistry.invoke({
+      extensionId: "acp.goal",
+      extensionVersion: 1,
+      method: action.action,
+      operationId,
+      idempotencyKey: `${providerSessionId}:goal:${operationId}`,
+      params: { providerSessionId, ...action },
+      timeoutMs: 18e4
+    });
+  }
+  async runControlPrompt(providerSessionId, prompt, signal) {
+    const state = this.sessions.get(providerSessionId);
+    if (!state || state.activeMapper) {
+      throw new AgentRuntimeError(
+        "ACP control prompt requires an idle loaded session.",
+        "acp",
+        "request_failed"
+      );
+    }
+    let startedTurnId = null;
+    let cleanupCompletion;
+    const completed = new Promise(
+      (resolve, reject) => {
+        const cleanup = () => {
+          this.off("event", onEvent);
+          signal.removeEventListener("abort", onAbort);
+        };
+        const onEvent = (event) => {
+          if (event.type === "turn.completed" && event.providerSessionId === providerSessionId && (!startedTurnId || event.turn.providerTurnId === startedTurnId)) {
+            cleanup();
+            resolve(event);
+          }
+        };
+        const onAbort = () => {
+          cleanup();
+          reject(signal.reason ?? new Error("ACP control prompt cancelled."));
+        };
+        cleanupCompletion = cleanup;
+        this.on("event", onEvent);
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+    );
+    try {
+      const turn = await this.startTurn({
+        providerSessionId,
+        prompt,
+        hidden: true
+      });
+      startedTurnId = turn.providerTurnId;
+      const event = await completed;
+      if (event.turn.status === "failed") {
+        throw new Error(event.turn.error?.message ?? "ACP control prompt failed.");
+      }
+      return { providerTurnId: event.turn.providerTurnId, status: event.turn.status };
+    } catch (error) {
+      cleanupCompletion();
+      throw error;
+    }
+  }
+  registerNegotiatedExtensions(response) {
+    const snapshot = snapshotAcpInitializeResponse(response);
+    if (!snapshot || !this.context) {
+      return;
+    }
+    const wireTransport = {
+      request: (method, params, signal) => this.context.request(method, params, {
+        cancellationSignal: signal
+      })
+    };
+    for (const descriptor of snapshot.harnessExtensions) {
+      this.extensionRegistry.register({
+        ownerId: "acp-agent",
+        descriptor,
+        transport: wireTransport
+      });
+    }
+    if (snapshot.legacyExtensions.steering?.supported) {
+      this.extensionRegistry.register({
+        ownerId: "acp-agent",
+        descriptor: {
+          id: "acp.steering",
+          version: 1,
+          stability: "experimental",
+          methods: ["steer"],
+          events: []
+        },
+        transport: wireTransport,
+        wireMethods: { steer: "_session/steering" },
+        paramMappers: {
+          steer: (envelope) => {
+            const params = isRecord13(envelope.params) ? envelope.params : {};
+            return {
+              sessionId: params.providerSessionId,
+              prompt: params.prompt
+            };
+          }
+        },
+        capabilityPatch: { turns: { steer: true } }
+      });
+    }
+    const goal = snapshot.legacyExtensions.goal;
+    const goalVersion = typeof goal?.version === "number" ? goal.version : goal?.version === "1" ? 1 : null;
+    if (goal?.controlMethod && goalVersion === 1 && goal.actions.includes("set") && goal.actions.includes("clear")) {
+      const actions = goal.actions.filter((action) => ["set", "pause", "resume", "clear"].includes(action));
+      this.extensionRegistry.register({
+        ownerId: "acp-agent",
+        descriptor: {
+          id: "acp.goal",
+          version: goalVersion,
+          stability: "experimental",
+          methods: actions,
+          events: []
+        },
+        transport: wireTransport,
+        wireMethods: Object.fromEntries(actions.map((action) => [action, goal.controlMethod])),
+        paramMappers: Object.fromEntries(actions.map((action) => [
+          action,
+          (envelope) => {
+            const params = isRecord13(envelope.params) ? envelope.params : {};
+            return {
+              sessionId: params.providerSessionId,
+              action,
+              ...action === "set" ? { objective: params.objective } : {}
+            };
+          }
+        ])),
+        capabilityPatch: { controls: { goals: true } }
+      });
+    }
+    if (snapshot.agentInfo?.name === "@agentclientprotocol/codex-acp") {
+      this.extensionRegistry.register({
+        ownerId: "acp-agent",
+        descriptor: {
+          id: "codex.control",
+          version: 1,
+          stability: "experimental",
+          methods: ["compact"],
+          events: []
+        },
+        transport: {
+          request: async (_method, params, signal) => {
+            const providerSessionId = isRecord13(params) ? String(params.providerSessionId ?? "") : "";
+            return this.runControlPrompt(providerSessionId, "/compact", signal);
+          }
+        },
+        paramMappers: {
+          compact: (envelope) => ({
+            providerSessionId: isRecord13(envelope.params) ? envelope.params.providerSessionId : null
+          })
+        },
+        capabilityPatch: { turns: { compact: true } }
+      });
+    }
+    const effective = this.extensionRegistry.effectiveCapabilities(this.capabilities);
+    for (const section of Object.keys(effective)) {
+      Object.assign(this.capabilities[section], effective[section]);
+    }
   }
   withStartupTimeout(promise) {
     const timeoutMs = this.options.startupTimeoutMs ?? 1e4;
@@ -21381,6 +22533,8 @@ ${input.prompt}` : input.prompt;
   }
   markFailed(error) {
     const message = errorMessage3(error);
+    this.settleActiveTurns("failed", message);
+    this.cancelPendingPermissions();
     this.status = {
       ...this.status,
       state: "failed",
@@ -21389,14 +22543,49 @@ ${input.prompt}` : input.prompt;
     this.installation.lastError = message;
     this.emit("status", this.getStatus());
   }
+  cancelPendingPermissions() {
+    for (const [id, permission] of this.pendingPermissions) {
+      clearTimeout(permission.timer);
+      permission.resolve(cancelledPermission());
+      this.pendingPermissions.delete(id);
+    }
+  }
+  settleActiveTurns(status, error) {
+    for (const state of this.sessions.values()) {
+      const mapper = state.activeMapper;
+      if (!mapper) {
+        continue;
+      }
+      const completed = mapper.complete(status, error);
+      for (const itemUpdate of completed.updates) {
+        this.emitItemUpdate(state, mapper.turnId, itemUpdate);
+      }
+      const turn = {
+        ...completed.turn,
+        startedAt: state.turns.find(
+          (candidate) => candidate.providerTurnId === mapper.turnId
+        )?.startedAt ?? null
+      };
+      this.replaceTurn(state, turn);
+      state.activeMapper = null;
+      state.status = status;
+      state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.emitRuntimeEvent({
+        type: "turn.completed",
+        provider: "acp",
+        providerSessionId: state.providerSessionId,
+        turn
+      });
+    }
+  }
   emitRuntimeEvent(event) {
     this.emit("event", event);
   }
 };
 
 // ../../packages/acp/src/codex-environment.ts
-import fs12 from "fs/promises";
-import path15 from "path";
+import fs14 from "fs/promises";
+import path17 from "path";
 
 // ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/date.js
 var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
@@ -22060,7 +23249,7 @@ async function loadCodexAcpEnvironment(codexHome, inheritedEnv = process.env, co
     return env;
   }
   try {
-    const source = await fs12.readFile(path15.join(normalizedHome, "config.toml"), "utf8");
+    const source = await fs14.readFile(path17.join(normalizedHome, "config.toml"), "utf8");
     env.CODEX_CONFIG = JSON.stringify(parse(source));
   } catch {
   }
@@ -22113,7 +23302,12 @@ var catalogCapabilities = {
 };
 var catalogManagementSchema = {
   hostConfigFiles: [],
-  toolboxItems: [],
+  toolboxItems: [
+    { action: "fast", command: "/fast", label: "Fast mode" },
+    { action: "compact", command: "/compact", label: "Compact context" },
+    { action: "goal", command: "/goal", label: "Goal" },
+    { action: "fork", command: "/fork", label: "Fork" }
+  ],
   hookCommandTemplates: [],
   providerConfigFormat: "none",
   mcpConfigFormat: "none",
@@ -22137,12 +23331,14 @@ function decodeScopedId(value) {
 function scopedSession(agentId, session) {
   return {
     ...session,
+    agentId,
     providerSessionId: encodeSessionId(agentId, session.providerSessionId)
   };
 }
 function scopedSummary(agentId, session) {
   return {
     ...session,
+    agentId,
     providerSessionId: encodeSessionId(agentId, session.providerSessionId)
   };
 }
@@ -22151,7 +23347,7 @@ function delegatedSessionInput(input) {
   delete delegated.agentId;
   return delegated;
 }
-var AcpCatalogRuntimeAdapter = class extends EventEmitter8 {
+var AcpCatalogRuntimeAdapter = class extends EventEmitter9 {
   constructor(options = {}) {
     super();
     this.options = options;
@@ -22167,8 +23363,8 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter8 {
   managementSchema = catalogManagementSchema;
   installation = {
     packageName: null,
-    installed: false,
-    installedVersion: null,
+    installed: true,
+    installedVersion: "Built in \xB7 0 ACP agents ready",
     latestVersion: null,
     installCommand: null,
     updateCommand: null,
@@ -22178,6 +23374,11 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter8 {
   catalog;
   agents = /* @__PURE__ */ new Map();
   modelCache = /* @__PURE__ */ new Map();
+  operationalMetrics = {
+    sessionStartFailures: 0,
+    resumeFailures: 0,
+    capabilityProbeFailures: 0
+  };
   status = {
     state: "stopped",
     transport: "stdio",
@@ -22186,7 +23387,10 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter8 {
     restartCount: 0
   };
   getStatus() {
-    return { ...this.status };
+    return {
+      ...this.status,
+      operationalMetrics: { ...this.operationalMetrics }
+    };
   }
   async start() {
     this.status = {
@@ -22201,6 +23405,7 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter8 {
   async stop() {
     await Promise.allSettled([...this.agents.values()].map((agent) => agent.stop()));
     this.agents.clear();
+    this.recomputeAgentCapabilities();
     this.status = {
       ...this.status,
       state: "stopped",
@@ -22228,21 +23433,58 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter8 {
     }));
   }
   async listModelsForAgent(agentId, cwd) {
-    const cacheKey = `${agentId}\0${cwd}`;
-    const cached = this.modelCache.get(cacheKey);
-    if (cached && Date.now() - cached.at < 3e4) {
-      return cached.models;
-    }
-    const agent = await this.agentFor(agentId);
-    let models = await agent.inspectModelOptions(cwd);
-    if (models.length === 1 && models[0]?.model === "default") {
-      const commandModels = await this.catalog.listCommandModels(agentId);
-      if (commandModels.length > 0) {
-        models = commandModels;
+    try {
+      const cacheKey = `${agentId}\0${cwd}`;
+      const cached = this.modelCache.get(cacheKey);
+      if (cached && Date.now() - cached.at < 3e4) {
+        return cached.models;
+      }
+      const agent = await this.agentFor(agentId);
+      let models = await agent.inspectModelOptions(cwd);
+      if (agent.capabilities.controls.performanceMode) {
+        models = models.map((model) => ({
+          ...model,
+          supportsPerformanceMode: true
+        }));
+      }
+      if (models.length === 1 && models[0]?.model === "default") {
+        const commandModels = await this.catalog.listCommandModels(agentId);
+        if (commandModels.length > 0) {
+          models = commandModels;
+        }
       }
+      this.modelCache.set(cacheKey, { at: Date.now(), models });
+      return models;
+    } catch (error) {
+      this.operationalMetrics.capabilityProbeFailures += 1;
+      throw error;
     }
-    this.modelCache.set(cacheKey, { at: Date.now(), models });
-    return models;
+  }
+  async getAgentCapabilitySnapshot(agentId) {
+    const entry = (await this.refreshCatalog()).find((candidate) => candidate.id === agentId);
+    if (!entry) {
+      throw new AgentRuntimeError(`Unknown ACP agent: ${agentId}`, "acp", "request_failed");
+    }
+    if (entry.availability !== "ready") {
+      return snapshotAcpAgentCapabilities({
+        agentId,
+        availability: entry.availability,
+        effectiveCapabilities: this.capabilities
+      });
+    }
+    const agent = await this.agentFor(agentId);
+    return snapshotAcpAgentCapabilities({
+      agentId,
+      availability: entry.availability,
+      negotiated: agent.getProtocolSnapshot(),
+      effectiveCapabilities: agent.capabilities
+    });
+  }
+  getScopedCapabilities(input) {
+    const sessionOwner = input.providerSessionId ? decodeScopedId(input.providerSessionId) : null;
+    const agentId = sessionOwner?.agentId ?? input.agentId ?? null;
+    const child = agentId ? this.agents.get(agentId) : null;
+    return structuredClone(child?.capabilities ?? catalogCapabilities);
   }
   async installModel(modelId) {
     await this.catalog.installAdapter(modelId);
@@ -22256,6 +23498,23 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter8 {
     );
     return sessions.flat();
   }
+  async listImportSessions(agentId) {
+    const entries = agentId ? (await this.refreshCatalog()).filter((entry) => entry.id === agentId) : [];
+    const sessions = await Promise.all(
+      entries.map(async (entry) => {
+        if (entry.availability !== "ready") {
+          return [];
+        }
+        try {
+          const agent = await this.agentFor(entry.id);
+          return (await agent.listSessions()).map((session) => scopedSummary(entry.id, session));
+        } catch {
+          return [];
+        }
+      })
+    );
+    return sessions.flat();
+  }
   async listLoadedSessions() {
     const sessions = await Promise.all(
       [...this.agents.entries()].map(
@@ -22280,25 +23539,43 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter8 {
     if (!agentId) {
       throw new AgentRuntimeError("Select an ACP agent before creating the thread.", "acp");
     }
-    const agent = await this.agentFor(agentId);
-    const response = await agent.startSession(delegatedSessionInput(input));
+    let agent;
+    let response;
+    try {
+      agent = await this.agentFor(agentId);
+      response = await agent.startSession(delegatedSessionInput(input));
+    } catch (error) {
+      this.operationalMetrics.sessionStartFailures += 1;
+      throw error;
+    }
+    const probedDefaultModel = this.modelCache.get(`${agentId}\0${input.cwd}`)?.models.find((model) => model.isDefault)?.model ?? null;
+    const resolvedModel = response.model && response.model !== "default" ? response.model : input.model !== "default" ? input.model : probedDefaultModel ?? input.model;
+    this.refreshAgentSessionCapabilities(agentId, agent);
     const session = scopedSession(agentId, response.session);
     return {
       ...response,
       agentId,
       providerSessionId: session.providerSessionId,
-      model: response.model ?? input.model,
+      model: resolvedModel,
       reasoningEffort: response.reasoningEffort ?? input.reasoningEffort ?? null,
       session
     };
   }
   async resumeSession(input) {
     const owner = this.requireSessionOwner(input.providerSessionId);
-    const agent = await this.agentFor(owner.agentId);
-    const response = await agent.resumeSession({
-      ...input,
-      providerSessionId: owner.rawId
-    });
+    let agent;
+    let response;
+    try {
+      agent = await this.agentFor(owner.agentId);
+      response = await agent.resumeSession({
+        ...input,
+        providerSessionId: owner.rawId
+      });
+    } catch (error) {
+      this.operationalMetrics.resumeFailures += 1;
+      throw error;
+    }
+    this.refreshAgentSessionCapabilities(owner.agentId, agent);
     const session = scopedSession(owner.agentId, response.session);
     return {
       ...response,
@@ -22324,15 +23601,63 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter8 {
       providerSessionId: owner.rawId
     });
   }
+  async sendInput(input) {
+    const owner = this.requireSessionOwner(input.providerSessionId);
+    const agent = await this.agentFor(owner.agentId);
+    return agent.sendInput({
+      ...input,
+      providerSessionId: owner.rawId
+    });
+  }
+  async compactSession(providerSessionId) {
+    const owner = this.requireSessionOwner(providerSessionId);
+    const agent = await this.agentFor(owner.agentId);
+    return agent.compactSession(owner.rawId);
+  }
+  async forkSession(input) {
+    const owner = this.requireSessionOwner(input.providerSessionId);
+    const agent = await this.agentFor(owner.agentId);
+    return scopedSession(owner.agentId, await agent.forkSession({
+      ...input,
+      providerSessionId: owner.rawId
+    }));
+  }
+  async getGoal(providerSessionId) {
+    const owner = this.requireSessionOwner(providerSessionId);
+    const agent = await this.agentFor(owner.agentId);
+    return agent.getGoal(owner.rawId);
+  }
+  async setGoal(input) {
+    const owner = this.requireSessionOwner(input.providerSessionId);
+    const agent = await this.agentFor(owner.agentId);
+    const goal = await agent.setGoal({
+      ...input,
+      providerSessionId: owner.rawId
+    });
+    return {
+      ...goal,
+      providerSessionId: encodeSessionId(owner.agentId, goal.providerSessionId)
+    };
+  }
+  async clearGoal(providerSessionId) {
+    const owner = this.requireSessionOwner(providerSessionId);
+    const agent = await this.agentFor(owner.agentId);
+    return agent.clearGoal(owner.rawId);
+  }
   mapProviderRequest(request, options) {
     const owner = decodeScopedId(request.id);
     const agent = owner ? this.agents.get(owner.agentId) : null;
     if (!owner || !agent) {
       return null;
     }
+    const scopedProviderSessionId = request.params && typeof request.params === "object" ? String(request.params.sessionId ?? "") : "";
+    const sessionOwner = decodeScopedId(scopedProviderSessionId);
+    if (!sessionOwner || sessionOwner.agentId !== owner.agentId || !sessionOwner.rawId) {
+      return null;
+    }
     const params = request.params && typeof request.params === "object" ? {
       ...request.params,
-      sessionId: owner.rawId
+      sessionId: sessionOwner.rawId
     } : request.params;
     const mapping = agent.mapProviderRequest({
       ...request,
@@ -22377,8 +23702,8 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter8 {
     const entries = await this.catalog.list({ force });
     const ready = entries.filter((entry) => entry.availability === "ready");
     const baseInstalled = entries.filter((entry) => entry.availability !== "base_missing");
-    this.installation.installed = baseInstalled.length > 0;
-    this.installation.installedVersion = ready.length > 0 ? `${ready.length} ACP agent${ready.length === 1 ? "" : "s"} ready` : null;
+    this.installation.installed = true;
+    this.installation.installedVersion = `Built in \xB7 ${ready.length} ACP agent${ready.length === 1 ? "" : "s"} ready`;
     this.installation.lastError = ready.length > 0 ? null : baseInstalled.length > 0 ? "ACP adapters or native ACP servers are not ready." : "No supported base agent was detected.";
     this.status = {
       ...this.status,
@@ -22393,6 +23718,7 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter8 {
     const existing = this.agents.get(agentId);
     if (existing) {
       await existing.start();
+      this.mergeAgentCapabilities(existing);
       return existing;
     }
     const entry = (await this.catalog.list()).find((candidate) => candidate.id === agentId);
@@ -22411,12 +23737,41 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter8 {
     this.agents.set(agentId, agent);
     try {
       await agent.start();
+      this.mergeAgentCapabilities(agent);
       return agent;
     } catch (error) {
       this.agents.delete(agentId);
       throw error;
     }
   }
+  mergeAgentCapabilities(agent) {
+    void agent;
+    this.recomputeAgentCapabilities();
+  }
+  refreshAgentSessionCapabilities(agentId, agent) {
+    for (const key of this.modelCache.keys()) {
+      if (key.startsWith(`${agentId}\0`)) {
+        this.modelCache.delete(key);
+      }
+    }
+    this.mergeAgentCapabilities(agent);
+  }
+  recomputeAgentCapabilities() {
+    const next = structuredClone(catalogCapabilities);
+    for (const child of this.agents.values()) {
+      next.turns.steer ||= child.capabilities.turns.steer;
+      next.turns.compact ||= child.capabilities.turns.compact;
+      next.branching.fork ||= child.capabilities.branching.fork;
+      next.controls.goals ||= child.capabilities.controls.goals;
+      next.controls.performanceMode ||= child.capabilities.controls.performanceMode;
+      next.management.mcpStatus ||= child.capabilities.management.mcpStatus;
+      next.management.skills ||= child.capabilities.management.skills;
+      next.management.hooks ||= child.capabilities.management.hooks;
+    }
+    for (const section of Object.keys(next)) {
+      Object.assign(this.capabilities[section], next[section]);
+    }
+  }
   async createAgent(entry) {
     const env = entry.id === "codex" ? await loadCodexAcpEnvironment(
       this.options.codexHome,
@@ -22430,9 +23785,16 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter8 {
       ...this.options.clientInfo !== void 0 ? { clientInfo: this.options.clientInfo } : {}
     });
     agent.on("event", (event) => {
+      const providerSessionId = encodeSessionId(entry.id, event.providerSessionId);
       this.emit("event", {
         ...event,
-        providerSessionId: encodeSessionId(entry.id, event.providerSessionId)
+        providerSessionId,
+        ...event.type === "goal.updated" ? {
+          goal: {
+            ...event.goal,
+            providerSessionId
+          }
+        } : {}
       });
     });
     agent.on("provider-request", (request) => {
@@ -22467,9 +23829,9 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter8 {
 };
 
 // src/e2e-fake-runtime.ts
-import { EventEmitter as EventEmitter9 } from "events";
+import { EventEmitter as EventEmitter10 } from "events";
 import { mkdir, writeFile } from "fs/promises";
-import path16 from "path";
+import path18 from "path";
 var provider = "claude";
 var firstDelta = "IOS_STREAM_DELTA_READY";
 var secondDelta = " IOS_STREAM_COMPLETED";
@@ -22481,7 +23843,7 @@ var historyDetailPromptMarker = "IOS_HISTORY_DETAIL";
 var historyPagePromptMarker = "IOS_HISTORY_PAGE";
 var imageAssetPromptMarker = "IOS_IMAGE_ASSET";
 var imageAssetPngBase64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=";
-var E2EFakeRuntime = class extends EventEmitter9 {
+var E2EFakeRuntime = class extends EventEmitter10 {
   provider = provider;
   displayName = "E2E Fake Runtime";
   description = "Deterministic runtime for live iOS and web end-to-end tests.";
@@ -22891,8 +24253,8 @@ var E2EFakeRuntime = class extends EventEmitter9 {
     }
     if (input.prompt.includes(imageAssetPromptMarker)) {
       const relativeImagePath = `./.temp/threads/${providerTurnId}/ios-webview-image.png`;
-      const absoluteImagePath = path16.join(session.cwd, relativeImagePath);
-      await mkdir(path16.dirname(absoluteImagePath), { recursive: true });
+      const absoluteImagePath = path18.join(session.cwd, relativeImagePath);
+      await mkdir(path18.dirname(absoluteImagePath), { recursive: true });
       await writeFile(absoluteImagePath, Buffer.from(imageAssetPngBase64, "base64"));
       const imageItem = {
         id: `${providerTurnId}:image-asset`,
@@ -23029,20 +24391,20 @@ var E2EFakeRuntime = class extends EventEmitter9 {
     return [];
   }
   mapProviderRequest(request) {
-    if (request.provider !== provider || !isRecord13(request.params)) {
+    if (request.provider !== provider || !isRecord14(request.params)) {
       return null;
     }
-    const providerSessionId = stringValue4(request.params.providerSessionId);
-    const providerTurnId = stringValue4(request.params.providerTurnId);
+    const providerSessionId = stringValue5(request.params.providerSessionId);
+    const providerTurnId = stringValue5(request.params.providerTurnId);
     if (!providerSessionId) {
       return null;
     }
     if (request.method === "item/commandExecution/requestApproval") {
       const requestId = String(request.id);
       const description = [
-        stringValue4(request.params.reason),
-        stringValue4(request.params.command) ? `Command: ${stringValue4(request.params.command)}` : null,
-        stringValue4(request.params.cwd) ? `CWD: ${stringValue4(request.params.cwd)}` : null
+        stringValue5(request.params.reason),
+        stringValue5(request.params.command) ? `Command: ${stringValue5(request.params.command)}` : null,
+        stringValue5(request.params.cwd) ? `CWD: ${stringValue5(request.params.cwd)}` : null
       ].filter(Boolean).join("\n");
       return {
         providerRequestId: request.id,
@@ -23057,7 +24419,7 @@ var E2EFakeRuntime = class extends EventEmitter9 {
             title: "Command approval required",
             description: description || "iOS E2E approval request.",
             turnId: providerTurnId,
-            itemId: stringValue4(request.params.itemId),
+            itemId: stringValue5(request.params.itemId),
             createdAt: (/* @__PURE__ */ new Date()).toISOString(),
             questions: [
               {
@@ -23091,7 +24453,7 @@ var E2EFakeRuntime = class extends EventEmitter9 {
             title: "Mode",
             description: "Which iOS E2E path should continue?",
             turnId: providerTurnId,
-            itemId: stringValue4(request.params.toolUseId),
+            itemId: stringValue5(request.params.toolUseId),
             createdAt: (/* @__PURE__ */ new Date()).toISOString(),
             questions: [
               {
@@ -23179,10 +24541,10 @@ function isE2EFakeRuntimeEnabled(env = process.env) {
   const value = env.REMOTE_CODEX_E2E_FAKE_RUNTIME;
   return value ? ["1", "true", "yes", "on"].includes(value.toLowerCase()) : false;
 }
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function stringValue4(value) {
+function stringValue5(value) {
   return typeof value === "string" ? value : null;
 }
 function deltasForPrompt(prompt) {
@@ -23279,8 +24641,8 @@ function createOpenCodeRuntime(config) {
 }
 
 // src/event-bus.ts
-import { EventEmitter as EventEmitter10 } from "events";
-var SupervisorEventBus = class extends EventEmitter10 {
+import { EventEmitter as EventEmitter11 } from "events";
+var SupervisorEventBus = class extends EventEmitter11 {
   emitThreadEvent(event) {
     this.emit("thread-event", event);
   }
@@ -23302,7 +24664,7 @@ var SupervisorEventBus = class extends EventEmitter10 {
 };
 
 // src/thread-service.ts
-import fs17 from "fs/promises";
+import fs19 from "fs/promises";
 
 // src/thread-auxiliary-state-store.ts
 var ThreadAuxiliaryStateStore = class {
@@ -23544,7 +24906,8 @@ var ThreadGoalCoordinator = class {
       });
     }
     const runtime = this.callbacks.runtimeForProvider(record2.provider);
-    if (!runtime.setGoal || !runtime.capabilities.controls.goals) {
+    const capabilities = await this.callbacks.capabilitiesForRecord(record2);
+    if (!runtime.setGoal || !capabilities.controls.goals) {
       throw new HttpError(409, {
         code: "conflict",
         message: "This backend does not support goals."
@@ -23621,7 +24984,8 @@ var ThreadGoalCoordinator = class {
       });
     }
     const runtime = this.callbacks.runtimeForProvider(record2.provider);
-    if (!runtime.clearGoal || !runtime.capabilities.controls.goals) {
+    const capabilities = await this.callbacks.capabilitiesForRecord(record2);
+    if (!runtime.clearGoal || !capabilities.controls.goals) {
       throw new HttpError(409, {
         code: "conflict",
         message: "This backend does not support goals."
@@ -23647,7 +25011,8 @@ var ThreadGoalCoordinator = class {
         await this.ensureGoalsFeatureEnabled(record2.provider);
       }
       const runtime = this.callbacks.runtimeForProvider(record2.provider);
-      if (!runtime.getGoal || !runtime.capabilities.controls.goals) {
+      const capabilities = await this.callbacks.capabilitiesForRecord(record2);
+      if (!runtime.getGoal || !capabilities.controls.goals) {
         return null;
       }
       const goal = await runtime.getGoal(record2.providerSessionId);
@@ -24609,7 +25974,7 @@ function agentMessageMatchScore(finalText, liveText) {
 }
 
 // src/thread-usage-accounting.ts
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function numberOrNull2(value) {
@@ -24655,11 +26020,11 @@ function computeContextRemainingPercent(tokensInContextWindow, contextWindow) {
   return clampPercentage(Math.round(remaining / contextWindow * 100));
 }
 function buildThreadContextUsageFromPayload(payload, model = null, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
-  const tokenUsage = isRecord14(payload) ? payload : null;
+  const tokenUsage = isRecord15(payload) ? payload : null;
   const modelContextWindow = numberOrNull2(
     tokenUsage?.modelContextWindow ?? tokenUsage?.model_context_window
   ) ?? contextWindowForModel(model);
-  const lastUsage = isRecord14(tokenUsage?.last) ? tokenUsage.last : null;
+  const lastUsage = isRecord15(tokenUsage?.last) ? tokenUsage.last : null;
   const tokensInContextWindow = numberOrNull2(
     lastUsage?.totalTokens ?? lastUsage?.total_tokens
   );
@@ -24679,7 +26044,7 @@ function buildThreadContextUsageFromPayload(payload, model = null, timestamp = (
 }
 function mergeThreadContextUsageFromPayload(current, payload, model = null, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
   const next = buildThreadContextUsageFromPayload(payload, model, timestamp);
-  const payloadRecord = isRecord14(payload) ? payload : null;
+  const payloadRecord = isRecord15(payload) ? payload : null;
   const reportedModelContextWindow = numberOrNull2(
     payloadRecord?.modelContextWindow ?? payloadRecord?.model_context_window
   );
@@ -24705,11 +26070,11 @@ function shouldResetThreadContextUsageForTurnStart(current) {
   return current?.availability !== "available";
 }
 function buildTurnTokenBreakdown(payload) {
-  const usage = isRecord14(payload) ? payload : null;
-  const inputDetails = isRecord14(
+  const usage = isRecord15(payload) ? payload : null;
+  const inputDetails = isRecord15(
     usage?.inputTokensDetails ?? usage?.input_tokens_details
   ) ? usage?.inputTokensDetails ?? usage?.input_tokens_details : null;
-  const cache = isRecord14(usage?.cache) ? usage.cache : null;
+  const cache = isRecord15(usage?.cache) ? usage.cache : null;
   const totalTokens2 = numberOrNull2(usage?.totalTokens ?? usage?.total_tokens);
   const inputTokens = numberOrNull2(usage?.inputTokens ?? usage?.input_tokens);
   const cachedInputTokens = numberOrNull2(
@@ -24764,12 +26129,12 @@ function subtractTurnTokenBreakdowns(current, previous) {
   };
 }
 function parseThreadTurnTokenUsage(payload) {
-  const tokenUsage = isRecord14(payload) ? payload : null;
+  const tokenUsage = isRecord15(payload) ? payload : null;
   const total = buildTurnTokenBreakdown(
-    isRecord14(tokenUsage?.total) ? tokenUsage.total : null
+    isRecord15(tokenUsage?.total) ? tokenUsage.total : null
   );
   const last = buildTurnTokenBreakdown(
-    isRecord14(tokenUsage?.last) ? tokenUsage.last : null
+    isRecord15(tokenUsage?.last) ? tokenUsage.last : null
   );
   const modelContextWindow = numberOrNull2(
     tokenUsage?.modelContextWindow ?? tokenUsage?.model_context_window
@@ -24794,7 +26159,7 @@ function parseStoredThreadTurnTokenUsageState(value) {
   try {
     const parsed = JSON.parse(value);
     const baselineTotal = buildTurnTokenBreakdown(
-      isRecord14(parsed?.baselineTotal) ? parsed.baselineTotal : null
+      isRecord15(parsed?.baselineTotal) ? parsed.baselineTotal : null
     );
     const usage = parseThreadTurnTokenUsage(parsed);
     const modelContextWindow = usage?.modelContextWindow ?? numberOrNull2(parsed?.modelContextWindow ?? parsed?.model_context_window);
@@ -24842,12 +26207,12 @@ function stringifyStoredThreadTurnTokenUsageState(state) {
   });
 }
 function buildThreadTurnTokenUsage(payload, baselineTotal, previous = null, fallbackModelContextWindow = null) {
-  const tokenUsage = isRecord14(payload) ? payload : null;
+  const tokenUsage = isRecord15(payload) ? payload : null;
   const cumulativeTotal = buildTurnTokenBreakdown(
-    isRecord14(tokenUsage?.total) ? tokenUsage.total : null
+    isRecord15(tokenUsage?.total) ? tokenUsage.total : null
   );
   const last = buildTurnTokenBreakdown(
-    isRecord14(tokenUsage?.last) ? tokenUsage.last : null
+    isRecord15(tokenUsage?.last) ? tokenUsage.last : null
   );
   const modelContextWindow = numberOrNull2(
     tokenUsage?.modelContextWindow ?? tokenUsage?.model_context_window
@@ -24941,7 +26306,7 @@ var ThreadUsageAccounting = class {
       input.localThreadId
     );
     const currentCumulativeTotal = buildTurnTokenBreakdown(
-      isRecord14(input.tokenUsage?.total) ? input.tokenUsage.total : null
+      isRecord15(input.tokenUsage?.total) ? input.tokenUsage.total : null
     );
     if (currentCumulativeTotal) {
       this.threadCumulativeTokenUsage.set(input.localThreadId, currentCumulativeTotal);
@@ -25148,7 +26513,10 @@ var ThreadRuntimeEventProjector = class {
         }
         const pricingSnapshot = buildThreadTurnPricingSnapshot(
           record2.model,
-          callbacks.fastModeForProvider(record2.provider, record2.fastMode)
+          callbacks.fastModeForProvider(record2.provider, record2.fastMode, {
+            agentId: record2.agentId ?? null,
+            providerSessionId: record2.providerSessionId ?? null
+          })
         );
         upsertThreadTurnMetadata(db, {
           threadId: record2.id,
@@ -25279,7 +26647,8 @@ var ThreadRuntimeEventProjector = class {
           itemId: event.itemId,
           delta: event.delta,
           sequence,
-          createdAt
+          createdAt,
+          checkpoint: event.provider === "acp"
         });
         callbacks.invalidateThreadDetailCache(record2.id);
         callbacks.emitThreadEvent("thread.output.delta", record2.id, {
@@ -25291,6 +26660,37 @@ var ThreadRuntimeEventProjector = class {
         });
         return;
       }
+      case "harness.extension": {
+        const record2 = this.findRecordByProviderSessionId(
+          event.provider,
+          event.providerSessionId
+        );
+        if (!record2 || !event.providerTurnId || !event.providerItemId) {
+          return;
+        }
+        const turnId = liveState.displayTurnIdForRuntimeTurn(record2.id, event.providerTurnId) ?? event.providerTurnId;
+        const item = {
+          id: event.providerItemId,
+          kind: "other",
+          text: `${event.extensionId}: ${event.event}`,
+          status: "completed",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          sequence: liveState.recordTurnItemOrder(
+            record2.id,
+            turnId,
+            event.providerItemId
+          ),
+          sourceTurnId: event.providerTurnId
+        };
+        callbacks.persistLiveHistoryItem(record2.id, turnId, item);
+        liveState.upsertLiveItem(record2.id, turnId, item);
+        callbacks.invalidateThreadDetailCache(record2.id);
+        callbacks.emitThreadEvent("thread.item.completed", record2.id, {
+          turnId,
+          item
+        });
+        return;
+      }
       case "turn.completed": {
         const record2 = this.findRecordByProviderSessionId(
           event.provider,
@@ -25542,7 +26942,7 @@ var ProviderRequestCoordinator = class {
     const defaultMappedRequest = runtime.mapProviderRequest?.(request, {
       approvalMode: "guarded"
     });
-    const providerSessionIdFromParams = isRecord15(request.params) ? request.params.providerSessionId ?? request.params.threadId ?? request.params.conversationId ?? request.params.sessionId : null;
+    const providerSessionIdFromParams = isRecord16(request.params) ? request.params.providerSessionId ?? request.params.threadId ?? request.params.conversationId ?? request.params.sessionId : null;
     const providerSessionId = defaultMappedRequest?.providerSessionId ?? (typeof providerSessionIdFromParams === "string" ? providerSessionIdFromParams : null);
     const record2 = providerSessionId ? this.callbacks.findRecordByProviderSessionId(request.provider, providerSessionId) : null;
     if (!record2) {
@@ -25755,7 +27155,7 @@ function buildRequestAnswerLines(request, input) {
     return `- ${question.question}: ${answers.join(", ")}`;
   }).filter((line) => Boolean(line));
 }
-function isRecord15(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -25867,6 +27267,15 @@ var ThreadDetailAssembler = class {
     const persistedItemsByTurnIdForPatch = this.input.callbacks.listPersistedHistoryItemsByTurnId(
       input.localThreadId
     );
+    if (input.record.provider === "acp") {
+      remoteSession = {
+        ...remoteSession,
+        turns: alignHydratedAcpTurnsWithPersistedHistory(
+          remoteSession.turns,
+          persistedItemsByTurnIdForPatch
+        )
+      };
+    }
     const activeDisplayTurnId = this.input.liveState.displayTurnIdForRuntimeTurn(
       input.localThreadId,
       input.record.providerTurnId
@@ -26117,6 +27526,101 @@ function appendPersistedFailureTurnsIfMissing(turns, persistedItemsByTurnId, met
   }
   return sortTurnsByStartedAt([...turns, ...missingFailureTurns]);
 }
+function normalizedConversationText(value) {
+  return value?.replace(/\s+/g, " ").trim() ?? "";
+}
+function turnConversationText(items, kind) {
+  return items.filter((item) => item.kind === kind).map((item) => normalizedConversationText(item.text)).filter(Boolean).join("\n");
+}
+function conversationMatchScore(turn, persistedItems) {
+  const remoteUser = turnConversationText(turn.items, "userMessage");
+  const persistedUser = turnConversationText(persistedItems, "userMessage");
+  if (!remoteUser || !persistedUser) {
+    return 0;
+  }
+  const userScore = remoteUser === persistedUser ? 2 : Math.min(remoteUser.length, persistedUser.length) >= 16 && (remoteUser.includes(persistedUser) || persistedUser.includes(remoteUser)) ? 1 : 0;
+  if (userScore === 0) {
+    return 0;
+  }
+  const remoteAgent = turnConversationText(turn.items, "agentMessage");
+  const persistedAgent = turnConversationText(persistedItems, "agentMessage");
+  if (!remoteAgent || !persistedAgent) {
+    return userScore;
+  }
+  if (remoteAgent === persistedAgent) {
+    return userScore + 4;
+  }
+  if (remoteAgent.includes(persistedAgent) || persistedAgent.includes(remoteAgent)) {
+    return userScore + 3;
+  }
+  return userScore;
+}
+function historyItemMatchScore(remote, persisted) {
+  if (remote.id === persisted.id) {
+    return 100;
+  }
+  if (remote.kind !== persisted.kind) {
+    return 0;
+  }
+  const remoteText = normalizedConversationText(remote.detailText ?? remote.text);
+  const persistedText = normalizedConversationText(persisted.detailText ?? persisted.text);
+  if (!remoteText || !persistedText) {
+    return 0;
+  }
+  if (remoteText === persistedText) {
+    return 50;
+  }
+  if ((remote.kind === "agentMessage" || remote.kind === "reasoning") && (remoteText.includes(persistedText) || persistedText.includes(remoteText))) {
+    return 40;
+  }
+  return 0;
+}
+function alignHydratedItems(remoteItems, persistedItems, turnId) {
+  const used = /* @__PURE__ */ new Set();
+  return remoteItems.map((remote) => {
+    const match = persistedItems.filter((persisted) => !used.has(persisted.id)).map((persisted, index) => ({
+      persisted,
+      index,
+      score: historyItemMatchScore(remote, persisted)
+    })).filter((candidate) => candidate.score > 0).sort((left, right) => right.score - left.score || left.index - right.index)[0];
+    if (!match) {
+      return remote.sourceTurnId ? { ...remote, sourceTurnId: turnId } : remote;
+    }
+    used.add(match.persisted.id);
+    return {
+      ...remote,
+      id: match.persisted.id,
+      ...remote.sourceTurnId || remote.kind === "agentMessage" ? { sourceTurnId: turnId } : {}
+    };
+  });
+}
+function alignHydratedAcpTurnsWithPersistedHistory(turns, persistedItemsByTurnId) {
+  const remoteTurnIds = new Set(turns.map((turn) => turn.providerTurnId));
+  const candidates = [...persistedItemsByTurnId.entries()].filter(
+    ([turnId]) => !remoteTurnIds.has(turnId)
+  );
+  const used = /* @__PURE__ */ new Set();
+  return turns.map((turn) => {
+    if (!turn.providerTurnId.startsWith("acp-hydrated:")) {
+      return turn;
+    }
+    const match = candidates.filter(([turnId]) => !used.has(turnId)).map(([turnId, items], index) => ({
+      turnId,
+      items,
+      index,
+      score: conversationMatchScore(turn, items)
+    })).filter((candidate) => candidate.score > 0).sort((left, right) => right.score - left.score || left.index - right.index)[0];
+    if (!match) {
+      return turn;
+    }
+    used.add(match.turnId);
+    return {
+      ...turn,
+      providerTurnId: match.turnId,
+      items: alignHydratedItems(turn.items, match.items, match.turnId)
+    };
+  });
+}
 function appendPersistedTurnsIfMissing(turns, persistedItemsByTurnId, metadataById) {
   if (persistedItemsByTurnId.size === 0) {
     return turns;
@@ -26389,15 +27893,37 @@ var ThreadProviderRuntimeCoordinator = class {
   isCodexProvider(provider2) {
     return this.providerForRecord({ provider: provider2 }) === "codex";
   }
-  runtimeSupportsFastMode(provider2) {
-    return this.optionalRuntimeForProvider(provider2)?.capabilities.controls.performanceMode ?? false;
+  capabilitiesFor(input) {
+    const runtime = this.runtimeForProvider(input.provider);
+    return runtime.getScopedCapabilities?.({
+      agentId: input.agentId ?? null,
+      providerSessionId: input.providerSessionId ?? null
+    }) ?? runtime.capabilities;
+  }
+  async resolveCapabilitiesFor(input) {
+    const runtime = this.runtimeForProvider(input.provider);
+    if (input.agentId && runtime.getAgentCapabilitySnapshot) {
+      const snapshot = await runtime.getAgentCapabilitySnapshot(input.agentId);
+      if (snapshot.effectiveCapabilities) {
+        return snapshot.effectiveCapabilities;
+      }
+    }
+    return this.capabilitiesFor(input);
+  }
+  runtimeSupportsFastMode(provider2, scope = {}) {
+    const runtime = this.optionalRuntimeForProvider(provider2);
+    if (!runtime) return false;
+    return (runtime.getScopedCapabilities?.({
+      agentId: scope.agentId ?? null,
+      providerSessionId: scope.providerSessionId ?? null
+    }) ?? runtime.capabilities).controls.performanceMode;
   }
-  fastModeForProvider(provider2, fastMode) {
-    return this.runtimeSupportsFastMode(provider2) ? normalizeFastMode(fastMode) : false;
+  fastModeForProvider(provider2, fastMode, scope = {}) {
+    return this.runtimeSupportsFastMode(provider2, scope) ? normalizeFastMode(fastMode) : false;
   }
   performanceModeForRecord(record2) {
     return performanceModeForFastMode(
-      this.fastModeForProvider(record2.provider, record2.fastMode)
+      this.fastModeForProvider(record2.provider, record2.fastMode, record2)
     );
   }
   async listLoadedProviderSessionIds(provider2 = "codex") {
@@ -26691,7 +28217,7 @@ var ThreadPromptTurnCoordinator = class {
   async startPromptTurn(localThreadId, record2, input) {
     const displayPrompt = input.displayPrompt ?? input.prompt;
     const runtime = this.callbacks.runtimeForProvider(record2.provider);
-    const modelRecords = await runtime.listModels().catch(() => []);
+    const modelRecords = await (record2.agentId && runtime.listModelsForAgent ? runtime.listModelsForAgent(record2.agentId, input.workspacePath) : runtime.listModels()).catch(() => []);
     ensureFastModeSupported(
       input.effectiveModel,
       input.performanceMode === "fast",
@@ -27011,7 +28537,10 @@ function toThreadDto(record2, loadedIds, callbacks) {
     title: record2.title,
     model,
     reasoningEffort: normalizeReasoningEffort2(record2.reasoningEffort),
-    fastMode: callbacks.fastModeForProvider(record2.provider, record2.fastMode),
+    fastMode: callbacks.fastModeForProvider(record2.provider, record2.fastMode, {
+      agentId,
+      providerSessionId: record2.providerSessionId ?? null
+    }),
     collaborationMode: normalizeCollaborationMode(record2.collaborationMode),
     approvalMode: record2.approvalMode ?? "yolo",
     sandboxMode: normalizeSandboxMode(record2.sandboxMode) ?? defaultSandboxModeForApprovalMode(record2.approvalMode ?? "yolo"),
@@ -27055,24 +28584,32 @@ var ThreadSessionCoordinator = class {
       agentId: input.threadInput.agentId,
       workspacePath: input.workspacePath
     }).catch(() => []);
+    const effectiveModel = input.threadInput.model === "default" ? modelRecords.find((model) => model.isDefault)?.model ?? input.threadInput.model : input.threadInput.model;
     const reasoningEffort = this.providerRuntime.normalizeReasoningForModel(
       modelRecords,
-      input.threadInput.model,
+      effectiveModel,
       input.threadInput.reasoningEffort ?? null
     );
     const sandboxMode = defaultSandboxModeForApprovalMode(input.threadInput.approvalMode);
-    const fastMode = this.providerRuntime.runtimeSupportsFastMode(provider2) ? this.performanceModeSettings.readFastMode() : false;
-    if (this.providerRuntime.runtimeSupportsFastMode(provider2)) {
-      ensureFastModeSupported(input.threadInput.model, fastMode, modelRecords);
+    const capabilityScope = {
+      agentId: input.threadInput.agentId ?? null
+    };
+    const supportsFastMode2 = this.providerRuntime.runtimeSupportsFastMode(
+      provider2,
+      capabilityScope
+    );
+    const fastMode = supportsFastMode2 ? this.performanceModeSettings.readFastMode() : false;
+    if (supportsFastMode2) {
+      ensureFastModeSupported(effectiveModel, fastMode, modelRecords);
     }
     const response = await runtime.startSession({
       cwd: input.workspacePath,
       ...input.threadInput.agentId ? { agentId: input.threadInput.agentId } : {},
-      model: input.threadInput.model,
+      model: effectiveModel,
       reasoningEffort,
       approvalMode: input.threadInput.approvalMode,
       sandboxMode,
-      performanceMode: performanceModeForFastMode(fastMode)
+      ...supportsFastMode2 ? { performanceMode: performanceModeForFastMode(fastMode) } : {}
     });
     return {
       provider: provider2,
@@ -27113,6 +28650,10 @@ var ThreadSessionCoordinator = class {
       provider: provider2
     });
   }
+  async listImportSessions(provider2, agentId) {
+    const runtime = this.providerRuntime.runtimeForProvider(provider2);
+    return runtime.listImportSessions ? runtime.listImportSessions(agentId) : runtime.listSessions();
+  }
   async resolveRuntimeImportSession(provider2, sessionId) {
     try {
       const session = await this.providerRuntime.runtimeForProvider(provider2).readSession(sessionId);
@@ -27121,13 +28662,17 @@ var ThreadSessionCoordinator = class {
       }
       return {
         provider: provider2,
-        source: "supervisor",
+        agentId: session.agentId ?? null,
+        source: "local_provider_import",
         sessionId,
         cwd: session.cwd,
         title: session.title?.trim() || session.preview?.trim() || "Untitled imported session",
         model: null,
         summaryText: session.preview,
-        fastMode: this.providerRuntime.runtimeSupportsFastMode(provider2) ? this.performanceModeSettings.readFastMode() : false
+        fastMode: this.providerRuntime.runtimeSupportsFastMode(provider2, {
+          agentId: session.agentId ?? null,
+          providerSessionId: sessionId
+        }) ? this.performanceModeSettings.readFastMode() : false
       };
     } catch {
       return null;
@@ -27153,12 +28698,24 @@ var ThreadSessionCoordinator = class {
   async resumeThreadSession(input) {
     const runtime = this.providerRuntime.runtimeForProvider(input.provider);
     const sandboxMode = input.resumeInput.sandboxMode ?? normalizeSandboxMode(input.currentSandboxMode) ?? defaultSandboxModeForApprovalMode(input.approvalMode);
-    const fastMode = this.providerRuntime.fastModeForProvider(input.provider, input.fastMode);
     const modelRecords = await this.listSessionModels({
       provider: input.provider,
       agentId: input.agentId,
       workspacePath: input.workspacePath
     }).catch(() => []);
+    const capabilityScope = {
+      agentId: input.agentId ?? null,
+      providerSessionId: input.providerSessionId
+    };
+    const supportsFastMode2 = this.providerRuntime.runtimeSupportsFastMode(
+      input.provider,
+      capabilityScope
+    );
+    const fastMode = this.providerRuntime.fastModeForProvider(
+      input.provider,
+      input.fastMode,
+      capabilityScope
+    );
     let response;
     try {
       ensureFastModeSupported(
@@ -27170,7 +28727,7 @@ var ThreadSessionCoordinator = class {
         providerSessionId: input.providerSessionId,
         model: input.resumeInput.model ?? input.currentModel ?? null,
         sandboxMode,
-        performanceMode: performanceModeForFastMode(fastMode)
+        ...supportsFastMode2 ? { performanceMode: performanceModeForFastMode(fastMode) } : {}
       });
     } catch (error) {
       if (!isRemoteThreadBootstrapError(error)) {
@@ -27195,7 +28752,8 @@ var ThreadSessionCoordinator = class {
   }
   async compactThreadSession(input) {
     const runtime = this.providerRuntime.runtimeForProvider(input.provider);
-    if (!runtime.compactSession) {
+    const capabilities = this.providerRuntime.capabilitiesFor(input);
+    if (!runtime.compactSession || !capabilities.turns.compact) {
       throw new HttpError(409, {
         code: "conflict",
         message: "This backend does not support context compaction."
@@ -27212,25 +28770,27 @@ var ThreadSessionCoordinator = class {
       });
     }
     const runtime = this.providerRuntime.runtimeForProvider(input.provider);
-    if (!runtime.forkSession) {
+    const capabilities = this.providerRuntime.capabilitiesFor(input);
+    if (!runtime.forkSession || !capabilities.branching.fork) {
       throw new HttpError(409, {
         code: "conflict",
         message: "This backend does not support session fork."
       });
     }
+    const turnsToRollback = selectedTurn == null ? 0 : Math.max(0, input.turnOptions.length - selectedTurn.turnIndex);
+    const rollbackSession = runtime.rollbackSession?.bind(runtime);
+    if (turnsToRollback > 0 && !rollbackSession) {
+      throw new HttpError(409, {
+        code: "conflict",
+        message: "This backend supports latest-session fork only."
+      });
+    }
     let forkedSession = await runtime.forkSession({
       providerSessionId: input.providerSessionId,
       atTurnId: selectedTurn?.turnId ?? null
     });
-    const turnsToRollback = selectedTurn == null ? 0 : Math.max(0, input.turnOptions.length - selectedTurn.turnIndex);
     if (turnsToRollback > 0) {
-      if (!runtime.rollbackSession) {
-        throw new HttpError(409, {
-          code: "conflict",
-          message: "This backend does not support rollback after fork."
-        });
-      }
-      forkedSession = await runtime.rollbackSession({
+      forkedSession = await rollbackSession({
         providerSessionId: forkedSession.providerSessionId,
         count: turnsToRollback
       });
@@ -27266,10 +28826,18 @@ var ThreadSessionCoordinator = class {
       workspacePath: input.workspacePath
     });
     const fallbackModel = modelRecords.find((entry) => entry.isDefault) ?? modelRecords[0] ?? null;
-    const supportsFastMode2 = this.providerRuntime.runtimeSupportsFastMode(input.provider);
+    const capabilityScope = {
+      agentId: input.agentId ?? null,
+      providerSessionId: null
+    };
+    const supportsFastMode2 = this.providerRuntime.runtimeSupportsFastMode(
+      input.provider,
+      capabilityScope
+    );
     const currentFastMode = this.providerRuntime.fastModeForProvider(
       input.provider,
-      input.currentFastMode
+      input.currentFastMode,
+      capabilityScope
     );
     const nextFastMode = supportsFastMode2 && input.settings.fastMode !== void 0 ? input.settings.fastMode : currentFastMode;
     const currentModel = input.currentModel ?? fallbackModel?.model ?? null;
@@ -27314,9 +28882,15 @@ var ThreadSessionCoordinator = class {
     );
     const collaborationMode = input.promptInput?.collaborationMode ?? normalizeCollaborationMode(input.currentCollaborationMode);
     const sandboxMode = (input.promptInput?.sandboxMode !== void 0 ? normalizeSandboxMode(input.promptInput.sandboxMode) : normalizeSandboxMode(input.currentSandboxMode)) ?? defaultSandboxModeForApprovalMode(input.approvalMode);
+    const capabilities = this.providerRuntime.capabilitiesFor({
+      provider: input.provider,
+      agentId: input.agentId ?? null
+    });
+    const supportsFastMode2 = capabilities.controls.performanceMode;
     const fastMode = this.providerRuntime.fastModeForProvider(
       input.provider,
-      input.currentFastMode
+      input.currentFastMode,
+      { agentId: input.agentId ?? null }
     );
     ensureFastModeSupported(effectiveModel, fastMode, modelRecords);
     return {
@@ -27324,8 +28898,8 @@ var ThreadSessionCoordinator = class {
       normalizedReasoning,
       collaborationMode,
       sandboxMode,
-      performanceMode: performanceModeForFastMode(fastMode),
-      supportsRunningTurnInput: Boolean(runtime.sendInput && runtime.capabilities.turns.steer)
+      performanceMode: supportsFastMode2 ? performanceModeForFastMode(fastMode) : null,
+      supportsRunningTurnInput: Boolean(runtime.sendInput && capabilities.turns.steer)
     };
   }
 };
@@ -27437,12 +29011,15 @@ var ThreadSessionLifecycleCoordinator = class {
 
 // src/thread-history-persistence-coordinator.ts
 var ThreadHistoryPersistenceCoordinator = class {
-  constructor(db, liveState) {
+  constructor(db, liveState, checkpointOptions = {}) {
     this.db = db;
     this.liveState = liveState;
+    this.checkpointOptions = checkpointOptions;
   }
   db;
   liveState;
+  checkpointOptions;
+  liveAgentMessageCheckpoints = /* @__PURE__ */ new Map();
   listPersistedHistoryItemsByTurnId(localThreadId) {
     const itemsByTurnId = /* @__PURE__ */ new Map();
     for (const record2 of listThreadHistoryItemRecordsByThreadId(this.db, localThreadId)) {
@@ -27480,10 +29057,64 @@ var ThreadHistoryPersistenceCoordinator = class {
       itemJson: JSON.stringify(item)
     });
   }
+  checkpointLiveAgentMessage(localThreadId, turnId, item) {
+    if (item.kind !== "agentMessage") {
+      return;
+    }
+    const key = `${localThreadId}\0${turnId}\0${item.id}`;
+    const previous = this.liveAgentMessageCheckpoints.get(key);
+    const now = (this.checkpointOptions.now ?? Date.now)();
+    const intervalMs = this.checkpointOptions.intervalMs ?? 250;
+    const textDelta = this.checkpointOptions.textDelta ?? 512;
+    if (previous && now - previous.savedAt < intervalMs && item.text.length - previous.textLength < textDelta) {
+      return;
+    }
+    this.persistLiveHistoryItem(localThreadId, turnId, item);
+    this.liveAgentMessageCheckpoints.set(key, {
+      savedAt: now,
+      textLength: item.text.length
+    });
+  }
+  clearThread(localThreadId) {
+    const prefix = `${localThreadId}\0`;
+    for (const key of this.liveAgentMessageCheckpoints.keys()) {
+      if (key.startsWith(prefix)) {
+        this.liveAgentMessageCheckpoints.delete(key);
+      }
+    }
+  }
+  persistHydratedTurns(localThreadId, turns) {
+    for (const turn of turns) {
+      if (turn.startedAt) {
+        upsertThreadTurnMetadata(this.db, {
+          threadId: localThreadId,
+          turnId: turn.providerTurnId,
+          createdAt: turn.startedAt
+        });
+      }
+      turn.items.forEach((item, index) => {
+        if (!shouldPersistRuntimeFinalHistoryItem(item)) {
+          return;
+        }
+        const createdAt = item.createdAt ?? turn.startedAt;
+        this.persistProjectedHistoryItem(
+          localThreadId,
+          turn.providerTurnId,
+          {
+            ...item,
+            ...createdAt ? { createdAt } : {},
+            sequence: item.sequence ?? index,
+            ...item.kind === "agentMessage" && !item.sourceTurnId ? { sourceTurnId: turn.providerTurnId } : {}
+          }
+        );
+      });
+    }
+  }
   deletePersistedHistoryItemsForTurn(localThreadId, turnId) {
     deleteThreadHistoryItemRecordsByThreadAndTurnId(this.db, localThreadId, turnId);
   }
   persistFinalTurnOrderingHints(localThreadId, turnId, items) {
+    this.clearTurnCheckpoints(localThreadId, turnId);
     const orderingHints = this.liveState.finalTurnAgentMessageOrderingMetadata(
       localThreadId,
       turnId,
@@ -27510,6 +29141,14 @@ var ThreadHistoryPersistenceCoordinator = class {
       });
     }
   }
+  clearTurnCheckpoints(localThreadId, turnId) {
+    const prefix = `${localThreadId}\0${turnId}\0`;
+    for (const key of this.liveAgentMessageCheckpoints.keys()) {
+      if (key.startsWith(prefix)) {
+        this.liveAgentMessageCheckpoints.delete(key);
+      }
+    }
+  }
   persistRuntimeTurnItemsAsDisplayTurn(localThreadId, runtimeTurnId, displayTurnId, items) {
     if (runtimeTurnId === displayTurnId) {
       return;
@@ -27574,10 +29213,10 @@ var ThreadHistoryPersistenceCoordinator = class {
 };
 
 // src/thread-deletion-coordinator.ts
-import fs13 from "fs/promises";
-import path17 from "path";
+import fs15 from "fs/promises";
+import path19 from "path";
 function threadTempDirectoryPath(workspacePath, localThreadId) {
-  return path17.join(workspacePath, ".temp", "threads", localThreadId);
+  return path19.join(workspacePath, ".temp", "threads", localThreadId);
 }
 var ThreadDeletionCoordinator = class {
   constructor(db, requestCoordinator, usageAccounting, liveState, auxiliaryState, callbacks) {
@@ -27605,10 +29244,11 @@ var ThreadDeletionCoordinator = class {
     const workspace = getWorkspaceRecordById(this.db, record2.workspaceId);
     if (workspace) {
       const tempDirectory = threadTempDirectoryPath(workspace.absPath, localThreadId);
-      await fs13.rm(tempDirectory, { recursive: true, force: true }).catch(() => {
+      await fs15.rm(tempDirectory, { recursive: true, force: true }).catch(() => {
       });
     }
     this.requestCoordinator.clearThread(localThreadId);
+    this.callbacks.clearHistoryPersistence(localThreadId);
     this.callbacks.invalidateThreadDetailCache(localThreadId);
     this.usageAccounting.clearThread(localThreadId);
     this.liveState.clearThread(localThreadId);
@@ -27629,9 +29269,9 @@ var ThreadDeletionCoordinator = class {
 };
 
 // src/exports/thread-pdf-export.ts
-import fs14 from "fs";
+import fs16 from "fs";
 import { createRequire as createRequire3 } from "module";
-import path18 from "path";
+import path20 from "path";
 import puppeteer from "puppeteer-core";
 import { marked } from "marked";
 var MAX_TEXT_CHARS = 12e3;
@@ -27682,10 +29322,10 @@ function renderEmbeddedSystemCjkFontCss() {
   embeddedSystemCjkFontCss = "";
   for (const candidate of EMBEDDED_CJK_FONT_CANDIDATES) {
     try {
-      if (!fs14.existsSync(candidate.path)) {
+      if (!fs16.existsSync(candidate.path)) {
         continue;
       }
-      const font = fs14.readFileSync(candidate.path);
+      const font = fs16.readFileSync(candidate.path);
       embeddedSystemCjkFontCss = `
       @font-face {
         font-family: "RemoteCodexCJK";
@@ -27748,7 +29388,7 @@ function containsCjkCodePoint(codePoints) {
 }
 function renderBundledFontCss(source, usedCodePoints) {
   const packageRoot = resolvePackageRoot3(source.packageName);
-  const cssPath = path18.join(packageRoot, source.cssFile);
+  const cssPath = path20.join(packageRoot, source.cssFile);
   const blocks = getFontFaceBlocks(cssPath);
   return blocks.filter((block) => !usedCodePoints || fontFaceIntersects(block.ranges, usedCodePoints)).map((block) => inlineFontFaceBlock(block, packageRoot)).filter(Boolean);
 }
@@ -27757,7 +29397,7 @@ function resolvePackageRoot3(packageName) {
   if (cached) {
     return cached;
   }
-  const packageRoot = path18.dirname(require2.resolve(`${packageName}/package.json`));
+  const packageRoot = path20.dirname(require2.resolve(`${packageName}/package.json`));
   packageRootCache.set(packageName, packageRoot);
   return packageRoot;
 }
@@ -27766,7 +29406,7 @@ function getFontFaceBlocks(cssPath) {
   if (cached) {
     return cached;
   }
-  const css = fs14.readFileSync(cssPath, "utf8");
+  const css = fs16.readFileSync(cssPath, "utf8");
   const blocks = Array.from(css.matchAll(/@font-face\s*{[\s\S]*?}/g)).map((match) => {
     const block = match[0];
     const fontPath = block.match(/url\((['"]?)(\.\/files\/[^)'"]+\.woff2)\1\)\s*format\((['"]?)woff2\3\)/)?.[2] ?? "";
@@ -27805,9 +29445,9 @@ function fontFaceIntersects(ranges, usedCodePoints) {
   return false;
 }
 function inlineFontFaceBlock(block, packageRoot) {
-  const fontPath = path18.join(packageRoot, block.fontPath);
+  const fontPath = path20.join(packageRoot, block.fontPath);
   try {
-    const font = fs14.readFileSync(fontPath);
+    const font = fs16.readFileSync(fontPath);
     return block.block.replace(/font-display:\s*swap;/g, "font-display: block;").replace(/src:\s*[^;]+;/, `src: url("data:font/woff2;base64,${font.toString("base64")}") format("woff2");`);
   } catch {
     return "";
@@ -28806,7 +30446,7 @@ endobj
 function resolvePdfBrowserExecutablePath() {
   try {
     const executablePath = process.env.PUPPETEER_EXECUTABLE_PATH ? process.env.PUPPETEER_EXECUTABLE_PATH : puppeteer.executablePath(PUPPETEER_CHANNEL);
-    if (!fs14.existsSync(executablePath)) {
+    if (!fs16.existsSync(executablePath)) {
       throw new Error(`Browser executable was not found at ${executablePath}`);
     }
     return executablePath;
@@ -29075,6 +30715,7 @@ var ThreadForkCoordinator = class {
     const turnOptions = await this.listForkTurnOptions(localThreadId);
     const forkResult = await this.sessionCoordinator.forkThreadSession({
       provider: record2.provider,
+      agentId: record2.agentId,
       providerSessionId,
       mode: input.mode,
       ...input.turnId ? { turnId: input.turnId } : {},
@@ -29085,11 +30726,15 @@ var ThreadForkCoordinator = class {
     const created = createThreadRecord(this.db, {
       workspaceId: record2.workspaceId,
       provider: this.callbacks.providerForRecord(record2),
+      agentId: forkedSession.agentId ?? record2.agentId ?? null,
       providerSessionId: forkedSession.providerSessionId,
       title: `${forkTitleBase} / fork`,
       model: record2.model,
       reasoningEffort: record2.reasoningEffort,
-      fastMode: this.callbacks.fastModeForProvider(record2.provider, record2.fastMode),
+      fastMode: this.callbacks.fastModeForProvider(record2.provider, record2.fastMode, {
+        agentId: record2.agentId ?? null,
+        providerSessionId
+      }),
       fastBaseModel: record2.fastBaseModel,
       fastBaseReasoningEffort: record2.fastBaseReasoningEffort,
       collaborationMode: this.callbacks.normalizeCollaborationMode(record2.collaborationMode),
@@ -29126,19 +30771,19 @@ var ThreadForkCoordinator = class {
 
 // src/thread-attachment-coordinator.ts
 import { randomUUID as randomUUID6 } from "crypto";
-import fs15 from "fs/promises";
-import path19 from "path";
+import fs17 from "fs/promises";
+import path21 from "path";
 async function pathExists(absPath) {
   try {
-    await fs15.access(absPath);
+    await fs17.access(absPath);
     return true;
   } catch {
     return false;
   }
 }
 function sanitizeAttachmentFileName(originalName) {
-  const basename = path19.basename(originalName).trim() || "attachment";
-  const extension = path19.extname(basename).replace(/[^a-zA-Z0-9.]/g, "");
+  const basename = path21.basename(originalName).trim() || "attachment";
+  const extension = path21.extname(basename).replace(/[^a-zA-Z0-9.]/g, "");
   const rawStem = extension ? basename.slice(0, -extension.length) : basename;
   const sanitizedStem = rawStem.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 64);
   const stem = sanitizedStem || "attachment";
@@ -29146,7 +30791,7 @@ function sanitizeAttachmentFileName(originalName) {
   return `${stem}-${randomUUID6().slice(0, 8)}${normalizedExtension}`;
 }
 function threadTempDirectoryPath2(workspacePath, localThreadId) {
-  return path19.join(workspacePath, ".temp", "threads", localThreadId);
+  return path21.join(workspacePath, ".temp", "threads", localThreadId);
 }
 var ThreadAttachmentCoordinator = class {
   constructor(db) {
@@ -29175,7 +30820,7 @@ var ThreadAttachmentCoordinator = class {
       });
     }
     const tempDirectory = threadTempDirectoryPath2(workspace.absPath, localThreadId);
-    await fs15.mkdir(tempDirectory, { recursive: true });
+    await fs17.mkdir(tempDirectory, { recursive: true });
     let rewrittenPrompt = input.prompt;
     for (const attachment of attachments) {
       if (!rewrittenPrompt.includes(attachment.manifest.placeholder)) {
@@ -29187,7 +30832,7 @@ var ThreadAttachmentCoordinator = class {
       const savedFileName = sanitizeAttachmentFileName(
         attachment.manifest.originalName
       );
-      await fs15.writeFile(path19.join(tempDirectory, savedFileName), attachment.buffer);
+      await fs17.writeFile(path21.join(tempDirectory, savedFileName), attachment.buffer);
       const relativePath = `./.temp/threads/${localThreadId}/${savedFileName}`;
       const replacementToken = attachment.manifest.kind === "photo" ? `[PHOTO ${relativePath}]` : `[FILE ${relativePath}]`;
       rewrittenPrompt = rewrittenPrompt.split(attachment.manifest.placeholder).join(replacementToken);
@@ -29200,30 +30845,30 @@ var ThreadAttachmentCoordinator = class {
 };
 
 // src/thread-import-coordinator.ts
-import fs16 from "fs/promises";
-import path20 from "path";
+import fs18 from "fs/promises";
+import path22 from "path";
 async function pathExists2(absPath) {
   try {
-    await fs16.access(absPath);
+    await fs18.access(absPath);
     return true;
   } catch {
     return false;
   }
 }
 async function resolveComparablePath2(absPath) {
-  const resolved = path20.resolve(absPath);
+  const resolved = path22.resolve(absPath);
   if (await pathExists2(resolved)) {
-    return fs16.realpath(resolved);
+    return fs18.realpath(resolved);
   }
-  const parentPath = path20.dirname(resolved);
+  const parentPath = path22.dirname(resolved);
   if (parentPath === resolved) {
     return resolved;
   }
   const resolvedParent = await resolveComparablePath2(parentPath);
-  return path20.join(resolvedParent, path20.basename(resolved));
+  return path22.join(resolvedParent, path22.basename(resolved));
 }
 async function resolveImportedWorkspacePath(candidatePath) {
-  if (!path20.isAbsolute(candidatePath)) {
+  if (!path22.isAbsolute(candidatePath)) {
     throw new HttpError(400, {
       code: "bad_request",
       message: "Imported session path must be absolute."
@@ -29232,12 +30877,33 @@ async function resolveImportedWorkspacePath(candidatePath) {
   return resolveComparablePath2(candidatePath);
 }
 var ThreadImportCoordinator = class {
-  constructor(db, sessionCoordinator, _workspaceRoot) {
+  constructor(db, sessionCoordinator) {
     this.db = db;
     this.sessionCoordinator = sessionCoordinator;
   }
   db;
   sessionCoordinator;
+  async listImportCandidates(providerInput, agentId) {
+    const provider2 = normalizeAgentBackendId(providerInput ?? "codex") ?? "codex";
+    const sessions = await this.sessionCoordinator.listImportSessions(provider2, agentId);
+    return sessions.filter((session) => Boolean(session.providerSessionId.trim()) && path22.isAbsolute(session.cwd) && !getThreadRecordByProviderSessionId(
+      this.db,
+      provider2,
+      session.providerSessionId
+    )).map((session) => ({
+      provider: provider2,
+      agentId: session.agentId ?? null,
+      sessionId: session.providerSessionId,
+      cwd: session.cwd,
+      title: session.title?.trim() || session.preview?.trim() || "Untitled session",
+      preview: session.preview,
+      createdAt: session.createdAt,
+      updatedAt: session.updatedAt,
+      historyStatus: "unknown"
+    })).sort((left, right) => (right.updatedAt ?? right.createdAt ?? "").localeCompare(
+      left.updatedAt ?? left.createdAt ?? ""
+    ));
+  }
   async importLocalThread(input) {
     const normalizedSessionId = input.sessionId.trim();
     if (!normalizedSessionId) {
@@ -29270,12 +30936,13 @@ var ThreadImportCoordinator = class {
     if (!workspace) {
       workspace = createWorkspaceRecord(this.db, {
         absPath: importedPath,
-        label: path20.basename(importedPath) || "workspace"
+        label: path22.basename(importedPath) || "workspace"
       });
     }
     const created = createThreadRecord(this.db, {
       workspaceId: workspace.id,
       provider: importSession.provider,
+      agentId: importSession.agentId ?? null,
       providerSessionId: importSession.sessionId,
       title: importSession.title,
       model: importSession.model,
@@ -29291,7 +30958,7 @@ var ThreadImportCoordinator = class {
     return created.id;
   }
   async assertImportedThreadReadyForPrompt(input) {
-    if (input.source !== "local_codex_import") {
+    if (input.source !== "local_codex_import" && input.source !== "local_provider_import") {
       return;
     }
     const loadedIds = await input.listLoadedProviderSessionIds(input.provider);
@@ -29303,7 +30970,7 @@ var ThreadImportCoordinator = class {
     }
   }
   async ensureImportedThreadConnectedForImplementation(input) {
-    if (input.source !== "local_codex_import") {
+    if (input.source !== "local_codex_import" && input.source !== "local_provider_import") {
       return;
     }
     const loadedIds = await input.listLoadedProviderSessionIds(input.provider);
@@ -29356,7 +31023,7 @@ function pluginDeveloperInstructions(pluginService) {
 }
 async function pathExists3(absPath) {
   try {
-    await fs17.access(absPath);
+    await fs19.access(absPath);
     return true;
   } catch {
     return false;
@@ -29398,8 +31065,7 @@ var ThreadService = class {
     );
     this.importCoordinator = new ThreadImportCoordinator(
       db,
-      this.sessionCoordinator,
-      workspaceRoot
+      this.sessionCoordinator
     );
     this.promptTurnCoordinator = new ThreadPromptTurnCoordinator(
       db,
@@ -29445,6 +31111,12 @@ var ThreadService = class {
         },
         syncAfterRemoteSession: (localThreadId, remoteSession) => {
           const updated = getThreadRecordById(this.db, localThreadId);
+          if (updated.provider === "acp") {
+            this.historyPersistence.persistHydratedTurns(
+              updated.id,
+              remoteSession.turns
+            );
+          }
           this.syncPendingPlanDecisionRequest(
             updated.id,
             updated.collaborationMode,
@@ -29464,6 +31136,11 @@ var ThreadService = class {
       emitThreadEvent: (type, threadId, payload) => this.emitThreadEvent(type, threadId, payload),
       requireProviderSessionId: (record2) => this.requireProviderSessionId(record2),
       runtimeForProvider: (provider2) => this.runtimeForProvider(provider2),
+      capabilitiesForRecord: (record2) => this.providerRuntime.resolveCapabilitiesFor({
+        provider: record2.provider,
+        agentId: record2.agentId ?? null,
+        providerSessionId: record2.providerSessionId ?? null
+      }),
       appendGoalActivityNote: (threadId, objective) => this.auxiliaryState.appendActivityNote(threadId, {
         kind: "goal",
         text: objective
@@ -29492,6 +31169,7 @@ var ThreadService = class {
       this.liveState,
       this.auxiliaryState,
       {
+        clearHistoryPersistence: (localThreadId) => this.historyPersistence.clearThread(localThreadId),
         invalidateThreadDetailCache: (localThreadId) => this.invalidateThreadDetailCache(localThreadId)
       }
     );
@@ -29509,7 +31187,7 @@ var ThreadService = class {
       this.sessionCoordinator,
       {
         buildThreadPatch: (remoteSession, model, reasoningEffort) => buildThreadPatch(remoteSession, model, reasoningEffort),
-        fastModeForProvider: (provider2, fastMode) => this.fastModeForProvider(provider2, fastMode),
+        fastModeForProvider: (provider2, fastMode, scope) => this.fastModeForProvider(provider2, fastMode, scope),
         getThreadDetail: (localThreadId) => this.getThreadDetail(localThreadId),
         invalidateThreadDetailCache: (localThreadId) => this.invalidateThreadDetailCache(localThreadId),
         normalizeCollaborationMode,
@@ -29530,7 +31208,8 @@ var ThreadService = class {
           input.itemId,
           input.delta,
           input.sequence,
-          input.createdAt
+          input.createdAt,
+          input.checkpoint
         ),
         clearPendingPlanDecisionRequests: (localThreadId, emitEvents) => this.clearPendingPlanDecisionRequests(localThreadId, emitEvents),
         clearPendingSteersForTurn: (localThreadId, turnId) => this.auxiliaryState.clearPendingSteersForTurn(localThreadId, turnId),
@@ -29670,14 +31349,8 @@ var ThreadService = class {
       providerSessionId
     );
   }
-  runtimeSupportsFastMode(provider2) {
-    return this.providerRuntime.runtimeSupportsFastMode(provider2);
-  }
-  fastModeForProvider(provider2, fastMode) {
-    return this.providerRuntime.fastModeForProvider(provider2, fastMode);
-  }
-  performanceModeForRecord(record2) {
-    return this.providerRuntime.performanceModeForRecord(record2);
+  fastModeForProvider(provider2, fastMode, scope = {}) {
+    return this.providerRuntime.fastModeForProvider(provider2, fastMode, scope);
   }
   async handleProviderRequest(request) {
     await this.handleProviderRuntimeRequest(request);
@@ -29767,7 +31440,7 @@ var ThreadService = class {
     updateThreadRecord(this.db, created.id, {
       ...buildThreadPatch(
         session.response.session,
-        input.model,
+        session.response.model ?? input.model,
         session.response.reasoningEffort ?? session.reasoningEffort
       ),
       title: session.normalizedTitle === DEFAULT_THREAD_TITLE2 && session.response.session.title && session.response.session.title.trim() !== GENERIC_REMOTE_THREAD_TITLE ? truncateAutoThreadTitle(session.response.session.title) : session.normalizedTitle
@@ -29779,6 +31452,9 @@ var ThreadService = class {
     const localThreadId = await this.importCoordinator.importLocalThread(input);
     return this.getThreadDetail(localThreadId);
   }
+  async listImportCandidates(provider2, agentId) {
+    return this.importCoordinator.listImportCandidates(provider2, agentId);
+  }
   async getThreadDetail(localThreadId, options = {}) {
     const record2 = this.requireThreadRecord(localThreadId);
     const workspace = this.requireWorkspaceForThread(record2);
@@ -30138,6 +31814,7 @@ var ThreadService = class {
     }
     await this.sessionCoordinator.compactThreadSession({
       provider: record2.provider,
+      agentId: record2.agentId,
       providerSessionId
     });
     const updated = getThreadRecordById(this.db, localThreadId);
@@ -30285,7 +31962,12 @@ var ThreadService = class {
     }
     const providerSessionId = this.requireProviderSessionId(record2);
     const runtime = this.runtimeForProvider(record2.provider);
-    if (!runtime.sendInput) {
+    const capabilities = this.providerRuntime.capabilitiesFor({
+      provider: record2.provider,
+      agentId: record2.agentId ?? null,
+      providerSessionId
+    });
+    if (!runtime.sendInput || !capabilities.turns.steer) {
       throw new HttpError(409, {
         code: "conflict",
         message: "This backend does not support steering an active turn."
@@ -30399,10 +32081,6 @@ var ThreadService = class {
   async handleRuntimeEvent(event) {
     await this.runtimeEventProjector.handleRuntimeEvent(event);
   }
-  runtimeSupportsLiveRunningTurnInput(provider2) {
-    const runtime = this.runtimeForProvider(provider2);
-    return Boolean(runtime.sendInput && runtime.capabilities.turns.steer);
-  }
   shouldPreserveCompletedPendingSteer(localThreadId) {
     const record2 = getThreadRecordById(this.db, localThreadId);
     if (!record2) {
@@ -30496,7 +32174,7 @@ var ThreadService = class {
   }
   toThreadDto(record2, loadedIds) {
     return toThreadDto(record2, loadedIds, {
-      fastModeForProvider: (provider2, fastMode) => this.fastModeForProvider(provider2, fastMode),
+      fastModeForProvider: (provider2, fastMode, scope) => this.fastModeForProvider(provider2, fastMode, scope),
       getThreadContextUsage: (localThreadId) => this.getThreadContextUsage(localThreadId)
     });
   }
@@ -30511,8 +32189,8 @@ var ThreadService = class {
   listPendingRequests(localThreadId, options = {}) {
     return this.requestCoordinator.listPendingRequests(localThreadId, options);
   }
-  appendLiveAgentMessageDelta(localThreadId, turnId, itemId, delta, sequence, createdAt) {
-    this.liveState.appendLiveAgentMessageDelta({
+  appendLiveAgentMessageDelta(localThreadId, turnId, itemId, delta, sequence, createdAt, checkpoint = false) {
+    const item = this.liveState.appendLiveAgentMessageDelta({
       localThreadId,
       turnId,
       itemId,
@@ -30520,6 +32198,13 @@ var ThreadService = class {
       sequence,
       createdAt
     });
+    if (checkpoint) {
+      this.historyPersistence.checkpointLiveAgentMessage(
+        localThreadId,
+        turnId,
+        item
+      );
+    }
   }
   createPendingPlanDecisionRequest(localThreadId, turnId, emitEvents) {
     this.requestCoordinator.createPendingPlanDecisionRequest(
@@ -30598,8 +32283,8 @@ function parseQueuedTurnConfig(value) {
 }
 
 // src/routes/agent-runtimes.ts
-import fs18 from "fs/promises";
-import path21 from "path";
+import fs20 from "fs/promises";
+import path23 from "path";
 import { fileURLToPath } from "url";
 import { z as z6 } from "zod";
 
@@ -30619,8 +32304,8 @@ var modelQuerySchema = z6.object({
   agentId: z6.string().min(1).optional(),
   cwd: z6.string().min(1).optional()
 });
-var repositoryRoot = path21.resolve(
-  path21.dirname(fileURLToPath(import.meta.url)),
+var repositoryRoot = path23.resolve(
+  path23.dirname(fileURLToPath(import.meta.url)),
   "..",
   "..",
   "..",
@@ -30792,6 +32477,21 @@ async function registerAgentRuntimeRoutes(app2) {
     }
     return (await runtime.listAgentOptions()).map(modelDto);
   });
+  app2.get("/api/agent-runtimes/:provider/capabilities", async (request) => {
+    const { provider: provider2 } = providerParamSchema.parse(request.params);
+    const query = z6.object({ agentId: z6.string().min(1) }).parse(request.query);
+    const runtime = app2.services.agentRuntimes.getOptional(provider2);
+    if (!runtime) {
+      throw providerNotConfigured(provider2);
+    }
+    if (!runtime.getAgentCapabilitySnapshot) {
+      throw new HttpError(409, {
+        code: "conflict",
+        message: `${runtime.displayName} does not expose per-agent capabilities.`
+      });
+    }
+    return runtime.getAgentCapabilitySnapshot(query.agentId);
+  });
   app2.post("/api/agent-runtimes/:provider/build-restart", async (request) => {
     if (!app2.services.config.managementRoutesEnabled) {
       throw new HttpError(403, {
@@ -30843,7 +32543,7 @@ async function refreshBackendInstallation(app2, runtime) {
     const [cliVersion, sdkVersion, latestCliVersion] = await Promise.all([
       commandVersion(command, ["--version"]),
       installedPackageVersion("@anthropic-ai/claude-agent-sdk", [
-        path21.join(repositoryRoot, "packages", "claude", "node_modules")
+        path23.join(repositoryRoot, "packages", "claude", "node_modules")
       ]),
       latestPackageVersion("@anthropic-ai/claude-code")
     ]);
@@ -30862,7 +32562,7 @@ async function refreshBackendInstallation(app2, runtime) {
       commandVersion(command, ["--version"]),
       latestPackageVersion("opencode-ai"),
       installedPackageVersion("@opencode-ai/sdk", [
-        path21.join(repositoryRoot, "packages", "opencode", "node_modules")
+        path23.join(repositoryRoot, "packages", "opencode", "node_modules")
       ])
     ]);
     runtime.installation.installed = Boolean(cliVersion && sdkVersion);
@@ -30881,13 +32581,13 @@ async function refreshBackendInstallation(app2, runtime) {
 async function installedPackageVersion(packageName, extraNodeModuleRoots = []) {
   const globalRoot = await npmGlobalRoot3();
   if (globalRoot) {
-    const global = await packageVersionFromPath(path21.join(globalRoot, packageName, "package.json"));
+    const global = await packageVersionFromPath(path23.join(globalRoot, packageName, "package.json"));
     if (global) {
       return global;
     }
   }
   for (const root of extraNodeModuleRoots) {
-    const local = await packageVersionFromPath(path21.join(root, packageName, "package.json"));
+    const local = await packageVersionFromPath(path23.join(root, packageName, "package.json"));
     if (local) {
       return local;
     }
@@ -30940,11 +32640,11 @@ function versionStringContains(installedVersion, latestVersion) {
   return Boolean(installedVersion && latestVersion && installedVersion.includes(latestVersion));
 }
 async function packageVersionFromNode(packageName) {
-  return packageVersionFromPath(path21.resolve("node_modules", packageName, "package.json"));
+  return packageVersionFromPath(path23.resolve("node_modules", packageName, "package.json"));
 }
 async function packageVersionFromPath(packageJsonPath) {
   try {
-    const parsed = JSON.parse(await fs18.readFile(packageJsonPath, "utf8"));
+    const parsed = JSON.parse(await fs20.readFile(packageJsonPath, "utf8"));
     return typeof parsed.version === "string" && parsed.version.trim() ? parsed.version.trim() : null;
   } catch {
     return null;
@@ -30976,7 +32676,7 @@ async function npmGlobalBin(platform = process.platform) {
     return firstLine(result.stdout);
   }
   const prefix = await npmGlobalPrefix();
-  return prefix ? platform === "win32" ? prefix : path21.join(prefix, "bin") : null;
+  return prefix ? platform === "win32" ? prefix : path23.join(prefix, "bin") : null;
 }
 async function npmGlobalPrefix() {
   const result = await runProcess({
@@ -31271,8 +32971,8 @@ async function registerSystemRoutes(app2) {
 }
 
 // src/routes/threads.ts
-import fs19 from "fs/promises";
-import path22 from "path";
+import fs21 from "fs/promises";
+import path24 from "path";
 import { z as z8 } from "zod";
 var reasoningEffortValues = [
   "none",
@@ -31332,6 +33032,10 @@ var importThreadSchema = z8.object({
   sessionId: z8.string().min(1),
   provider: agentBackendIdSchema.optional()
 });
+var importThreadCandidatesQuerySchema = z8.object({
+  provider: agentBackendIdSchema.optional(),
+  agentId: z8.string().min(1).optional()
+});
 var resumeThreadSchema = z8.object({
   model: z8.string().min(1).optional()
 });
@@ -31563,6 +33267,13 @@ async function registerThreadRoutes(app2) {
     };
     return app2.services.threadService.importThread(input);
   });
+  app2.get("/api/threads/import-candidates", async (request) => {
+    const query = importThreadCandidatesQuerySchema.parse(request.query);
+    return app2.services.threadService.listImportCandidates(
+      query.provider,
+      query.agentId
+    );
+  });
   app2.get("/api/threads/:id", async (request) => {
     const params = z8.object({ id: z8.string().uuid() }).parse(request.params);
     const query = threadDetailQuerySchema.parse(request.query);
@@ -31645,15 +33356,15 @@ async function registerThreadRoutes(app2) {
         message: "Workspace was not found for this thread."
       });
     }
-    const candidatePath = path22.isAbsolute(query.path) ? query.path : path22.resolve(workspace.absPath, query.path);
-    const requestedPath = await fs19.realpath(candidatePath).catch(() => null);
+    const candidatePath = path24.isAbsolute(query.path) ? query.path : path24.resolve(workspace.absPath, query.path);
+    const requestedPath = await fs21.realpath(candidatePath).catch(() => null);
     if (!requestedPath) {
       throw new HttpError(404, {
         code: "not_found",
         message: "Image file was not found."
       });
     }
-    const resolvedWorkspaceRoot = await fs19.realpath(app2.services.config.workspaceRoot).catch(() => path22.resolve(app2.services.config.workspaceRoot));
+    const resolvedWorkspaceRoot = await fs21.realpath(app2.services.config.workspaceRoot).catch(() => path24.resolve(app2.services.config.workspaceRoot));
     try {
       await assertPathWithinRoot(resolvedWorkspaceRoot, requestedPath);
     } catch {
@@ -31662,7 +33373,7 @@ async function registerThreadRoutes(app2) {
         message: "Image path must stay within the configured workspace root."
       });
     }
-    const stats = await fs19.stat(requestedPath).catch(() => null);
+    const stats = await fs21.stat(requestedPath).catch(() => null);
     if (!stats?.isFile()) {
       throw new HttpError(404, {
         code: "not_found",
@@ -31673,7 +33384,7 @@ async function registerThreadRoutes(app2) {
     const contentType = lowerPath.endsWith(".png") ? "image/png" : lowerPath.endsWith(".jpg") || lowerPath.endsWith(".jpeg") ? "image/jpeg" : lowerPath.endsWith(".gif") ? "image/gif" : lowerPath.endsWith(".webp") ? "image/webp" : lowerPath.endsWith(".svg") ? "image/svg+xml" : lowerPath.endsWith(".heic") ? "image/heic" : lowerPath.endsWith(".heif") ? "image/heif" : "application/octet-stream";
     reply.header("Content-Type", contentType);
     reply.header("Cache-Control", "private, max-age=60");
-    return reply.send(await fs19.readFile(requestedPath));
+    return reply.send(await fs21.readFile(requestedPath));
   });
   app2.patch("/api/threads/:id", async (request) => {
     const params = z8.object({ id: z8.string().uuid() }).parse(request.params);
@@ -31869,34 +33580,34 @@ async function registerThreadRoutes(app2) {
 }
 
 // src/routes/workspaces.ts
-import fs22 from "fs/promises";
+import fs24 from "fs/promises";
 import { createReadStream } from "fs";
-import path25 from "path";
+import path27 from "path";
 import { Readable as Readable2 } from "stream";
 import { z as z9 } from "zod";
 
 // src/workspace-artifact-service.ts
-import fs20 from "fs/promises";
-import path23 from "path";
+import fs22 from "fs/promises";
+import path25 from "path";
 function artifactRoot(record2) {
-  return path23.join(record2.absPath, ".remote-codex", "artifacts");
+  return path25.join(record2.absPath, ".remote-codex", "artifacts");
 }
 function artifactFilePath(record2, artifactId) {
-  return path23.join(artifactRoot(record2), artifactId, "artifact.bin");
+  return path25.join(artifactRoot(record2), artifactId, "artifact.bin");
 }
 function artifactMetadataPath(record2, artifactId) {
-  return path23.join(artifactRoot(record2), artifactId, "metadata.json");
+  return path25.join(artifactRoot(record2), artifactId, "metadata.json");
 }
 function safeArtifactFileName(value) {
-  return path23.basename(value).replace(/[^a-zA-Z0-9_. -]/g, "_") || "artifact.bin";
+  return path25.basename(value).replace(/[^a-zA-Z0-9_. -]/g, "_") || "artifact.bin";
 }
 function artifactIdFromName(name) {
-  const base = path23.basename(name).replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 96);
+  const base = path25.basename(name).replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 96);
   return `${base || "artifact"}-${Date.now().toString(36)}`;
 }
 async function readWorkspaceArtifactMetadata(record2, artifactId) {
   try {
-    const raw = await fs20.readFile(artifactMetadataPath(record2, artifactId), "utf8");
+    const raw = await fs22.readFile(artifactMetadataPath(record2, artifactId), "utf8");
     return JSON.parse(raw);
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -31911,7 +33622,7 @@ async function readWorkspaceArtifactMetadata(record2, artifactId) {
 async function listWorkspaceArtifacts(record2) {
   let entries;
   try {
-    entries = await fs20.readdir(artifactRoot(record2));
+    entries = await fs22.readdir(artifactRoot(record2));
   } catch (error) {
     if (error.code === "ENOENT") {
       return [];
@@ -31947,10 +33658,10 @@ async function createWorkspaceArtifact({
       message: "Artifact content must not be empty."
     });
   }
-  const dir = path23.dirname(artifactFilePath(record2, artifactId));
-  await fs20.mkdir(dir, { recursive: true, mode: 448 });
+  const dir = path25.dirname(artifactFilePath(record2, artifactId));
+  await fs22.mkdir(dir, { recursive: true, mode: 448 });
   const filePath = artifactFilePath(record2, artifactId);
-  await fs20.writeFile(filePath, content, { flag: "wx" }).catch((error) => {
+  await fs22.writeFile(filePath, content, { flag: "wx" }).catch((error) => {
     if (error.code === "EEXIST") {
       throw new HttpError(409, {
         code: "conflict",
@@ -31970,12 +33681,12 @@ async function createWorkspaceArtifact({
     updatedAt: now,
     metadata: metadata ?? {}
   };
-  await fs20.writeFile(artifactMetadataPath(record2, artifactId), JSON.stringify(artifact, null, 2));
+  await fs22.writeFile(artifactMetadataPath(record2, artifactId), JSON.stringify(artifact, null, 2));
   return artifact;
 }
 async function readWorkspaceArtifactContent(record2, artifactId) {
   try {
-    return await fs20.readFile(artifactFilePath(record2, artifactId));
+    return await fs22.readFile(artifactFilePath(record2, artifactId));
   } catch (error) {
     if (error.code === "ENOENT") {
       throw new HttpError(404, {
@@ -31988,7 +33699,7 @@ async function readWorkspaceArtifactContent(record2, artifactId) {
 }
 async function deleteWorkspaceArtifact(record2, artifactId) {
   const artifact = await readWorkspaceArtifactMetadata(record2, artifactId);
-  await fs20.rm(path23.dirname(artifactFilePath(record2, artifactId)), {
+  await fs22.rm(path25.dirname(artifactFilePath(record2, artifactId)), {
     recursive: true,
     force: true
   });
@@ -31996,9 +33707,9 @@ async function deleteWorkspaceArtifact(record2, artifactId) {
 }
 
 // src/workspace-file-service.ts
-import fs21 from "fs/promises";
+import fs23 from "fs/promises";
 import os3 from "os";
-import path24 from "path";
+import path26 from "path";
 var PREVIEW_DEFAULT_LIMIT_BYTES = 5e4;
 var WORKSPACE_UPLOAD_MAX_BYTES = 50 * 1024 * 1024;
 var WORKSPACE_FOLDER_DOWNLOAD_MAX_BYTES = 100 * 1024 * 1024;
@@ -32034,7 +33745,7 @@ function toWorkspaceFileDto(file) {
   };
 }
 function languageForPath(filePath) {
-  const extension = path24.extname(filePath).slice(1).toLowerCase();
+  const extension = path26.extname(filePath).slice(1).toLowerCase();
   switch (extension) {
     case "js":
     case "jsx":
@@ -32080,18 +33791,18 @@ function languageForPath(filePath) {
   }
 }
 function relativeWorkspacePath(rootPath, absPath) {
-  const relative = path24.relative(rootPath, absPath);
-  return relative === "" ? "" : relative.split(path24.sep).join("/");
+  const relative = path26.relative(rootPath, absPath);
+  return relative === "" ? "" : relative.split(path26.sep).join("/");
 }
 async function resolveWorkspaceItemPath(rootPath, relativePath = "") {
-  const candidate = path24.resolve(rootPath, relativePath || ".");
+  const candidate = path26.resolve(rootPath, relativePath || ".");
   const comparable = await assertPathWithinRoot(rootPath, candidate);
   return comparable;
 }
 async function buildWorkspaceTreeNode(rootPath, absPath) {
-  const stats = await fs21.stat(absPath);
+  const stats = await fs23.stat(absPath);
   const relativePath = relativeWorkspacePath(rootPath, absPath);
-  const name = relativePath ? path24.basename(absPath) : path24.basename(rootPath);
+  const name = relativePath ? path26.basename(absPath) : path26.basename(rootPath);
   if (!stats.isDirectory()) {
     return {
       name,
@@ -32109,7 +33820,7 @@ async function buildWorkspaceTreeNode(rootPath, absPath) {
   };
   const visible = [];
   try {
-    const directory = await fs21.opendir(absPath);
+    const directory = await fs23.opendir(absPath);
     let scanned = 0;
     for await (const entry of directory) {
       scanned += 1;
@@ -32144,7 +33855,7 @@ async function buildWorkspaceTreeNode(rootPath, absPath) {
   });
   node.children = (await Promise.all(
     visible.map(async (entry) => {
-      const childPath = path24.join(absPath, entry.name);
+      const childPath = path26.join(absPath, entry.name);
       try {
         const childRelativePath = relativeWorkspacePath(rootPath, childPath);
         if (entry.isDirectory()) {
@@ -32156,7 +33867,7 @@ async function buildWorkspaceTreeNode(rootPath, absPath) {
             childrenLoaded: false
           };
         }
-        const childStats = await fs21.stat(childPath);
+        const childStats = await fs23.stat(childPath);
         return {
           name: entry.name,
           path: childRelativePath,
@@ -32171,7 +33882,7 @@ async function buildWorkspaceTreeNode(rootPath, absPath) {
   return node;
 }
 function contentTypeForPath(filePath) {
-  switch (path24.extname(filePath).slice(1).toLowerCase()) {
+  switch (path26.extname(filePath).slice(1).toLowerCase()) {
     case "png":
       return "image/png";
     case "jpg":
@@ -32201,15 +33912,15 @@ function contentTypeForPath(filePath) {
   }
 }
 async function collectFolderZipEntries(rootPath, folderPath) {
-  const folderName = path24.basename(folderPath) || "workspace-folder";
+  const folderName = path26.basename(folderPath) || "workspace-folder";
   const entries = [];
   let totalBytes = 0;
   const pending = [folderPath];
   while (pending.length > 0) {
     const current = pending.pop();
-    const children = await fs21.readdir(current, { withFileTypes: true });
+    const children = await fs23.readdir(current, { withFileTypes: true });
     for (const child of children) {
-      const childPath = await resolveWorkspaceItemPath(rootPath, path24.relative(rootPath, path24.join(current, child.name)));
+      const childPath = await resolveWorkspaceItemPath(rootPath, path26.relative(rootPath, path26.join(current, child.name)));
       if (child.isDirectory()) {
         pending.push(childPath);
         continue;
@@ -32217,7 +33928,7 @@ async function collectFolderZipEntries(rootPath, folderPath) {
       if (!child.isFile()) {
         continue;
       }
-      const stats = await fs21.stat(childPath);
+      const stats = await fs23.stat(childPath);
       totalBytes += stats.size;
       entries.push({
         absPath: childPath,
@@ -32268,8 +33979,8 @@ async function createFolderZipFile(rootPath, folderPath) {
   const centralParts = [];
   let offset = 0;
   for (const entry of entries) {
-    const data = await fs21.readFile(entry.absPath);
-    const name = Buffer.from(entry.archivePath.split(path24.sep).join("/"), "utf8");
+    const data = await fs23.readFile(entry.absPath);
+    const name = Buffer.from(entry.archivePath.split(path26.sep).join("/"), "utf8");
     const checksum = crc32(data);
     const { dosDate, dosTime } = zipDosDateTime(entry.updatedAt);
     const localHeader = Buffer.alloc(30);
@@ -32316,19 +34027,19 @@ async function createFolderZipFile(rootPath, folderPath) {
   endRecord.writeUInt32LE(centralSize, 12);
   endRecord.writeUInt32LE(offset, 16);
   endRecord.writeUInt16LE(0, 20);
-  const tempDir = await fs21.mkdtemp(path24.join(os3.tmpdir(), "remote-codex-folder-download-"));
-  const zipPath = path24.join(tempDir, `${path24.basename(folderPath) || "workspace-folder"}.zip`);
-  await fs21.writeFile(zipPath, Buffer.concat([...localParts, ...centralParts, endRecord]));
+  const tempDir = await fs23.mkdtemp(path26.join(os3.tmpdir(), "remote-codex-folder-download-"));
+  const zipPath = path26.join(tempDir, `${path26.basename(folderPath) || "workspace-folder"}.zip`);
+  await fs23.writeFile(zipPath, Buffer.concat([...localParts, ...centralParts, endRecord]));
   return { zipPath, tempDir };
 }
 function cleanupTemporaryZip(zipPath, tempDir) {
   return async () => {
-    await fs21.rm(zipPath, { force: true }).catch(() => void 0);
-    await fs21.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
+    await fs23.rm(zipPath, { force: true }).catch(() => void 0);
+    await fs23.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
   };
 }
 function sanitizeUploadFilename(filename) {
-  const baseName = path24.basename(filename?.trim() || "upload");
+  const baseName = path26.basename(filename?.trim() || "upload");
   if (!baseName || baseName === "." || baseName === "..") {
     return "upload";
   }
@@ -32340,7 +34051,7 @@ function inferGitRepoName(gitUrl) {
   const normalized = withoutQuery.replace(/[\\/]+$/, "");
   const rawName = normalized.split(/[\\/:]/).filter(Boolean).at(-1) ?? "";
   const repoName = rawName.endsWith(".git") ? rawName.slice(0, -4) : rawName;
-  if (!repoName || repoName === "." || repoName === ".." || repoName.includes(path24.sep)) {
+  if (!repoName || repoName === "." || repoName === ".." || repoName.includes(path26.sep)) {
     throw new HttpError(400, {
       code: "bad_request",
       message: "Unable to infer a target directory from the Git URL."
@@ -32350,7 +34061,7 @@ function inferGitRepoName(gitUrl) {
 }
 async function pathExists4(absPath) {
   try {
-    await fs21.stat(absPath);
+    await fs23.stat(absPath);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -32474,7 +34185,7 @@ async function registerWorkspaceRoutes(app2) {
   });
   app2.get("/api/workspaces/tree", async (request) => {
     const query = treeQuerySchema.parse(request.query);
-    const requestedPath = query.path ? path25.resolve(query.path) : app2.services.config.workspaceRoot;
+    const requestedPath = query.path ? path27.resolve(query.path) : app2.services.config.workspaceRoot;
     const tree = await readWorkspaceTree({
       rootPath: app2.services.config.workspaceRoot,
       targetPath: requestedPath,
@@ -32501,7 +34212,7 @@ async function registerWorkspaceRoutes(app2) {
     const params = z9.object({ id: z9.string().uuid() }).parse(request.params);
     const query = workspaceFileQuerySchema.parse(request.query);
     const record2 = requireWorkspaceRecord(app2, params.id);
-    const rootPath = await fs22.realpath(record2.absPath);
+    const rootPath = await fs24.realpath(record2.absPath);
     const targetPath = await resolveWorkspaceItemPath(rootPath, query.path);
     return buildWorkspaceTreeNode(rootPath, targetPath);
   });
@@ -32520,9 +34231,9 @@ async function registerWorkspaceRoutes(app2) {
     const params = z9.object({ id: z9.string().uuid() }).parse(request.params);
     const query = workspacePreviewQuerySchema.parse(request.query);
     const record2 = requireWorkspaceRecord(app2, params.id);
-    const rootPath = await fs22.realpath(record2.absPath);
+    const rootPath = await fs24.realpath(record2.absPath);
     const filePath = await resolveWorkspaceItemPath(rootPath, query.path);
-    const stats = await fs22.stat(filePath);
+    const stats = await fs24.stat(filePath);
     if (!stats.isFile()) {
       throw new HttpError(400, {
         code: "bad_request",
@@ -32531,7 +34242,7 @@ async function registerWorkspaceRoutes(app2) {
     }
     const offset = query.offset ?? 0;
     const limit = query.limit ?? PREVIEW_DEFAULT_LIMIT_BYTES;
-    const handle = await fs22.open(filePath, "r");
+    const handle = await fs24.open(filePath, "r");
     try {
       const length = Math.min(limit, Math.max(0, stats.size - offset));
       const buffer = Buffer.alloc(length);
@@ -32539,7 +34250,7 @@ async function registerWorkspaceRoutes(app2) {
       const nextOffset = offset + read.bytesRead;
       return {
         path: relativeWorkspacePath(rootPath, filePath),
-        name: path25.basename(filePath),
+        name: path27.basename(filePath),
         content: buffer.subarray(0, read.bytesRead).toString("utf8"),
         language: languageForPath(filePath),
         size: stats.size,
@@ -32554,9 +34265,9 @@ async function registerWorkspaceRoutes(app2) {
     const params = z9.object({ id: z9.string().uuid() }).parse(request.params);
     const query = workspacePreviewQuerySchema.pick({ path: true }).parse(request.query);
     const record2 = requireWorkspaceRecord(app2, params.id);
-    const rootPath = await fs22.realpath(record2.absPath);
+    const rootPath = await fs24.realpath(record2.absPath);
     const filePath = await resolveWorkspaceItemPath(rootPath, query.path);
-    const stats = await fs22.stat(filePath);
+    const stats = await fs24.stat(filePath);
     if (!stats.isFile()) {
       throw new HttpError(400, {
         code: "bad_request",
@@ -32564,18 +34275,18 @@ async function registerWorkspaceRoutes(app2) {
       });
     }
     reply.header("content-type", contentTypeForPath(filePath));
-    return reply.send(Readable2.from(await fs22.readFile(filePath)));
+    return reply.send(Readable2.from(await fs24.readFile(filePath)));
   });
   app2.get("/api/workspaces/:id/files/download", async (request, reply) => {
     const params = z9.object({ id: z9.string().uuid() }).parse(request.params);
     const query = workspaceFileQuerySchema.parse(request.query);
     const record2 = requireWorkspaceRecord(app2, params.id);
-    const rootPath = await fs22.realpath(record2.absPath);
+    const rootPath = await fs24.realpath(record2.absPath);
     const itemPath = await resolveWorkspaceItemPath(rootPath, query.path);
-    const stats = await fs22.stat(itemPath);
+    const stats = await fs24.stat(itemPath);
     if (stats.isDirectory()) {
       const { zipPath, tempDir } = await createFolderZipFile(rootPath, itemPath);
-      const filename2 = `${path25.basename(itemPath) || "workspace-folder"}.zip`;
+      const filename2 = `${path27.basename(itemPath) || "workspace-folder"}.zip`;
       const cleanup = cleanupTemporaryZip(zipPath, tempDir);
       reply.raw.once("finish", () => void cleanup());
       reply.raw.once("close", () => void cleanup());
@@ -32591,17 +34302,17 @@ async function registerWorkspaceRoutes(app2) {
         message: "Only file and folder downloads are supported from this endpoint."
       });
     }
-    const filename = path25.basename(itemPath);
+    const filename = path27.basename(itemPath);
     reply.header("content-type", contentTypeForPath(itemPath)).header(
       "content-disposition",
       `attachment; filename="${filename}"; filename*=UTF-8''${encodeURIComponent(filename)}`
     );
-    return reply.send(Readable2.from(await fs22.readFile(itemPath)));
+    return reply.send(Readable2.from(await fs24.readFile(itemPath)));
   });
   app2.post("/api/workspaces/:id/files/upload", async (request) => {
     const params = z9.object({ id: z9.string().uuid() }).parse(request.params);
     const record2 = requireWorkspaceRecord(app2, params.id);
-    const rootPath = await fs22.realpath(record2.absPath);
+    const rootPath = await fs24.realpath(record2.absPath);
     const uploadRequest = request;
     if (!uploadRequest.isMultipart()) {
       throw new HttpError(400, {
@@ -32656,7 +34367,7 @@ async function registerWorkspaceRoutes(app2) {
       kind: "file",
       file: {
         path: file.path,
-        name: path25.basename(file.path),
+        name: path27.basename(file.path),
         size: file.size
       }
     };
@@ -32732,7 +34443,7 @@ async function registerWorkspaceRoutes(app2) {
     let validated;
     if ("gitUrl" in body) {
       const repoName = inferGitRepoName(body.gitUrl);
-      const targetPath = path25.join(settings.devHome, repoName);
+      const targetPath = path27.join(settings.devHome, repoName);
       if (await pathExists4(targetPath)) {
         throw new HttpError(409, {
           code: "conflict",
@@ -32746,14 +34457,14 @@ async function registerWorkspaceRoutes(app2) {
       validated = await validateWorkspacePath(app2.services.config.workspaceRoot, targetPath);
     } else {
       const requestedPath = body.absPath.trim();
-      const isWorkspaceName = !path25.isAbsolute(requestedPath) && /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(requestedPath) && requestedPath !== "." && requestedPath !== "..";
-      if (!path25.isAbsolute(requestedPath) && !isWorkspaceName) {
+      const isWorkspaceName = !path27.isAbsolute(requestedPath) && /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(requestedPath) && requestedPath !== "." && requestedPath !== "..";
+      if (!path27.isAbsolute(requestedPath) && !isWorkspaceName) {
         throw new HttpError(400, {
           code: "bad_request",
           message: "Use a simple directory name, an absolute path, or a Git URL."
         });
       }
-      const targetPath = isWorkspaceName ? path25.join(settings.devHome, requestedPath) : requestedPath;
+      const targetPath = isWorkspaceName ? path27.join(settings.devHome, requestedPath) : requestedPath;
       validated = await validateWorkspacePath(app2.services.config.workspaceRoot, targetPath, {
         devHome: settings.devHome,
         createMissingLeaf: true
@@ -32860,8 +34571,8 @@ async function registerWorkspaceRoutes(app2) {
 import { z as z10 } from "zod";
 
 // src/plugins/plugin-service.ts
-import fs23 from "fs/promises";
-import path26 from "path";
+import fs25 from "fs/promises";
+import path28 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";
@@ -32882,7 +34593,7 @@ function normalizeManagedCommand(server, repoRoot) {
   if (server.name === "remote_codex_plugins") {
     return {
       command: process.execPath,
-      args: [path26.join(repoRoot, "bin", "remote-codex-plugin-mcp.mjs")]
+      args: [path28.join(repoRoot, "bin", "remote-codex-plugin-mcp.mjs")]
     };
   }
   return {
@@ -33081,10 +34792,10 @@ var PluginService = class {
     if (!input.codexHome) {
       return;
     }
-    const configPath = path26.join(input.codexHome, "config.toml");
+    const configPath = path28.join(input.codexHome, "config.toml");
     let current = "";
     try {
-      current = await fs23.readFile(configPath, "utf8");
+      current = await fs25.readFile(configPath, "utf8");
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -33099,8 +34810,8 @@ var PluginService = class {
     if (next === current) {
       return;
     }
-    await fs23.mkdir(path26.dirname(configPath), { recursive: true });
-    await fs23.writeFile(configPath, next, "utf8");
+    await fs25.mkdir(path28.dirname(configPath), { recursive: true });
+    await fs25.writeFile(configPath, next, "utf8");
   }
   async importPlugin(input) {
     const manifestInput = input.manifest ?? (input.manifestUrl ? await this.fetchManifestUrl(input.manifestUrl) : this.parseManifestJson(input.manifestJson));
@@ -33466,8 +35177,8 @@ async function registerAuthRoutes(app2) {
 }
 
 // src/provider-host-config-service.ts
-import fs24 from "fs/promises";
-import path27 from "path";
+import fs26 from "fs/promises";
+import path29 from "path";
 import { randomUUID as randomUUID7 } from "crypto";
 function providerError(message, statusCode = 404) {
   const error = new Error(message);
@@ -33475,23 +35186,23 @@ function providerError(message, statusCode = 404) {
   return error;
 }
 function resolveProviderHostFilePath(providerHome, name) {
-  return path27.join(providerHome, name);
+  return path29.join(providerHome, name);
 }
 function resolveArchiveRoot(providerHome) {
-  return path27.join(providerHome, "supervisor-config-archives");
+  return path29.join(providerHome, "supervisor-config-archives");
 }
 function resolveArchiveIndexPath(providerHome) {
-  return path27.join(resolveArchiveRoot(providerHome), "index.json");
+  return path29.join(resolveArchiveRoot(providerHome), "index.json");
 }
 function resolveArchivePath(providerHome, archiveId) {
-  return path27.join(resolveArchiveRoot(providerHome), archiveId);
+  return path29.join(resolveArchiveRoot(providerHome), archiveId);
 }
 function defaultArchiveLabel(createdAt) {
   return `Backup ${createdAt.replace("T", " ").replace(/\.\d{3}Z$/, " UTC")}`;
 }
 async function readArchiveIndex(providerHome) {
   try {
-    const raw = await fs24.readFile(resolveArchiveIndexPath(providerHome), "utf8");
+    const raw = await fs26.readFile(resolveArchiveIndexPath(providerHome), "utf8");
     const parsed = JSON.parse(raw);
     return {
       archives: Array.isArray(parsed.archives) ? parsed.archives : []
@@ -33505,8 +35216,8 @@ async function readArchiveIndex(providerHome) {
 }
 async function writeArchiveIndex(providerHome, index) {
   const root = resolveArchiveRoot(providerHome);
-  await fs24.mkdir(root, { recursive: true });
-  await fs24.writeFile(
+  await fs26.mkdir(root, { recursive: true });
+  await fs26.writeFile(
     resolveArchiveIndexPath(providerHome),
     `${JSON.stringify(index, null, 2)}
 `,
@@ -33577,7 +35288,7 @@ var ProviderHostConfigService = class {
     const fileName = this.assertHostFile(provider2, name);
     const filePath = resolveProviderHostFilePath(providerHome, fileName);
     try {
-      const content = await fs24.readFile(filePath, "utf8");
+      const content = await fs26.readFile(filePath, "utf8");
       return {
         name: fileName,
         path: filePath,
@@ -33600,8 +35311,8 @@ var ProviderHostConfigService = class {
     const providerHome = this.providerHome(provider2);
     const fileName = this.assertHostFile(provider2, name);
     const filePath = resolveProviderHostFilePath(providerHome, fileName);
-    await fs24.mkdir(path27.dirname(filePath), { recursive: true });
-    await fs24.writeFile(filePath, input.content, "utf8");
+    await fs26.mkdir(path29.dirname(filePath), { recursive: true });
+    await fs26.writeFile(filePath, input.content, "utf8");
     return this.readFile(provider2, fileName);
   }
   async listArchives(provider2) {
@@ -33627,7 +35338,7 @@ var ProviderHostConfigService = class {
         }
       ])
     );
-    await fs24.mkdir(archivePath, { recursive: true });
+    await fs26.mkdir(archivePath, { recursive: true });
     for (const name of fileNames) {
       const hostFile = await this.readFile(provider2, name);
       files[name] = {
@@ -33635,7 +35346,7 @@ var ProviderHostConfigService = class {
         exists: hostFile.exists
       };
       if (hostFile.exists) {
-        await fs24.writeFile(path27.join(archivePath, name), hostFile.content, "utf8");
+        await fs26.writeFile(path29.join(archivePath, name), hostFile.content, "utf8");
       }
     }
     const archive = {
@@ -33671,14 +35382,14 @@ var ProviderHostConfigService = class {
     const fileNames = this.archiveFileNames(provider2);
     const { archive } = await findArchiveOrThrow(providerHome, id);
     const archivePath = resolveArchivePath(providerHome, archive.id);
-    await fs24.mkdir(providerHome, { recursive: true });
+    await fs26.mkdir(providerHome, { recursive: true });
     for (const name of fileNames) {
       const hostPath = resolveProviderHostFilePath(providerHome, name);
       if (archive.files[name]?.exists) {
-        const content = await fs24.readFile(path27.join(archivePath, name), "utf8");
-        await fs24.writeFile(hostPath, content, "utf8");
+        const content = await fs26.readFile(path29.join(archivePath, name), "utf8");
+        await fs26.writeFile(hostPath, content, "utf8");
       } else {
-        await fs24.rm(hostPath, { force: true });
+        await fs26.rm(hostPath, { force: true });
       }
     }
     await runtime.stop();
@@ -33691,12 +35402,12 @@ var ProviderHostConfigService = class {
 };
 
 // src/shell/shell-session-service.ts
-import fs26 from "fs/promises";
+import fs28 from "fs/promises";
 
 // src/shell/shell-prompt.ts
-import fs25 from "fs/promises";
+import fs27 from "fs/promises";
 import os4 from "os";
-import path28 from "path";
+import path30 from "path";
 function basenameFromPath2(filePath) {
   if (!filePath) {
     return "";
@@ -33705,7 +35416,7 @@ function basenameFromPath2(filePath) {
   if (!normalized) {
     return "";
   }
-  return path28.basename(normalized) || normalized;
+  return path30.basename(normalized) || normalized;
 }
 function isInteractiveShellCommand(command) {
   const normalized = (command ?? "").trim().toLowerCase();
@@ -33866,11 +35577,11 @@ function buildShellPromptInitScriptContents(command) {
 async function ensureShellPromptInitScript(command) {
   const normalized = command.trim().toLowerCase();
   const extension = normalized === "zsh" ? "zsh" : "sh";
-  const filePath = path28.join(
+  const filePath = path30.join(
     os4.tmpdir(),
     `remote-codex-shell-prompt.${extension}`
   );
-  await fs25.writeFile(filePath, buildShellPromptInitScriptContents(command), "utf8");
+  await fs27.writeFile(filePath, buildShellPromptInitScriptContents(command), "utf8");
   return filePath;
 }
 async function buildShellPromptInitCommand(command, options = {}) {
@@ -33886,7 +35597,7 @@ clear
 // src/shell/shell-session-service.ts
 async function pathExists5(filePath) {
   try {
-    await fs26.access(filePath);
+    await fs28.access(filePath);
     return true;
   } catch {
     return false;
@@ -34623,19 +36334,19 @@ var BackendPluginHost = class {
 
 // src/shell/pty-shell-backend.ts
 import { createRequire as createRequire4 } from "module";
-import path29 from "path";
+import path31 from "path";
 
 // src/shell/default-shell.ts
-import fs27 from "fs";
+import fs29 from "fs";
 var POSIX_SHELL_CANDIDATES = ["/bin/bash", "/usr/bin/bash", "/bin/sh"];
 function resolveDefaultShell(env = process.env, platform = process.platform) {
   if (platform === "win32") {
     return env.COMSPEC ?? "cmd.exe";
   }
-  if (env.SHELL && fs27.existsSync(env.SHELL)) {
+  if (env.SHELL && fs29.existsSync(env.SHELL)) {
     return env.SHELL;
   }
-  return POSIX_SHELL_CANDIDATES.find((candidate) => fs27.existsSync(candidate)) ?? "/bin/sh";
+  return POSIX_SHELL_CANDIDATES.find((candidate) => fs29.existsSync(candidate)) ?? "/bin/sh";
 }
 
 // src/shell/pty-shell-backend.ts
@@ -34647,7 +36358,7 @@ function spawnPty(...args) {
   return nodePty.spawn(...args);
 }
 function shellArgs(shell) {
-  const shellName = path29.basename(shell).toLowerCase();
+  const shellName = path31.basename(shell).toLowerCase();
   if (process.platform === "win32") {
     return [];
   }
@@ -34669,7 +36380,7 @@ function lastVisibleLine(snapshot) {
 }
 function inferRuntime(session) {
   const promptLine = lastVisibleLine(session.scrollback);
-  const shell = path29.basename(session.shell);
+  const shell = path31.basename(session.shell);
   const isCommandRunning = session.exitCode !== null ? false : !/[$#>]\s*$/.test(promptLine.trimEnd());
   return {
     panePid: session.pty.pid,
@@ -34815,8 +36526,8 @@ var PtyShellBackend = class {
 };
 
 // src/shell/tmux-manager.ts
-import fs28 from "fs";
-import path30 from "path";
+import fs30 from "fs";
+import path32 from "path";
 import { spawn as spawnChild } from "child_process";
 async function defaultExecCommand(command, args) {
   return await new Promise((resolve, reject) => {
@@ -34843,17 +36554,17 @@ async function defaultExecCommand(command, args) {
   });
 }
 function resolveExecutablePath(command) {
-  if (command.includes(path30.sep)) {
+  if (command.includes(path32.sep)) {
     return command;
   }
   const searchPath = process.env.PATH ?? "";
-  for (const entry of searchPath.split(path30.delimiter)) {
+  for (const entry of searchPath.split(path32.delimiter)) {
     const trimmed = entry.trim();
     if (!trimmed) {
       continue;
     }
-    const candidate = path30.join(trimmed, command);
-    if (fs28.existsSync(candidate)) {
+    const candidate = path32.join(trimmed, command);
+    if (fs30.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -35331,13 +37042,17 @@ var UnsupportedShellBackend = class {
   async listSessionNames() {
     return [];
   }
-  async hasSession(_sessionId) {
+  async hasSession(sessionId) {
+    void sessionId;
     return false;
   }
-  async createSession(_input) {
+  async createSession(input) {
+    void input;
     this.throwUnavailable();
   }
-  async attach(_sessionId, _options) {
+  async attach(sessionId, options) {
+    void sessionId;
+    void options;
     return this.throwUnavailable();
   }
   async sendInput() {
@@ -36090,16 +37805,16 @@ var HttpError = class extends Error {
 };
 function findRepoRoot(start = process.cwd()) {
   if (process.env.REMOTE_CODEX_REPO_ROOT) {
-    return path31.resolve(process.env.REMOTE_CODEX_REPO_ROOT);
+    return path33.resolve(process.env.REMOTE_CODEX_REPO_ROOT);
   }
-  let current = path31.resolve(start);
-  while (current !== path31.dirname(current)) {
-    if (fs29.existsSync(path31.join(current, "pnpm-workspace.yaml")) && fs29.existsSync(path31.join(current, "scripts", "service-restart.mjs"))) {
+  let current = path33.resolve(start);
+  while (current !== path33.dirname(current)) {
+    if (fs31.existsSync(path33.join(current, "pnpm-workspace.yaml")) && fs31.existsSync(path33.join(current, "scripts", "service-restart.mjs"))) {
       return current;
     }
-    current = path31.dirname(current);
+    current = path33.dirname(current);
   }
-  return path31.resolve(process.cwd());
+  return path33.resolve(process.cwd());
 }
 function createServiceLifecycle() {
   return {
@@ -36111,12 +37826,12 @@ function createServiceLifecycle() {
         });
       }
       const repoRoot = findRepoRoot();
-      const restartScript = path31.join(
+      const restartScript = path33.join(
         repoRoot,
         "scripts",
         "service-restart.mjs"
       );
-      if (!fs29.existsSync(restartScript) || !fs29.existsSync(path31.join(repoRoot, "pnpm-workspace.yaml"))) {
+      if (!fs31.existsSync(restartScript) || !fs31.existsSync(path33.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."
@@ -36599,9 +38314,9 @@ function relayResponseHeaders(headers) {
 }
 
 // src/platform/lifecycle-control.ts
-import fs30 from "fs/promises";
+import fs32 from "fs/promises";
 import net2 from "net";
-import path32 from "path";
+import path34 from "path";
 var LifecycleControlServer = class {
   constructor(options) {
     this.options = options;
@@ -36613,12 +38328,12 @@ var LifecycleControlServer = class {
       return;
     }
     if (process.platform !== "win32") {
-      await fs30.unlink(this.options.endpoint).catch((error) => {
+      await fs32.unlink(this.options.endpoint).catch((error) => {
         if (error.code !== "ENOENT") {
           throw error;
         }
       });
-      await fs30.mkdir(path32.dirname(this.options.endpoint), { recursive: true });
+      await fs32.mkdir(path34.dirname(this.options.endpoint), { recursive: true });
     }
     const server = net2.createServer((socket) => {
       socket.setEncoding("utf8");
@@ -36655,7 +38370,7 @@ var LifecycleControlServer = class {
       await new Promise((resolve) => server.close(() => resolve()));
     }
     if (process.platform !== "win32") {
-      await fs30.unlink(this.options.endpoint).catch(() => void 0);
+      await fs32.unlink(this.options.endpoint).catch(() => void 0);
     }
   }
   async handleRequest(line, socket) {
@@ -36698,7 +38413,7 @@ var LifecycleControlServer = class {
 };
 
 // src/index.ts
-if (fs31.existsSync(".env")) {
+if (fs33.existsSync(".env")) {
   process.loadEnvFile?.(".env");
 }
 var app = buildApp();