@dashup/connector 0.1.14 → 0.1.16

package/README.md

@@ -34,10 +34,10 @@ Each history read stages a new encrypted database snapshot and publishes it only
 
 Dashup discovers existing local OpenCode listeners, Codex control sockets, and VS Code Agent Host endpoints. These connections remain local; their tokens are never sent to Parcae or the phone. Native endpoints are checked for local ownership or loopback access, and redirects and remote endpoint URLs are rejected.
 
-- **OpenCode:** the existing TUI/server supplies conversations, live events, prompts, native tool permissions, and supported single-choice questions. A reply targets the original session ID and preserves its latest native agent, model, and variant. For an existing session, Dashup does not run `opencode serve` or create another one.
+- **OpenCode:** the existing TUI/server supplies conversations, live events, prompts, native tool permissions, and questions, which the phone answers or skips. A reply targets the original session ID and preserves its latest native agent, model, and variant. For an existing session, Dashup does not run `opencode serve` or create another one.
 - **Codex:** the existing control socket supplies already-loaded threads. Replies require a recognized native server and a thread that is still loaded and idle immediately before sending. For an existing thread, Dashup never calls `thread/start`, `thread/resume`, or `session/load`. Approval controls appear only for native requests routed to this connection; approvals owned by another client may remain available only in the original UI.
 - **VS Code:** Microsoft's official AHP client subscribes to existing host sessions and chats. Native choices are retained, and delivery is acknowledged by the host. Older extension-host chats without an accessible Agent Host remain saved history. AHP chat IDs are namespaced rather than guessed to equal CLI thread IDs. Non-file remote AHP workspace URIs are not presented as local execution environments.
-- **Claude Code:** existing transcripts are readable without starting Claude. `dashup install` adds Dashup's plugin to Claude Code (`dashup@dashup`, read in place from this package's `claude/` folder), and `dashup uninstall` removes it. A session that starts with the plugin holds a stream open to `~/.dashup/claude.sock` through `curl`, and takes each reply as the person's own words; a reply that starts with `/` runs that command. Claude Code's inbox socket is not used, because Claude presents anything posted there as another session's message, without the person's authority. Sessions opened before the plugin was installed, and sessions on Windows, stay read-only.
+- **Claude Code:** existing transcripts are readable without starting Claude. `dashup install` adds Dashup's plugin to Claude Code (`dashup@dashup`, read in place from this package's `claude/` folder), and `dashup uninstall` removes it. A session that starts with the plugin holds a stream open to `~/.dashup/claude.sock` through `curl`, and takes each reply as the person's own words; a reply that starts with `/` runs that command. The plugin also puts each permission request the session waits on to the phone: a tool to allow once or under the rule Claude Code suggests, questions, or a plan. The dialog on the computer, or the editor hosting the session, stays open, and the first answer wins. Claude Code lets only the person there or its host approve a plan, so the phone can only send a running session's plan back with what to change. Claude Code's inbox socket is not used, because Claude presents anything posted there as another session's message, without the person's authority. Sessions opened before the plugin was installed, and sessions on Windows, stay read-only.
 
 Native listener discovery supports the host's available process/socket interfaces. File and socket formats are versioned implementation boundaries; unavailable or unfamiliar interfaces leave history readable and controls disabled. Existing editor and agent processes continue independently when the Dashup connector disconnects. The PC's saved SSH relationship is retained; reading it does not grant access to a remote machine's CLI store.
 
@@ -47,7 +47,7 @@ Only an explicit Queue reply starts a temporary official app-server helper to in
 
 Delivery requires that exact typed client-message ID in the original thread's native history database. A response receipt requires a later native assistant item in the same turn; it does not mean the agent finished. Receipts remain encrypted through the ordinary Dashup relay. History is read on request; the phone asks again while a thread is open and its session changes. Native approvals owned by the private-stdio process remain unsupported and require its original UI. Queue text never substitutes for a native approval.
 
-A running Claude Code session shows the model its newest reply ran on and, where that model takes them, fast mode and ultracode, as its transcript records them. The choices and their names are the models `claude` offers hosts in its initialize answer. The phone changes them through the plugin with Claude Code's own `/model`, `/fast` and `/effort ultracode` commands, and in a session the phone started with control requests at the start of each turn. Claude Code records a change when the next turn starts, so it shows from the next reply. A change expires with other commands after 60 seconds.
+A running Claude Code session shows the model its newest reply ran on and, where that model takes them, fast mode and ultracode, as its transcript records them. The choices and their names are the models the session's own Claude Code binary offers hosts in its initialize answer, or `claude`'s where the system does not name the binary. The phone changes them through the plugin with Claude Code's own `/model`, `/fast` and `/effort ultracode` commands, and in a session the phone started with control requests at the start of each turn. Claude Code records a change when the next turn starts, so it shows from the next reply. A change expires with other commands after 60 seconds.
 
 Stop interrupts the running turn through each live interface: OpenCode's session abort, Codex `turn/interrupt`, the AHP client's turn cancellation, ACP `session/cancel`, and the Claude Code plugin's turn abort. It refuses when nothing is running and expires with other commands after 60 seconds, so a late stop cannot end a newer turn.
 
@@ -55,7 +55,7 @@ Live discovery is bounded to 100 sessions per endpoint. OpenCode supplies the la
 
 ## Starting sessions from the phone
 
-The phone starts a session in a local project, or in a new folder inside one of the folders that already hold this computer's projects, with Claude Code, Codex or OpenCode: whichever of `claude`, `codex` and `opencode` runs here. The agent works with its own settings and permission rules, and asks the phone before anything they don't allow. Claude Code runs headless (`claude -p`) for each turn and resumes the session for the next; Codex threads start in Codex's own app-server daemon (`codex app-server daemon start`) and outlive the connector; OpenCode sessions run on an `opencode serve` the connector starts for that folder. Claude Code's permission requests arrive with the command, or the diff an edit or write would make.
+The phone starts a session in a local project, or in a new folder inside one of the folders that already hold this computer's projects, with Claude Code, Codex or OpenCode: whichever of `claude`, `codex` and `opencode` runs here. The agent works with its own settings and permission rules, and asks the phone before anything they don't allow. Claude Code runs headless (`claude -p`) for each turn and resumes the session for the next; Codex threads start in Codex's own app-server daemon (`codex app-server daemon start`) and outlive the connector; OpenCode sessions run on an `opencode serve` the connector starts for that folder. Claude Code's permission requests arrive with the command, or the diff an edit or write would make, and the rule that would stop it asking again; the phone answers its questions and plans as Claude Code's host.
 
 A saved conversation is answered the same way when its agent runs here, its project is local, and nothing else has it open: Claude Code resumes it (`claude -p --resume`), Codex loads it in its daemon (`thread/resume`), and OpenCode serves its folder. One a native Codex process owns takes queued messages instead. A start expires with other commands after 60 seconds.
 

package/claude/.claude-plugin/plugin.json

@@ -1,4 +1,4 @@
 {
   "name": "dashup",
-  "description": "Takes what you send this session from the Dashup app as your own words"
+  "description": "Takes what you send this session from the Dashup app as your own words, and lets you answer its approvals, questions and plans there"
 }

package/claude/hooks/register.ts

@@ -13,9 +13,85 @@ type Delivery = { text?: string; now?: true };
 
 const RETRY_MS = 10_000;
 
+// =============================================================================
+// Permission requests
+// =============================================================================
+
+// The connector holds each request this session waits on open until the phone answers it. The
+// dialog here, the editor hosting the session or the person's own hooks may answer first. No hook
+// hears the dialog's answer, so the call it settles closes the request: both hooks see the call,
+// with its fields in different orders.
+function call(agent: string | undefined, tool: string, input: unknown): string {
+  const sorted = (value: unknown): unknown =>
+    Array.isArray(value)
+      ? value.map(sorted)
+      : value && typeof value === 'object'
+        ? Object.fromEntries(
+            Object.keys(value)
+              .sort()
+              .map((key) => [key, sorted((value as Record<string, unknown>)[key])]),
+          )
+        : value;
+  return JSON.stringify([agent ?? '', tool, sorted(input)]);
+}
+
 export const register: Register = (on) => {
   let turnId: string | undefined;
   let stream: AsyncGenerator<unknown, unknown> | undefined;
+  // The requests the phone is asked, by the call each waits on.
+  const asks = new Map<string, AsyncGenerator<unknown, unknown>>();
+  on('classic.PermissionRequest', async ($, e, next) => {
+    const key = call(e.agent_id, e.tool_name, e.tool_input);
+    const ask = $.process.spawn({
+      argv: [
+        'curl',
+        '-sfN',
+        '--unix-socket',
+        `${await $.env.get('HOME')}/.dashup/claude.sock`,
+        '--data-binary',
+        '@-',
+        `http://dashup/sessions/${await $.session.id()}/prompts`,
+      ],
+      input: JSON.stringify({
+        tool        : e.tool_name,
+        input       : e.tool_input,
+        suggestions : e.permission_suggestions,
+      }),
+    });
+    const open: AsyncGenerator<unknown, unknown> = ask;
+    asks.set(key, open);
+    const beneath = next(e).then((result) => {
+      if (result.decision) void open.return(undefined);
+      return result;
+    });
+    let answer = '';
+    try {
+      for await (const { stream: name, text } of ask) if (name === 'stdout') answer += text;
+    } catch {
+      // curl is missing.
+    } finally {
+      if (asks.get(key) === open) asks.delete(key);
+    }
+    try {
+      return answer ? { decision: JSON.parse(answer) } : beneath;
+    } catch {
+      // The connector stopped mid-answer.
+      return beneath;
+    }
+  });
+  on('tool.call', async ($, e, next) => {
+    try {
+      return await next(e);
+    } finally {
+      if (asks.size) {
+        const { tool, tool_use_id, consent, agentId, requestMeta, ...input } = e as Record<
+          string,
+          unknown
+        >;
+        void asks.get(call(agentId as string | undefined, String(tool), input))?.return(undefined);
+      }
+    }
+  });
   on('turn.start', ($, e, next) => {
     if (e.agentId === undefined) turnId = e.turnId;
     return next(e);
@@ -23,6 +99,7 @@ export const register: Register = (on) => {
   // `/clear` starts another conversation in this process, which streams under its own id.
   on('session.end', ($, e, next) => {
     void stream?.return(undefined);
+    for (const ask of asks.values()) void ask.return(undefined);
     return next(e);
   });
   on('session.start', async ($, e, next) => {

package/dist/index.js

@@ -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.14";
+var version = "0.1.16";
 
 // 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;
@@ -13246,22 +13264,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 models2 = items.map(
+      const models = items.map(
         (row) => modelClass.hydrate(this, row)
       );
       if (result?.__queryHash) {
-        Object.defineProperty(models2, "__queryHash", {
+        Object.defineProperty(models, "__queryHash", {
           value: result.__queryHash,
           enumerable: false
         });
       }
       if (typeof result?.totalCount === "number") {
-        Object.defineProperty(models2, "__totalCount", {
+        Object.defineProperty(models, "__totalCount", {
           value: result.totalCount,
           enumerable: false
         });
       }
-      return models2;
+      return models;
     };
     chain.first = async () => {
       const all = await chain.find();
@@ -16728,13 +16746,14 @@ var Client = class {
             });
             this.changed();
           }) : void 0,
-          approve: approvals.length ? (requestId, approvalId, choice) => this.once(requestId, async () => {
-            const approval3 = this.approvals.get(approvalId);
+          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 (!approval3 || approval3.threadId !== id || !approval3.approval.choices.some((value2) => value2.id === choice) || socket?.readyState !== WebSocket2.OPEN)
+            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: approval3.requestId, result: { decision: choice } }),
+              JSON.stringify({ id: approval2.requestId, result: { decision: choice } }),
               (error) => error ? reject(new Error("Codex approval could not be sent")) : resolve3()
             ));
             this.approvals.delete(approvalId);
@@ -16810,18 +16829,18 @@ var Codex = class {
 };
 
 // src/harness/headless.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { readFileSync as readFileSync3 } from "node:fs";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { createInterface as createInterface3 } from "node:readline";
 import { spawn as spawn3 } from "node:child_process";
 
 // src/harness/claude.ts
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { dirname as dirname4, join as join5, basename as basename2 } from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 import { createInterface as createInterface2 } from "node:readline";
-import { watch as watch2 } from "node:fs";
-import { mkdir, readdir as readdir2, readFile as readFile2, rm } from "node:fs/promises";
+import { watch as watch2, readFileSync as readFileSync3 } from "node:fs";
+import { mkdir, readdir as readdir2, readFile as readFile2, readlink, rm } from "node:fs/promises";
 import { createServer as createServer2 } from "node:http";
 var MODELS_MS = 3e4;
 var COMMANDS = {
@@ -16829,32 +16848,48 @@ var COMMANDS = {
   fast: (value2) => `/fast ${value2 ? "on" : "off"}`,
   ultracode: (value2) => `/effort ultracode ${value2 ? "on" : "off"}`
 };
-var models = [];
-function askModels() {
+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(
-      "claude",
+      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("error", () => resolve3([]));
     child.once("exit", () => {
       clearTimeout(timer);
-      resolve3();
+      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 offered = message.response.response?.models;
-        if (Array.isArray(offered))
-          models = offered.filter(
+        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 {
       }
@@ -16865,7 +16900,7 @@ function askModels() {
     );
   });
 }
-function claudeOptions(recorded) {
+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 }));
@@ -16877,9 +16912,148 @@ function claudeOptions(recorded) {
     ...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: tool === "Bash" ? "Allow command?" : EDITS.has(tool) ? "Allow file changes?" : `Allow ${request2.label ?? tool}?`,
+    detail: preview2(
+      [
+        request2.description ?? (typeof input.description === "string" ? input.description : ""),
+        typeof input.command === "string" ? input.command : diff ? "" : JSON.stringify(input, null, 2)
+      ].filter(Boolean).join("\n\n")
+    ),
+    ...diff ? { change: diff } : {},
+    choices: [
+      { id: "accept", label: "Allow once" },
+      ...always ? [{ id: "always", label: always.label }] : [],
+      { id: "decline", label: "Reject" }
+    ]
+  };
+}
+function decide(request2, approval2, reply) {
+  const input = request2.input;
+  if ("answers" in reply)
+    return {
+      behavior: "allow",
+      updatedInput: {
+        ...input,
+        answers: Object.fromEntries(
+          (approval2.questions ?? []).map((item, index) => [
+            item.question,
+            reply.answers[index].join(", ")
+          ])
+        )
+      }
+    };
+  if (reply.choice === "accept")
+    return {
+      behavior: "allow",
+      updatedInput: input,
+      ...approval2.plan === void 0 ? {} : { updatedPermissions: [{ type: "setMode", mode: "default", destination: "session" }] }
+    };
+  if (reply.choice === "always")
+    return {
+      behavior: "allow",
+      updatedInput: input,
+      updatedPermissions: remember(request2.suggestions)?.updates ?? []
+    };
+  if (reply.choice === "revise")
+    return { behavior: "deny", message: reply.text?.trim() || "Keep planning." };
+  return {
+    behavior: "deny",
+    message: reply.choice === "skip" ? "The person skipped these questions." : "The person rejected this from their phone."
+  };
+}
 var MAX_SESSIONS2 = 100;
 var MAX_REQUESTS = 1e3;
-var SESSION = /^\/sessions\/([\w-]{1,100})$/;
+var MAX_PROMPT = 4 * 1024 * 1024;
+var SESSION = /^\/sessions\/([\w-]{1,100})(\/prompts)?$/;
 var STATUS = {
   busy: "working",
   idle: "idle",
@@ -16896,7 +17070,8 @@ async function registrations() {
         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);
-        return [value2];
+        const binary2 = await readlink(`/proc/${value2.pid}/exe`).catch(() => "");
+        return [{ ...value2, command: /[\\/]claude(?:\.exe)?$/.test(binary2) ? binary2 : "claude" }];
       } catch {
         return [];
       }
@@ -16915,23 +17090,32 @@ var Claude = class {
   notify;
   server;
   streams = /* @__PURE__ */ new Map();
+  prompts = /* @__PURE__ */ new Map();
   requests = /* @__PURE__ */ new Map();
   async refresh() {
     this.watch();
     return (await registrations()).map((session) => {
       const plugin = this.streams.has(session.sessionId);
+      const models = claudeModels(this.changed, session.command, session.version);
+      const approvals = [...this.prompts.values()].filter((prompt) => prompt.session === session.sessionId).map((prompt) => prompt.approval);
       return {
         id: session.sessionId,
         harness: "claude",
         cwd: session.cwd,
         updatedAt: new Date(session.updatedAt ?? 0).toISOString(),
-        status: STATUS[session.status ?? ""] ?? "unknown",
+        status: approvals.length ? "attention" : STATUS[session.status ?? ""] ?? "unknown",
         messages: [],
-        approvals: [],
+        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: claudeOptions,
+        options: (recorded) => claudeOptions(models, recorded),
         configure: plugin ? (requestId, option2, value2) => this.once(requestId, () => this.deliver(session.sessionId, { text: COMMANDS[option2](value2) })) : void 0
       };
     });
@@ -16940,8 +17124,9 @@ var Claude = class {
   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();
+      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", () => {
@@ -16959,6 +17144,46 @@ var Claude = class {
       server.listen(this.socket, resolve3);
     });
   }
+  // Asks the phone what the session's permission request asks the person.
+  prompt(session, request2, response) {
+    const chunks = [];
+    let bytes = 0;
+    request2.on("data", (chunk) => {
+      bytes += chunk.length;
+      if (bytes > MAX_PROMPT) request2.destroy();
+      else chunks.push(chunk);
+    });
+    request2.once("end", () => {
+      let asked;
+      try {
+        asked = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+      } catch {
+      }
+      if (typeof asked?.tool !== "string" || !asked.input || typeof asked.input !== "object")
+        return void response.writeHead(400).end();
+      const id = randomUUID3();
+      const prompted = {
+        tool: asked.tool,
+        input: asked.input,
+        ...Array.isArray(asked.suggestions) ? { suggestions: asked.suggestions } : {}
+      };
+      this.prompts.set(id, {
+        session,
+        request: prompted,
+        approval: ask(id, prompted, false),
+        answer: (decision) => {
+          this.prompts.delete(id);
+          response.end(JSON.stringify(decision));
+          this.changed();
+        }
+      });
+      response.once("close", () => {
+        if (this.prompts.delete(id)) this.changed();
+      });
+      response.writeHead(200, { "Content-Type": "application/json" }).flushHeaders();
+      this.changed();
+    });
+  }
   deliver(id, delivery) {
     const stream = this.streams.get(id);
     if (!stream) return Promise.reject(new Error("Claude Code is not taking messages"));
@@ -16997,6 +17222,7 @@ var Claude = class {
     clearTimeout(this.notify);
     this.watcher?.close();
     this.watcher = void 0;
+    this.prompts.clear();
     this.server?.closeAllConnections();
     this.server?.close();
     this.server = void 0;
@@ -17004,82 +17230,9 @@ var Claude = class {
 };
 
 // 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) {
@@ -17113,14 +17266,14 @@ var Session = class {
   interrupt() {
     this.write({
       type: "control_request",
-      request_id: randomUUID3(),
+      request_id: randomUUID4(),
       request: { subtype: "interrupt" }
     });
   }
   apply(option2, value2) {
     this.write({
       type: "control_request",
-      request_id: randomUUID3(),
+      request_id: randomUUID4(),
       request: option2 === "model" ? { subtype: "set_model", model: value2 } : { subtype: "apply_flag_settings", settings: { [SWITCHES[option2]]: value2 } }
     });
   }
@@ -17136,7 +17289,7 @@ var Session = class {
   // Resolves once Claude Code takes the message, or says why it could not start. `now` stops the
   // turn under way, so Claude Code takes the message at once.
   say(text3, now = false) {
-    this.messages.push({ id: randomUUID3(), role: "user", text: text3 });
+    this.messages.push({ id: randomUUID4(), role: "user", text: text3 });
     this.typing = "";
     this.status = "working";
     this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -17205,15 +17358,27 @@ var Session = class {
     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 });
+      this.messages.push({ id: String(message.uuid ?? randomUUID4()), role: "assistant", text: text3 });
     } else if (message.type === "control_request" && message.request?.subtype === "can_use_tool") {
-      const id = randomUUID3();
+      const id = randomUUID4();
+      const asked = message.request;
+      const request2 = {
+        tool: String(asked.tool_name),
+        input: asked.input ?? {},
+        label: typeof asked.display_name === "string" ? asked.display_name : void 0,
+        description: typeof asked.description === "string" ? asked.description : void 0,
+        suggestions: Array.isArray(asked.permission_suggestions) ? asked.permission_suggestions : void 0
+      };
       this.approvals.set(id, {
-        request: String(message.request_id),
-        input: message.request.input ?? {},
-        approval: approval2(id, message.request)
+        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) {
@@ -17229,7 +17394,7 @@ var Session = class {
     this.changed();
     return init;
   }
-  live() {
+  live(models) {
     return {
       id: this.id,
       cwd: this.cwd,
@@ -17242,7 +17407,7 @@ var Session = class {
       approvals: [...this.approvals.values()].map((pending) => pending.approval),
       send: (requestId, text3, now) => this.once(requestId, () => this.say(text3, now)),
       now: true,
-      options: claudeOptions,
+      options: (recorded) => claudeOptions(models, recorded),
       configure: (requestId, option2, value2) => this.once(requestId, async () => {
         this.chosen[option2] = value2;
         this.apply(option2, value2);
@@ -17251,16 +17416,16 @@ var Session = class {
         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 () => {
+      approve: this.approvals.size ? (requestId, approvalId, reply) => this.once(requestId, async () => {
         const pending = this.approvals.get(approvalId);
-        if (!pending || !this.turn || !CHOICES.some((value2) => value2.id === choice))
+        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.request,
-            response: choice === "accept" ? { behavior: "allow", updatedInput: pending.input } : { behavior: "deny", message: "The person rejected this from their phone." }
+            request_id: pending.control,
+            response: decide(pending.request, pending.approval, reply)
           }
         });
         this.approvals.delete(approvalId);
@@ -17291,7 +17456,7 @@ var Headless = class {
   // 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);
+    const session = new Session(randomUUID4(), cwd, title2, this.soon);
     this.sessions.set(session.id, session);
     try {
       await session.say(text3);
@@ -17314,7 +17479,8 @@ var Headless = class {
     }
   }
   async refresh() {
-    return [...this.sessions.values()].map((session) => session.live());
+    const models = claudeModels(this.changed);
+    return [...this.sessions.values()].map((session) => session.live(models));
   }
   stop() {
     clearTimeout(this.notify);
@@ -17329,9 +17495,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";
@@ -17349,7 +17515,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));
@@ -17391,12 +17557,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 {
@@ -17522,7 +17688,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();
@@ -17703,12 +17869,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}`;
@@ -17750,7 +17916,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;
@@ -17825,7 +17992,7 @@ import { join as join7 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 import { createHash as createHash4 } from "node:crypto";
 import { execFile as execFile4, spawn as spawn4 } from "node:child_process";
-import { stat as stat3, readlink, readdir as readdir4, readFile as readFile4 } from "node:fs/promises";
+import { stat as stat3, readlink as readlink2, readdir as readdir4, readFile as readFile4 } from "node:fs/promises";
 var run2 = promisify4(execFile4);
 var REQUEST_MS3 = 4e3;
 var MAX_BYTES3 = 8 * 1024 * 1024;
@@ -17880,7 +18047,7 @@ async function linuxEndpoints() {
         })
       );
       for (const fd of (await readdir4(join7(directory2, "fd"))).slice(0, 1024)) {
-        const target = await readlink(join7(directory2, "fd", fd)).catch(() => "");
+        const target = await readlink2(join7(directory2, "fd", fd)).catch(() => "");
         const inode = /^socket:\[(\d+)\]$/.exec(target)?.[1];
         const url2 = inode ? listeners.get(inode) : void 0;
         if (url2) result.push({ url: url2, authorization: authorization(environment) });
@@ -18123,21 +18290,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,
@@ -18173,23 +18333,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(
@@ -18413,10 +18571,10 @@ var LiveHarnesses = class {
     });
     return this.refreshing;
   }
-  // The agents whose own command runs on this computer, and the models Claude Code offers.
+  // The agents whose own command runs on this computer. Claude Code is asked its models again.
   async agents() {
     const harnesses = ["claude", "codex", "opencode"];
-    const asked = askModels();
+    forgetModels();
     const runs = await Promise.all(
       harnesses.map((harness) => promisify5(execFile5)(harness, ["--version"], {
         timeout: 1e4,
@@ -18426,7 +18584,6 @@ var LiveHarnesses = class {
         () => false
       ))
     );
-    await asked;
     return harnesses.filter((_, index) => runs[index]);
   }
   // Starts a session in `cwd` with its first message, and resolves with the session's native id.
@@ -18475,10 +18632,10 @@ 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 { join as join8, dirname as dirname6, basename as basename4 } from "node:path";
 import { statSync as statSync2, existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync4, readlinkSync, realpathSync as realpathSync2 } from "node:fs";
 var CODEX_VERSION = "0.160.1";
 var REQUEST_MS4 = 1e4;
@@ -18510,7 +18667,7 @@ function processOwners(pid) {
   const root = `/proc/${pid}`;
   if (process.getuid && statSync2(root).uid !== process.getuid()) return [];
   const executable = realpathSync2.native(join8(root, "exe"));
-  if (basename3(executable) !== "codex" || packageVersion(executable) !== CODEX_VERSION) return [];
+  if (basename4(executable) !== "codex" || packageVersion(executable) !== CODEX_VERSION) return [];
   const status2 = readFileSync4(join8(root, "stat"), "utf8");
   const start2 = status2.slice(status2.lastIndexOf(")") + 2).split(" ")[19];
   if (!start2 || !/^\d+$/.test(start2)) return [];
@@ -18523,8 +18680,8 @@ 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");
@@ -18760,7 +18917,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 {
@@ -18834,6 +18991,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),
@@ -18855,7 +19013,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"),
@@ -18971,15 +19137,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"
                 });
               }
@@ -19233,9 +19399,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,
@@ -19423,7 +19589,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)) {
@@ -19438,15 +19604,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));
@@ -19612,24 +19778,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
         });
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashup/connector",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "type": "module",
   "bin": {
     "dashup": "dist/index.js"
@@ -30,11 +30,11 @@
     "tsup": "^8.5.1",
     "tsx": "^4.22.4",
     "typescript": "^5.9.3",
+    "@dashup/models": "0.1.0",
     "@dashup/protocol": "0.1.0",
     "@dashup/typescript-config": "0.0.0",
-    "@dashup/models": "0.1.0",
-    "@parcae/sdk": "0.8.1",
-    "@parcae/lynx": "0.1.0"
+    "@parcae/lynx": "0.1.0",
+    "@parcae/sdk": "0.8.1"
   },
   "scripts": {
     "dashup": "tsx src/index.ts",