@dashup/connector 0.1.15 → 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;
@@ -3802,7 +3802,7 @@ function bridgeAcp(socket, onUpdate) {
     if (session && direction === "agent" && message.method === methods.client.session.requestPermission) {
       const tool = message.params.toolCall ?? {};
       const diff = (tool.content ?? []).find((part) => part.type === "diff");
-      const approval3 = {
+      const approval2 = {
         id: randomUUID(),
         title: String(message.params.title ?? tool.title ?? "Agent needs approval"),
         detail: String(message.params.description ?? ""),
@@ -3820,10 +3820,10 @@ ${String(diff.newText).split("\n").map((line) => "+" + line).join("\n")}`
           }
         } : {}
       };
-      session.approvals.set(String(message.id), approval3);
+      session.approvals.set(String(message.id), approval2);
       permissions.set(String(message.id), session);
       session.status = "attention";
-      publish(session, approval3);
+      publish(session, approval2);
     }
     if (direction === "editor" && !message.method) {
       const pending = permissions.get(String(message.id));
@@ -4048,7 +4048,7 @@ import * as ui from "@clack/prompts";
 import { z } from "zod";
 
 // package.json
-var version = "0.1.15";
+var version = "0.1.17";
 
 // src/pair.ts
 var Invitation = z.object({
@@ -4215,6 +4215,24 @@ var attached = (id, mime, data, name) => ({
 });
 var MAX_PREVIEW = 64 * 1024;
 var NO_PREVIEW = "Review the full request on your computer before approving.";
+function questionApproval(id, items, multiple) {
+  const asked = items.map((item) => ({
+    ...typeof item?.header === "string" ? { header: item.header } : {},
+    question: String(item?.question ?? ""),
+    options: (Array.isArray(item?.options) ? item.options : []).filter((option2) => typeof option2?.label === "string").map((option2) => ({
+      label: String(option2.label),
+      ...typeof option2.description === "string" ? { description: option2.description } : {}
+    })),
+    ...multiple(item) ? { multiple: true } : {}
+  }));
+  return {
+    id,
+    title: asked.length === 1 ? asked[0].question : `${asked.length} questions`,
+    detail: "",
+    choices: [{ id: "skip", label: "Skip" }],
+    questions: asked
+  };
+}
 
 // src/harness/history.ts
 var SAMPLE_BYTES = 128 * 1024;
@@ -4222,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;
 }
@@ -4288,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);
@@ -4544,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"))) {
@@ -4614,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();
@@ -4706,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}`);
@@ -4882,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,
@@ -4890,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")],
@@ -13246,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();
@@ -16433,720 +16502,460 @@ 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");
+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) ?? [];
+}
+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 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 {
+      }
+    });
+    child.stdin.write(
+      `${JSON.stringify({ type: "control_request", request_id: "models", request: { subtype: "initialize" } })}
+`
+    );
+  });
+}
+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 }] : []
+  ];
+}
+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 {
+  }
+  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: command2 ? "Allow command?" : "Allow file changes?",
-    detail,
-    choices: DECISIONS.filter((choice) => !unavailable || choice.id === "decline").map((choice) => ({ ...choice }))
+    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" }
+    ]
   };
 }
-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] : [];
+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 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;
+  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 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 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 [...homes].map((home) => join4(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 [];
-  }) : []);
+    })
+  );
+  return found.flat();
 }
-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";
+var Claude = class {
+  constructor(changed, socket = join4(dirname4(configPath()), "claude.sock")) {
+    this.changed = changed;
+    this.socket = socket;
   }
-  return "unknown";
-}
-var Client = class {
-  constructor(path, changed) {
-    this.path = path;
-    this.changed = changed;
-  }
-  path;
   changed;
   socket;
-  connecting;
-  stopped = false;
-  sequence = 0;
-  controls = false;
+  watcher;
   notify;
-  pending = /* @__PURE__ */ new Map();
-  approvals = /* @__PURE__ */ new Map();
+  server;
+  streams = /* @__PURE__ */ new Map();
+  prompts = /* @__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 }
+  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();
       });
-      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;
-    }
+      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);
+    });
   }
-  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"));
+  // 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 = 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 >= 1e3)
-      throw new Error("Codex command history is full; reconnect before sending");
+    if (this.requests.size >= MAX_REQUESTS)
+      this.requests.delete(this.requests.keys().next().value);
     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;
-      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, choice) => this.once(requestId, async () => {
-            const approval3 = this.approvals.get(approvalId);
-            const socket = this.socket;
-            if (!approval3 || approval3.threadId !== id || !approval3.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: approval3.requestId, result: { decision: choice } }),
-              (error) => error ? reject(new Error("Codex approval could not be sent")) : resolve3()
-            ));
-            this.approvals.delete(approvalId);
-            this.changed();
-          }) : void 0
-        });
-      } catch {
-      }
-    }
-    return sessions;
+  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 {
+    }
   }
   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 Codex = class {
-  constructor(changed) {
-    this.changed = changed;
-  }
-  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);
-  }
-  async resume(id, cwd, text3) {
-    await this.start(cwd, text3, id);
-  }
-  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 : []);
-  }
-  stop() {
-    for (const client of this.clients.values()) client.stop();
-    this.clients.clear();
+    this.watcher?.close();
+    this.watcher = void 0;
+    this.prompts.clear();
+    this.server?.closeAllConnections();
+    this.server?.close();
+    this.server = void 0;
   }
 };
 
 // src/harness/headless.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { readFileSync as readFileSync3 } from "node:fs";
-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 { dirname as dirname4, join as join5 } from "node:path";
-import { spawn as spawn2 } from "node:child_process";
-import { createInterface as createInterface2 } from "node:readline";
-import { watch as watch2 } 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" }
-    );
-    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 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 {
-      }
-    });
-    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 MAX_SESSIONS2 = 100;
-var MAX_REQUESTS = 1e3;
-var SESSION = /^\/sessions\/([\w-]{1,100})$/;
-var STATUS = {
-  busy: "working",
-  idle: "idle",
-  shell: "idle",
-  waiting: "attention"
-};
-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 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.socket = socket;
+    this.saved = saved;
   }
+  id;
+  cwd;
+  title;
   changed;
-  socket;
-  watcher;
-  notify;
-  server;
-  streams = /* @__PURE__ */ new Map();
+  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();
-  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);
-      return {
-        id: session.sessionId,
-        harness: "claude",
-        cwd: session.cwd,
-        updatedAt: new Date(session.updatedAt ?? 0).toISOString(),
-        status: STATUS[session.status ?? ""] ?? "unknown",
-        messages: [],
-        approvals: [],
-        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
-      };
-    });
+  // What the person chose for this session, applied to each turn as it starts.
+  chosen = {};
+  write(value2) {
+    this.turn?.stdin.write(`${JSON.stringify(value2)}
+`);
   }
-  // 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 = request2.method === "GET" ? SESSION.exec(request2.url ?? "")?.[1] : void 0;
-      if (!id) 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);
+  interrupt() {
+    this.write({
+      type: "control_request",
+      request_id: randomUUID3(),
+      request: { subtype: "interrupt" }
     });
   }
-  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()));
+  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 } }
+    });
   }
-  // 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(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 {
-    }
-  }
-  stop() {
-    clearTimeout(this.notify);
-    this.watcher?.close();
-    this.watcher = void 0;
-    this.server?.closeAllConnections();
-    this.server?.close();
-    this.server = void 0;
-  }
-};
-
-// src/harness/headless.ts
-var CHOICES = [
-  { id: "accept", label: "Allow once" },
-  { id: "decline", label: "Reject" }
-];
-var EDITS = /* @__PURE__ */ new Set(["Edit", "MultiEdit", "NotebookEdit", "Write"]);
-var MAX_REQUESTS2 = 1e3;
-var NOTIFY_MS = 100;
-var SWITCHES = { fast: "fastMode", ultracode: "ultracode" };
-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 {
-  }
-  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 approval2(id, request2) {
-  const input = request2.input ?? {};
-  const tool = String(request2.display_name ?? request2.tool_name ?? "a tool");
-  const diff = change(request2.tool_name, input);
-  let detail = [
-    typeof request2.description === "string" ? request2.description : "",
-    typeof input.command === "string" ? input.command : diff ? "" : JSON.stringify(input, null, 2)
-  ].filter(Boolean).join("\n\n");
-  if (Buffer.byteLength(detail) > MAX_PREVIEW)
-    detail = Buffer.from(detail).subarray(0, MAX_PREVIEW).toString("utf8");
-  return {
-    id,
-    title: request2.tool_name === "Bash" ? "Allow command?" : EDITS.has(request2.tool_name) ? "Allow file changes?" : `Allow ${tool}?`,
-    detail,
-    ...diff ? { change: diff } : {},
-    choices: CHOICES.map((choice) => ({ ...choice }))
-  };
-}
-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;
-  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)}
-`);
-  }
-  interrupt() {
-    this.write({
-      type: "control_request",
-      request_id: randomUUID3(),
-      request: { subtype: "interrupt" }
-    });
-  }
-  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 } }
-    });
-  }
-  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");
+    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;
@@ -17214,130 +17023,575 @@ var Session = class {
   receive(line) {
     let message;
     try {
-      message = JSON.parse(line);
-    } catch {
-      return false;
+      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 {
+      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();
+  }
+};
+var Headless = 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(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;
+  }
+  // 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;
+    }
+  }
+  async refresh() {
+    const models2 = claudeModels(this.changed);
+    return [...this.sessions.values()].map((session) => session.live(models2));
+  }
+  stop() {
+    clearTimeout(this.notify);
+    for (const session of this.sessions.values()) session.end();
+  }
+};
+
+// 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 {
+      }
+    }
+  }
+  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";
+  }
+  return "unknown";
+}
+var Client = class {
+  constructor(path, changed) {
+    this.path = path;
+    this.changed = changed;
+  }
+  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();
+  // 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
+      });
+      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();
+        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 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();
-      this.approvals.set(id, {
-        request: String(message.request_id),
-        input: message.request.input ?? {},
-        approval: approval2(id, message.request)
+  }
+  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 === "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, choice) => this.once(requestId, async () => {
-        const pending = this.approvals.get(approvalId);
-        if (!pending || !this.turn || !CHOICES.some((value2) => value2.id === choice))
-          throw new Error("Claude Code approval is no longer pending");
-        this.write({
-          type: "control_response",
-          response: {
-            subtype: "success",
-            request_id: pending.request,
-            response: choice === "accept" ? { behavior: "allow", updatedInput: pending.input } : { behavior: "deny", message: "The person rejected this from their phone." }
-          }
+  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(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;
+  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();
   }
 };
 
@@ -17348,9 +17602,9 @@ import { connect as connect2 } from "node:net";
 import { promisify as promisify3 } from "node:util";
 import { fileURLToPath } from "node:url";
 import { execFile as execFile3 } from "node:child_process";
-import { createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID5 } from "node:crypto";
 import { stat as stat2, readdir as readdir3, readFile as readFile3 } from "node:fs/promises";
-import { join as join6, dirname as dirname5, basename as basename2, isAbsolute as isAbsolute3 } from "node:path";
+import { join as join6, dirname as dirname5, basename as basename3, isAbsolute as isAbsolute3 } from "node:path";
 import { WebSocketTransport } from "@microsoft/agent-host-protocol/ws";
 import { AhpClient } from "@microsoft/agent-host-protocol/client";
 import { chatReducer, sessionReducer, SUPPORTED_PROTOCOL_VERSIONS } from "@microsoft/agent-host-protocol";
@@ -17368,7 +17622,7 @@ var CONFIRMATION_CHOICES = [
 function roots() {
   const override = process.env.DASHUP_AHP_DATA ?? process.env.DASHUP_VSCODE_DATA;
   if (override !== void 0)
-    return override ? [basename2(override) === "User" ? dirname5(override) : override] : [];
+    return override ? [basename3(override) === "User" ? dirname5(override) : override] : [];
   if (process.env.DASHUP_LIVE_DISCOVERY === "0") return [];
   const base = process.platform === "darwin" ? join6(homedir6(), "Library/Application Support") : process.platform === "win32" ? process.env.APPDATA ?? join6(homedir6(), "AppData/Roaming") : process.env.XDG_CONFIG_HOME ?? join6(homedir6(), ".config");
   return ["Code", "Code - Insiders"].map((name) => join6(base, name));
@@ -17410,12 +17664,12 @@ async function entries() {
       try {
         if (!await privateFile(path, MAX_METADATA)) continue;
         const parsed = JSON.parse(await readFile3(path, "utf8"));
-        const rows = basename2(path) === "metadata.json" && Array.isArray(parsed) ? parsed : [parsed];
+        const rows = basename3(path) === "metadata.json" && Array.isArray(parsed) ? parsed : [parsed];
         for (const row of rows.slice(0, MAX_HOSTS)) {
           if (row?.schemaVersion !== 2 || !["editor", "standalone"].includes(row.type) || !Number.isSafeInteger(row.pid) || row.pid <= 0 || typeof row.instanceId !== "string" || !row.instanceId || typeof row.connectionToken !== "string" || !row.connectionToken || row.connectionToken.length > 1024 || row.endpoint?.type !== "socket" || typeof row.endpoint.path !== "string" || !isAbsolute3(row.endpoint.path))
             continue;
           const identity2 = createHash3("sha256").update(`${row.type}\0${row.pid}\0${row.instanceId}`).digest("hex");
-          if (basename2(path) !== "metadata.json" && basename2(path) !== `${identity2}.json`) continue;
+          if (basename3(path) !== "metadata.json" && basename3(path) !== `${identity2}.json`) continue;
           try {
             process.kill(row.pid, 0);
           } catch {
@@ -17541,7 +17795,7 @@ var Host = class {
   client;
   connecting;
   stopped = false;
-  clientId = `dashup-${randomUUID4()}`;
+  clientId = `dashup-${randomUUID5()}`;
   resources = /* @__PURE__ */ new Map();
   subscriptions = /* @__PURE__ */ new Set();
   receipts = /* @__PURE__ */ new Map();
@@ -17700,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;
@@ -17722,12 +17976,12 @@ var Host = class {
           for (const pending of Array.isArray(session.inputNeeded) ? session.inputNeeded : []) {
             if (pending.kind !== "toolConfirmation" || pending.chat !== item.resource || pending.toolCall?.status !== "pending-confirmation")
               continue;
-            const preview2 = confirmation(pending.toolCall);
+            const preview3 = confirmation(pending.toolCall);
             approvals.push({
               id: pending.id,
               title: text2(pending.toolCall.confirmationTitle) || pending.toolCall.displayName || "Native agent approval",
-              detail: preview2.detail,
-              choices: preview2.choices.map(({ id: id2, label }) => ({ id: id2, label }))
+              detail: preview3.detail,
+              choices: preview3.choices.map(({ id: id2, label }) => ({ id: id2, label }))
             });
           }
           const id = `vscode-ahp:${createHash3("sha256").update(this.entry.root).digest("hex").slice(0, 16)}:${item.resource}`;
@@ -17769,7 +18023,8 @@ var Host = class {
                 message: { text: value2, origin: { kind: "user" } }
               });
             } : void 0,
-            approve: approvals.some((approval3) => approval3.choices.length) ? (requestId, approvalId, choice) => {
+            approve: approvals.some((approval2) => approval2.choices.length) ? (requestId, approvalId, reply) => {
+              const choice = "choice" in reply ? reply.choice : void 0;
               const prior = this.requests.get(requestId);
               if (prior) return prior;
               const current = this.resources.get(summary.resource)?.state;
@@ -18142,21 +18397,14 @@ var Server = class {
           (question) => question?.sessionID === id && typeof question.id === "string"
         ) : [];
         const approvals = pending.map((permission) => permissionApproval(permission, history, cwd));
-        for (const question of asks) {
-          const first = question.questions?.[0];
-          const options = first?.multiple !== true && question.questions?.length === 1 && Array.isArray(first?.options) ? first.options.filter(
-            (option2) => typeof option2?.label === "string"
-          ) : [];
-          approvals.push({
-            id: `question:${question.id}`,
-            title: typeof first?.header === "string" ? first.header : "OpenCode needs an answer",
-            detail: typeof first?.question === "string" ? first.question : "Open this question in the computer\u2019s native interface.",
-            choices: options.map((option2, index) => ({
-              id: `answer:${index}`,
-              label: option2.label
-            }))
-          });
-        }
+        for (const question of asks)
+          approvals.push(
+            questionApproval(
+              `question:${question.id}`,
+              Array.isArray(question.questions) ? question.questions : [],
+              (item) => item.multiple === true
+            )
+          );
         result.push({
           id,
           cwd,
@@ -18192,23 +18440,21 @@ var Server = class {
             });
             this.changed();
           }),
-          approve: approvals.some((approval3) => approval3.choices.length) ? (requestId, approvalId, choice) => this.once(requestId, async () => {
+          approve: approvals.some((approval2) => approval2.choices.length) ? (requestId, approvalId, reply) => this.once(requestId, async () => {
             if (this.stopped) throw new Error("OpenCode is disconnected");
+            const choice = "choice" in reply ? reply.choice : void 0;
             if (approvalId.startsWith("question:")) {
               const requestID = approvalId.slice("question:".length);
               const current = await this.request("/question", cwd);
-              const question = Array.isArray(current) ? current.find(
+              if (!Array.isArray(current) || !current.some(
                 (value2) => value2?.id === requestID && value2.sessionID === id
-              ) : void 0;
-              const index = /^answer:(\d+)$/.exec(choice)?.[1];
-              const option2 = index !== void 0 ? question?.questions?.[0]?.options?.[Number(index)] : void 0;
-              if (question?.questions?.length !== 1 || question.questions[0]?.multiple === true || typeof option2?.label !== "string")
-                throw new Error(
-                  "Question is no longer pending or requires the native interface"
-                );
-              await this.request(`/question/${encodeURIComponent(requestID)}/reply`, cwd, {
-                answers: [[option2.label]]
-              });
+              ))
+                throw new Error("Question is no longer pending");
+              await this.request(
+                `/question/${encodeURIComponent(requestID)}/${"answers" in reply ? "reply" : "reject"}`,
+                cwd,
+                "answers" in reply ? { answers: reply.answers } : {}
+              );
             } else {
               const current = await this.request("/permission", cwd);
               const permission = Array.isArray(current) ? current.find(
@@ -18432,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"];
@@ -18493,11 +18745,11 @@ var LiveHarnesses = class {
 };
 
 // src/harness/queue.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+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 basename3 } from "node:path";
-import { statSync as statSync2, existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync4, readlinkSync, realpathSync as realpathSync2 } from "node:fs";
+import { join as join8, dirname as dirname6, basename as basename4 } from "node:path";
+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;
@@ -18506,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 };
@@ -18519,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 (basename3(executable) !== "codex" || packageVersion(executable) !== CODEX_VERSION) return [];
-  const status2 = readFileSync4(join8(root, "stat"), "utf8");
+  if (basename4(executable) !== "codex" || packageVersion(executable) !== CODEX_VERSION) return [];
+  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);
@@ -18541,14 +18793,14 @@ function processOwners(pid) {
     }
   });
   return files2.flatMap(({ fd, path }) => {
-    if (basename3(dirname6(path)) !== "thread-writer-locks" || !path.endsWith(".lock")) return [];
-    const thread = basename3(path, ".lock");
+    if (basename4(dirname6(path)) !== "thread-writer-locks" || !path.endsWith(".lock")) return [];
+    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) => {
@@ -18616,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)
@@ -18778,7 +19030,7 @@ var NativeQueue = class {
     if (existing) return existing;
     if (this.stopped) throw new Error("The connector is stopping");
     validateOwner(scope2.owner);
-    const clientUserMessageId = randomUUID5();
+    const clientUserMessageId = randomUUID6();
     const request2 = { ...scope2, receipt: { state: "unknown", clientUserMessageId } };
     let writer;
     try {
@@ -18852,6 +19104,7 @@ var EPHEMERAL_TTL_MS = 6e4;
 var HOME_RECENT = 20;
 var FOLLOW_MS = 2 * 6e4;
 var RESCAN_MS = 1e3;
+var answers = (approval2, reply) => "answers" in reply ? reply.answers.length === approval2.questions?.length : approval2.choices.some((choice) => choice.id === reply.choice);
 var Command = z2.object({
   type: z2.literal("command"),
   requestId: z2.string().min(1),
@@ -18873,7 +19126,15 @@ var Command = z2.object({
       option: z2.string().min(1).max(100),
       value: z2.union([z2.string().min(1).max(200), z2.boolean()])
     }).strict(),
-    z2.object({ kind: z2.literal("approval.respond"), approvalId: z2.string(), choice: z2.string() }).strict(),
+    z2.object({
+      kind: z2.literal("approval.respond"),
+      approvalId: z2.string(),
+      choice: z2.string().optional(),
+      text: z2.string().max(1e5).optional(),
+      answers: z2.array(z2.array(z2.string().min(1).max(1e5)).min(1)).min(1).optional()
+    }).strict().refine(
+      (action) => action.choice === void 0 !== (action.answers === void 0) && (action.text === void 0 || action.choice !== void 0)
+    ),
     z2.object({ kind: z2.literal("attachment.read"), id: z2.string().regex(/^[a-f0-9]{64}$/) }).strict(),
     z2.object({
       kind: z2.literal("session.start"),
@@ -18989,15 +19250,15 @@ var Connector = class {
             for (const project of this.discovery.projects.values())
               for (const thread of project.threads) {
                 const native = this.discovery.locations.get(thread.id)?.live;
-                const approval3 = native?.approvals[0];
-                if (!approval3) continue;
+                const approval2 = native?.approvals[0];
+                if (!approval2) continue;
                 await this.thread(pair, project, thread);
                 await this.send(pair, {
                   type: "attention",
                   projectId: project.id,
                   threadId: thread.id,
-                  title: approval3.title,
-                  body: approval3.detail,
+                  title: approval2.title,
+                  body: approval2.detail,
                   reason: "approval"
                 });
               }
@@ -19145,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
       });
     }
@@ -19251,9 +19512,9 @@ var Connector = class {
       if (JSON.stringify(prior) === JSON.stringify(snapshot)) continue;
       this.nativeSnapshots.set(thread.id, structuredClone(snapshot));
       for (const pair of this.activePairs()) await this.thread(pair, project, thread);
-      for (const approval3 of session.approvals)
-        if (!prior?.approvals.some((item) => item.id === approval3.id))
-          await this.attention(project.id, thread.id, approval3.title, approval3.detail, "approval");
+      for (const approval2 of session.approvals)
+        if (!prior?.approvals.some((item) => item.id === approval2.id))
+          await this.attention(project.id, thread.id, approval2.title, approval2.detail, "approval");
       if (prior?.thread.status === "working" && thread.status === "idle")
         await this.attention(
           project.id,
@@ -19441,7 +19702,7 @@ var Connector = class {
     }
   }
   attach(socket) {
-    const sessions = bridgeAcp(socket, (session, approval3) => {
+    const sessions = bridgeAcp(socket, (session, approval2) => {
       this.agents.set(session.id, session);
       const { project, thread } = this.adopt(session);
       if (!this.snapshots.has(session.id)) {
@@ -19456,15 +19717,15 @@ var Connector = class {
           }
         }).catch((error) => this.report(error));
       }
-      if (approval3)
+      if (approval2)
         this.work = this.work.then(async () => {
-          if (this.agents.get(session.id) !== session || ![...session.approvals.values()].includes(approval3))
+          if (this.agents.get(session.id) !== session || ![...session.approvals.values()].includes(approval2))
             return;
           await this.attention(
             project.id,
             thread.id,
-            approval3.title,
-            approval3.detail,
+            approval2.title,
+            approval2.detail,
             "approval"
           );
         }).catch((error) => this.report(error));
@@ -19526,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();
@@ -19630,24 +19902,24 @@ var Connector = class {
       }
       case "approval.respond": {
         if (!thread) throw new Error("Thread not found");
-        const action = command2.action;
+        const { kind, approvalId, ...reply } = command2.action;
         const native = this.discovery.locations.get(thread.id)?.live;
         if (native?.approve) {
-          const approval4 = native.approvals.find((item) => item.id === action.approvalId);
-          if (!approval4?.choices.some((choice) => choice.id === action.choice))
+          const approval3 = native.approvals.find((item) => item.id === approvalId);
+          if (!approval3 || !answers(approval3, reply))
             throw new Error("Approval is no longer available");
-          return native.approve(command2.requestId, approval4.id, action.choice);
+          return native.approve(command2.requestId, approval3.id, reply);
         }
         const agent = this.attached(thread);
         if (!agent)
           throw new Error("Approval requires an attached ACP session. Answer it on your computer.");
-        const [request2, approval3] = [...agent.approvals].find(([, item]) => item.id === action.approvalId) ?? [];
-        if (!approval3?.choices.some((choice) => choice.id === action.choice))
+        const [request2, approval2] = [...agent.approvals].find(([, item]) => item.id === approvalId) ?? [];
+        if (!approval2 || !("choice" in reply) || !answers(approval2, reply))
           throw new Error("Approval is no longer available");
         return commandAcp(agent, command2.requestId, {
           kind: "approval",
           id: request2,
-          choice: action.choice
+          choice: reply.choice
         });
       }
     }