@ai-development-environment/control-agent 0.0.111 → 0.0.113

package/dist/control-agent.js

@@ -3814,12 +3814,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve10, reject) {
+        return new Promise(function(resolve11, reject) {
           isexe(path, options || {}, function(er2, is) {
             if (er2) {
               reject(er2);
             } else {
-              resolve10(is);
+              resolve11(is);
             }
           });
         });
@@ -3885,27 +3885,27 @@ var require_which = __commonJS({
         opt = {};
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
       const found = [];
-      const step = (i) => new Promise((resolve10, reject) => {
+      const step = (i) => new Promise((resolve11, reject) => {
         if (i === pathEnv.length)
-          return opt.all && found.length ? resolve10(found) : reject(getNotFoundError(cmd));
+          return opt.all && found.length ? resolve11(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
         const pCmd = path.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        resolve10(subStep(p, i, 0));
+        resolve11(subStep(p, i, 0));
       });
-      const subStep = (p, i, ii) => new Promise((resolve10, reject) => {
+      const subStep = (p, i, ii) => new Promise((resolve11, reject) => {
         if (ii === pathExt.length)
-          return resolve10(step(i + 1));
+          return resolve11(step(i + 1));
         const ext = pathExt[ii];
         isexe(p + ext, { pathExt: pathExtExe }, (er2, is) => {
           if (!er2 && is) {
             if (opt.all)
               found.push(p + ext);
             else
-              return resolve10(p + ext);
+              return resolve11(p + ext);
           }
-          return resolve10(subStep(p, i, ii + 1));
+          return resolve11(subStep(p, i, ii + 1));
         });
       });
       return cb2 ? step(0).then((res) => cb2(null, res), cb2) : step(0);
@@ -4511,8 +4511,8 @@ function createClient(options) {
     retryWait = async function randomisedExponentialBackoff(retries2) {
       const retryDelaySeconds = Math.pow(2, retries2);
       await new Promise(
-        (resolve10) => setTimeout(
-          resolve10,
+        (resolve11) => setTimeout(
+          resolve11,
           retryDelaySeconds * 1e3 + // add random timeout from 300ms to 3s
           Math.floor(Math.random() * (3e3 - 300) + 300)
         )
@@ -4754,14 +4754,14 @@ function createClient(options) {
     if (socket.readyState === WebSocketImpl.CLOSING) await throwOnClose;
     let release2 = () => {
     };
-    const released = new Promise((resolve10) => release2 = resolve10);
+    const released = new Promise((resolve11) => release2 = resolve11);
     return [
       socket,
       release2,
       // resolves on release or rejects on error/close, whichever comes first.
       // not racing with throwOnClose on purpose, it lives as long as the socket
       // and every race would leak memory per operation
-      new Promise((resolve10, reject) => {
+      new Promise((resolve11, reject) => {
         const unlisten = errorOrClosed(reject);
         if (socket.readyState !== WebSocketImpl.OPEN)
           throwOnClose.catch(reject);
@@ -4777,7 +4777,7 @@ function createClient(options) {
               complete();
             }
           }
-          resolve10();
+          resolve11();
         });
       })
     ];
@@ -4922,7 +4922,7 @@ function createClient(options) {
       const iterator = (async function* iterator2() {
         for (; ; ) {
           if (!pending.length) {
-            await new Promise((resolve10) => deferred.resolve = resolve10);
+            await new Promise((resolve11) => deferred.resolve = resolve11);
           }
           while (pending.length) {
             yield pending.shift();
@@ -5026,11 +5026,11 @@ async function writeArtifactTransferBytes(writer, bytes, position) {
   }
 }
 async function artifactTransferRetryDelay(attempt, signal) {
-  await new Promise((resolve10, reject) => {
+  await new Promise((resolve11, reject) => {
     const timeout = setTimeout(
       () => {
         signal.removeEventListener("abort", abort);
-        resolve10();
+        resolve11();
       },
       Math.min(4e3, 250 * 2 ** attempt)
     );
@@ -5441,7 +5441,7 @@ var AgentGraphQLClient = class {
           metadata.error || `Artifact transfer ${metadata.status.toLowerCase()}`
         );
       }
-      await new Promise((resolve10) => setTimeout(resolve10, 1e3));
+      await new Promise((resolve11) => setTimeout(resolve11, 1e3));
     }
     if (!Number.isSafeInteger(metadata.uploadLength) || !metadata.uploadLength || !metadata.checksum || !metadata.filename) {
       throw new Error("Artifact transfer metadata is incomplete");
@@ -5815,7 +5815,7 @@ function createAgentSubscriptionClient(config) {
     shouldRetry: () => true,
     retryWait: async (retries) => {
       const delay = Math.min(3e4, 1e3 * 2 ** Math.min(retries, 5));
-      await new Promise((resolve10) => setTimeout(resolve10, delay));
+      await new Promise((resolve11) => setTimeout(resolve11, delay));
     },
     on: {
       connected: () => console.log("Connected to control-plane WebSocket"),
@@ -7954,6 +7954,16 @@ var DSYMS_ARTIFACT_FILENAME = "dSYMs.zip";
 function resolveCollectDsyms(settings, action) {
   return settings.collectDsyms ?? action === "ARCHIVE";
 }
+var BUILD_ENDPOINT_PATHS = {
+  consoleLogs: "/api/telemetry/console-logs",
+  analyticsEvents: "/api/telemetry/analytics-events",
+  apnsRegistration: "/api/ios/apns-devices",
+  crashReports: "/api/public/crashes",
+  dsyms: "/api/dsyms",
+  dsymUploads: "/api/dsyms/uploads",
+  dsymUpload: "/api/dsyms/uploads/{uploadId}",
+  dsymUploadComplete: "/api/dsyms/uploads/{uploadId}/complete"
+};
 var BUILD_REPORT_KINDS = ["TEST_RESULTS", "CODE_COVERAGE"];
 function objectValue7(value, name) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -8218,26 +8228,6 @@ function parseBuildTelemetrySettings(value) {
   if (value === void 0 || value === null) return void 0;
   const input = objectValue7(value, "build job payload.telemetry");
   return {
-    localBaseUrl: httpUrl(
-      input.localBaseUrl,
-      "build job payload.telemetry.localBaseUrl"
-    ),
-    remoteBaseUrl: httpUrl(
-      input.remoteBaseUrl,
-      "build job payload.telemetry.remoteBaseUrl"
-    ),
-    selectedBaseUrl: httpUrl(
-      input.selectedBaseUrl,
-      "build job payload.telemetry.selectedBaseUrl"
-    ),
-    consoleLogsUrl: httpUrl(
-      input.consoleLogsUrl,
-      "build job payload.telemetry.consoleLogsUrl"
-    ),
-    analyticsEventsUrl: httpUrl(
-      input.analyticsEventsUrl,
-      "build job payload.telemetry.analyticsEventsUrl"
-    ),
     consoleCollectionEnabled: booleanValue2(
       input.consoleCollectionEnabled,
       "build job payload.telemetry.consoleCollectionEnabled"
@@ -8248,6 +8238,40 @@ function parseBuildTelemetrySettings(value) {
     )
   };
 }
+function parseBuildServer(value) {
+  if (value == null) return void 0;
+  const input = objectValue7(value, "build job payload.server");
+  const selectedUrlKind = input.selectedUrlKind;
+  if (selectedUrlKind !== "LOCAL" && selectedUrlKind !== "REMOTE" && selectedUrlKind !== "PROXY")
+    throw new Error("Invalid build server URL kind");
+  const origin2 = (value2, name) => {
+    const result = httpUrl(value2, name);
+    const parsed = new URL(result);
+    if (parsed.pathname !== "/" || parsed.search || parsed.hash || parsed.username || parsed.password)
+      throw new Error(`${name} must be an HTTP(S) origin`);
+    return parsed.origin;
+  };
+  const server = {
+    localBaseUrl: origin2(input.localBaseUrl, "server.localBaseUrl"),
+    remoteBaseUrl: origin2(input.remoteBaseUrl, "server.remoteBaseUrl"),
+    proxyBaseUrl: input.proxyBaseUrl == null ? null : origin2(input.proxyBaseUrl, "server.proxyBaseUrl"),
+    selectedUrlKind,
+    selectedBaseUrl: origin2(input.selectedBaseUrl, "server.selectedBaseUrl")
+  };
+  const selected = selectedUrlKind === "LOCAL" ? server.localBaseUrl : selectedUrlKind === "REMOTE" ? server.remoteBaseUrl : server.proxyBaseUrl;
+  if (selected !== server.selectedBaseUrl)
+    throw new Error("Selected server URL must match its configured base URL");
+  return server;
+}
+function parseBuildEndpointPaths(value) {
+  if (value == null) return void 0;
+  const input = objectValue7(value, "build job payload.endpointPaths");
+  for (const [key, expected] of Object.entries(BUILD_ENDPOINT_PATHS)) {
+    if (input[key] !== expected)
+      throw new Error(`Invalid build endpoint path: ${key}`);
+  }
+  return { ...BUILD_ENDPOINT_PATHS };
+}
 function parseBuildSourceDiscoverPayload(value) {
   return worktreeIdentity(objectValue7(value, "source discovery payload"));
 }
@@ -8336,6 +8360,8 @@ function parseBuildJobPayload(value) {
     advancedSettings,
     scripts,
     telemetry: parseBuildTelemetrySettings(input.telemetry),
+    server: parseBuildServer(input.server),
+    endpointPaths: parseBuildEndpointPaths(input.endpointPaths),
     worktreeCoverage: input.worktreeCoverage === void 0 ? false : booleanValue2(
       input.worktreeCoverage,
       "build job payload.worktreeCoverage"
@@ -9567,7 +9593,7 @@ function captureCommand(options) {
       outputTruncated: false
     });
   }
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     const stdoutChunks = [];
     const stderrChunks = [];
     let stdoutBytes = 0;
@@ -9663,7 +9689,7 @@ function captureCommand(options) {
       clearTimeout(timeout);
       if (killTimer) clearTimeout(killTimer);
       options.signal.removeEventListener("abort", abort);
-      resolve10({
+      resolve11({
         exitCode,
         signal,
         timedOut,
@@ -9751,11 +9777,11 @@ async function reapOrphanedCommandProcesses(agentId, signal = new AbortControlle
   console.error(
     `Terminating ${signalled.length} command process(es) left by a previous agent run.`
   );
-  await new Promise((resolve10) => {
-    const timer = setTimeout(resolve10, TERMINATE_GRACE_MS);
+  await new Promise((resolve11) => {
+    const timer = setTimeout(resolve11, TERMINATE_GRACE_MS);
     timer.unref();
-    if (signal.aborted) resolve10();
-    else signal.addEventListener("abort", () => resolve10(), { once: true });
+    if (signal.aborted) resolve11();
+    else signal.addEventListener("abort", () => resolve11(), { once: true });
   });
   for (const orphan of signalled) signalGroup(orphan.processGroup, "SIGKILL");
   return signalled;
@@ -9811,14 +9837,14 @@ var runCommand = async (rawPayload, _timeoutMs, signal, _onLog, context) => {
             `Could not append command output; retrying in ${delay}ms:`,
             error instanceof Error ? error.message : error
           );
-          await new Promise((resolve10) => {
+          await new Promise((resolve11) => {
             const onAbort = () => {
               clearTimeout(retryTimer);
-              resolve10();
+              resolve11();
             };
             const retryTimer = setTimeout(() => {
               signal.removeEventListener("abort", onAbort);
-              resolve10();
+              resolve11();
             }, delay);
             retryTimer.unref();
             signal.addEventListener("abort", onAbort, { once: true });
@@ -9856,7 +9882,7 @@ var runCommand = async (rawPayload, _timeoutMs, signal, _onLog, context) => {
     }
   };
   try {
-    return await new Promise((resolve10, reject) => {
+    return await new Promise((resolve11, reject) => {
       let cancelled = false;
       let settled = false;
       const child = spawn2(process.env.SHELL || "/bin/sh", ["-l", scriptPath], {
@@ -9923,7 +9949,7 @@ var runCommand = async (rawPayload, _timeoutMs, signal, _onLog, context) => {
         signal.removeEventListener("abort", abort);
         flush();
         void uploadChain.then(
-          () => resolve10({
+          () => resolve11({
             exitCode,
             signal: closeSignal,
             timedOut: false,
@@ -9964,8 +9990,8 @@ var RepositoryCoordinator = class {
   async run(key, task) {
     const previous = this.tails.get(key) ?? Promise.resolve();
     let release2;
-    const current = new Promise((resolve10) => {
-      release2 = resolve10;
+    const current = new Promise((resolve11) => {
+      release2 = resolve11;
     });
     const tail = previous.then(() => current);
     this.tails.set(key, tail);
@@ -12688,12 +12714,22 @@ if (typeof hookModule.default === "function") {
         BUILD_PHASE: options.phase,
         BUILD_CONTEXT_PATH: options.contextPath,
         BUILD_ARTIFACT_DIRECTORY: options.input.artifactDirectory,
+        ...options.input.server ? {
+          SERVER_LOCAL_BASE_URL: options.input.server.localBaseUrl,
+          SERVER_REMOTE_BASE_URL: options.input.server.remoteBaseUrl,
+          SERVER_PROXY_BASE_URL: options.input.server.proxyBaseUrl ?? "",
+          SERVER_BASE_URL: options.input.server.selectedBaseUrl,
+          SERVER_URL_KIND: options.input.server.selectedUrlKind
+        } : {},
+        ...Object.fromEntries(
+          Object.entries(options.input.endpointPaths ?? {}).map(
+            ([key, value]) => [
+              `${key.replace(/[A-Z]/g, (letter) => `_${letter}`).toUpperCase()}_PATH`,
+              value
+            ]
+          )
+        ),
         ...options.input.telemetry ? {
-          TELEMETRY_LOCAL_BASE_URL: options.input.telemetry.localBaseUrl,
-          TELEMETRY_REMOTE_BASE_URL: options.input.telemetry.remoteBaseUrl,
-          TELEMETRY_BASE_URL: options.input.telemetry.selectedBaseUrl,
-          CONSOLE_LOGS_URL: options.input.telemetry.consoleLogsUrl,
-          ANALYTICS_EVENTS_URL: options.input.telemetry.analyticsEventsUrl,
           CONSOLE_LOG_COLLECTION_ENABLED: String(
             options.input.telemetry.consoleCollectionEnabled
           ),
@@ -12879,14 +12915,14 @@ function normalizeTestResults(value) {
       suite: null
     });
   }
-  const count = (result) => tests.filter((test) => test.result === result).length;
+  const count3 = (result) => tests.filter((test) => test.result === result).length;
   return {
     summary: {
       total: tests.length,
-      passed: count("Passed"),
-      failed: count("Failed"),
-      skipped: count("Skipped"),
-      expectedFailures: count("Expected Failure"),
+      passed: count3("Passed"),
+      failed: count3("Failed"),
+      skipped: count3("Skipped"),
+      expectedFailures: count3("Expected Failure"),
       unknown: tests.filter(
         (test) => !["Passed", "Failed", "Skipped", "Expected Failure"].includes(
           String(test.result)
@@ -13018,9 +13054,9 @@ function changedLinesFromPatch(value) {
     const match = /\+(\d+)(?:,(\d+))?/.exec(line);
     if (!match) continue;
     const start = Number(match[1]);
-    const count = match[2] === void 0 ? 1 : Number(match[2]);
+    const count3 = match[2] === void 0 ? 1 : Number(match[2]);
     const lines = result.get(path);
-    for (let number = start; number < start + count; number += 1) {
+    for (let number = start; number < start + count3; number += 1) {
       lines.add(number);
     }
   }
@@ -13516,7 +13552,9 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
       source: input.source,
       scheme: input.scheme,
       configuration: input.configuration,
-      telemetry: input.telemetry ?? null
+      telemetry: input.telemetry ?? null,
+      server: input.server ?? null,
+      endpointPaths: input.endpointPaths ?? null
     };
     let buildResult = null;
     let preflightResult = null;
@@ -15396,7 +15434,7 @@ function prependPathDirectory(directory, env = process.env) {
 // src/process-runner.ts
 import { spawn as spawn5 } from "node:child_process";
 async function runProcess(options) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     let sequence = 0;
     let timedOut = false;
     let cancelled = false;
@@ -15491,7 +15529,7 @@ async function runProcess(options) {
       clearTimeout(timeout);
       options.signal.removeEventListener("abort", abort);
       void logChain.then(
-        () => resolve10({ exitCode, signal, timedOut, cancelled })
+        () => resolve11({ exitCode, signal, timedOut, cancelled })
       );
     });
   });
@@ -16409,8 +16447,8 @@ async function fileExists(path) {
     return false;
   }
 }
-async function findClaudeSessionFile(nativeId, home) {
-  const projectsDir = join12(home, ".claude", "projects");
+async function findClaudeSessionFile(nativeId, home, claudeHome = join12(home, ".claude")) {
+  const projectsDir = join12(claudeHome, "projects");
   let entries;
   try {
     entries = await readdir7(projectsDir, { withFileTypes: true });
@@ -16425,8 +16463,8 @@ async function findClaudeSessionFile(nativeId, home) {
   }
   return null;
 }
-async function findCodexSessionFile(nativeId, home) {
-  const sessionsDir = join12(home, ".codex", "sessions");
+async function findCodexSessionFile(nativeId, home, codexHome = join12(home, ".codex")) {
+  const sessionsDir = join12(codexHome, "sessions");
   const suffix = `-${nativeId}.jsonl`;
   const walk = async (dir) => {
     let entries;
@@ -16446,10 +16484,14 @@ async function findCodexSessionFile(nativeId, home) {
     }
     return null;
   };
-  return walk(sessionsDir);
+  return await walk(sessionsDir) ?? walk(join12(codexHome, "archived_sessions"));
 }
 async function locateSessionFile(payload, home) {
-  return payload.provider === "CLAUDE" ? findClaudeSessionFile(payload.nativeId, home) : findCodexSessionFile(payload.nativeId, home);
+  return payload.provider === "CLAUDE" ? findClaudeSessionFile(
+    payload.nativeId,
+    home,
+    process.env.CLAUDE_CONFIG_DIR
+  ) : findCodexSessionFile(payload.nativeId, home, process.env.CODEX_HOME);
 }
 var readRunSession = async (payload) => {
   const input = parseRunSessionReadPayload(payload);
@@ -16514,7 +16556,7 @@ async function optionalGit(cwd, args) {
 }
 function cappedGit(cwd, args, limit) {
   const budget = limit - TRUNCATION_RESERVE;
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     const child = spawn6("git", args, {
       cwd,
       env: {
@@ -16564,7 +16606,7 @@ function cappedGit(cwd, args, limit) {
         return;
       }
       const output = Buffer.concat(chunks).toString("utf8");
-      resolve10(
+      resolve11(
         truncated ? `${output.trimEnd()}
 
 [Truncated after ${budget} bytes]` : output.trim()
@@ -20107,11 +20149,11 @@ var mutationQueues = /* @__PURE__ */ new Map();
 function objectValue15(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function resolveTailscaleExecutable(platform2 = process.platform, resolve10 = findExecutable, isExecutable2 = (path) => {
+function resolveTailscaleExecutable(platform2 = process.platform, resolve11 = findExecutable, isExecutable2 = (path) => {
   accessSync2(path, constants2.X_OK);
   return true;
 }) {
-  const resolved = resolve10("tailscale", {
+  const resolved = resolve11("tailscale", {
     overrideVariable: "CONTROL_AGENT_TAILSCALE_EXECUTABLE"
   });
   if (resolved) return resolved;
@@ -20320,8 +20362,8 @@ function tailscaleUpsertCommandSequence(route, previousRoute) {
 async function serialized(agentId, work) {
   const previous = mutationQueues.get(agentId) ?? Promise.resolve();
   let release2;
-  const current = new Promise((resolve10) => {
-    release2 = resolve10;
+  const current = new Promise((resolve11) => {
+    release2 = resolve11;
   });
   const tail = previous.then(() => current);
   mutationQueues.set(agentId, tail);
@@ -20581,7 +20623,7 @@ var JobExecutor = class {
         );
         if (this.stopping) return;
         const delay = Math.min(3e4, 1e3 * 2 ** Math.min(retry++, 5));
-        await new Promise((resolve10) => setTimeout(resolve10, delay));
+        await new Promise((resolve11) => setTimeout(resolve11, delay));
       }
     }
   }
@@ -20870,6 +20912,254 @@ var RunJournal = class {
 
 // src/runs/claude-adapter.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
+import { homedir as homedir11 } from "node:os";
+
+// src/runs/claude-import.ts
+import { createReadStream as createReadStream4 } from "node:fs";
+import { createInterface } from "node:readline";
+
+// src/runs/provider.ts
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function firstString(value) {
+  const keys = [
+    "text",
+    "result",
+    "message",
+    "summary",
+    "content",
+    "output",
+    "items",
+    "parts"
+  ];
+  const pending = [value];
+  const visited = /* @__PURE__ */ new WeakSet();
+  while (pending.length) {
+    const candidate = pending.pop();
+    if (typeof candidate === "string" && candidate.trim()) return candidate;
+    if (!candidate || typeof candidate !== "object") continue;
+    if (visited.has(candidate)) continue;
+    visited.add(candidate);
+    if (Array.isArray(candidate)) {
+      for (let index = candidate.length - 1; index >= 0; index -= 1) {
+        pending.push(candidate[index]);
+      }
+      continue;
+    }
+    const record = asRecord(candidate);
+    for (let index = keys.length - 1; index >= 0; index -= 1) {
+      pending.push(record[keys[index]]);
+    }
+  }
+  return void 0;
+}
+function answerArrays(value) {
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry) => Array.isArray(entry) ? entry.map(String) : typeof entry === "object" && entry ? Array.isArray(entry.answers) ? entry.answers.map(
+        String
+      ) : [String(entry.answer ?? "")] : [String(entry)]
+    );
+  }
+  const record = asRecord(value);
+  return Object.values(record).map(
+    (entry) => Array.isArray(asRecord(entry).answers) ? asRecord(entry).answers.map(String) : Array.isArray(entry) ? entry.map(String) : [String(entry ?? "")]
+  );
+}
+
+// src/runs/claude-import.ts
+var tokenFields = [
+  "inputTokens",
+  "outputTokens",
+  "reasoningTokens",
+  "cacheReadTokens",
+  "cacheWriteTokens"
+];
+function amount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function count(value) {
+  return Math.floor(amount(value) ?? 0);
+}
+function textBlocks(content) {
+  if (typeof content === "string") return content.trim();
+  return Array.isArray(content) ? content.map(asRecord).filter(
+    (block) => block.type === "text" && typeof block.text === "string"
+  ).map((block) => String(block.text).trim()).filter(Boolean).join("\n\n") : "";
+}
+function timestamp(value) {
+  const date = typeof value === "string" || typeof value === "number" ? new Date(value) : void 0;
+  return date && Number.isFinite(date.getTime()) ? date.toISOString() : void 0;
+}
+function claudeTranscriptMetadata(values) {
+  const records = values.map(asRecord);
+  const requests = /* @__PURE__ */ new Map();
+  let model2;
+  let effort;
+  let lastAssistant = -1;
+  let costIndex = -1;
+  let costState;
+  for (const [index, record] of records.entries()) {
+    if (record.isSidechain === true) continue;
+    if (record.type === "cost-state" && Object.keys(asRecord(record.modelUsage)).length) {
+      costIndex = index;
+      costState = record;
+    }
+    const message = asRecord(record.message);
+    if (record.type !== "assistant" || typeof message.model !== "string" || message.model.startsWith("<"))
+      continue;
+    model2 = message.model;
+    lastAssistant = index;
+    const recordedEffort = record.perTurnEffort ?? record.effort;
+    if (typeof recordedEffort === "string" || typeof recordedEffort === "number")
+      effort = String(recordedEffort);
+    if (!message.usage) continue;
+    const usage2 = asRecord(message.usage);
+    const key = `${model2}:${String(message.id ?? record.uuid ?? index)}`;
+    const previous = requests.get(key);
+    const current = {
+      model: model2,
+      inputTokens: count(usage2.input_tokens),
+      outputTokens: count(usage2.output_tokens),
+      reasoningTokens: count(
+        asRecord(usage2.output_tokens_details).thinking_tokens
+      ),
+      cacheReadTokens: count(usage2.cache_read_input_tokens),
+      cacheWriteTokens: count(usage2.cache_creation_input_tokens),
+      pricingSource: "claude-transcript"
+    };
+    if (previous)
+      for (const field of tokenFields)
+        current[field] = Math.max(previous[field] ?? 0, current[field] ?? 0);
+    requests.set(key, current);
+  }
+  if (costState && costIndex >= lastAssistant) {
+    const usage2 = Object.entries(asRecord(costState.modelUsage)).map(
+      ([model3, value]) => {
+        const item = asRecord(value);
+        return {
+          model: model3,
+          inputTokens: count(item.inputTokens),
+          outputTokens: count(item.outputTokens),
+          reasoningTokens: count(item.thinkingTokens),
+          cacheReadTokens: count(item.cacheReadInputTokens),
+          cacheWriteTokens: count(item.cacheCreationInputTokens),
+          ...costState.hasUnknownModelCost !== true && amount(item.costUSD) !== void 0 ? { estimatedCost: amount(item.costUSD) } : {},
+          pricingSource: "claude-transcript"
+        };
+      }
+    );
+    return {
+      model: model2,
+      effort,
+      usage: usage2,
+      ...costState.hasUnknownModelCost !== true && amount(costState.totalCostUSD) !== void 0 ? {
+        estimatedCost: amount(costState.totalCostUSD),
+        pricingSource: "claude-transcript"
+      } : {}
+    };
+  }
+  const totals = /* @__PURE__ */ new Map();
+  for (const request of requests.values()) {
+    const total = totals.get(request.model) ?? {
+      model: request.model,
+      pricingSource: "claude-transcript"
+    };
+    for (const field of tokenFields)
+      total[field] = (total[field] ?? 0) + (request[field] ?? 0);
+    totals.set(request.model, total);
+  }
+  return {
+    model: model2,
+    effort,
+    ...totals.size ? { usage: [...totals.values()] } : {}
+  };
+}
+async function readClaudeTranscript(path) {
+  const stream = createReadStream4(path, { encoding: "utf8" });
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  const records = [];
+  try {
+    for await (const line of lines) {
+      try {
+        const record = JSON.parse(line);
+        if (["user", "assistant", "system", "result", "cost-state"].includes(
+          record.type
+        ))
+          records.push(record);
+      } catch {
+      }
+    }
+    return records;
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+}
+function claudeImportedHistory(messageValues, transcriptValues = []) {
+  const metadata = /* @__PURE__ */ new Map();
+  for (const value of transcriptValues) {
+    const record = asRecord(value);
+    if (typeof record.uuid === "string") metadata.set(record.uuid, record);
+  }
+  const messages = /* @__PURE__ */ new Map();
+  for (const [index, value] of messageValues.entries()) {
+    const message = asRecord(value);
+    const id2 = String(message.uuid ?? index);
+    messages.set(id2, { ...message, ...metadata.get(id2) });
+  }
+  const events = [];
+  const replies = /* @__PURE__ */ new Map();
+  let prompt;
+  let finalReplyId;
+  let kind = "SESSION";
+  for (const [id2, record] of messages) {
+    const message = asRecord(record.message);
+    if (record.permissionMode === "plan") kind = "PLAN";
+    const content = typeof message.content === "string" ? [{ type: "text", text: message.content }] : Array.isArray(message.content) ? message.content : [];
+    if (record.type === "user" && record.isMeta !== true && !prompt)
+      prompt = textBlocks(content) || void 0;
+    if (record.type === "assistant") {
+      const reply = textBlocks(content);
+      if (reply) {
+        const replyId = String(message.id ?? id2);
+        const parts = replies.get(replyId) ?? /* @__PURE__ */ new Map();
+        parts.set(id2, reply);
+        replies.set(replyId, parts);
+        finalReplyId = replyId;
+      }
+    }
+    const blocks = content.length ? content.map(asRecord) : [void 0];
+    for (const [index, block] of blocks.entries()) {
+      const detail = block?.type === "text" && typeof block.text === "string" ? block.text : void 0;
+      const summary = detail || (block?.type === "tool_use" ? String(block.name ?? "Tool call") : block?.type === "tool_result" ? textBlocks(block.content) || "Tool result" : String(
+        block?.type ?? record.subtype ?? record.type ?? "Claude message"
+      ));
+      events.push({
+        id: `${id2}:${String(block?.id ?? index)}`,
+        sequence: events.length,
+        type: String(record.type ?? "message").toUpperCase(),
+        summary: (summary.trim() || "Claude message").slice(0, 2e3),
+        detailMarkdown: detail,
+        createdAt: timestamp(record.timestamp),
+        raw: {
+          ...record,
+          ...block ? { message: { ...message, content: [block] } } : {}
+        }
+      });
+    }
+  }
+  return {
+    ...claudeTranscriptMetadata(
+      transcriptValues.length ? transcriptValues : [...messages.values()]
+    ),
+    kind,
+    prompt,
+    events,
+    finalOutput: finalReplyId ? [...replies.get(finalReplyId).values()].join("\n\n") : void 0
+  };
+}
 
 // ../../node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as nV } from "node:module";
@@ -46806,56 +47096,6 @@ async function Lze(e, t, n) {
   return wD(o, { limit: n.limit, offset: n.offset, includeSystemMessages: n.includeSystemMessages });
 }
 
-// src/runs/provider.ts
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function firstString(value) {
-  const keys = [
-    "text",
-    "result",
-    "message",
-    "summary",
-    "content",
-    "output",
-    "items",
-    "parts"
-  ];
-  const pending = [value];
-  const visited = /* @__PURE__ */ new WeakSet();
-  while (pending.length) {
-    const candidate = pending.pop();
-    if (typeof candidate === "string" && candidate.trim()) return candidate;
-    if (!candidate || typeof candidate !== "object") continue;
-    if (visited.has(candidate)) continue;
-    visited.add(candidate);
-    if (Array.isArray(candidate)) {
-      for (let index = candidate.length - 1; index >= 0; index -= 1) {
-        pending.push(candidate[index]);
-      }
-      continue;
-    }
-    const record = asRecord(candidate);
-    for (let index = keys.length - 1; index >= 0; index -= 1) {
-      pending.push(record[keys[index]]);
-    }
-  }
-  return void 0;
-}
-function answerArrays(value) {
-  if (Array.isArray(value)) {
-    return value.map(
-      (entry) => Array.isArray(entry) ? entry.map(String) : typeof entry === "object" && entry ? Array.isArray(entry.answers) ? entry.answers.map(
-        String
-      ) : [String(entry.answer ?? "")] : [String(entry)]
-    );
-  }
-  const record = asRecord(value);
-  return Object.values(record).map(
-    (entry) => Array.isArray(asRecord(entry).answers) ? asRecord(entry).answers.map(String) : Array.isArray(entry) ? entry.map(String) : [String(entry ?? "")]
-  );
-}
-
 // src/runs/claude-adapter.ts
 function findClaudeCodeExecutable(options = {}) {
   return findExecutable("claude", {
@@ -46895,7 +47135,7 @@ var MessageQueue = class {
         if (value) return Promise.resolve({ value, done: false });
         if (this.closed)
           return Promise.resolve({ value: void 0, done: true });
-        return new Promise((resolve10) => this.waiters.push(resolve10));
+        return new Promise((resolve11) => this.waiters.push(resolve11));
       }
     };
   }
@@ -47065,8 +47305,8 @@ var ClaudeAdapter = class {
           const requestId = options.toolUseID || randomUUID6();
           const questions = questionsFromInput(toolInput);
           await callbacks.onQuestion(requestId, questions);
-          const answers = await new Promise((resolve10) => {
-            pendingQuestions.set(requestId, { input: toolInput, resolve: resolve10 });
+          const answers = await new Promise((resolve11) => {
+            pendingQuestions.set(requestId, { input: toolInput, resolve: resolve11 });
           });
           return {
             behavior: "allow",
@@ -47160,39 +47400,51 @@ var ClaudeAdapter = class {
   async discover(worktrees) {
     const results = [];
     for (const worktree of worktrees) {
-      const sessions = await AEt({ dir: worktree.folder, limit: 500 });
+      const sessions = await AEt({
+        dir: worktree.folder,
+        includeWorktrees: false
+      });
       for (const session of sessions) {
-        const lastModifiedKey = String(session.lastModified ?? "");
+        const lastModifiedKey = `${session.lastModified ?? ""}:${session.fileSize ?? ""}`;
         const cached = this.hydrationCache.get(session.sessionId);
-        let kind = "SESSION";
-        let finalOutput;
+        let history = {};
         if (cached && cached.lastModified === lastModifiedKey) {
-          kind = cached.kind;
-          finalOutput = cached.finalOutput;
+          history = cached.history;
         } else {
+          let transcript = [];
           try {
-            const history = await xEt(session.sessionId, {
+            const path = await findClaudeSessionFile(
+              session.sessionId,
+              homedir11(),
+              process.env.CLAUDE_CONFIG_DIR
+            );
+            if (path) transcript = await readClaudeTranscript(path);
+            history = claudeTranscriptMetadata(transcript);
+          } catch {
+          }
+          try {
+            const messages = await xEt(session.sessionId, {
               dir: worktree.folder,
-              limit: 500
-            });
-            const serialized2 = JSON.stringify(history);
-            if (serialized2.includes('"permissionMode":"plan"')) kind = "PLAN";
-            finalOutput = firstString([...history].reverse());
-            this.hydrationCache.set(session.sessionId, {
-              lastModified: lastModifiedKey,
-              kind,
-              finalOutput
+              includeSystemMessages: true
             });
+            if (messages.length) {
+              history = claudeImportedHistory(messages, transcript);
+              if (history.model && history.usage) {
+                this.hydrationCache.set(session.sessionId, {
+                  lastModified: lastModifiedKey,
+                  history
+                });
+              }
+            }
           } catch {
           }
         }
         results.push({
           nativeId: session.sessionId,
           worktreeId: worktree.id,
-          kind,
+          ...history,
           status: "COMPLETED",
-          prompt: session.firstPrompt || session.summary,
-          finalOutput: finalOutput || session.summary,
+          prompt: history.prompt || session.firstPrompt || session.summary,
           branch: session.gitBranch || worktree.branch || void 0,
           createdAt: session.createdAt ? new Date(session.createdAt).toISOString() : void 0,
           updatedAt: new Date(session.lastModified).toISOString(),
@@ -47210,10 +47462,192 @@ import {
   spawn as spawn8
 } from "node:child_process";
 import { mkdtemp as mkdtemp8, rm as rm14, writeFile as writeFile10 } from "node:fs/promises";
-import { tmpdir as tmpdir8 } from "node:os";
+import { homedir as homedir12, tmpdir as tmpdir8 } from "node:os";
 import { join as join19 } from "node:path";
-import { createInterface } from "node:readline";
+import { createInterface as createInterface3 } from "node:readline";
 import { promisify as promisify3 } from "node:util";
+
+// src/runs/codex-import.ts
+import { createReadStream as createReadStream5 } from "node:fs";
+import { createInterface as createInterface2 } from "node:readline";
+var tokenFields2 = [
+  "inputTokens",
+  "outputTokens",
+  "reasoningTokens",
+  "cacheReadTokens",
+  "cacheWriteTokens"
+];
+function count2(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : 0;
+}
+function tokens(value, model2) {
+  const raw = asRecord(value);
+  const cached = count2(raw.cached_input_tokens);
+  return {
+    model: model2,
+    inputTokens: Math.max(0, count2(raw.input_tokens) - cached),
+    cacheReadTokens: cached,
+    cacheWriteTokens: count2(raw.cache_write_input_tokens),
+    outputTokens: count2(raw.output_tokens),
+    reasoningTokens: count2(raw.reasoning_output_tokens),
+    pricingSource: "codex-transcript"
+  };
+}
+function codexTranscriptMetadata(records) {
+  let model2;
+  let effort;
+  const turnModels = /* @__PURE__ */ new Map();
+  const responseTurns = /* @__PURE__ */ new Set();
+  let contextTurn = "unknown-turn";
+  for (const record of records) {
+    const context = asRecord(record.payload);
+    if (record.type === "turn_context") {
+      contextTurn = String(context.turn_id ?? "unknown-turn");
+      if (typeof context.model === "string") model2 = context.model;
+      if (typeof context.effort === "string") effort = context.effort;
+      if (model2) turnModels.set(contextTurn, model2);
+    }
+    if (record.type === "token_usage_record" && context.usage)
+      responseTurns.add(String(context.turn_id ?? contextTurn));
+  }
+  const totals = /* @__PURE__ */ new Map();
+  const seenResponses = /* @__PURE__ */ new Set();
+  let currentModel;
+  let currentTurn = "unknown-turn";
+  let previous = { model: "unknown" };
+  const add = (usage2) => {
+    const total = totals.get(usage2.model) ?? {
+      model: usage2.model,
+      pricingSource: usage2.pricingSource
+    };
+    for (const field of tokenFields2)
+      total[field] = (total[field] ?? 0) + (usage2[field] ?? 0);
+    totals.set(usage2.model, total);
+  };
+  for (const record of records) {
+    const payload = asRecord(record.payload);
+    if (record.type === "turn_context") {
+      currentTurn = String(payload.turn_id ?? "unknown-turn");
+      if (typeof payload.model === "string") currentModel = payload.model;
+    }
+    if (record.type === "token_usage_record") {
+      const responseId = typeof payload.response_id === "string" ? payload.response_id : void 0;
+      if (responseId && seenResponses.has(responseId)) continue;
+      if (responseId) seenResponses.add(responseId);
+      const responseModel = typeof payload.model === "string" ? payload.model : turnModels.get(String(payload.turn_id)) ?? currentModel;
+      if (responseModel && payload.usage)
+        add(tokens(payload.usage, responseModel));
+    } else if (record.type === "event_msg" && payload.type === "token_count") {
+      const raw = asRecord(payload.info).total_token_usage;
+      if (!raw) continue;
+      const cumulative = tokens(raw, currentModel ?? "unknown");
+      const delta = {
+        model: cumulative.model,
+        pricingSource: "codex-transcript"
+      };
+      for (const field of tokenFields2)
+        delta[field] = Math.max(
+          0,
+          (cumulative[field] ?? 0) - (previous[field] ?? 0)
+        );
+      previous = cumulative;
+      if (!responseTurns.has(currentTurn)) add(delta);
+    }
+  }
+  return {
+    model: model2,
+    effort,
+    ...totals.size ? { usage: [...totals.values()] } : {}
+  };
+}
+async function readCodexTranscriptMetadata(path) {
+  const records = [];
+  const stream = createReadStream5(path, { encoding: "utf8" });
+  const lines = createInterface2({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of lines) {
+      try {
+        const record = JSON.parse(line);
+        if (record.type === "turn_context" || record.type === "token_usage_record" || record.type === "event_msg" && asRecord(record.payload).type === "token_count")
+          records.push(record);
+      } catch {
+      }
+    }
+    return codexTranscriptMetadata(records);
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+}
+function timestamp2(value) {
+  const date = typeof value === "number" ? new Date(value < 1e12 ? value * 1e3 : value) : typeof value === "string" ? new Date(value) : void 0;
+  return date && Number.isFinite(date.getTime()) ? date.toISOString() : void 0;
+}
+function codexImportedHistory(threadValue) {
+  const thread = asRecord(threadValue);
+  const turns = Array.isArray(thread.turns) ? thread.turns : [];
+  const events = [];
+  let finalOutput;
+  let kind = "SESSION";
+  let status2;
+  for (const value of turns) {
+    const turn = asRecord(value);
+    for (const itemValue of Array.isArray(turn.items) ? turn.items : []) {
+      const item = asRecord(itemValue);
+      if (item.type === "plan") kind = "PLAN";
+      if (item.type === "agentMessage" && (item.phase === "final_answer" || item.phase == null) || item.type === "plan") {
+        if (typeof item.text === "string") finalOutput = item.text;
+      }
+      const detail = typeof item.text === "string" ? item.text : typeof item.command === "string" ? item.command : void 0;
+      const inProgress = [
+        "inProgress",
+        "in_progress",
+        "running",
+        "pending"
+      ].includes(String(item.status));
+      events.push({
+        id: `${String(turn.id ?? turns.indexOf(value))}:${String(item.id ?? events.length)}`,
+        sequence: events.length,
+        type: inProgress ? "ITEM_STARTED" : "ITEM_COMPLETED",
+        summary: (detail || String(item.type ?? "Codex item")).slice(0, 2e3),
+        detailMarkdown: detail,
+        createdAt: timestamp2(
+          item.createdAt ?? turn.startedAt ?? thread.createdAt
+        ),
+        raw: {
+          method: inProgress ? "item/started" : "item/completed",
+          params: { threadId: thread.id, turnId: turn.id, item }
+        }
+      });
+    }
+    if (typeof turn.status === "string") {
+      const inProgress = turn.status === "inProgress";
+      status2 = turn.status === "failed" ? "FAILED" : turn.status === "interrupted" ? "CANCELLED" : void 0;
+      const error = asRecord(turn.error);
+      const detail = typeof error.message === "string" ? error.message : typeof turn.error === "string" ? turn.error : void 0;
+      events.push({
+        id: `${String(turn.id ?? turns.indexOf(value))}:status`,
+        sequence: events.length,
+        type: inProgress ? "TURN_STARTED" : "TURN_COMPLETED",
+        summary: detail || `Turn ${turn.status}`,
+        detailMarkdown: detail,
+        createdAt: timestamp2(
+          turn.completedAt ?? turn.startedAt ?? thread.updatedAt ?? thread.createdAt
+        ),
+        raw: {
+          method: inProgress ? "turn/started" : "turn/completed",
+          params: {
+            threadId: thread.id,
+            turn: { ...turn, items: void 0, error: detail ?? turn.error }
+          }
+        }
+      });
+    }
+  }
+  return { events, finalOutput, kind, status: status2 };
+}
+
+// src/runs/codex-adapter.ts
 var execFileAsync2 = promisify3(execFile3);
 function codexAppServerArgs(modelCatalogPath) {
   return [
@@ -47309,10 +47743,10 @@ var CodexAppServer = class {
       const text2 = String(chunk).trim();
       if (text2) console.error(`codex app-server: ${text2}`);
     });
-    const lines = createInterface({ input: child.stdout });
+    const lines = createInterface3({ input: child.stdout });
     lines.on("line", (line) => this.receive(line));
-    await new Promise((resolve10, reject) => {
-      child.once("spawn", resolve10);
+    await new Promise((resolve11, reject) => {
+      child.once("spawn", resolve11);
       child.once("error", reject);
     });
     await this.requestDirect("initialize", {
@@ -47410,8 +47844,8 @@ var CodexAppServer = class {
   }
   requestDirect(method, params) {
     const id2 = this.nextId++;
-    return new Promise((resolve10, reject) => {
-      this.pending.set(id2, { resolve: resolve10, reject });
+    return new Promise((resolve11, reject) => {
+      this.pending.set(id2, { resolve: resolve11, reject });
       this.write({ id: id2, method, params });
     });
   }
@@ -47574,8 +48008,8 @@ var CodexAdapter = class {
     let lastUsageSignature = "";
     const pendingQuestions = /* @__PURE__ */ new Map();
     let resolveCompletion;
-    const completion = new Promise((resolve10) => {
-      resolveCompletion = resolve10;
+    const completion = new Promise((resolve11) => {
+      resolveCompletion = resolve11;
     });
     const unsubscribe = this.server.listen(nativeId, (message) => {
       void (async () => {
@@ -47720,7 +48154,8 @@ var CodexAdapter = class {
               archived,
               cursor,
               limit: 100,
-              sortDirection: "asc"
+              sortDirection: "asc",
+              sourceKinds: ["cli", "vscode", "exec", "appServer"]
             })
           );
           const threads = Array.isArray(page.data) ? page.data : [];
@@ -47728,12 +48163,13 @@ var CodexAdapter = class {
             const thread = asRecord(value);
             const updatedAtKey = String(thread.updatedAt ?? "");
             const cached = this.hydrationCache.get(String(thread.id));
-            let finalOutput;
-            let kind = "SESSION";
-            if (cached && cached.updatedAt === updatedAtKey) {
-              kind = cached.kind;
-              finalOutput = cached.finalOutput;
+            let history = {};
+            const active = asRecord(thread.status).type === "active";
+            if (active) this.hydrationCache.delete(String(thread.id));
+            if (cached && cached.updatedAt === updatedAtKey && !active) {
+              history = cached.history;
             } else {
+              let hydratedSuccessfully = false;
               try {
                 const detail = asRecord(
                   await this.server.request("thread/read", {
@@ -47742,31 +48178,41 @@ var CodexAdapter = class {
                   })
                 );
                 const hydrated = asRecord(detail.thread);
-                const serialized2 = JSON.stringify(hydrated.turns ?? []);
-                if (serialized2.includes('"type":"plan"')) kind = "PLAN";
-                finalOutput = firstString(
-                  Array.isArray(hydrated.turns) ? [...hydrated.turns].reverse() : []
+                if (Array.isArray(hydrated.turns)) {
+                  history = codexImportedHistory(hydrated);
+                  hydratedSuccessfully = true;
+                }
+              } catch {
+              }
+              try {
+                const path = typeof thread.path === "string" ? thread.path : await findCodexSessionFile(
+                  String(thread.id),
+                  homedir12(),
+                  process.env.CODEX_HOME
                 );
+                if (path)
+                  Object.assign(
+                    history,
+                    await readCodexTranscriptMetadata(path)
+                  );
+              } catch {
+              }
+              if (!active && hydratedSuccessfully && history.model && history.usage) {
                 this.hydrationCache.set(String(thread.id), {
                   updatedAt: updatedAtKey,
-                  kind,
-                  finalOutput
+                  history
                 });
-              } catch {
               }
             }
             results.push({
               nativeId: String(thread.id),
               worktreeId: worktree.id,
-              kind,
-              status: String(
-                asRecord(thread.status).type ?? thread.status ?? "COMPLETED"
-              ).toUpperCase(),
+              ...history,
+              status: active ? "IN_PROGRESS" : asRecord(thread.status).type === "systemError" ? "FAILED" : history.status ?? "COMPLETED",
               archived,
               prompt: String(
                 thread.preview ?? thread.name ?? "Imported Codex thread"
               ),
-              finalOutput,
               branch: firstString(asRecord(thread.gitInfo).branch) || worktree.branch || void 0,
               createdAt: thread.createdAt ? new Date(Number(thread.createdAt) * 1e3).toISOString() : void 0,
               updatedAt: thread.updatedAt ? new Date(Number(thread.updatedAt) * 1e3).toISOString() : void 0,
@@ -47785,13 +48231,13 @@ var CodexAdapter = class {
 };
 
 // src/runs/opencode-adapter.ts
-import { dirname as dirname12 } from "node:path";
+import { dirname as dirname12, resolve as resolve10 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // ../../node_modules/@opencode-ai/sdk/dist/v2/gen/core/serverSentEvents.gen.js
 var createSseClient = ({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) => {
   let lastEventId;
-  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve10) => setTimeout(resolve10, ms)));
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve11) => setTimeout(resolve11, ms)));
   const createStream = async function* () {
     let retryDelay = sseDefaultRetryDelay ?? 3e3;
     let attempt = 0;
@@ -53243,7 +53689,7 @@ async function createOpencodeServer(options) {
   });
   let clear = () => {
   };
-  const url = await new Promise((resolve10, reject) => {
+  const url = await new Promise((resolve11, reject) => {
     const id2 = setTimeout(() => {
       clear();
       stop(proc);
@@ -53268,7 +53714,7 @@ async function createOpencodeServer(options) {
           }
           clearTimeout(id2);
           resolved = true;
-          resolve10(match[1]);
+          resolve11(match[1]);
           return;
         }
       }
@@ -53317,10 +53763,231 @@ async function createOpencode(options) {
   };
 }
 
+// src/runs/opencode-import.ts
+function opencodeModel(value) {
+  const model2 = asRecord(value);
+  const id2 = model2.modelID ?? model2.id;
+  return typeof model2.providerID === "string" && typeof id2 === "string" ? `${model2.providerID}/${id2}` : void 0;
+}
+function opencodeTimestamp(value) {
+  const date = typeof value === "number" ? new Date(value) : void 0;
+  return date && Number.isFinite(date.getTime()) ? date.toISOString() : void 0;
+}
+function amount2(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function tokenUsage(value, model2) {
+  const tokens2 = asRecord(value);
+  const cache = asRecord(tokens2.cache);
+  const count3 = (value2) => Math.floor(amount2(value2) ?? 0);
+  return {
+    model: model2,
+    inputTokens: count3(tokens2.input),
+    outputTokens: count3(tokens2.output),
+    reasoningTokens: count3(tokens2.reasoning),
+    cacheReadTokens: count3(cache.read),
+    cacheWriteTokens: count3(cache.write),
+    pricingSource: "opencode-history"
+  };
+}
+var tokenFields3 = [
+  "inputTokens",
+  "outputTokens",
+  "reasoningTokens",
+  "cacheReadTokens",
+  "cacheWriteTokens"
+];
+function textParts(parts) {
+  return parts.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => String(part.text).trim()).filter(Boolean).join("\n\n");
+}
+function userPrompt(parts) {
+  const originalParts = parts.filter((part) => part.synthetic !== true);
+  return textParts(originalParts) || originalParts.filter(
+    (part) => part.type === "subtask" && typeof part.prompt === "string"
+  ).map((part) => String(part.prompt).trim()).filter(Boolean).join("\n\n");
+}
+function nativePart(value) {
+  const part = asRecord(value);
+  if (part.type !== "tool") return part;
+  const state = asRecord(part.state);
+  const time = asRecord(part.time);
+  const content = Array.isArray(state.content) ? state.content.map(asRecord) : [];
+  return {
+    ...part,
+    tool: part.name,
+    state: {
+      ...state,
+      output: textParts(content),
+      metadata: state.structured,
+      time: { start: time.ran ?? time.created, end: time.completed }
+    }
+  };
+}
+function opencodeImportedHistory(sessionValue, messageValues) {
+  const session = asRecord(sessionValue);
+  const messages = /* @__PURE__ */ new Map();
+  for (const [index, value] of messageValues.entries()) {
+    const message = asRecord(value);
+    const info = asRecord(message.info ?? message);
+    messages.set(String(info.id ?? index), message);
+  }
+  const ordered = [...messages.entries()].sort(([, left], [, right]) => {
+    const leftInfo = asRecord(left.info ?? left);
+    const rightInfo = asRecord(right.info ?? right);
+    return Number(asRecord(leftInfo.time).created ?? 0) - Number(asRecord(rightInfo.time).created ?? 0);
+  });
+  const events = [];
+  const totals = /* @__PURE__ */ new Map();
+  const unpricedModels = /* @__PURE__ */ new Set();
+  let model2;
+  let effort;
+  let prompt;
+  let finalOutput;
+  let status2;
+  let requestedModel;
+  let requestedVariant;
+  let agent;
+  const addUsage = (usage2) => {
+    const total = totals.get(usage2.model) ?? {
+      model: usage2.model,
+      pricingSource: "opencode-history"
+    };
+    for (const field of tokenFields3)
+      total[field] = (total[field] ?? 0) + (usage2[field] ?? 0);
+    if (usage2.estimatedCost === void 0) unpricedModels.add(usage2.model);
+    else total.estimatedCost = (total.estimatedCost ?? 0) + usage2.estimatedCost;
+    totals.set(usage2.model, total);
+  };
+  const emit = (id2, type, summary, properties, createdAt, detailMarkdown) => {
+    events.push({
+      id: id2,
+      sequence: events.length,
+      type: type.toUpperCase().replaceAll(".", "_"),
+      summary: (summary.trim() || type).slice(0, 2e3),
+      detailMarkdown,
+      createdAt,
+      raw: { type, properties }
+    });
+  };
+  for (const [id2, message] of ordered) {
+    const legacy = !!message.info;
+    const original = asRecord(message.info ?? message);
+    const role = original.role ?? original.type;
+    const time = asRecord(original.time);
+    const createdAt = opencodeTimestamp(
+      time.created ?? asRecord(session.time).created
+    );
+    const parts = legacy ? Array.isArray(message.parts) ? message.parts.map(asRecord) : [] : Array.isArray(original.content) ? original.content.map(nativePart) : [];
+    if (!legacy && ["user", "synthetic", "system", "compaction"].includes(String(role)))
+      parts.push({
+        id: "text",
+        type: "text",
+        text: role === "user" ? original.text : original.text ?? original.summary
+      });
+    if (!legacy && role === "shell")
+      parts.push({
+        id: original.callID ?? "shell",
+        type: "tool",
+        tool: "bash",
+        state: {
+          input: { command: original.command },
+          output: original.output,
+          status: time.completed ? "completed" : "running",
+          time: { start: time.created, end: time.completed }
+        }
+      });
+    const info = {
+      ...original,
+      id: id2,
+      sessionID: session.id,
+      role,
+      modelID: original.modelID ?? asRecord(original.model).id
+    };
+    delete info.content;
+    emit(
+      `message:${id2}`,
+      "message.updated",
+      `${String(role ?? "Message")} message`,
+      { info },
+      createdAt
+    );
+    for (const [index, part] of parts.entries()) {
+      const state = asRecord(part.state);
+      const detail = typeof part.text === "string" ? part.text : void 0;
+      const summary = detail ?? (part.type === "tool" ? String(part.tool ?? "Tool") : String(part.type ?? "Message part"));
+      emit(
+        `${id2}:part:${String(part.id ?? index)}`,
+        "message.part.updated",
+        summary,
+        { part: { ...part, sessionID: session.id, messageID: id2 } },
+        opencodeTimestamp(
+          asRecord(state.time).start ?? asRecord(part.time).created
+        ) ?? createdAt,
+        detail
+      );
+    }
+    if (role === "user" || role === "model-switched") {
+      requestedModel = opencodeModel(original.model);
+      requestedVariant = typeof asRecord(original.model).variant === "string" ? String(asRecord(original.model).variant) : void 0;
+      if (role === "user" && !prompt) prompt = userPrompt(parts) || void 0;
+    }
+    if (role !== "assistant") continue;
+    const actualModel = opencodeModel(original) ?? opencodeModel(original.model);
+    if (actualModel) {
+      model2 = actualModel;
+      effort = typeof original.variant === "string" ? original.variant : typeof asRecord(original.model).variant === "string" ? String(asRecord(original.model).variant) : actualModel === requestedModel ? requestedVariant ?? "auto" : "auto";
+    }
+    agent = typeof original.agent === "string" ? original.agent : agent;
+    const error = asRecord(original.error);
+    status2 = original.error ? error.name === "MessageAbortedError" ? "CANCELLED" : "FAILED" : "COMPLETED";
+    const responseText = textParts(parts);
+    if (responseText && original.summary !== true && !["tool-calls", "tool_calls"].includes(String(original.finish)))
+      finalOutput = responseText;
+    const steps = parts.filter((part) => part.type === "step-finish");
+    if (original.tokens || steps.length || amount2(original.cost) !== void 0) {
+      const usage2 = tokenUsage(original.tokens, actualModel ?? "unknown");
+      if (!original.tokens)
+        for (const step of steps) {
+          const stepUsage = tokenUsage(step.tokens, usage2.model);
+          for (const field of tokenFields3)
+            usage2[field] = (usage2[field] ?? 0) + (stepUsage[field] ?? 0);
+        }
+      usage2.estimatedCost = amount2(original.cost) ?? (steps.length && steps.every((step) => amount2(step.cost) !== void 0) ? steps.reduce((sum, step) => sum + amount2(step.cost), 0) : void 0);
+      addUsage(usage2);
+    }
+  }
+  if (session.tokens) {
+    const usage2 = tokenUsage(session.tokens, "unknown");
+    for (const field of tokenFields3)
+      usage2[field] = Math.max(
+        0,
+        (usage2[field] ?? 0) - [...totals.values()].reduce((sum, row) => sum + (row[field] ?? 0), 0)
+      );
+    if (tokenFields3.some((field) => usage2[field])) addUsage(usage2);
+  }
+  for (const model3 of unpricedModels) {
+    const usage2 = totals.get(model3);
+    if (usage2) delete usage2.estimatedCost;
+  }
+  const estimatedCost = amount2(session.cost);
+  return {
+    events,
+    ...totals.size || session.tokens ? { usage: [...totals.values()] } : {},
+    model: model2 ?? requestedModel ?? opencodeModel(session.model),
+    effort: effort ?? requestedVariant ?? (typeof asRecord(session.model).variant === "string" ? String(asRecord(session.model).variant) : void 0),
+    prompt,
+    finalOutput,
+    status: status2,
+    kind: (agent ?? session.agent) === "plan" ? "PLAN" : "SESSION",
+    ...estimatedCost !== void 0 ? { estimatedCost, pricingSource: "opencode-history" } : {}
+  };
+}
+
 // src/runs/opencode-adapter.ts
 var QUESTION_RECONCILIATION_INTERVAL_MS = 1e3;
 var QUESTION_RECONCILIATION_TIMEOUT_MS = 5e3;
 var POST_ANSWER_COMPLETION_TIMEOUT_MS = 15 * 6e4;
+var IMPORT_PAGE_SIZE = 200;
 function resultData(value) {
   const record = asRecord(value);
   return "data" in record ? record.data : value;
@@ -53516,11 +54183,11 @@ function responseItems(value) {
 }
 function waitForPoll(signal) {
   if (signal.aborted) return Promise.resolve();
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     const finish = () => {
       clearTimeout(timer);
       signal.removeEventListener("abort", finish);
-      resolve10();
+      resolve11();
     };
     const timer = setTimeout(finish, QUESTION_RECONCILIATION_INTERVAL_MS);
     timer.unref();
@@ -53539,6 +54206,7 @@ var OpenCodeAdapter = class {
     nativeDelete: true
   };
   runtime;
+  hydrationCache = /* @__PURE__ */ new Map();
   async client() {
     if (!this.runtime) {
       const executable = findExecutable("opencode", {
@@ -53838,14 +54506,14 @@ var OpenCodeAdapter = class {
         }
         const finalOutput = opencodeResponseText(response);
         const info = asRecord(asRecord(response).info);
-        const tokens = asRecord(info.tokens);
+        const tokens2 = asRecord(info.tokens);
         await callbacks.onUsage({
           model: input.run.model,
-          inputTokens: Number(tokens.input ?? 0),
-          outputTokens: Number(tokens.output ?? 0),
-          reasoningTokens: Number(tokens.reasoning ?? 0),
-          cacheReadTokens: Number(asRecord(tokens.cache).read ?? 0),
-          cacheWriteTokens: Number(asRecord(tokens.cache).write ?? 0),
+          inputTokens: Number(tokens2.input ?? 0),
+          outputTokens: Number(tokens2.output ?? 0),
+          reasoningTokens: Number(tokens2.reasoning ?? 0),
+          cacheReadTokens: Number(asRecord(tokens2.cache).read ?? 0),
+          cacheWriteTokens: Number(asRecord(tokens2.cache).write ?? 0),
           estimatedCost: Number(info.cost ?? 0),
           pricingSource: "opencode-sdk"
         });
@@ -53913,64 +54581,209 @@ var OpenCodeAdapter = class {
     const client2 = await this.client();
     await client2.session.delete({ sessionID: nativeId, directory: cwd });
   }
+  async legacyHistory(client2, nativeId, directory) {
+    const messages = [];
+    const seenCursors = /* @__PURE__ */ new Set();
+    let before;
+    do {
+      const response = await client2.session.messages(
+        {
+          sessionID: nativeId,
+          directory,
+          limit: IMPORT_PAGE_SIZE,
+          ...before ? { before } : {}
+        },
+        { throwOnError: true }
+      );
+      const page = resultData(response);
+      if (!Array.isArray(page))
+        throw new Error("Invalid legacy OpenCode message history");
+      messages.push(...page);
+      before = response.response?.headers.get("x-next-cursor") ?? void 0;
+      if (before && seenCursors.has(before))
+        throw new Error("Repeated legacy OpenCode message cursor");
+      if (before) seenCursors.add(before);
+    } while (before);
+    return messages;
+  }
+  async importedHistory(client2, nativeId, directory, surface) {
+    if (surface === "LEGACY")
+      return this.legacyHistory(client2, nativeId, directory);
+    const messages = [];
+    let cursor;
+    const seenCursors = /* @__PURE__ */ new Set();
+    try {
+      do {
+        const page = asRecord(
+          resultData(
+            await client2.v2.session.messages(
+              {
+                sessionID: nativeId,
+                limit: IMPORT_PAGE_SIZE,
+                ...cursor ? { cursor } : { order: "asc" }
+              },
+              { throwOnError: true }
+            )
+          )
+        );
+        if (!Array.isArray(page.data))
+          throw new Error("Invalid OpenCode message history");
+        messages.push(...page.data);
+        cursor = typeof asRecord(page.cursor).next === "string" ? String(asRecord(page.cursor).next) : void 0;
+        if (cursor && seenCursors.has(cursor))
+          throw new Error("Repeated OpenCode message cursor");
+        if (cursor) seenCursors.add(cursor);
+      } while (cursor);
+    } catch (error) {
+      if (messages.length || cursor) throw error;
+      return this.legacyHistory(client2, nativeId, directory);
+    }
+    if (messages.length) return messages;
+    try {
+      return await this.legacyHistory(client2, nativeId, directory);
+    } catch (error) {
+      const name = String(asRecord(error)._tag ?? asRecord(error).name ?? "");
+      if (["NotFoundError", "SessionNotFoundError"].includes(name))
+        return messages;
+      throw error;
+    }
+  }
   async discover(worktrees) {
     const client2 = await this.client();
     const results = [];
-    const activeResponse = asRecord(
-      resultData(await client2.v2.session.active())
-    );
-    const activeIds = new Set(Object.keys(asRecord(activeResponse.data)));
+    const hydrationFailures = [];
+    let hydratedCount = 0;
+    const activeIds = /* @__PURE__ */ new Set();
+    try {
+      const active = asRecord(
+        resultData(await client2.v2.session.active({ throwOnError: true }))
+      );
+      for (const id2 of Object.keys(asRecord(active.data))) activeIds.add(id2);
+    } catch {
+    }
     for (const worktree of worktrees) {
-      let cursor;
-      do {
-        const response = asRecord(
-          resultData(
-            await client2.v2.session.list({
-              directory: worktree.folder,
-              limit: 500,
-              order: "asc",
-              cursor
-            })
+      const sessions = /* @__PURE__ */ new Map();
+      let listed = false;
+      let listError;
+      try {
+        let cursor;
+        const seenCursors = /* @__PURE__ */ new Set();
+        do {
+          const response = asRecord(
+            resultData(
+              await client2.v2.session.list(
+                {
+                  directory: worktree.folder,
+                  limit: IMPORT_PAGE_SIZE,
+                  ...cursor ? { cursor } : { order: "asc" }
+                },
+                { throwOnError: true }
+              )
+            )
+          );
+          if (!Array.isArray(response.data))
+            throw new Error("Invalid OpenCode session list");
+          for (const value of response.data) {
+            const session = asRecord(value);
+            if (typeof session.id === "string")
+              sessions.set(session.id, { session, surface: "V2" });
+          }
+          cursor = typeof asRecord(response.cursor).next === "string" ? String(asRecord(response.cursor).next) : void 0;
+          if (cursor && seenCursors.has(cursor))
+            throw new Error("Repeated OpenCode session cursor");
+          if (cursor) seenCursors.add(cursor);
+        } while (cursor);
+        listed = true;
+      } catch (error) {
+        listError = error;
+      }
+      try {
+        const legacy = resultData(
+          await client2.session.list(
+            { directory: worktree.folder, limit: IMPORT_PAGE_SIZE },
+            { throwOnError: true }
           )
         );
-        const sessions = Array.isArray(response.data) ? response.data : [];
-        for (const value of sessions) {
+        if (!Array.isArray(legacy))
+          throw new Error("Invalid legacy OpenCode session list");
+        for (const value of legacy) {
           const session = asRecord(value);
-          const time = asRecord(session.time);
-          const selectedModel = asRecord(session.model);
-          let finalOutput;
+          if (typeof session.id === "string" && !sessions.has(session.id))
+            sessions.set(session.id, { session, surface: "LEGACY" });
+        }
+        listed = true;
+      } catch (error) {
+        listError ??= error;
+      }
+      if (!listed) throw listError;
+      try {
+        const statuses = asRecord(
+          resultData(
+            await client2.session.status(
+              { directory: worktree.folder },
+              { throwOnError: true }
+            )
+          )
+        );
+        for (const [id2, value] of Object.entries(statuses))
+          if (["busy", "retry"].includes(String(asRecord(value).type)))
+            activeIds.add(id2);
+      } catch {
+      }
+      for (const [nativeId, { session, surface }] of sessions) {
+        const directory = session.directory ?? asRecord(session.location).directory;
+        if (typeof directory === "string" && resolve10(directory) !== resolve10(worktree.folder))
+          continue;
+        const time = asRecord(session.time);
+        const active = activeIds.has(nativeId);
+        const key = JSON.stringify([
+          surface,
+          time.updated,
+          session.cost,
+          session.tokens,
+          session.model
+        ]);
+        const cached = this.hydrationCache.get(nativeId);
+        if (active) this.hydrationCache.delete(nativeId);
+        let history = {};
+        if (!active && cached?.key === key) history = cached.history;
+        else {
           try {
-            const messages = asRecord(
-              resultData(
-                await client2.v2.session.messages({
-                  sessionID: String(session.id),
-                  limit: 1,
-                  order: "desc"
-                })
-              )
-            );
-            finalOutput = firstString(
-              Array.isArray(messages.data) ? messages.data[0] : messages
+            const messages = await this.importedHistory(
+              client2,
+              nativeId,
+              worktree.folder,
+              surface
             );
-          } catch {
+            history = opencodeImportedHistory(session, messages);
+            if (!active) this.hydrationCache.set(nativeId, { key, history });
+          } catch (error) {
+            const detail = error instanceof Error ? error.message : firstString(asRecord(error).message) ?? String(asRecord(error)._tag ?? error);
+            hydrationFailures.push(`${nativeId}: ${detail}`);
           }
-          results.push({
-            nativeId: String(session.id),
-            worktreeId: worktree.id,
-            kind: session.agent === "plan" ? "PLAN" : "SESSION",
-            status: activeIds.has(String(session.id)) ? "IN_PROGRESS" : "COMPLETED",
-            archived: Boolean(time.archived),
-            model: typeof selectedModel.providerID === "string" && typeof selectedModel.id === "string" ? `${selectedModel.providerID}/${selectedModel.id}` : void 0,
-            prompt: firstString(session.title ?? session.summary) || "Imported OpenCode session",
-            finalOutput: finalOutput || firstString(session.summary),
-            branch: worktree.branch || void 0,
-            createdAt: time.created ? new Date(Number(time.created)).toISOString() : void 0,
-            updatedAt: time.updated ? new Date(Number(time.updated)).toISOString() : void 0,
-            rawMetadata: session
-          });
         }
-        cursor = typeof asRecord(response.cursor).next === "string" ? String(asRecord(response.cursor).next) : void 0;
-      } while (cursor);
+        if (history.events) hydratedCount += 1;
+        results.push({
+          nativeId,
+          worktreeId: worktree.id,
+          ...typeof session.cost === "number" && Number.isFinite(session.cost) && session.cost >= 0 ? { estimatedCost: session.cost, pricingSource: "opencode-history" } : {},
+          ...history,
+          kind: history.kind ?? (session.agent === "plan" ? "PLAN" : "SESSION"),
+          status: active ? "IN_PROGRESS" : history.status ?? "COMPLETED",
+          archived: Boolean(time.archived),
+          model: history.model,
+          prompt: history.prompt,
+          branch: worktree.branch || void 0,
+          createdAt: opencodeTimestamp(time.created),
+          updatedAt: opencodeTimestamp(time.updated),
+          rawMetadata: session
+        });
+      }
+    }
+    if (hydrationFailures.length) {
+      const detail = `OpenCode history unavailable for ${hydrationFailures.length} sessions: ${hydrationFailures.slice(0, 3).join("; ")}`;
+      if (!hydratedCount) throw new Error(detail);
+      console.warn(detail);
     }
     return results;
   }
@@ -54707,10 +55520,19 @@ var RunManager = class {
             { ...catalog, capabilities: adapter.capabilities }
           );
           const runs = await adapter.discover(worktrees);
-          await this.client.importProviderRuns(
-            adapter.key,
-            runs
-          );
+          let batch = [];
+          let batchBytes = 0;
+          for (const run of runs) {
+            const bytes = Buffer.byteLength(JSON.stringify(run), "utf8");
+            if (batch.length && batchBytes + bytes > 4 * 1024 * 1024) {
+              await this.client.importProviderRuns(adapter.key, batch);
+              batch = [];
+              batchBytes = 0;
+            }
+            batch.push(run);
+            batchBytes += bytes;
+          }
+          await this.client.importProviderRuns(adapter.key, batch);
         } catch (error) {
           await this.client.reportRunProviderImportStatus(
             adapter.key,
@@ -54745,7 +55567,7 @@ var RunManager = class {
         return await operation();
       } catch (error) {
         if (this.stopped || attempt >= attempts) throw error;
-        await new Promise((resolve10) => setTimeout(resolve10, delay));
+        await new Promise((resolve11) => setTimeout(resolve11, delay));
         delay = Math.min(delay * 2, 3e4);
       }
     }
@@ -55025,9 +55847,9 @@ async function runAgentSession(config, signal, onUnhealthy) {
       }
     }
   );
-  await new Promise((resolve10) => {
-    if (signal.aborted) resolve10();
-    else signal.addEventListener("abort", () => resolve10(), { once: true });
+  await new Promise((resolve11) => {
+    if (signal.aborted) resolve11();
+    else signal.addEventListener("abort", () => resolve11(), { once: true });
   });
   if (heartbeatTimer) clearTimeout(heartbeatTimer);
   if (jobReconciliationTimer) clearTimeout(jobReconciliationTimer);
@@ -55094,7 +55916,7 @@ var defaultDependencies = {
   inventory: collectInventory,
   load: loadConfig,
   save: saveConfig,
-  wait: (milliseconds, signal) => new Promise((resolve10, reject) => {
+  wait: (milliseconds, signal) => new Promise((resolve11, reject) => {
     if (signal.aborted) {
       reject(new Error("Development agent startup was cancelled"));
       return;
@@ -55105,7 +55927,7 @@ var defaultDependencies = {
     };
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve10();
+      resolve11();
     }, milliseconds);
     signal.addEventListener("abort", onAbort, { once: true });
   })