@dashup/connector 0.1.16 → 0.1.17

package/dist/index.js

@@ -670,13 +670,13 @@ var require_common = __commonJS({
           }
         }
       }
-      function matchesTemplate(search, template) {
+      function matchesTemplate(search2, template) {
         let searchIndex = 0;
         let templateIndex = 0;
         let starIndex = -1;
         let matchIndex = 0;
-        while (searchIndex < search.length) {
-          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+        while (searchIndex < search2.length) {
+          if (templateIndex < template.length && (template[templateIndex] === search2[searchIndex] || template[templateIndex] === "*")) {
             if (template[templateIndex] === "*") {
               starIndex = templateIndex;
               matchIndex = searchIndex;
@@ -4048,7 +4048,7 @@ import * as ui from "@clack/prompts";
 import { z } from "zod";
 
 // package.json
-var version = "0.1.16";
+var version = "0.1.17";
 
 // src/pair.ts
 var Invitation = z.object({
@@ -4240,8 +4240,11 @@ var READ_BYTES = 64 * 1024;
 var TITLE_LIMIT = 120;
 var LATEST_BYTES = 8 * 1024 * 1024;
 var JOURNALS = 16;
+var SEARCH_BYTES = 1024 * 1024;
+var MARKED = 512;
 var journals = /* @__PURE__ */ new Map();
 var metadata = /* @__PURE__ */ new Map();
+var marked = /* @__PURE__ */ new Map();
 function object(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : void 0;
 }
@@ -4306,6 +4309,40 @@ function described(path, until, describe2) {
   metadata.set(path, { stamp, value: value2 });
   return value2;
 }
+function newest(path, marker) {
+  const key = `${path}\0${marker}`;
+  const stamp = statSync(path);
+  const saved = marked.get(key);
+  if (saved && unchanged(saved.stamp, stamp)) return saved.row;
+  const grown = saved && saved.stamp.ino === stamp.ino && saved.stamp.size <= stamp.size;
+  const start2 = grown ? Math.max(0, saved.stamp.size - SEARCH_BYTES) : 0;
+  const row = search(path, marker, start2, stamp.size) ?? (grown ? saved.row : void 0);
+  marked.delete(key);
+  marked.set(key, { stamp, row });
+  if (marked.size > MARKED) marked.delete(marked.keys().next().value);
+  return row;
+}
+function search(path, marker, from, to) {
+  let carry = Buffer.alloc(0);
+  let position = to;
+  while (position > from) {
+    const begin = Math.max(from, position - SEARCH_BYTES);
+    const buffer = Buffer.concat([readRange(path, begin, position - begin), carry]);
+    const first = begin > from ? buffer.indexOf(10) + 1 : 0;
+    position = begin;
+    if (begin > from && !first) {
+      carry = buffer;
+      continue;
+    }
+    const lines = buffer.subarray(first).toString("utf8").split("\n");
+    for (let index = lines.length - 1; index >= 0; index--) {
+      const row = lines[index].includes(marker) ? parse(lines[index]) : void 0;
+      if (row) return row;
+    }
+    carry = buffer.subarray(0, first);
+  }
+  return void 0;
+}
 var windowed = (path, messages5) => journals.get(path)?.start ? [EARLIER, ...messages5] : messages5;
 function journal(path, latest = false) {
   const stamp = statSync(path);
@@ -4562,20 +4599,18 @@ function claudeConversation(conversation, rows) {
 }
 function claudeSettings(path) {
   const rows = journal(path, true);
-  const settings = {};
+  const marker = object(newest(path, '"ultra_effort_')?.attachment)?.type;
   for (let index = rows.length - 1; index >= 0; index--) {
     const row = rows[index];
     const message = object(row.message);
-    const marker = row.type === "attachment" ? object(row.attachment)?.type : void 0;
-    if (settings.model === void 0 && row.type === "assistant" && !row.isSidechain && typeof message?.model === "string" && message.model !== "<synthetic>") {
-      settings.model = message.model;
-      settings.fast = object(message.usage)?.speed === "fast";
-    }
-    if (settings.ultracode === void 0 && (marker === "ultra_effort_enter" || marker === "ultra_effort_exit"))
-      settings.ultracode = marker === "ultra_effort_enter";
-    if (settings.model !== void 0 && settings.ultracode !== void 0) break;
+    if (row.type === "assistant" && !row.isSidechain && typeof message?.model === "string" && message.model !== "<synthetic>")
+      return {
+        model: message.model,
+        fast: object(message.usage)?.speed === "fast",
+        ultracode: marker === "ultra_effort_enter"
+      };
   }
-  return { ultracode: false, ...settings };
+  return { ultracode: marker === "ultra_effort_enter" };
 }
 function claude(root, scan) {
   for (const path of files(join2(root, "projects"), scan, 1).filter((file) => file.endsWith(".jsonl"))) {
@@ -4632,6 +4667,21 @@ function applyPatch(patch) {
 +++ ${kind === "Delete" ? "/dev/null" : path}`
   ).replace(/^\*\*\* .*\n?/gm, "");
 }
+function codexSettings(path) {
+  const rows = journal(path, true);
+  const applied = object(newest(path, '"thread_settings_applied"')?.payload?.thread_settings);
+  const fast = applied ? { fast: applied.service_tier === "priority" } : {};
+  for (let index = rows.length - 1; index >= 0; index--) {
+    const row = rows[index];
+    const turn = row.type === "turn_context" ? object(row.payload) : void 0;
+    const settings = row.payload?.type === "thread_settings_applied" ? object(row.payload.thread_settings) : void 0;
+    const model = settings?.model ?? turn?.model;
+    const effort = settings?.reasoning_effort ?? turn?.effort;
+    if (typeof model === "string")
+      return { model, ...typeof effort === "string" ? { effort } : {}, ...fast };
+  }
+  return fast;
+}
 function codexMessages(path) {
   const rows = journal(path, true);
   const outputs = /* @__PURE__ */ new Map();
@@ -4724,7 +4774,8 @@ function codex(root, scan) {
           "Codex thread"
         ),
         files: [path, ...indexed ? [index] : []],
-        read: () => codexMessages(path)
+        read: () => codexMessages(path),
+        settings: () => codexSettings(path)
       });
     } catch {
       scan.warnings.push(`Cannot read Codex session: ${path}`);
@@ -4900,7 +4951,7 @@ function openCodeLegacy(root, scan) {
         continue;
       scan.paths.add(root);
       const messages5 = join2(root, "message", row.id);
-      const newest = files(messages5, scan, 0).filter((file) => file.endsWith(".json")).sort().at(-1);
+      const newest2 = files(messages5, scan, 0).filter((file) => file.endsWith(".json")).sort().at(-1);
       scan.sessions.push({
         harness: "opencode",
         id: row.id,
@@ -4908,7 +4959,7 @@ function openCodeLegacy(root, scan) {
         title: title(row.title, "OpenCode thread"),
         parent: typeof row.parentID === "string" ? row.parentID : void 0,
         updatedAt: date(
-          newest ? jsonFile(newest)?.time?.created : row.time?.created,
+          newest2 ? jsonFile(newest2)?.time?.created : row.time?.created,
           statSync(path).mtimeMs
         ),
         files: [path, messages5, join2(root, "part")],
@@ -13264,22 +13315,22 @@ var FrontendAdapter = class {
       if (options.subscribe === false) requestData.__subscribe = false;
       const result = await this.transport.get(path, requestData);
       const items = result?.[(0, import_pluralize.default)(modelClass.type)] ?? result?.[modelClass.type + "s"] ?? result?.items ?? [];
-      const models = items.map(
+      const models2 = items.map(
         (row) => modelClass.hydrate(this, row)
       );
       if (result?.__queryHash) {
-        Object.defineProperty(models, "__queryHash", {
+        Object.defineProperty(models2, "__queryHash", {
           value: result.__queryHash,
           enumerable: false
         });
       }
       if (typeof result?.totalCount === "number") {
-        Object.defineProperty(models, "__totalCount", {
+        Object.defineProperty(models2, "__totalCount", {
           value: result.totalCount,
           enumerable: false
         });
       }
-      return models;
+      return models2;
     };
     chain.first = async () => {
       const all = await chain.find();
@@ -16451,1040 +16502,1096 @@ async function shareAttachment(config2, pair, project, thread, messages5, id) {
 import { promisify as promisify5 } from "node:util";
 import { execFile as execFile5 } from "node:child_process";
 
-// src/harness/codex.ts
-import WebSocket2 from "ws";
+// src/harness/headless.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { createInterface as createInterface3 } from "node:readline";
+import { spawn as spawn3 } from "node:child_process";
+
+// src/harness/claude.ts
 import { homedir as homedir4 } from "node:os";
-import { connect } from "node:net";
-import { promisify as promisify2 } from "node:util";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { execFile as execFile2 } from "node:child_process";
-import { join as join4, isAbsolute as isAbsolute2 } from "node:path";
-import { stat, readdir, readFile } from "node:fs/promises";
-var REQUEST_MS = 4e3;
-var MAX_BYTES = 8 * 1024 * 1024;
-var MAX_SESSIONS = 100;
-var MAX_SOCKETS = 32;
-var MAX_PROCESSES = 4096;
-var SOCKET_PARTS = ["app-server-control", "app-server-control.sock"];
-var DECISIONS = [
-  { id: "accept", label: "Allow once" },
-  { id: "decline", label: "Reject" }
-];
-function approval(id, method, params) {
-  const command2 = method === "item/commandExecution/requestApproval";
-  let detail = [
-    command2 && typeof params.command === "string" ? params.command : "",
-    typeof params.cwd === "string" ? `Working directory: ${params.cwd}` : "",
-    typeof params.grantRoot === "string" ? `Write access root: ${params.grantRoot}` : "",
-    typeof params.reason === "string" ? params.reason : ""
-  ].filter(Boolean).join("\n\n");
-  const oversized = Buffer.byteLength(detail) > MAX_PREVIEW;
-  const unavailable = !command2 || params.kind !== void 0 && params.kind !== "command" || typeof params.command !== "string" || !params.command.trim() || oversized;
-  if (oversized) detail = Buffer.from(detail).subarray(0, MAX_PREVIEW).toString("utf8");
-  if (unavailable) detail = [detail, NO_PREVIEW].filter(Boolean).join("\n\n");
-  return {
-    id,
-    title: command2 ? "Allow command?" : "Allow file changes?",
-    detail,
-    choices: DECISIONS.filter((choice) => !unavailable || choice.id === "decline").map((choice) => ({ ...choice }))
-  };
+import { dirname as dirname4, join as join4, basename as basename2 } from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+import { createInterface as createInterface2 } from "node:readline";
+import { watch as watch2, readFileSync as readFileSync3 } from "node:fs";
+import { mkdir, readdir, readFile, readlink, rm } from "node:fs/promises";
+import { createServer as createServer2 } from "node:http";
+var MODELS_MS = 3e4;
+var COMMANDS = {
+  model: (value2) => `/model ${value2}`,
+  fast: (value2) => `/fast ${value2 ? "on" : "off"}`,
+  ultracode: (value2) => `/effort ultracode ${value2 ? "on" : "off"}`
+};
+var offered = /* @__PURE__ */ new Map();
+var asking = /* @__PURE__ */ new Set();
+var forgetModels = () => offered.clear();
+function claudeModels(changed, command2 = "claude", version2 = "") {
+  const key = `${command2}\0${version2}`;
+  if (!offered.has(key) && !asking.has(key)) {
+    asking.add(key);
+    void listModels(command2).then((models2) => {
+      asking.delete(key);
+      if (!models2.length) return;
+      offered.set(key, models2);
+      changed();
+    });
+  }
+  return offered.get(key) ?? [];
 }
-var codexHome = () => process.env.DASHUP_CODEX_HOME ?? process.env.CODEX_HOME ?? join4(homedir4(), ".codex");
-async function sockets() {
-  const explicit = process.env.DASHUP_CODEX_SOCKET;
-  if (explicit !== void 0) return explicit && isAbsolute2(explicit) ? [explicit] : [];
-  if (process.env.DASHUP_LIVE_DISCOVERY === "0") return [];
-  const homes = /* @__PURE__ */ new Set([codexHome()]);
-  if (process.platform === "linux") {
-    const entries2 = await readdir("/proc").catch(() => []);
-    for (const pid of entries2.filter((value2) => /^\d+$/.test(value2)).slice(0, MAX_PROCESSES)) {
-      if (homes.size >= MAX_SOCKETS) break;
+function listModels(command2) {
+  return new Promise((resolve3) => {
+    const child = spawn2(
+      command2,
+      ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose"],
+      { cwd: homedir4(), stdio: "pipe", shell: process.platform === "win32" }
+    );
+    const timer = setTimeout(() => child.kill(), MODELS_MS);
+    child.stdin.on("error", () => {
+    });
+    child.once("error", () => resolve3([]));
+    child.once("exit", () => {
+      clearTimeout(timer);
+      resolve3([]);
+    });
+    createInterface2({ input: child.stdout }).on("line", (line) => {
       try {
-        const directory2 = `/proc/${pid}`;
-        const owner = await stat(directory2);
-        if (process.getuid && owner.uid !== process.getuid()) continue;
-        const command2 = (await readFile(join4(directory2, "cmdline"), "utf8")).slice(0, 4096);
-        if (!/(?:^|[\/\0 ])codex(?:[\0 .]|$)/.test(command2)) continue;
-        const environment = await readFile(join4(directory2, "environ"), "utf8");
-        const home = environment.split("\0").find((value2) => value2.startsWith("CODEX_HOME="))?.slice("CODEX_HOME=".length);
-        if (home && isAbsolute2(home)) homes.add(home);
+        const message = JSON.parse(line);
+        if (message?.type !== "control_response" || message.response?.request_id !== "models")
+          return;
+        const models2 = message.response.response?.models;
+        resolve3(
+          (Array.isArray(models2) ? models2 : []).filter(
+            (model) => typeof model?.value === "string" && typeof model.displayName === "string"
+          )
+        );
+        child.stdin.end();
       } catch {
       }
-    }
-  }
-  return [...homes].map((home) => join4(home, ...SOCKET_PARTS));
+    });
+    child.stdin.write(
+      `${JSON.stringify({ type: "control_request", request_id: "models", request: { subtype: "initialize" } })}
+`
+    );
+  });
 }
-function messages2(thread) {
-  if (!Array.isArray(thread.turns)) return [];
-  return thread.turns.flatMap((turn) => Array.isArray(turn?.items) ? turn.items.flatMap((item) => {
-    if (typeof item?.id !== "string") return [];
-    if (item.type === "userMessage" && Array.isArray(item.content)) {
-      const text3 = item.content.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
-      return text3 ? [{ id: item.id, role: "user", text: text3 }] : [];
-    }
-    if (item.type === "agentMessage" && typeof item.text === "string")
-      return [{ id: item.id, role: "assistant", text: item.text }];
-    if (item.type === "commandExecution" && typeof item.command === "string")
-      return [
-        {
-          id: item.id,
-          role: "tool",
-          text: [item.command, item.aggregatedOutput].filter((value2) => typeof value2 === "string").join("\n\n")
-        }
-      ];
-    return [];
-  }) : []);
+function claudeOptions(models2, recorded) {
+  const ran = typeof recorded.model === "string" ? recorded.model : "";
+  const current = models2.find((model) => model.value !== "default" && model.resolvedModel === ran) ?? models2.find((model) => model.value === ran);
+  const choices = models2.map((model) => ({ value: model.value, name: model.displayName }));
+  if (!ran) return [];
+  if (!current) choices.push({ value: ran, name: ran });
+  return [
+    { id: "model", name: "Model", value: current?.value ?? ran, choices },
+    ...current?.supportsFastMode ? [{ id: "fast", name: "Fast", value: recorded.fast === true }] : [],
+    ...current?.supportedEffortLevels?.includes("xhigh") ? [{ id: "ultracode", name: "Ultracode", value: recorded.ultracode === true }] : []
+  ];
 }
-function status(thread) {
-  if (thread.status?.type === "idle") return "idle";
-  if (thread.status?.type === "active") {
-    return thread.status.activeFlags?.some(
-      (flag) => flag === "waitingOnApproval" || flag === "waitingOnUserInput"
-    ) ? "attention" : "working";
-  }
-  return "unknown";
+var EDITS = /* @__PURE__ */ new Set(["Edit", "MultiEdit", "NotebookEdit", "Write"]);
+var SCOPE = 32;
+var preview2 = (text3) => Buffer.byteLength(text3) > MAX_PREVIEW ? Buffer.from(text3).subarray(0, MAX_PREVIEW).toString("utf8") : text3;
+function hunk(before, after, offset = 0) {
+  const old = before ? before.replace(/\n$/, "").split("\n") : [];
+  const next = after ? after.replace(/\n$/, "").split("\n") : [];
+  let start2 = 0;
+  while (start2 < old.length && start2 < next.length && old[start2] === next[start2]) start2++;
+  let end = 0;
+  while (end < old.length - start2 && end < next.length - start2 && old[old.length - 1 - end] === next[next.length - 1 - end])
+    end++;
+  const removed = old.slice(start2, old.length - end);
+  const added2 = next.slice(start2, next.length - end);
+  return {
+    lines: [
+      `@@ -${offset + start2 + 1},${removed.length} +${offset + start2 + 1},${added2.length} @@`,
+      ...old.slice(Math.max(0, start2 - 3), start2).map((line) => ` ${line}`),
+      ...removed.map((line) => `-${line}`),
+      ...added2.map((line) => `+${line}`),
+      ...old.slice(old.length - end, old.length - end + 3).map((line) => ` ${line}`)
+    ],
+    added: added2.length,
+    deleted: removed.length
+  };
 }
-var Client = class {
-  constructor(path, changed) {
-    this.path = path;
-    this.changed = changed;
+function change(tool, input) {
+  const path = input.file_path;
+  if (typeof path !== "string") return void 0;
+  let current = "";
+  try {
+    current = readFileSync3(path, "utf8");
+  } catch {
   }
-  path;
-  changed;
-  socket;
-  connecting;
-  stopped = false;
-  sequence = 0;
-  controls = false;
-  notify;
-  pending = /* @__PURE__ */ new Map();
-  approvals = /* @__PURE__ */ new Map();
-  requests = /* @__PURE__ */ new Map();
-  // The reply each thread is writing, as far as it has streamed, and the item it belongs to.
-  typing = /* @__PURE__ */ new Map();
-  async connect() {
-    if (this.socket?.readyState === WebSocket2.OPEN) return;
-    if (this.connecting) return this.connecting;
-    this.connecting = (async () => {
-      const file = await stat(this.path);
-      if (!file.isSocket() || process.getuid && file.uid !== process.getuid())
-        throw new Error("Codex control socket is not owned by this user");
-      const socket = this.socket = new WebSocket2("ws://localhost/rpc", {
-        createConnection: () => connect(this.path),
-        maxPayload: MAX_BYTES,
-        handshakeTimeout: REQUEST_MS
-      });
-      socket.on("error", () => {
-      });
-      socket.on("message", (bytes) => {
-        let message;
-        try {
-          message = JSON.parse(bytes.toString());
-        } catch {
-          return;
-        }
-        if (typeof message.id === "number" && !message.method) {
-          const pending = this.pending.get(message.id);
-          if (!pending) return;
-          this.pending.delete(message.id);
-          clearTimeout(pending.timer);
-          if (message.error)
-            pending.reject(
-              new Error(`Codex native request failed (${String(message.error.code ?? "unknown")})`)
-            );
-          else pending.resolve(message.result ?? {});
-          return;
-        }
-        if (typeof message.method !== "string") return;
-        const params = message.params;
-        if (message.method === "item/agentMessage/delta" && typeof params?.threadId === "string" && typeof params.delta === "string") {
-          const known = this.typing.get(params.threadId);
-          this.typing.set(params.threadId, {
-            item: params.itemId,
-            text: (known && known.item === params.itemId ? known.text : "") + params.delta
-          });
-        }
-        if (message.method === "serverRequest/resolved") {
-          for (const [id, pending] of this.approvals)
-            if (pending.requestId === message.params?.requestId) this.approvals.delete(id);
-        }
-        if ((message.method === "item/commandExecution/requestApproval" || message.method === "item/fileChange/requestApproval") && (typeof message.id === "string" || typeof message.id === "number") && typeof message.params?.threadId === "string") {
-          const id = randomUUID2();
-          this.approvals.set(id, {
-            requestId: message.id,
-            threadId: params.threadId,
-            approval: approval(id, message.method, params)
-          });
-        }
-        if (/^(thread|turn|item|serverRequest)\//.test(message.method) && !this.notify) {
-          this.notify = setTimeout(() => {
-            this.notify = void 0;
-            this.changed();
-          }, 100);
-          this.notify.unref();
-        }
-      });
-      socket.on("close", () => {
-        if (this.socket !== socket) return;
-        this.socket = void 0;
-        this.controls = false;
-        this.approvals.clear();
-        for (const pending of this.pending.values()) {
-          clearTimeout(pending.timer);
-          pending.reject(new Error("Codex control socket disconnected"));
-        }
-        this.pending.clear();
-        if (!this.stopped) this.changed();
-      });
-      await new Promise((resolve3, reject) => {
-        socket.once("open", resolve3);
-        socket.once("error", reject);
-        socket.once("close", () => reject(new Error("Codex control socket closed before initialization")));
-      });
-      const initialized = await this.call("initialize", {
-        clientInfo: { name: "dashup", title: "Dashup", version },
-        capabilities: { experimentalApi: false, requestAttestation: false }
-      });
-      socket.send(JSON.stringify({ method: "initialized", params: {} }));
-      const version2 = typeof initialized.userAgent === "string" ? /\b0\.(\d+)\.\d+\b/.exec(initialized.userAgent) : null;
-      this.controls = !!version2 && Number(version2[1]) >= 140;
-    })();
-    try {
-      await this.connecting;
-    } catch (error) {
-      this.socket?.terminate();
-      throw error;
-    } finally {
-      this.connecting = void 0;
-    }
+  const edit = (value2) => {
+    const before = String(value2?.old_string ?? "");
+    const at = before ? current.indexOf(before) : -1;
+    return hunk(
+      before,
+      String(value2?.new_string ?? ""),
+      at < 0 ? 0 : current.slice(0, at).split("\n").length - 1
+    );
+  };
+  const hunks = tool === "Write" && typeof input.content === "string" ? [hunk(current, input.content)] : tool === "Edit" ? [edit(input)] : tool === "MultiEdit" && Array.isArray(input.edits) ? input.edits.map(edit) : [];
+  if (!hunks.length) return void 0;
+  const diff = [`--- ${path}`, `+++ ${path}`, ...hunks.flatMap((item) => item.lines)].join("\n");
+  if (Buffer.byteLength(diff) > MAX_PREVIEW) return void 0;
+  return {
+    path,
+    diff,
+    added: hunks.reduce((sum, item) => sum + item.added, 0),
+    deleted: hunks.reduce((sum, item) => sum + item.deleted, 0)
+  };
+}
+function remember(suggestions = []) {
+  const updates = suggestions.filter(
+    (update) => update?.type === "addRules" && update.behavior === "allow" || update?.type === "addDirectories"
+  );
+  const rule = updates.flatMap((update) => update.rules ?? [])[0];
+  const folder = updates.flatMap((update) => update.directories ?? [])[0];
+  const scope2 = rule ? String(rule.ruleContent ?? rule.toolName) : folder ? `access to ${basename2(String(folder))}` : "";
+  if (scope2)
+    return {
+      label: `Always allow ${scope2.length > SCOPE ? `${scope2.slice(0, SCOPE - 1)}\u2026` : scope2}`,
+      updates
+    };
+  const edits = suggestions.find(
+    (update) => update?.type === "setMode" && update.mode === "acceptEdits"
+  );
+  return edits ? { label: "Allow all edits", updates: [edits] } : void 0;
+}
+function ask(id, request2, host) {
+  const { tool, input } = request2;
+  if (tool === "AskUserQuestion" && Array.isArray(input.questions))
+    return questionApproval(id, input.questions, (item) => item.multiSelect === true);
+  if (tool === "ExitPlanMode")
+    return {
+      id,
+      title: "Approve this plan?",
+      detail: host ? "" : "Approve it on your computer, or tell Claude what to change.",
+      choices: [
+        ...host ? [{ id: "accept", label: "Approve" }] : [],
+        { id: "revise", label: "Keep planning", text: true }
+      ],
+      plan: preview2(String(input.plan ?? ""))
+    };
+  const diff = change(tool, input);
+  const always = remember(request2.suggestions);
+  return {
+    id,
+    title: tool === "Bash" ? "Allow command?" : EDITS.has(tool) ? "Allow file changes?" : `Allow ${request2.label ?? tool}?`,
+    detail: preview2(
+      [
+        request2.description ?? (typeof input.description === "string" ? input.description : ""),
+        typeof input.command === "string" ? input.command : diff ? "" : JSON.stringify(input, null, 2)
+      ].filter(Boolean).join("\n\n")
+    ),
+    ...diff ? { change: diff } : {},
+    choices: [
+      { id: "accept", label: "Allow once" },
+      ...always ? [{ id: "always", label: always.label }] : [],
+      { id: "decline", label: "Reject" }
+    ]
+  };
+}
+function decide(request2, approval2, reply) {
+  const input = request2.input;
+  if ("answers" in reply)
+    return {
+      behavior: "allow",
+      updatedInput: {
+        ...input,
+        answers: Object.fromEntries(
+          (approval2.questions ?? []).map((item, index) => [
+            item.question,
+            reply.answers[index].join(", ")
+          ])
+        )
+      }
+    };
+  if (reply.choice === "accept")
+    return {
+      behavior: "allow",
+      updatedInput: input,
+      ...approval2.plan === void 0 ? {} : { updatedPermissions: [{ type: "setMode", mode: "default", destination: "session" }] }
+    };
+  if (reply.choice === "always")
+    return {
+      behavior: "allow",
+      updatedInput: input,
+      updatedPermissions: remember(request2.suggestions)?.updates ?? []
+    };
+  if (reply.choice === "revise")
+    return { behavior: "deny", message: reply.text?.trim() || "Keep planning." };
+  return {
+    behavior: "deny",
+    message: reply.choice === "skip" ? "The person skipped these questions." : "The person rejected this from their phone."
+  };
+}
+var MAX_SESSIONS = 100;
+var MAX_REQUESTS = 1e3;
+var MAX_PROMPT = 4 * 1024 * 1024;
+var SESSION = /^\/sessions\/([\w-]{1,100})(\/prompts)?$/;
+var STATUS = {
+  busy: "working",
+  idle: "idle",
+  shell: "idle",
+  waiting: "attention"
+};
+async function registrations() {
+  if (process.env.DASHUP_LIVE_DISCOVERY === "0") return [];
+  const directory2 = join4(claudeHome(), "sessions");
+  const names = await readdir(directory2).catch(() => []);
+  const found = await Promise.all(
+    names.filter((name) => /^\d+\.json$/.test(name)).slice(0, MAX_SESSIONS).map(async (name) => {
+      try {
+        const value2 = JSON.parse(await readFile(join4(directory2, name), "utf8"));
+        if (typeof value2.sessionId !== "string" || typeof value2.cwd !== "string") return [];
+        process.kill(value2.pid, 0);
+        const binary2 = await readlink(`/proc/${value2.pid}/exe`).catch(() => "");
+        return [{ ...value2, command: /[\\/]claude(?:\.exe)?$/.test(binary2) ? binary2 : "claude" }];
+      } catch {
+        return [];
+      }
+    })
+  );
+  return found.flat();
+}
+var Claude = class {
+  constructor(changed, socket = join4(dirname4(configPath()), "claude.sock")) {
+    this.changed = changed;
+    this.socket = socket;
   }
-  call(method, params) {
-    const socket = this.socket;
-    if (this.stopped || socket?.readyState !== WebSocket2.OPEN)
-      return Promise.reject(new Error("Codex control socket is disconnected"));
-    if (this.pending.size >= 32) return Promise.reject(new Error("Codex request limit reached"));
-    const id = ++this.sequence;
-    return new Promise((resolve3, reject) => {
-      const timer = setTimeout(() => {
-        this.pending.delete(id);
-        reject(new Error("Codex native request timed out"));
-      }, REQUEST_MS);
-      timer.unref();
-      this.pending.set(id, { resolve: resolve3, reject, timer });
-      socket.send(JSON.stringify({ id, method, params }), (error) => {
-        if (error) {
-          clearTimeout(timer);
-          this.pending.delete(id);
-          reject(new Error("Codex native request could not be sent"));
-        }
+  changed;
+  socket;
+  watcher;
+  notify;
+  server;
+  streams = /* @__PURE__ */ new Map();
+  prompts = /* @__PURE__ */ new Map();
+  requests = /* @__PURE__ */ new Map();
+  async refresh() {
+    this.watch();
+    return (await registrations()).map((session) => {
+      const plugin = this.streams.has(session.sessionId);
+      const models2 = claudeModels(this.changed, session.command, session.version);
+      const approvals = [...this.prompts.values()].filter((prompt) => prompt.session === session.sessionId).map((prompt) => prompt.approval);
+      return {
+        id: session.sessionId,
+        harness: "claude",
+        cwd: session.cwd,
+        updatedAt: new Date(session.updatedAt ?? 0).toISOString(),
+        status: approvals.length ? "attention" : STATUS[session.status ?? ""] ?? "unknown",
+        messages: [],
+        approvals,
+        approve: approvals.length ? (requestId, approvalId, reply) => this.once(requestId, async () => {
+          const prompt = this.prompts.get(approvalId);
+          if (prompt?.session !== session.sessionId)
+            throw new Error("Claude Code approval is no longer pending");
+          prompt.answer(decide(prompt.request, prompt.approval, reply));
+        }) : void 0,
+        send: plugin ? (requestId, text3, now) => this.once(requestId, () => this.deliver(session.sessionId, now ? { text: text3, now } : { text: text3 })) : void 0,
+        stop: plugin ? (requestId) => this.once(requestId, () => this.deliver(session.sessionId, { now: true })) : void 0,
+        now: plugin,
+        options: (recorded) => claudeOptions(models2, recorded),
+        configure: plugin ? (requestId, option2, value2) => this.once(requestId, () => this.deliver(session.sessionId, { text: COMMANDS[option2](value2) })) : void 0
+      };
+    });
+  }
+  // Only the connector serves the plugin; one-off commands such as `dashup doctor` read alone.
+  async listen() {
+    if (this.server || process.env.DASHUP_LIVE_DISCOVERY === "0") return;
+    const server = this.server = createServer2((request2, response) => {
+      const [, id, prompt] = SESSION.exec(request2.url ?? "") ?? [];
+      if (id && prompt && request2.method === "POST") return this.prompt(id, request2, response);
+      if (!id || prompt || request2.method !== "GET") return void response.writeHead(404).end();
+      this.streams.get(id)?.end();
+      this.streams.set(id, response);
+      response.once("close", () => {
+        if (this.streams.get(id) === response) this.streams.delete(id);
+        this.changed();
       });
+      response.writeHead(200, { "Content-Type": "application/x-ndjson" }).flushHeaders();
+      this.changed();
+    });
+    await mkdir(dirname4(this.socket), { recursive: true, mode: 448 });
+    await rm(this.socket, { force: true });
+    if (this.server !== server) return;
+    await new Promise((resolve3, reject) => {
+      server.once("error", reject);
+      server.listen(this.socket, resolve3);
     });
   }
-  once(id, action) {
-    const known = this.requests.get(id);
-    if (known) return known;
-    if (this.requests.size >= 1e3)
-      throw new Error("Codex command history is full; reconnect before sending");
-    const result = action();
-    this.requests.set(id, result);
-    return result;
-  }
-  // Starts a thread in `cwd` with Codex's own settings, or loads a saved one, then a turn.
-  async start(cwd, text3, saved) {
-    await this.connect();
-    if (!this.controls) throw new Error("Update Codex to start threads from Dashup");
-    const id = saved ? (await this.call("thread/resume", { threadId: saved, excludeTurns: true })).thread?.id : (await this.call("thread/start", { cwd })).thread?.id;
-    if (typeof id !== "string") throw new Error("Codex did not open the thread");
-    await this.call("turn/start", { threadId: id, input: [{ type: "text", text: text3, text_elements: [] }] });
-    this.changed();
-    return id;
-  }
-  async read() {
-    await this.connect();
-    const loaded = await this.call("thread/loaded/list", { limit: MAX_SESSIONS });
-    if (!Array.isArray(loaded.data)) return [];
-    const sessions = [];
-    for (const id of loaded.data.slice(0, MAX_SESSIONS)) {
-      if (typeof id !== "string") continue;
+  // Asks the phone what the session's permission request asks the person.
+  prompt(session, request2, response) {
+    const chunks = [];
+    let bytes = 0;
+    request2.on("data", (chunk) => {
+      bytes += chunk.length;
+      if (bytes > MAX_PROMPT) request2.destroy();
+      else chunks.push(chunk);
+    });
+    request2.once("end", () => {
+      let asked;
       try {
-        const read = await this.call("thread/read", { threadId: id, includeTurns: true });
-        const thread = read.thread;
-        if (thread?.id !== id || typeof thread.cwd !== "string" || !thread.cwd) continue;
-        const approvals = [...this.approvals.values()].filter((value2) => value2.threadId === id).map((value2) => value2.approval);
-        sessions.push({
-          id,
-          harness: "codex",
-          cwd: thread.cwd,
-          title: typeof thread.name === "string" && thread.name ? thread.name : typeof thread.preview === "string" && thread.preview ? thread.preview : "Codex thread",
-          updatedAt: new Date(Number(thread.updatedAt ?? 0) * 1e3).toISOString(),
-          status: approvals.length ? "attention" : status(thread),
-          messages: messages2(thread),
-          typing: this.typing.get(id)?.text,
-          approvals,
-          // An interrupt for a finished turn is never answered, so the active turn is read first.
-          stop: this.controls ? (requestId) => this.once(requestId, async () => {
-            const native = (await this.call("thread/read", { threadId: id, includeTurns: true })).thread;
-            const turn = native?.status?.type === "active" && Array.isArray(native.turns) ? native.turns.at(-1) : void 0;
-            if (turn?.status !== "inProgress" || typeof turn.id !== "string")
-              throw new Error("Nothing is running in this Codex thread");
-            await this.call("turn/interrupt", { threadId: id, turnId: turn.id });
-            this.changed();
-          }) : void 0,
-          send: this.controls && thread.status?.type === "idle" ? (requestId, text3) => this.once(requestId, async () => {
-            if (!text3.trim() || Buffer.byteLength(text3) > MAX_BYTES / 2)
-              throw new Error("Message is empty or too large");
-            const current = await this.call("thread/loaded/list", { limit: MAX_SESSIONS });
-            if (!Array.isArray(current.data) || !current.data.includes(id))
-              throw new Error("Codex thread is no longer loaded");
-            const native = (await this.call("thread/read", { threadId: id, includeTurns: false })).thread;
-            if (native?.id !== id || native.status?.type !== "idle")
-              throw new Error("Codex thread is busy or unavailable");
-            await this.call("turn/start", {
-              threadId: id,
-              clientUserMessageId: requestId,
-              input: [{ type: "text", text: text3, text_elements: [] }]
-            });
-            this.changed();
-          }) : void 0,
-          approve: approvals.length ? (requestId, approvalId, reply) => this.once(requestId, async () => {
-            const approval2 = this.approvals.get(approvalId);
-            const choice = "choice" in reply ? reply.choice : void 0;
-            const socket = this.socket;
-            if (!approval2 || approval2.threadId !== id || !approval2.approval.choices.some((value2) => value2.id === choice) || socket?.readyState !== WebSocket2.OPEN)
-              throw new Error("Codex approval is no longer pending");
-            await new Promise((resolve3, reject) => socket.send(
-              JSON.stringify({ id: approval2.requestId, result: { decision: choice } }),
-              (error) => error ? reject(new Error("Codex approval could not be sent")) : resolve3()
-            ));
-            this.approvals.delete(approvalId);
-            this.changed();
-          }) : void 0
-        });
+        asked = JSON.parse(Buffer.concat(chunks).toString("utf8"));
       } catch {
       }
+      if (typeof asked?.tool !== "string" || !asked.input || typeof asked.input !== "object")
+        return void response.writeHead(400).end();
+      const id = randomUUID2();
+      const prompted = {
+        tool: asked.tool,
+        input: asked.input,
+        ...Array.isArray(asked.suggestions) ? { suggestions: asked.suggestions } : {}
+      };
+      this.prompts.set(id, {
+        session,
+        request: prompted,
+        approval: ask(id, prompted, false),
+        answer: (decision) => {
+          this.prompts.delete(id);
+          response.end(JSON.stringify(decision));
+          this.changed();
+        }
+      });
+      response.once("close", () => {
+        if (this.prompts.delete(id)) this.changed();
+      });
+      response.writeHead(200, { "Content-Type": "application/json" }).flushHeaders();
+      this.changed();
+    });
+  }
+  deliver(id, delivery) {
+    const stream = this.streams.get(id);
+    if (!stream) return Promise.reject(new Error("Claude Code is not taking messages"));
+    return new Promise((resolve3, reject) => stream.write(`${JSON.stringify(delivery)}
+`, (error) => error ? reject(error) : resolve3()));
+  }
+  // Each request delivers at most once.
+  once(id, action) {
+    const known = this.requests.get(id);
+    if (known) return known;
+    if (this.requests.size >= MAX_REQUESTS)
+      this.requests.delete(this.requests.keys().next().value);
+    const result = action();
+    this.requests.set(id, result);
+    return result;
+  }
+  watch() {
+    if (this.watcher || process.env.DASHUP_LIVE_DISCOVERY === "0") return;
+    try {
+      const watcher = this.watcher = watch2(join4(claudeHome(), "sessions"), () => {
+        if (this.notify) return;
+        this.notify = setTimeout(() => {
+          this.notify = void 0;
+          this.changed();
+        }, 100);
+        this.notify.unref();
+      });
+      watcher.on("error", () => {
+        watcher.close();
+        if (this.watcher === watcher) this.watcher = void 0;
+      });
+    } catch {
     }
-    return sessions;
   }
   stop() {
-    this.stopped = true;
     clearTimeout(this.notify);
-    this.socket?.terminate();
-    for (const pending of this.pending.values()) {
-      clearTimeout(pending.timer);
-      pending.reject(new Error("Codex observation stopped"));
-    }
-    this.pending.clear();
-    this.approvals.clear();
+    this.watcher?.close();
+    this.watcher = void 0;
+    this.prompts.clear();
+    this.server?.closeAllConnections();
+    this.server?.close();
+    this.server = void 0;
   }
 };
-var Codex = class {
-  constructor(changed) {
+
+// src/harness/headless.ts
+var MAX_REQUESTS2 = 1e3;
+var NOTIFY_MS = 100;
+var SWITCHES = { fast: "fastMode", ultracode: "ultracode" };
+var Session = class {
+  // A resumed session is `saved` and keeps the title its history gives.
+  constructor(id, cwd, title2, changed, saved = false) {
+    this.id = id;
+    this.cwd = cwd;
+    this.title = title2;
     this.changed = changed;
+    this.saved = saved;
   }
+  id;
+  cwd;
+  title;
   changed;
-  clients = /* @__PURE__ */ new Map();
-  // Control sockets of daemons this connector started, which discovery may not look for.
-  started = /* @__PURE__ */ new Set();
-  // Codex's own daemon runs the threads Dashup starts or resumes, so they outlive this connector.
-  async start(cwd, text3, saved) {
-    const path = process.env.DASHUP_CODEX_SOCKET || join4(codexHome(), ...SOCKET_PARTS);
-    await promisify2(execFile2)("codex", ["app-server", "daemon", "start"], {
-      timeout: 6e4,
-      shell: process.platform === "win32"
-    });
-    this.started.add(path);
-    let client = this.clients.get(path);
-    if (!client) {
-      client = new Client(path, this.changed);
-      this.clients.set(path, client);
-    }
-    return client.start(cwd, text3, saved);
+  saved;
+  messages = [];
+  status = "idle";
+  updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  turn;
+  // Messages written to this turn's process that Claude Code has not finished answering.
+  open = 0;
+  // The text Claude Code is writing, as far as it has streamed.
+  typing = "";
+  approvals = /* @__PURE__ */ new Map();
+  requests = /* @__PURE__ */ new Map();
+  // What the person chose for this session, applied to each turn as it starts.
+  chosen = {};
+  write(value2) {
+    this.turn?.stdin.write(`${JSON.stringify(value2)}
+`);
   }
-  async resume(id, cwd, text3) {
-    await this.start(cwd, text3, id);
+  interrupt() {
+    this.write({
+      type: "control_request",
+      request_id: randomUUID3(),
+      request: { subtype: "interrupt" }
+    });
   }
-  async refresh() {
-    const paths = /* @__PURE__ */ new Set([...await sockets(), ...this.started]);
-    for (const [path, client] of this.clients)
-      if (!paths.has(path)) {
-        client.stop();
-        this.clients.delete(path);
-      }
-    const results = await Promise.allSettled(
-      [...paths].map(async (path) => {
-        let client = this.clients.get(path);
-        if (!client) {
-          client = new Client(path, this.changed);
-          this.clients.set(path, client);
-        }
-        return client.read();
-      })
-    );
-    return results.flatMap((result) => result.status === "fulfilled" ? result.value : []);
+  apply(option2, value2) {
+    this.write({
+      type: "control_request",
+      request_id: randomUUID3(),
+      request: option2 === "model" ? { subtype: "set_model", model: value2 } : { subtype: "apply_flag_settings", settings: { [SWITCHES[option2]]: value2 } }
+    });
   }
-  stop() {
-    for (const client of this.clients.values()) client.stop();
-    this.clients.clear();
+  once(id, action) {
+    const known = this.requests.get(id);
+    if (known) return known;
+    if (this.requests.size >= MAX_REQUESTS2)
+      throw new Error("Claude Code command history is full; restart Dashup before sending");
+    const result = action();
+    this.requests.set(id, result);
+    return result;
   }
-};
-
-// src/harness/headless.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-import { createInterface as createInterface3 } from "node:readline";
-import { spawn as spawn3 } from "node:child_process";
-
-// src/harness/claude.ts
-import { homedir as homedir5 } from "node:os";
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { dirname as dirname4, join as join5, basename as basename2 } from "node:path";
-import { spawn as spawn2 } from "node:child_process";
-import { createInterface as createInterface2 } from "node:readline";
-import { watch as watch2, readFileSync as readFileSync3 } from "node:fs";
-import { mkdir, readdir as readdir2, readFile as readFile2, readlink, rm } from "node:fs/promises";
-import { createServer as createServer2 } from "node:http";
-var MODELS_MS = 3e4;
-var COMMANDS = {
-  model: (value2) => `/model ${value2}`,
-  fast: (value2) => `/fast ${value2 ? "on" : "off"}`,
-  ultracode: (value2) => `/effort ultracode ${value2 ? "on" : "off"}`
-};
-var offered = /* @__PURE__ */ new Map();
-var asking = /* @__PURE__ */ new Set();
-var forgetModels = () => offered.clear();
-function claudeModels(changed, command2 = "claude", version2 = "") {
-  const key = `${command2}\0${version2}`;
-  if (!offered.has(key) && !asking.has(key)) {
-    asking.add(key);
-    void listModels(command2).then((models) => {
-      asking.delete(key);
-      if (!models.length) return;
-      offered.set(key, models);
-      changed();
-    });
-  }
-  return offered.get(key) ?? [];
-}
-function listModels(command2) {
-  return new Promise((resolve3) => {
-    const child = spawn2(
-      command2,
-      ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose"],
-      { cwd: homedir5(), stdio: "pipe", shell: process.platform === "win32" }
+  // Resolves once Claude Code takes the message, or says why it could not start. `now` stops the
+  // turn under way, so Claude Code takes the message at once.
+  say(text3, now = false) {
+    this.messages.push({ id: randomUUID3(), role: "user", text: text3 });
+    this.typing = "";
+    this.status = "working";
+    this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const message = { type: "user", message: { role: "user", content: text3 } };
+    if (this.turn) {
+      if (now) this.interrupt();
+      this.open++;
+      this.write(message);
+      this.changed();
+      return Promise.resolve();
+    }
+    const turn = this.turn = spawn3(
+      "claude",
+      [
+        "-p",
+        "--input-format",
+        "stream-json",
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--include-partial-messages",
+        "--permission-prompt-tool",
+        "stdio",
+        ...this.saved ? ["--resume", this.id] : ["--session-id", this.id]
+      ],
+      { cwd: this.cwd, stdio: "pipe", shell: process.platform === "win32" }
     );
-    const timer = setTimeout(() => child.kill(), MODELS_MS);
-    child.stdin.on("error", () => {
+    this.open = 1;
+    let errors = "";
+    turn.stdin.on("error", () => {
     });
-    child.once("error", () => resolve3([]));
-    child.once("exit", () => {
-      clearTimeout(timer);
-      resolve3([]);
+    turn.stderr.on("data", (chunk) => {
+      errors = (errors + String(chunk)).slice(-2e3);
     });
-    createInterface2({ input: child.stdout }).on("line", (line) => {
-      try {
-        const message = JSON.parse(line);
-        if (message?.type !== "control_response" || message.response?.request_id !== "models")
-          return;
-        const models = message.response.response?.models;
-        resolve3(
-          (Array.isArray(models) ? models : []).filter(
-            (model) => typeof model?.value === "string" && typeof model.displayName === "string"
-          )
-        );
-        child.stdin.end();
-      } catch {
-      }
+    const started = new Promise((resolve3, reject) => {
+      createInterface3({ input: turn.stdout }).on("line", (line) => {
+        if (this.receive(line)) resolve3();
+      });
+      const end = (reason) => {
+        reject(new Error(reason));
+        if (this.turn !== turn) return;
+        this.turn = void 0;
+        this.open = 0;
+        this.approvals.clear();
+        this.status = "idle";
+        this.changed();
+      };
+      turn.once("error", () => end("Claude Code is not installed on this computer"));
+      turn.once("exit", () => end(errors.trim() || "Claude Code stopped before starting"));
     });
-    child.stdin.write(
-      `${JSON.stringify({ type: "control_request", request_id: "models", request: { subtype: "initialize" } })}
-`
-    );
-  });
-}
-function claudeOptions(models, recorded) {
-  const ran = typeof recorded.model === "string" ? recorded.model : "";
-  const current = models.find((model) => model.value !== "default" && model.resolvedModel === ran) ?? models.find((model) => model.value === ran);
-  const choices = models.map((model) => ({ value: model.value, name: model.displayName }));
-  if (ran && !current) choices.push({ value: ran, name: ran });
-  if (!choices.length) return [];
-  return [
-    { id: "model", name: "Model", value: current?.value ?? ran, choices },
-    ...current?.supportsFastMode ? [{ id: "fast", name: "Fast", value: recorded.fast === true }] : [],
-    ...current?.supportedEffortLevels?.includes("xhigh") ? [{ id: "ultracode", name: "Ultracode", value: recorded.ultracode === true }] : []
-  ];
-}
-var EDITS = /* @__PURE__ */ new Set(["Edit", "MultiEdit", "NotebookEdit", "Write"]);
-var SCOPE = 32;
-var preview2 = (text3) => Buffer.byteLength(text3) > MAX_PREVIEW ? Buffer.from(text3).subarray(0, MAX_PREVIEW).toString("utf8") : text3;
-function hunk(before, after, offset = 0) {
-  const old = before ? before.replace(/\n$/, "").split("\n") : [];
-  const next = after ? after.replace(/\n$/, "").split("\n") : [];
-  let start2 = 0;
-  while (start2 < old.length && start2 < next.length && old[start2] === next[start2]) start2++;
-  let end = 0;
-  while (end < old.length - start2 && end < next.length - start2 && old[old.length - 1 - end] === next[next.length - 1 - end])
-    end++;
-  const removed = old.slice(start2, old.length - end);
-  const added2 = next.slice(start2, next.length - end);
-  return {
-    lines: [
-      `@@ -${offset + start2 + 1},${removed.length} +${offset + start2 + 1},${added2.length} @@`,
-      ...old.slice(Math.max(0, start2 - 3), start2).map((line) => ` ${line}`),
-      ...removed.map((line) => `-${line}`),
-      ...added2.map((line) => `+${line}`),
-      ...old.slice(old.length - end, old.length - end + 3).map((line) => ` ${line}`)
-    ],
-    added: added2.length,
-    deleted: removed.length
-  };
-}
-function change(tool, input) {
-  const path = input.file_path;
-  if (typeof path !== "string") return void 0;
-  let current = "";
-  try {
-    current = readFileSync3(path, "utf8");
-  } catch {
+    for (const [option2, value2] of Object.entries(this.chosen)) this.apply(option2, value2);
+    this.write(message);
+    this.changed();
+    return started;
   }
-  const edit = (value2) => {
-    const before = String(value2?.old_string ?? "");
-    const at = before ? current.indexOf(before) : -1;
-    return hunk(
-      before,
-      String(value2?.new_string ?? ""),
-      at < 0 ? 0 : current.slice(0, at).split("\n").length - 1
-    );
-  };
-  const hunks = tool === "Write" && typeof input.content === "string" ? [hunk(current, input.content)] : tool === "Edit" ? [edit(input)] : tool === "MultiEdit" && Array.isArray(input.edits) ? input.edits.map(edit) : [];
-  if (!hunks.length) return void 0;
-  const diff = [`--- ${path}`, `+++ ${path}`, ...hunks.flatMap((item) => item.lines)].join("\n");
-  if (Buffer.byteLength(diff) > MAX_PREVIEW) return void 0;
-  return {
-    path,
-    diff,
-    added: hunks.reduce((sum, item) => sum + item.added, 0),
-    deleted: hunks.reduce((sum, item) => sum + item.deleted, 0)
-  };
-}
-function remember(suggestions = []) {
-  const updates = suggestions.filter(
-    (update) => update?.type === "addRules" && update.behavior === "allow" || update?.type === "addDirectories"
-  );
-  const rule = updates.flatMap((update) => update.rules ?? [])[0];
-  const folder = updates.flatMap((update) => update.directories ?? [])[0];
-  const scope2 = rule ? String(rule.ruleContent ?? rule.toolName) : folder ? `access to ${basename2(String(folder))}` : "";
-  if (scope2)
-    return {
-      label: `Always allow ${scope2.length > SCOPE ? `${scope2.slice(0, SCOPE - 1)}\u2026` : scope2}`,
-      updates
-    };
-  const edits = suggestions.find(
-    (update) => update?.type === "setMode" && update.mode === "acceptEdits"
-  );
-  return edits ? { label: "Allow all edits", updates: [edits] } : void 0;
-}
-function ask(id, request2, host) {
-  const { tool, input } = request2;
-  if (tool === "AskUserQuestion" && Array.isArray(input.questions))
-    return questionApproval(id, input.questions, (item) => item.multiSelect === true);
-  if (tool === "ExitPlanMode")
-    return {
-      id,
-      title: "Approve this plan?",
-      detail: host ? "" : "Approve it on your computer, or tell Claude what to change.",
-      choices: [
-        ...host ? [{ id: "accept", label: "Approve" }] : [],
-        { id: "revise", label: "Keep planning", text: true }
-      ],
-      plan: preview2(String(input.plan ?? ""))
-    };
-  const diff = change(tool, input);
-  const always = remember(request2.suggestions);
-  return {
-    id,
-    title: tool === "Bash" ? "Allow command?" : EDITS.has(tool) ? "Allow file changes?" : `Allow ${request2.label ?? tool}?`,
-    detail: preview2(
-      [
-        request2.description ?? (typeof input.description === "string" ? input.description : ""),
-        typeof input.command === "string" ? input.command : diff ? "" : JSON.stringify(input, null, 2)
-      ].filter(Boolean).join("\n\n")
-    ),
-    ...diff ? { change: diff } : {},
-    choices: [
-      { id: "accept", label: "Allow once" },
-      ...always ? [{ id: "always", label: always.label }] : [],
-      { id: "decline", label: "Reject" }
-    ]
-  };
-}
-function decide(request2, approval2, reply) {
-  const input = request2.input;
-  if ("answers" in reply)
-    return {
-      behavior: "allow",
-      updatedInput: {
-        ...input,
-        answers: Object.fromEntries(
-          (approval2.questions ?? []).map((item, index) => [
-            item.question,
-            reply.answers[index].join(", ")
-          ])
-        )
-      }
-    };
-  if (reply.choice === "accept")
-    return {
-      behavior: "allow",
-      updatedInput: input,
-      ...approval2.plan === void 0 ? {} : { updatedPermissions: [{ type: "setMode", mode: "default", destination: "session" }] }
-    };
-  if (reply.choice === "always")
+  // Handles one line of Claude Code's output, and says whether it started the session.
+  receive(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return false;
+    }
+    const init = message.type === "system" && message.subtype === "init";
+    if (init) this.saved = true;
+    else if (message.type === "assistant") {
+      const text3 = (Array.isArray(message.message?.content) ? message.message.content : []).filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n\n");
+      if (!text3) return false;
+      this.messages.push({ id: String(message.uuid ?? randomUUID3()), role: "assistant", text: text3 });
+    } else if (message.type === "control_request" && message.request?.subtype === "can_use_tool") {
+      const id = randomUUID3();
+      const asked = message.request;
+      const request2 = {
+        tool: String(asked.tool_name),
+        input: asked.input ?? {},
+        label: typeof asked.display_name === "string" ? asked.display_name : void 0,
+        description: typeof asked.description === "string" ? asked.description : void 0,
+        suggestions: Array.isArray(asked.permission_suggestions) ? asked.permission_suggestions : void 0
+      };
+      this.approvals.set(id, {
+        control: String(message.request_id),
+        request: request2,
+        approval: ask(id, request2, true)
+      });
+      this.status = "attention";
+    } else if (message.type === "control_cancel_request") {
+      for (const [id, pending] of this.approvals)
+        if (pending.control === message.request_id) this.approvals.delete(id);
+      if (this.status === "attention" && !this.approvals.size) this.status = "working";
+    } else if (message.type === "result") {
+      if (--this.open <= 0) this.turn?.stdin.end();
+    } else if (message.type === "stream_event" && !message.parent_tool_use_id) {
+      const event = message.event;
+      if (event?.type === "content_block_start") this.typing = "";
+      else if (event?.type === "content_block_delta" && event.delta?.type === "text_delta")
+        this.typing += String(event.delta.text ?? "");
+      else return false;
+      this.changed();
+      return false;
+    } else return false;
+    this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.changed();
+    return init;
+  }
+  live(models2) {
     return {
-      behavior: "allow",
-      updatedInput: input,
-      updatedPermissions: remember(request2.suggestions)?.updates ?? []
-    };
-  if (reply.choice === "revise")
-    return { behavior: "deny", message: reply.text?.trim() || "Keep planning." };
-  return {
-    behavior: "deny",
-    message: reply.choice === "skip" ? "The person skipped these questions." : "The person rejected this from their phone."
-  };
-}
-var MAX_SESSIONS2 = 100;
-var MAX_REQUESTS = 1e3;
-var MAX_PROMPT = 4 * 1024 * 1024;
-var SESSION = /^\/sessions\/([\w-]{1,100})(\/prompts)?$/;
-var STATUS = {
-  busy: "working",
-  idle: "idle",
-  shell: "idle",
-  waiting: "attention"
+      id: this.id,
+      cwd: this.cwd,
+      title: this.title,
+      harness: "claude",
+      updatedAt: this.updatedAt,
+      status: this.status,
+      messages: [...this.messages],
+      typing: this.typing,
+      approvals: [...this.approvals.values()].map((pending) => pending.approval),
+      send: (requestId, text3, now) => this.once(requestId, () => this.say(text3, now)),
+      now: true,
+      options: (recorded) => claudeOptions(models2, recorded),
+      configure: (requestId, option2, value2) => this.once(requestId, async () => {
+        this.chosen[option2] = value2;
+        this.apply(option2, value2);
+      }),
+      stop: this.turn ? (requestId) => this.once(requestId, async () => {
+        if (!this.turn) throw new Error("Nothing is running in this Claude Code session");
+        this.interrupt();
+      }) : void 0,
+      approve: this.approvals.size ? (requestId, approvalId, reply) => this.once(requestId, async () => {
+        const pending = this.approvals.get(approvalId);
+        if (!pending || !this.turn)
+          throw new Error("Claude Code approval is no longer pending");
+        this.write({
+          type: "control_response",
+          response: {
+            subtype: "success",
+            request_id: pending.control,
+            response: decide(pending.request, pending.approval, reply)
+          }
+        });
+        this.approvals.delete(approvalId);
+        if (!this.approvals.size) this.status = "working";
+        this.changed();
+      }) : void 0
+    };
+  }
+  end() {
+    this.turn?.kill();
+  }
 };
-async function registrations() {
-  if (process.env.DASHUP_LIVE_DISCOVERY === "0") return [];
-  const directory2 = join5(claudeHome(), "sessions");
-  const names = await readdir2(directory2).catch(() => []);
-  const found = await Promise.all(
-    names.filter((name) => /^\d+\.json$/.test(name)).slice(0, MAX_SESSIONS2).map(async (name) => {
-      try {
-        const value2 = JSON.parse(await readFile2(join5(directory2, name), "utf8"));
-        if (typeof value2.sessionId !== "string" || typeof value2.cwd !== "string") return [];
-        process.kill(value2.pid, 0);
-        const binary2 = await readlink(`/proc/${value2.pid}/exe`).catch(() => "");
-        return [{ ...value2, command: /[\\/]claude(?:\.exe)?$/.test(binary2) ? binary2 : "claude" }];
-      } catch {
-        return [];
-      }
-    })
-  );
-  return found.flat();
-}
-var Claude = class {
-  constructor(changed, socket = join5(dirname4(configPath()), "claude.sock")) {
+var Headless = class {
+  constructor(changed) {
     this.changed = changed;
-    this.socket = socket;
   }
   changed;
-  socket;
-  watcher;
+  sessions = /* @__PURE__ */ new Map();
   notify;
-  server;
-  streams = /* @__PURE__ */ new Map();
-  prompts = /* @__PURE__ */ new Map();
-  requests = /* @__PURE__ */ new Map();
-  async refresh() {
-    this.watch();
-    return (await registrations()).map((session) => {
-      const plugin = this.streams.has(session.sessionId);
-      const models = claudeModels(this.changed, session.command, session.version);
-      const approvals = [...this.prompts.values()].filter((prompt) => prompt.session === session.sessionId).map((prompt) => prompt.approval);
-      return {
-        id: session.sessionId,
-        harness: "claude",
-        cwd: session.cwd,
-        updatedAt: new Date(session.updatedAt ?? 0).toISOString(),
-        status: approvals.length ? "attention" : STATUS[session.status ?? ""] ?? "unknown",
-        messages: [],
-        approvals,
-        approve: approvals.length ? (requestId, approvalId, reply) => this.once(requestId, async () => {
-          const prompt = this.prompts.get(approvalId);
-          if (prompt?.session !== session.sessionId)
-            throw new Error("Claude Code approval is no longer pending");
-          prompt.answer(decide(prompt.request, prompt.approval, reply));
-        }) : void 0,
-        send: plugin ? (requestId, text3, now) => this.once(requestId, () => this.deliver(session.sessionId, now ? { text: text3, now } : { text: text3 })) : void 0,
-        stop: plugin ? (requestId) => this.once(requestId, () => this.deliver(session.sessionId, { now: true })) : void 0,
-        now: plugin,
-        options: (recorded) => claudeOptions(models, recorded),
-        configure: plugin ? (requestId, option2, value2) => this.once(requestId, () => this.deliver(session.sessionId, { text: COMMANDS[option2](value2) })) : void 0
-      };
-    });
-  }
-  // Only the connector serves the plugin; one-off commands such as `dashup doctor` read alone.
-  async listen() {
-    if (this.server || process.env.DASHUP_LIVE_DISCOVERY === "0") return;
-    const server = this.server = createServer2((request2, response) => {
-      const [, id, prompt] = SESSION.exec(request2.url ?? "") ?? [];
-      if (id && prompt && request2.method === "POST") return this.prompt(id, request2, response);
-      if (!id || prompt || request2.method !== "GET") return void response.writeHead(404).end();
-      this.streams.get(id)?.end();
-      this.streams.set(id, response);
-      response.once("close", () => {
-        if (this.streams.get(id) === response) this.streams.delete(id);
-        this.changed();
-      });
-      response.writeHead(200, { "Content-Type": "application/x-ndjson" }).flushHeaders();
+  soon = () => {
+    if (this.notify) return;
+    this.notify = setTimeout(() => {
+      this.notify = void 0;
       this.changed();
-    });
-    await mkdir(dirname4(this.socket), { recursive: true, mode: 448 });
-    await rm(this.socket, { force: true });
-    if (this.server !== server) return;
-    await new Promise((resolve3, reject) => {
-      server.once("error", reject);
-      server.listen(this.socket, resolve3);
-    });
+    }, NOTIFY_MS);
+    this.notify.unref();
+  };
+  // Starts a session in `cwd` with its first message, and resolves with the session's id.
+  async start(cwd, text3) {
+    const title2 = text3.trim().split("\n")[0].slice(0, 80);
+    const session = new Session(randomUUID3(), cwd, title2, this.soon);
+    this.sessions.set(session.id, session);
+    try {
+      await session.say(text3);
+    } catch (error) {
+      this.sessions.delete(session.id);
+      throw error;
+    }
+    return session.id;
   }
-  // Asks the phone what the session's permission request asks the person.
-  prompt(session, request2, response) {
-    const chunks = [];
-    let bytes = 0;
-    request2.on("data", (chunk) => {
-      bytes += chunk.length;
-      if (bytes > MAX_PROMPT) request2.destroy();
-      else chunks.push(chunk);
-    });
-    request2.once("end", () => {
-      let asked;
-      try {
-        asked = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-      } catch {
-      }
-      if (typeof asked?.tool !== "string" || !asked.input || typeof asked.input !== "object")
-        return void response.writeHead(400).end();
-      const id = randomUUID3();
-      const prompted = {
-        tool: asked.tool,
-        input: asked.input,
-        ...Array.isArray(asked.suggestions) ? { suggestions: asked.suggestions } : {}
-      };
-      this.prompts.set(id, {
-        session,
-        request: prompted,
-        approval: ask(id, prompted, false),
-        answer: (decision) => {
-          this.prompts.delete(id);
-          response.end(JSON.stringify(decision));
-          this.changed();
-        }
-      });
-      response.once("close", () => {
-        if (this.prompts.delete(id)) this.changed();
-      });
-      response.writeHead(200, { "Content-Type": "application/json" }).flushHeaders();
-      this.changed();
-    });
+  // Continues a saved session with a message; Claude Code resumes it from its own transcript.
+  async resume(id, cwd, text3) {
+    const known = this.sessions.get(id);
+    const session = known ?? new Session(id, cwd, void 0, this.soon, true);
+    this.sessions.set(id, session);
+    try {
+      await session.say(text3);
+    } catch (error) {
+      if (!known) this.sessions.delete(id);
+      throw error;
+    }
   }
-  deliver(id, delivery) {
-    const stream = this.streams.get(id);
-    if (!stream) return Promise.reject(new Error("Claude Code is not taking messages"));
-    return new Promise((resolve3, reject) => stream.write(`${JSON.stringify(delivery)}
-`, (error) => error ? reject(error) : resolve3()));
+  async refresh() {
+    const models2 = claudeModels(this.changed);
+    return [...this.sessions.values()].map((session) => session.live(models2));
   }
-  // Each request delivers at most once.
-  once(id, action) {
-    const known = this.requests.get(id);
-    if (known) return known;
-    if (this.requests.size >= MAX_REQUESTS)
-      this.requests.delete(this.requests.keys().next().value);
-    const result = action();
-    this.requests.set(id, result);
-    return result;
+  stop() {
+    clearTimeout(this.notify);
+    for (const session of this.sessions.values()) session.end();
   }
-  watch() {
-    if (this.watcher || process.env.DASHUP_LIVE_DISCOVERY === "0") return;
-    try {
-      const watcher = this.watcher = watch2(join5(claudeHome(), "sessions"), () => {
-        if (this.notify) return;
-        this.notify = setTimeout(() => {
-          this.notify = void 0;
-          this.changed();
-        }, 100);
-        this.notify.unref();
-      });
-      watcher.on("error", () => {
-        watcher.close();
-        if (this.watcher === watcher) this.watcher = void 0;
-      });
-    } catch {
+};
+
+// src/harness/codex.ts
+import WebSocket2 from "ws";
+import { homedir as homedir5 } from "node:os";
+import { connect } from "node:net";
+import { promisify as promisify2 } from "node:util";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { execFile as execFile2 } from "node:child_process";
+import { join as join5, isAbsolute as isAbsolute2 } from "node:path";
+import { statSync as statSync2, readFileSync as readFileSync4 } from "node:fs";
+import { stat, readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
+var REQUEST_MS = 4e3;
+var MAX_BYTES = 8 * 1024 * 1024;
+var MAX_SESSIONS2 = 100;
+var MAX_SOCKETS = 32;
+var MAX_PROCESSES = 4096;
+var SOCKET_PARTS = ["app-server-control", "app-server-control.sock"];
+var DECISIONS = [
+  { id: "accept", label: "Allow once" },
+  { id: "decline", label: "Reject" }
+];
+function approval(id, method, params) {
+  const command2 = method === "item/commandExecution/requestApproval";
+  let detail = [
+    command2 && typeof params.command === "string" ? params.command : "",
+    typeof params.cwd === "string" ? `Working directory: ${params.cwd}` : "",
+    typeof params.grantRoot === "string" ? `Write access root: ${params.grantRoot}` : "",
+    typeof params.reason === "string" ? params.reason : ""
+  ].filter(Boolean).join("\n\n");
+  const oversized = Buffer.byteLength(detail) > MAX_PREVIEW;
+  const unavailable = !command2 || params.kind !== void 0 && params.kind !== "command" || typeof params.command !== "string" || !params.command.trim() || oversized;
+  if (oversized) detail = Buffer.from(detail).subarray(0, MAX_PREVIEW).toString("utf8");
+  if (unavailable) detail = [detail, NO_PREVIEW].filter(Boolean).join("\n\n");
+  return {
+    id,
+    title: command2 ? "Allow command?" : "Allow file changes?",
+    detail,
+    choices: DECISIONS.filter((choice) => !unavailable || choice.id === "decline").map((choice) => ({ ...choice }))
+  };
+}
+var codexHome = () => process.env.DASHUP_CODEX_HOME ?? process.env.CODEX_HOME ?? join5(homedir5(), ".codex");
+var catalog;
+function models() {
+  const path = join5(codexHome(), "models_cache.json");
+  try {
+    const { mtimeMs } = statSync2(path);
+    if (catalog?.path !== path || catalog.mtimeMs !== mtimeMs) {
+      const listed = JSON.parse(readFileSync4(path, "utf8"))?.models;
+      catalog = {
+        path,
+        mtimeMs,
+        models: (Array.isArray(listed) ? listed : []).filter(
+          (model) => typeof model?.slug === "string"
+        )
+      };
+    }
+    return catalog.models;
+  } catch {
+    return [];
+  }
+}
+function codexOptions(recorded) {
+  const listed = models();
+  const ran = typeof recorded.model === "string" ? recorded.model : "";
+  const current = listed.find((model) => model.slug === ran);
+  const choices = listed.filter((model) => model.visibility !== "hide").map((model) => ({ value: model.slug, name: model.display_name ?? model.slug }));
+  if (!ran) return [];
+  if (!choices.some((choice) => choice.value === ran))
+    choices.push({ value: ran, name: current?.display_name ?? ran });
+  const effort = typeof recorded.effort === "string" ? recorded.effort : current?.default_reasoning_level;
+  const efforts = [...(current?.supported_reasoning_levels ?? []).map((level) => level.effort)];
+  if (effort && !efforts.includes(effort)) efforts.push(effort);
+  const fast = current?.service_tiers?.find((tier) => tier.id === "priority");
+  return [
+    { id: "model", name: "Model", value: ran, choices },
+    ...effort ? [
+      {
+        id: "effort",
+        name: "Effort",
+        value: effort,
+        choices: efforts.map((value2) => ({ value: value2, name: `${value2} effort` }))
+      }
+    ] : [],
+    ...fast ? [{ id: "fast", name: fast.name ?? "Fast", value: recorded.fast === true }] : []
+  ];
+}
+async function sockets() {
+  const explicit = process.env.DASHUP_CODEX_SOCKET;
+  if (explicit !== void 0) return explicit && isAbsolute2(explicit) ? [explicit] : [];
+  if (process.env.DASHUP_LIVE_DISCOVERY === "0") return [];
+  const homes = /* @__PURE__ */ new Set([codexHome()]);
+  if (process.platform === "linux") {
+    const entries2 = await readdir2("/proc").catch(() => []);
+    for (const pid of entries2.filter((value2) => /^\d+$/.test(value2)).slice(0, MAX_PROCESSES)) {
+      if (homes.size >= MAX_SOCKETS) break;
+      try {
+        const directory2 = `/proc/${pid}`;
+        const owner = await stat(directory2);
+        if (process.getuid && owner.uid !== process.getuid()) continue;
+        const command2 = (await readFile2(join5(directory2, "cmdline"), "utf8")).slice(0, 4096);
+        if (!/(?:^|[\/\0 ])codex(?:[\0 .]|$)/.test(command2)) continue;
+        const environment = await readFile2(join5(directory2, "environ"), "utf8");
+        const home = environment.split("\0").find((value2) => value2.startsWith("CODEX_HOME="))?.slice("CODEX_HOME=".length);
+        if (home && isAbsolute2(home)) homes.add(home);
+      } catch {
+      }
     }
   }
-  stop() {
-    clearTimeout(this.notify);
-    this.watcher?.close();
-    this.watcher = void 0;
-    this.prompts.clear();
-    this.server?.closeAllConnections();
-    this.server?.close();
-    this.server = void 0;
+  return [...homes].map((home) => join5(home, ...SOCKET_PARTS));
+}
+function messages2(thread) {
+  if (!Array.isArray(thread.turns)) return [];
+  return thread.turns.flatMap((turn) => Array.isArray(turn?.items) ? turn.items.flatMap((item) => {
+    if (typeof item?.id !== "string") return [];
+    if (item.type === "userMessage" && Array.isArray(item.content)) {
+      const text3 = item.content.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
+      return text3 ? [{ id: item.id, role: "user", text: text3 }] : [];
+    }
+    if (item.type === "agentMessage" && typeof item.text === "string")
+      return [{ id: item.id, role: "assistant", text: item.text }];
+    if (item.type === "commandExecution" && typeof item.command === "string")
+      return [
+        {
+          id: item.id,
+          role: "tool",
+          text: [item.command, item.aggregatedOutput].filter((value2) => typeof value2 === "string").join("\n\n")
+        }
+      ];
+    return [];
+  }) : []);
+}
+function status(thread) {
+  if (thread.status?.type === "idle") return "idle";
+  if (thread.status?.type === "active") {
+    return thread.status.activeFlags?.some(
+      (flag) => flag === "waitingOnApproval" || flag === "waitingOnUserInput"
+    ) ? "attention" : "working";
   }
-};
-
-// src/harness/headless.ts
-var MAX_REQUESTS2 = 1e3;
-var NOTIFY_MS = 100;
-var SWITCHES = { fast: "fastMode", ultracode: "ultracode" };
-var Session = class {
-  // A resumed session is `saved` and keeps the title its history gives.
-  constructor(id, cwd, title2, changed, saved = false) {
-    this.id = id;
-    this.cwd = cwd;
-    this.title = title2;
+  return "unknown";
+}
+var Client = class {
+  constructor(path, changed) {
+    this.path = path;
     this.changed = changed;
-    this.saved = saved;
   }
-  id;
-  cwd;
-  title;
+  path;
   changed;
-  saved;
-  messages = [];
-  status = "idle";
-  updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  turn;
-  // Messages written to this turn's process that Claude Code has not finished answering.
-  open = 0;
-  // The text Claude Code is writing, as far as it has streamed.
-  typing = "";
+  socket;
+  connecting;
+  stopped = false;
+  sequence = 0;
+  controls = false;
+  notify;
+  pending = /* @__PURE__ */ new Map();
   approvals = /* @__PURE__ */ new Map();
   requests = /* @__PURE__ */ new Map();
-  // What the person chose for this session, applied to each turn as it starts.
-  chosen = {};
-  write(value2) {
-    this.turn?.stdin.write(`${JSON.stringify(value2)}
-`);
-  }
-  interrupt() {
-    this.write({
-      type: "control_request",
-      request_id: randomUUID4(),
-      request: { subtype: "interrupt" }
-    });
-  }
-  apply(option2, value2) {
-    this.write({
-      type: "control_request",
-      request_id: randomUUID4(),
-      request: option2 === "model" ? { subtype: "set_model", model: value2 } : { subtype: "apply_flag_settings", settings: { [SWITCHES[option2]]: value2 } }
-    });
-  }
-  once(id, action) {
-    const known = this.requests.get(id);
-    if (known) return known;
-    if (this.requests.size >= MAX_REQUESTS2)
-      throw new Error("Claude Code command history is full; restart Dashup before sending");
-    const result = action();
-    this.requests.set(id, result);
-    return result;
-  }
-  // Resolves once Claude Code takes the message, or says why it could not start. `now` stops the
-  // turn under way, so Claude Code takes the message at once.
-  say(text3, now = false) {
-    this.messages.push({ id: randomUUID4(), role: "user", text: text3 });
-    this.typing = "";
-    this.status = "working";
-    this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const message = { type: "user", message: { role: "user", content: text3 } };
-    if (this.turn) {
-      if (now) this.interrupt();
-      this.open++;
-      this.write(message);
-      this.changed();
-      return Promise.resolve();
-    }
-    const turn = this.turn = spawn3(
-      "claude",
-      [
-        "-p",
-        "--input-format",
-        "stream-json",
-        "--output-format",
-        "stream-json",
-        "--verbose",
-        "--include-partial-messages",
-        "--permission-prompt-tool",
-        "stdio",
-        ...this.saved ? ["--resume", this.id] : ["--session-id", this.id]
-      ],
-      { cwd: this.cwd, stdio: "pipe", shell: process.platform === "win32" }
-    );
-    this.open = 1;
-    let errors = "";
-    turn.stdin.on("error", () => {
-    });
-    turn.stderr.on("data", (chunk) => {
-      errors = (errors + String(chunk)).slice(-2e3);
-    });
-    const started = new Promise((resolve3, reject) => {
-      createInterface3({ input: turn.stdout }).on("line", (line) => {
-        if (this.receive(line)) resolve3();
+  // The reply each thread is writing, as far as it has streamed, and the item it belongs to.
+  typing = /* @__PURE__ */ new Map();
+  // What the person chose for each thread, which its next turn takes and keeps.
+  chosen = /* @__PURE__ */ new Map();
+  async connect() {
+    if (this.socket?.readyState === WebSocket2.OPEN) return;
+    if (this.connecting) return this.connecting;
+    this.connecting = (async () => {
+      const file = await stat(this.path);
+      if (!file.isSocket() || process.getuid && file.uid !== process.getuid())
+        throw new Error("Codex control socket is not owned by this user");
+      const socket = this.socket = new WebSocket2("ws://localhost/rpc", {
+        createConnection: () => connect(this.path),
+        maxPayload: MAX_BYTES,
+        handshakeTimeout: REQUEST_MS
       });
-      const end = (reason) => {
-        reject(new Error(reason));
-        if (this.turn !== turn) return;
-        this.turn = void 0;
-        this.open = 0;
+      socket.on("error", () => {
+      });
+      socket.on("message", (bytes) => {
+        let message;
+        try {
+          message = JSON.parse(bytes.toString());
+        } catch {
+          return;
+        }
+        if (typeof message.id === "number" && !message.method) {
+          const pending = this.pending.get(message.id);
+          if (!pending) return;
+          this.pending.delete(message.id);
+          clearTimeout(pending.timer);
+          if (message.error)
+            pending.reject(
+              new Error(`Codex native request failed (${String(message.error.code ?? "unknown")})`)
+            );
+          else pending.resolve(message.result ?? {});
+          return;
+        }
+        if (typeof message.method !== "string") return;
+        const params = message.params;
+        if (message.method === "item/agentMessage/delta" && typeof params?.threadId === "string" && typeof params.delta === "string") {
+          const known = this.typing.get(params.threadId);
+          this.typing.set(params.threadId, {
+            item: params.itemId,
+            text: (known && known.item === params.itemId ? known.text : "") + params.delta
+          });
+        }
+        if (message.method === "serverRequest/resolved") {
+          for (const [id, pending] of this.approvals)
+            if (pending.requestId === message.params?.requestId) this.approvals.delete(id);
+        }
+        if ((message.method === "item/commandExecution/requestApproval" || message.method === "item/fileChange/requestApproval") && (typeof message.id === "string" || typeof message.id === "number") && typeof message.params?.threadId === "string") {
+          const id = randomUUID4();
+          this.approvals.set(id, {
+            requestId: message.id,
+            threadId: params.threadId,
+            approval: approval(id, message.method, params)
+          });
+        }
+        if (/^(thread|turn|item|serverRequest)\//.test(message.method) && !this.notify) {
+          this.notify = setTimeout(() => {
+            this.notify = void 0;
+            this.changed();
+          }, 100);
+          this.notify.unref();
+        }
+      });
+      socket.on("close", () => {
+        if (this.socket !== socket) return;
+        this.socket = void 0;
+        this.controls = false;
         this.approvals.clear();
-        this.status = "idle";
-        this.changed();
-      };
-      turn.once("error", () => end("Claude Code is not installed on this computer"));
-      turn.once("exit", () => end(errors.trim() || "Claude Code stopped before starting"));
-    });
-    for (const [option2, value2] of Object.entries(this.chosen)) this.apply(option2, value2);
-    this.write(message);
-    this.changed();
-    return started;
-  }
-  // Handles one line of Claude Code's output, and says whether it started the session.
-  receive(line) {
-    let message;
+        for (const pending of this.pending.values()) {
+          clearTimeout(pending.timer);
+          pending.reject(new Error("Codex control socket disconnected"));
+        }
+        this.pending.clear();
+        if (!this.stopped) this.changed();
+      });
+      await new Promise((resolve3, reject) => {
+        socket.once("open", resolve3);
+        socket.once("error", reject);
+        socket.once("close", () => reject(new Error("Codex control socket closed before initialization")));
+      });
+      const initialized = await this.call("initialize", {
+        clientInfo: { name: "dashup", title: "Dashup", version },
+        capabilities: { experimentalApi: false, requestAttestation: false }
+      });
+      socket.send(JSON.stringify({ method: "initialized", params: {} }));
+      const version2 = typeof initialized.userAgent === "string" ? /\b0\.(\d+)\.\d+\b/.exec(initialized.userAgent) : null;
+      this.controls = !!version2 && Number(version2[1]) >= 140;
+    })();
     try {
-      message = JSON.parse(line);
-    } catch {
-      return false;
+      await this.connecting;
+    } catch (error) {
+      this.socket?.terminate();
+      throw error;
+    } finally {
+      this.connecting = void 0;
     }
-    const init = message.type === "system" && message.subtype === "init";
-    if (init) this.saved = true;
-    else if (message.type === "assistant") {
-      const text3 = (Array.isArray(message.message?.content) ? message.message.content : []).filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n\n");
-      if (!text3) return false;
-      this.messages.push({ id: String(message.uuid ?? randomUUID4()), role: "assistant", text: text3 });
-    } else if (message.type === "control_request" && message.request?.subtype === "can_use_tool") {
-      const id = randomUUID4();
-      const asked = message.request;
-      const request2 = {
-        tool: String(asked.tool_name),
-        input: asked.input ?? {},
-        label: typeof asked.display_name === "string" ? asked.display_name : void 0,
-        description: typeof asked.description === "string" ? asked.description : void 0,
-        suggestions: Array.isArray(asked.permission_suggestions) ? asked.permission_suggestions : void 0
-      };
-      this.approvals.set(id, {
-        control: String(message.request_id),
-        request: request2,
-        approval: ask(id, request2, true)
+  }
+  call(method, params) {
+    const socket = this.socket;
+    if (this.stopped || socket?.readyState !== WebSocket2.OPEN)
+      return Promise.reject(new Error("Codex control socket is disconnected"));
+    if (this.pending.size >= 32) return Promise.reject(new Error("Codex request limit reached"));
+    const id = ++this.sequence;
+    return new Promise((resolve3, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("Codex native request timed out"));
+      }, REQUEST_MS);
+      timer.unref();
+      this.pending.set(id, { resolve: resolve3, reject, timer });
+      socket.send(JSON.stringify({ id, method, params }), (error) => {
+        if (error) {
+          clearTimeout(timer);
+          this.pending.delete(id);
+          reject(new Error("Codex native request could not be sent"));
+        }
       });
-      this.status = "attention";
-    } else if (message.type === "control_cancel_request") {
-      for (const [id, pending] of this.approvals)
-        if (pending.control === message.request_id) this.approvals.delete(id);
-      if (this.status === "attention" && !this.approvals.size) this.status = "working";
-    } else if (message.type === "result") {
-      if (--this.open <= 0) this.turn?.stdin.end();
-    } else if (message.type === "stream_event" && !message.parent_tool_use_id) {
-      const event = message.event;
-      if (event?.type === "content_block_start") this.typing = "";
-      else if (event?.type === "content_block_delta" && event.delta?.type === "text_delta")
-        this.typing += String(event.delta.text ?? "");
-      else return false;
-      this.changed();
-      return false;
-    } else return false;
-    this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    });
+  }
+  once(id, action) {
+    const known = this.requests.get(id);
+    if (known) return known;
+    if (this.requests.size >= 1e3)
+      throw new Error("Codex command history is full; reconnect before sending");
+    const result = action();
+    this.requests.set(id, result);
+    return result;
+  }
+  // Starts a thread in `cwd` with Codex's own settings, or loads a saved one, then a turn.
+  async start(cwd, text3, saved) {
+    await this.connect();
+    if (!this.controls) throw new Error("Update Codex to start threads from Dashup");
+    const id = saved ? (await this.call("thread/resume", { threadId: saved, excludeTurns: true })).thread?.id : (await this.call("thread/start", { cwd })).thread?.id;
+    if (typeof id !== "string") throw new Error("Codex did not open the thread");
+    await this.call("turn/start", { threadId: id, input: [{ type: "text", text: text3, text_elements: [] }] });
     this.changed();
-    return init;
+    return id;
   }
-  live(models) {
-    return {
-      id: this.id,
-      cwd: this.cwd,
-      title: this.title,
-      harness: "claude",
-      updatedAt: this.updatedAt,
-      status: this.status,
-      messages: [...this.messages],
-      typing: this.typing,
-      approvals: [...this.approvals.values()].map((pending) => pending.approval),
-      send: (requestId, text3, now) => this.once(requestId, () => this.say(text3, now)),
-      now: true,
-      options: (recorded) => claudeOptions(models, recorded),
-      configure: (requestId, option2, value2) => this.once(requestId, async () => {
-        this.chosen[option2] = value2;
-        this.apply(option2, value2);
-      }),
-      stop: this.turn ? (requestId) => this.once(requestId, async () => {
-        if (!this.turn) throw new Error("Nothing is running in this Claude Code session");
-        this.interrupt();
-      }) : void 0,
-      approve: this.approvals.size ? (requestId, approvalId, reply) => this.once(requestId, async () => {
-        const pending = this.approvals.get(approvalId);
-        if (!pending || !this.turn)
-          throw new Error("Claude Code approval is no longer pending");
-        this.write({
-          type: "control_response",
-          response: {
-            subtype: "success",
-            request_id: pending.control,
-            response: decide(pending.request, pending.approval, reply)
-          }
+  async read() {
+    await this.connect();
+    const loaded = await this.call("thread/loaded/list", { limit: MAX_SESSIONS2 });
+    if (!Array.isArray(loaded.data)) return [];
+    const sessions = [];
+    for (const id of loaded.data.slice(0, MAX_SESSIONS2)) {
+      if (typeof id !== "string") continue;
+      try {
+        const read = await this.call("thread/read", { threadId: id, includeTurns: true });
+        const thread = read.thread;
+        if (thread?.id !== id || typeof thread.cwd !== "string" || !thread.cwd) continue;
+        const approvals = [...this.approvals.values()].filter((value2) => value2.threadId === id).map((value2) => value2.approval);
+        sessions.push({
+          id,
+          harness: "codex",
+          cwd: thread.cwd,
+          title: typeof thread.name === "string" && thread.name ? thread.name : typeof thread.preview === "string" && thread.preview ? thread.preview : "Codex thread",
+          updatedAt: new Date(Number(thread.updatedAt ?? 0) * 1e3).toISOString(),
+          status: approvals.length ? "attention" : status(thread),
+          messages: messages2(thread),
+          typing: this.typing.get(id)?.text,
+          approvals,
+          // An interrupt for a finished turn is never answered, so the active turn is read first.
+          stop: this.controls ? (requestId) => this.once(requestId, async () => {
+            const native = (await this.call("thread/read", { threadId: id, includeTurns: true })).thread;
+            const turn = native?.status?.type === "active" && Array.isArray(native.turns) ? native.turns.at(-1) : void 0;
+            if (turn?.status !== "inProgress" || typeof turn.id !== "string")
+              throw new Error("Nothing is running in this Codex thread");
+            await this.call("turn/interrupt", { threadId: id, turnId: turn.id });
+            this.changed();
+          }) : void 0,
+          send: this.controls && thread.status?.type === "idle" ? (requestId, text3) => this.once(requestId, async () => {
+            if (!text3.trim() || Buffer.byteLength(text3) > MAX_BYTES / 2)
+              throw new Error("Message is empty or too large");
+            const current = await this.call("thread/loaded/list", { limit: MAX_SESSIONS2 });
+            if (!Array.isArray(current.data) || !current.data.includes(id))
+              throw new Error("Codex thread is no longer loaded");
+            const native = (await this.call("thread/read", { threadId: id, includeTurns: false })).thread;
+            if (native?.id !== id || native.status?.type !== "idle")
+              throw new Error("Codex thread is busy or unavailable");
+            const chosen = this.chosen.get(id) ?? {};
+            await this.call("turn/start", {
+              threadId: id,
+              clientUserMessageId: requestId,
+              input: [{ type: "text", text: text3, text_elements: [] }],
+              ..."model" in chosen ? { model: chosen.model } : {},
+              ..."effort" in chosen ? { effort: chosen.effort } : {},
+              ..."fast" in chosen ? { serviceTier: chosen.fast ? "priority" : null } : {}
+            });
+            this.changed();
+          }) : void 0,
+          options: codexOptions,
+          configure: this.controls ? (requestId, option2, value2) => this.once(requestId, async () => {
+            this.chosen.set(id, { ...this.chosen.get(id), [option2]: value2 });
+          }) : void 0,
+          approve: approvals.length ? (requestId, approvalId, reply) => this.once(requestId, async () => {
+            const approval2 = this.approvals.get(approvalId);
+            const choice = "choice" in reply ? reply.choice : void 0;
+            const socket = this.socket;
+            if (!approval2 || approval2.threadId !== id || !approval2.approval.choices.some((value2) => value2.id === choice) || socket?.readyState !== WebSocket2.OPEN)
+              throw new Error("Codex approval is no longer pending");
+            await new Promise((resolve3, reject) => socket.send(
+              JSON.stringify({ id: approval2.requestId, result: { decision: choice } }),
+              (error) => error ? reject(new Error("Codex approval could not be sent")) : resolve3()
+            ));
+            this.approvals.delete(approvalId);
+            this.changed();
+          }) : void 0
         });
-        this.approvals.delete(approvalId);
-        if (!this.approvals.size) this.status = "working";
-        this.changed();
-      }) : void 0
-    };
+      } catch {
+      }
+    }
+    return sessions;
   }
-  end() {
-    this.turn?.kill();
+  stop() {
+    this.stopped = true;
+    clearTimeout(this.notify);
+    this.socket?.terminate();
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Codex observation stopped"));
+    }
+    this.pending.clear();
+    this.approvals.clear();
   }
 };
-var Headless = class {
+var Codex = class {
   constructor(changed) {
     this.changed = changed;
   }
   changed;
-  sessions = /* @__PURE__ */ new Map();
-  notify;
-  soon = () => {
-    if (this.notify) return;
-    this.notify = setTimeout(() => {
-      this.notify = void 0;
-      this.changed();
-    }, NOTIFY_MS);
-    this.notify.unref();
-  };
-  // Starts a session in `cwd` with its first message, and resolves with the session's id.
-  async start(cwd, text3) {
-    const title2 = text3.trim().split("\n")[0].slice(0, 80);
-    const session = new Session(randomUUID4(), cwd, title2, this.soon);
-    this.sessions.set(session.id, session);
-    try {
-      await session.say(text3);
-    } catch (error) {
-      this.sessions.delete(session.id);
-      throw error;
+  clients = /* @__PURE__ */ new Map();
+  // Control sockets of daemons this connector started, which discovery may not look for.
+  started = /* @__PURE__ */ new Set();
+  // Codex's own daemon runs the threads Dashup starts or resumes, so they outlive this connector.
+  async start(cwd, text3, saved) {
+    const path = process.env.DASHUP_CODEX_SOCKET || join5(codexHome(), ...SOCKET_PARTS);
+    await promisify2(execFile2)("codex", ["app-server", "daemon", "start"], {
+      timeout: 6e4,
+      shell: process.platform === "win32"
+    });
+    this.started.add(path);
+    let client = this.clients.get(path);
+    if (!client) {
+      client = new Client(path, this.changed);
+      this.clients.set(path, client);
     }
-    return session.id;
+    return client.start(cwd, text3, saved);
   }
-  // Continues a saved session with a message; Claude Code resumes it from its own transcript.
   async resume(id, cwd, text3) {
-    const known = this.sessions.get(id);
-    const session = known ?? new Session(id, cwd, void 0, this.soon, true);
-    this.sessions.set(id, session);
-    try {
-      await session.say(text3);
-    } catch (error) {
-      if (!known) this.sessions.delete(id);
-      throw error;
-    }
+    await this.start(cwd, text3, id);
   }
   async refresh() {
-    const models = claudeModels(this.changed);
-    return [...this.sessions.values()].map((session) => session.live(models));
+    const paths = /* @__PURE__ */ new Set([...await sockets(), ...this.started]);
+    for (const [path, client] of this.clients)
+      if (!paths.has(path)) {
+        client.stop();
+        this.clients.delete(path);
+      }
+    const results = await Promise.allSettled(
+      [...paths].map(async (path) => {
+        let client = this.clients.get(path);
+        if (!client) {
+          client = new Client(path, this.changed);
+          this.clients.set(path, client);
+        }
+        return client.read();
+      })
+    );
+    return results.flatMap((result) => result.status === "fulfilled" ? result.value : []);
   }
   stop() {
-    clearTimeout(this.notify);
-    for (const session of this.sessions.values()) session.end();
+    for (const client of this.clients.values()) client.stop();
+    this.clients.clear();
   }
 };
 
@@ -17847,14 +17954,14 @@ var Host = class {
   }
   async read() {
     await this.connect();
-    const catalog = await this.client.request("listSessions", {
+    const catalog2 = await this.client.request("listSessions", {
       channel: ROOT_CHANNEL,
       limit: MAX_SESSIONS3
     });
-    if (!Array.isArray(catalog.items)) return [];
+    if (!Array.isArray(catalog2.items)) return [];
     const result = [];
     const active = /* @__PURE__ */ new Set();
-    for (const summary of catalog.items.slice(0, MAX_SESSIONS3)) {
+    for (const summary of catalog2.items.slice(0, MAX_SESSIONS3)) {
       try {
         const session = await this.subscribe(summary.resource);
         if (!session || session.lifecycle !== "ready" || !Array.isArray(session.chats)) continue;
@@ -18571,6 +18678,12 @@ var LiveHarnesses = class {
     });
     return this.refreshing;
   }
+  // What a saved session last ran with, as its agent names its options.
+  recorded(harness, settings) {
+    const changed = () => this.changed();
+    if (harness === "claude") return claudeOptions(claudeModels(changed), settings);
+    return harness === "codex" ? codexOptions(settings) : [];
+  }
   // The agents whose own command runs on this computer. Claude Code is asked its models again.
   async agents() {
     const harnesses = ["claude", "codex", "opencode"];
@@ -18636,7 +18749,7 @@ import { randomUUID as randomUUID6 } from "node:crypto";
 import { spawn as spawn5 } from "node:child_process";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 import { join as join8, dirname as dirname6, basename as basename4 } from "node:path";
-import { statSync as statSync2, existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync4, readlinkSync, realpathSync as realpathSync2 } from "node:fs";
+import { statSync as statSync3, existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, readlinkSync, realpathSync as realpathSync2 } from "node:fs";
 var CODEX_VERSION = "0.160.1";
 var REQUEST_MS4 = 1e4;
 var MAX_BYTES4 = 1024 * 1024;
@@ -18645,7 +18758,7 @@ var MAX_FILES = 4096;
 var THREAD_ID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
 function identity(path) {
   const canonical2 = realpathSync2.native(path);
-  const file = statSync2(canonical2);
+  const file = statSync3(canonical2);
   if (!file.isFile() || process.getuid && file.uid !== process.getuid())
     throw new Error("Native queue files are not owned by this user");
   return { path: canonical2, device: file.dev, inode: file.ino };
@@ -18658,17 +18771,17 @@ function packageVersion(executable) {
   for (let depth = 0; depth < 8; depth++, directory2 = dirname6(directory2)) {
     const path = join8(directory2, "package.json");
     if (!existsSync4(path)) continue;
-    const value2 = JSON.parse(readFileSync4(path, "utf8"));
+    const value2 = JSON.parse(readFileSync5(path, "utf8"));
     if (value2.name?.startsWith("@openai/codex-")) return value2.version;
   }
   return void 0;
 }
 function processOwners(pid) {
   const root = `/proc/${pid}`;
-  if (process.getuid && statSync2(root).uid !== process.getuid()) return [];
+  if (process.getuid && statSync3(root).uid !== process.getuid()) return [];
   const executable = realpathSync2.native(join8(root, "exe"));
   if (basename4(executable) !== "codex" || packageVersion(executable) !== CODEX_VERSION) return [];
-  const status2 = readFileSync4(join8(root, "stat"), "utf8");
+  const status2 = readFileSync5(join8(root, "stat"), "utf8");
   const start2 = status2.slice(status2.lastIndexOf(")") + 2).split(" ")[19];
   if (!start2 || !/^\d+$/.test(start2)) return [];
   const fds = readdirSync3(join8(root, "fd")).slice(0, MAX_FILES);
@@ -18684,10 +18797,10 @@ function processOwners(pid) {
     const thread = basename4(path, ".lock");
     if (!THREAD_ID.test(thread)) return [];
     try {
-      const lock = readFileSync4(join8(root, "fdinfo", fd), "utf8");
+      const lock = readFileSync5(join8(root, "fdinfo", fd), "utf8");
       if (!/FLOCK\s+ADVISORY\s+WRITE/.test(lock)) return [];
       const home = realpathSync2.native(dirname6(dirname6(path)));
-      const directory2 = statSync2(home);
+      const directory2 = statSync3(home);
       if (process.getuid && directory2.uid !== process.getuid()) return [];
       const queue = identity(join8(home, "queue_1.sqlite"));
       if (!files2.some((file) => {
@@ -18755,7 +18868,7 @@ function validateOwner(owner) {
     throw new Error("The original native conversation owner is no longer available");
 }
 function validateEvidence(owner) {
-  if (realpathSync2.native(owner.home) !== owner.home || process.getuid && statSync2(owner.home).uid !== process.getuid() || !sameFile(identity(owner.queue.path), owner.queue) || !sameFile(identity(owner.rollout.path), owner.rollout))
+  if (realpathSync2.native(owner.home) !== owner.home || process.getuid && statSync3(owner.home).uid !== process.getuid() || !sameFile(identity(owner.queue.path), owner.queue) || !sameFile(identity(owner.rollout.path), owner.rollout))
     throw new Error("The original native history storage changed");
   const path = join8(owner.home, "thread_history_1.sqlite");
   if (existsSync4(path) && identity(path).path !== path)
@@ -19293,7 +19406,7 @@ var Connector = class {
       const started = threads.filter((thread) => !thread.parent);
       this.listedProjects.set(project.id, {
         ...project,
-        active: started.reduce((newest, thread) => thread.updatedAt > newest ? thread.updatedAt : newest, ""),
+        active: started.reduce((newest2, thread) => thread.updatedAt > newest2 ? thread.updatedAt : newest2, ""),
         started: started.length
       });
     }
@@ -19674,11 +19787,22 @@ var Connector = class {
     };
   }
   thread(pair, project, thread, history) {
+    const state = this.threadState(project, thread);
     return this.send(pair, {
-      ...this.threadState(project, thread),
+      ...state,
+      thread: this.recorded(state.thread),
       ...history ? { history } : {}
     });
   }
+  // A thread no live session holds shows what its record says it last ran with, without the
+  // choices only a live session takes. Only its own state carries them: a project's snapshot
+  // holds every thread.
+  recorded(thread) {
+    const settings = thread.options || !thread.agent ? void 0 : this.discovery.locations.get(thread.id)?.history?.settings?.();
+    if (!settings) return thread;
+    const options = this.harnesses.recorded(thread.agent.harness, settings).map((option2) => option2.choices ? { ...option2, choices: option2.choices.filter((choice) => choice.value === option2.value) } : option2);
+    return options.length ? { ...thread, options } : thread;
+  }
   async command(pair, command2) {
     if (command2.action.kind === "projects.refresh") {
       await this.findAgents();