@dashup/connector 0.1.4 → 0.1.6

package/dist/index.js

@@ -42,7 +42,7 @@ var require_XMLHttpRequest = __commonJS({
     "use strict";
     var fs = __require("fs");
     var Url = __require("url");
-    var spawn5 = __require("child_process").spawn;
+    var spawn7 = __require("child_process").spawn;
     module.exports = XMLHttpRequest3;
     XMLHttpRequest3.XMLHttpRequest = XMLHttpRequest3;
     function XMLHttpRequest3(opts) {
@@ -338,7 +338,7 @@ var require_XMLHttpRequest = __commonJS({
           var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
           fs.writeFileSync(syncFile, "", "utf8");
           var execString = "var http = require('http'), https = require('https'), fs = require('fs');var doRequest = http" + (ssl ? "s" : "") + ".request;var options = " + JSON.stringify(options) + ";var responseText = '';var responseData = Buffer.alloc(0);var req = doRequest(options, function(response) {response.on('data', function(chunk) {  var data = Buffer.from(chunk);  responseText += data.toString('utf8');  responseData = Buffer.concat([responseData, data]);});response.on('end', function() {fs.writeFileSync('" + contentFile + "', JSON.stringify({err: null, data: {statusCode: response.statusCode, headers: response.headers, text: responseText, data: responseData.toString('base64')}}), 'utf8');fs.unlinkSync('" + syncFile + "');});response.on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});}).on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});" + (data ? "req.write('" + JSON.stringify(data).slice(1, -1).replace(/'/g, "\\'") + "');" : "") + "req.end();";
-          var syncProc = spawn5(process.argv[0], ["-e", execString]);
+          var syncProc = spawn7(process.argv[0], ["-e", execString]);
           var statusText;
           while (fs.existsSync(syncFile)) {
           }
@@ -2714,10 +2714,14 @@ import { z as z3 } from "zod";
 var PRODUCT = {
   name: "Dashup",
   shorthand: "-up",
+  app: "com.dashup.mobile",
+  site: "https://dashup.com",
   api: "https://api.dashup.com",
+  support: "support@dashup.com",
   currency: "USD",
   trialDays: 14,
-  monthlyPrice: 10
+  monthlyPrice: 10,
+  storeProduct: "dashup.monthly"
 };
 var PAIRING_TTL_MS = 5 * 6e4;
 var PROTOCOL_VERSION = 1;
@@ -3767,7 +3771,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 approval2 = {
+      const approval3 = {
         id: randomUUID(),
         title: String(message.params.title ?? tool.title ?? "Agent needs approval"),
         detail: String(message.params.description ?? ""),
@@ -3785,10 +3789,10 @@ ${String(diff.newText).split("\n").map((line) => "+" + line).join("\n")}`
           }
         } : {}
       };
-      session.approvals.set(String(message.id), approval2);
+      session.approvals.set(String(message.id), approval3);
       permissions.set(String(message.id), session);
       session.status = "attention";
-      publish(session, approval2);
+      publish(session, approval3);
     }
     if (direction === "editor" && !message.method) {
       const pending = permissions.get(String(message.id));
@@ -3836,16 +3840,16 @@ function attachAcp(socket, onEvent) {
 async function proxyAcp(config2, executable, args2) {
   if (!config2.localSecret) throw new Error("Start dashup watch before using the ACP proxy");
   const socket = await new Promise((resolve3, reject) => {
-    const connect3 = request({
+    const connect4 = request({
       hostname: "127.0.0.1",
       port: connectorPort(),
       method: "CONNECT",
       path: "/acp",
       headers: { Authorization: `Bearer ${config2.localSecret}` }
     });
-    connect3.on("connect", (response, stream) => response.statusCode === 200 ? resolve3(stream) : reject(new Error("Dashup ACP connection was rejected")));
-    connect3.on("error", reject);
-    connect3.end();
+    connect4.on("connect", (response, stream) => response.statusCode === 200 ? resolve3(stream) : reject(new Error("Dashup ACP connection was rejected")));
+    connect4.on("error", reject);
+    connect4.end();
   });
   const child = spawn(executable, args2, { stdio: ["pipe", "pipe", "inherit"], windowsHide: true });
   const local = /* @__PURE__ */ new Set();
@@ -4013,7 +4017,7 @@ import * as ui from "@clack/prompts";
 import { z } from "zod";
 
 // package.json
-var version = "0.1.4";
+var version = "0.1.6";
 
 // src/pair.ts
 var Invitation = z.object({
@@ -4409,7 +4413,7 @@ var Viewer = class _Viewer {
 // src/discovery.ts
 import { homedir as homedir3 } from "node:os";
 import { createHmac } from "node:crypto";
-import { basename, join as join3 } from "node:path";
+import { basename, dirname as dirname3, join as join3 } from "node:path";
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 import { zstdDecompressSync } from "node:zlib";
 import { watch, existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "node:fs";
@@ -4569,6 +4573,7 @@ function title(value2, fallback) {
   const text3 = typeof value2 === "string" ? value2.trim().split("\n")[0].trim() : "";
   return text3 ? text3.slice(0, TITLE_LIMIT) : fallback;
 }
+var injected = (content) => /^\s*(# AGENTS\.md instructions for |<[a-z_][\w -]*>)/i.test(text(content));
 function text(value2) {
   if (typeof value2 === "string") return value2;
   if (Array.isArray(value2)) return value2.map(text).filter(Boolean).join("\n");
@@ -4637,18 +4642,19 @@ function step(id, name, input, result) {
     }
   };
 }
+var claudeHome = () => process.env.CLAUDE_CONFIG_DIR ?? join2(homedir2(), ".claude");
 var claudeMessage = (row) => (row.type === "user" || row.type === "assistant") && !row.isSidechain;
-function claudeChange(change) {
-  if (typeof change?.filePath !== "string") return void 0;
-  const hunks = list(change.structuredPatch);
+function claudeChange(change2) {
+  if (typeof change2?.filePath !== "string") return void 0;
+  const hunks = list(change2.structuredPatch);
   if (!hunks.length)
-    return change.type === "create" && typeof change.content === "string" ? added(change.filePath, change.content) : void 0;
+    return change2.type === "create" && typeof change2.content === "string" ? added(change2.filePath, change2.content) : void 0;
   return [
-    `--- ${change.filePath}`,
-    `+++ ${change.filePath}`,
-    ...hunks.flatMap((hunk) => [
-      `@@ -${hunk?.oldStart},${hunk?.oldLines} +${hunk?.newStart},${hunk?.newLines} @@`,
-      ...list(hunk?.lines)
+    `--- ${change2.filePath}`,
+    `+++ ${change2.filePath}`,
+    ...hunks.flatMap((hunk2) => [
+      `@@ -${hunk2?.oldStart},${hunk2?.oldLines} +${hunk2?.newStart},${hunk2?.newLines} @@`,
+      ...list(hunk2?.lines)
     ])
   ].join("\n");
 }
@@ -4714,7 +4720,9 @@ function claude(root, scan) {
         continue;
       }
       const named = latest.find((row) => row.type === "custom-title" || row.type === "ai-title");
-      const first = rows.find((row) => row.type === "user" && !row.isMeta && !row.isSidechain);
+      const first = rows.find(
+        (row) => row.type === "user" && !row.isMeta && !row.isSidechain && !injected(row.message?.content)
+      );
       scan.sessions.push({
         harness: "claude",
         id: owner.sessionId,
@@ -4762,7 +4770,7 @@ function codexMessages(path) {
     if (!item) return [];
     const id = String(item.id ?? row.ordinal ?? `${index}`);
     if (item.type === "message" && ["user", "assistant"].includes(item.role))
-      return prose(id, item.role, item.content);
+      return item.role === "user" && injected(item.content) ? [] : prose(id, item.role, item.content);
     if (!["function_call", "custom_tool_call"].includes(item.type)) return [];
     const input = item.type === "function_call" ? parse(String(item.arguments)) ?? item.arguments : item.input;
     const output = outputs.get(item.call_id);
@@ -4803,6 +4811,7 @@ function codex(root, scan) {
       scan.warnings.push(`Cannot read Codex session index: ${index}`);
     }
   }
+  const titles = codexTitles(root);
   for (const path of [
     ...files(join2(root, "sessions"), scan),
     ...files(join2(root, "archived_sessions"), scan)
@@ -4818,13 +4827,16 @@ function codex(root, scan) {
       }
       const named = names.get(owner.id);
       const first = rows.find(
-        (row) => row.type === "response_item" && row.payload?.type === "message" && row.payload.role === "user"
+        (row) => row.type === "response_item" && row.payload?.type === "message" && row.payload.role === "user" && !injected(row.payload.content)
       );
       scan.sessions.push({
         harness: "codex",
         id: owner.id,
         cwd,
-        title: title(named?.thread_name ?? text(first?.payload?.content), "Codex thread"),
+        title: title(
+          named?.thread_name ?? titles.get(owner.id) ?? text(first?.payload?.content),
+          "Codex thread"
+        ),
         parent: typeof owner.parent_thread_id === "string" ? owner.parent_thread_id : void 0,
         updatedAt: date(latest.find(codexItem)?.timestamp, statSync(path).mtimeMs),
         files: [path, ...existsSync3(index) ? [index] : []],
@@ -4893,6 +4905,30 @@ function databaseMessages(path, session) {
     db.close();
   }
 }
+function codexSubagent(row) {
+  const spawn7 = object(object(parse(String(row.source ?? "")))?.subagent)?.thread_spawn;
+  const task = typeof spawn7?.agent_path === "string" ? spawn7.agent_path.split("/").pop() : "";
+  return [row.agent_nickname, task?.replace(/_/g, " ")].filter(Boolean).join(" \xB7 ");
+}
+function codexTitles(root) {
+  const titles = /* @__PURE__ */ new Map();
+  const state = (existsSync3(root) ? readdirSync(root) : []).filter((name) => /^state_\d+\.sqlite$/.test(name)).sort((a, b) => Number(b.match(/\d+/)[0]) - Number(a.match(/\d+/)[0]))[0];
+  if (!state) return titles;
+  let db;
+  try {
+    db = openDatabase(join2(root, state));
+    for (const row of db.prepare("SELECT id, title, first_user_message, source, agent_nickname FROM threads").all()) {
+      const name = [row.title, row.first_user_message].find(
+        (value2) => typeof value2 === "string" && !!value2.trim() && !injected(value2)
+      );
+      if (typeof row.id === "string") titles.set(row.id, name ?? codexSubagent(row));
+    }
+  } catch {
+  } finally {
+    db?.close();
+  }
+  return titles;
+}
 function openCodeDatabase(path, scan) {
   if (!existsSync3(path)) {
     watchParent(path, scan);
@@ -4991,7 +5027,7 @@ function openCodeLegacy(root, scan) {
 function scanHistories() {
   const home = homedir2();
   const scan = { sessions: [], paths: /* @__PURE__ */ new Set(), warnings: [] };
-  claude(process.env.CLAUDE_CONFIG_DIR ?? join2(home, ".claude"), scan);
+  claude(claudeHome(), scan);
   codex(process.env.CODEX_HOME ?? join2(home, ".codex"), scan);
   const opencode = join2(process.env.XDG_DATA_HOME ?? join2(home, ".local/share"), "opencode");
   openCodeDatabase(process.env.OPENCODE_DB ?? join2(opencode, "opencode.db"), scan);
@@ -5133,7 +5169,7 @@ var Discovery = class {
     const project = this.project(session.cwd);
     const thread = {
       id: agentThread(session.harness, session.id, this.secret),
-      title: session.title,
+      title: session.title ?? "",
       editor: "cli",
       status: "unknown",
       updatedAt: session.updatedAt,
@@ -5152,13 +5188,24 @@ var Discovery = class {
     thread.updatedAt = session.updatedAt;
     if (session.parent) thread.parent = agentThread(session.harness, session.parent, this.secret);
   }
+  // Where new projects go: the folders holding this computer's projects, most used first.
+  folders() {
+    const counts = /* @__PURE__ */ new Map();
+    for (const project of this.projects.values())
+      if (!project.remote) {
+        const parent = dirname3(project.path);
+        counts.set(parent, (counts.get(parent) ?? 0) + 1);
+      }
+    const folders = [...counts].sort((a, b) => b[1] - a[1]).map(([folder]) => folder).filter((folder) => existsSync4(folder)).slice(0, 3);
+    return folders.length ? folders : [homedir3()];
+  }
   observe(session) {
     const found = this.native(session);
     const location2 = this.locations.get(found.thread.id);
     location2.live = session;
     Object.assign(found.thread, {
       editor: session.editor ?? found.thread.editor,
-      title: session.title,
+      title: session.title ?? found.thread.title,
       status: session.status,
       updatedAt: location2.history?.updatedAt ?? session.updatedAt,
       capabilities: {
@@ -5377,6 +5424,8 @@ var Discovery = class {
 
 // src/connector.ts
 import { z as z2 } from "zod";
+import { join as join9 } from "node:path";
+import { mkdir } from "node:fs/promises";
 import { randomBytes as randomBytes4 } from "node:crypto";
 
 // ../../node_modules/.pnpm/engine.io-client@6.6.7/node_modules/engine.io-client/build/esm-debug/transports/polling-xhr.node.js
@@ -16395,11 +16444,17 @@ async function publishHistory(config2, pair, project, thread, messages5) {
   return summary;
 }
 
+// src/harness/live.ts
+import { promisify as promisify6 } from "node:util";
+import { execFile as execFile6 } from "node:child_process";
+
 // src/harness/codex.ts
 import WebSocket2 from "ws";
 import { homedir as homedir4 } from "node:os";
 import { connect } from "node:net";
+import { promisify as promisify3 } from "node:util";
 import { randomUUID as randomUUID2 } from "node:crypto";
+import { execFile as execFile3 } 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;
@@ -16431,13 +16486,12 @@ function approval(id, method, params) {
     choices: DECISIONS.filter((choice) => !unavailable || choice.id === "decline").map((choice) => ({ ...choice }))
   };
 }
+var codexHome = () => process.env.DASHUP_CODEX_HOME ?? process.env.CODEX_HOME ?? join4(homedir4(), ".codex");
 async function sockets() {
   const explicit = process.env.DASHUP_CODEX_SOCKET;
   if (explicit !== void 0) return explicit && isAbsolute2(explicit) ? [explicit] : [];
   if (process.env.DASHUP_LIVE_DISCOVERY === "0") return [];
-  const homes = /* @__PURE__ */ new Set([
-    process.env.DASHUP_CODEX_HOME ?? process.env.CODEX_HOME ?? join4(homedir4(), ".codex")
-  ]);
+  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)) {
@@ -16623,6 +16677,16 @@ var Client = class {
     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 });
@@ -16670,12 +16734,12 @@ var Client = class {
             this.changed();
           }) : void 0,
           approve: approvals.length ? (requestId, approvalId, choice) => this.once(requestId, async () => {
-            const approval2 = this.approvals.get(approvalId);
+            const approval3 = this.approvals.get(approvalId);
             const socket = this.socket;
-            if (!approval2 || approval2.threadId !== id || !approval2.approval.choices.some((value2) => value2.id === choice) || socket?.readyState !== WebSocket2.OPEN)
+            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: approval2.requestId, result: { decision: choice } }),
+              JSON.stringify({ id: approval3.requestId, result: { decision: choice } }),
               (error) => error ? reject(new Error("Codex approval could not be sent")) : resolve3()
             ));
             this.approvals.delete(approvalId);
@@ -16705,8 +16769,28 @@ var Codex = class {
   }
   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 promisify3(execFile3)("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 = new Set(await sockets());
+    const paths = /* @__PURE__ */ new Set([...await sockets(), ...this.started]);
     for (const [path, client] of this.clients)
       if (!paths.has(path)) {
         client.stop();
@@ -16730,26 +16814,426 @@ var Codex = class {
   }
 };
 
+// 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";
+var CHOICES = [
+  { id: "accept", label: "Allow once" },
+  { id: "decline", label: "Reject" }
+];
+var EDITS = /* @__PURE__ */ new Set(["Edit", "MultiEdit", "NotebookEdit", "Write"]);
+var MAX_REQUESTS = 1e3;
+var NOTIFY_MS = 100;
+function hunk(before, after, offset = 0) {
+  const old = before ? before.replace(/\n$/, "").split("\n") : [];
+  const next = after ? after.replace(/\n$/, "").split("\n") : [];
+  let start = 0;
+  while (start < old.length && start < next.length && old[start] === next[start]) start++;
+  let end = 0;
+  while (end < old.length - start && end < next.length - start && old[old.length - 1 - end] === next[next.length - 1 - end])
+    end++;
+  const removed = old.slice(start, old.length - end);
+  const added2 = next.slice(start, next.length - end);
+  return {
+    lines: [
+      `@@ -${offset + start + 1},${removed.length} +${offset + start + 1},${added2.length} @@`,
+      ...old.slice(Math.max(0, start - 3), start).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;
+  approvals = /* @__PURE__ */ new Map();
+  requests = /* @__PURE__ */ new Map();
+  write(value2) {
+    this.turn?.stdin.write(`${JSON.stringify(value2)}
+`);
+  }
+  once(id, action) {
+    const known = this.requests.get(id);
+    if (known) return known;
+    if (this.requests.size >= MAX_REQUESTS)
+      throw new Error("Claude Code command history is full; restart Dashup before sending");
+    const result = action();
+    this.requests.set(id, result);
+    return result;
+  }
+  // Resolves once Claude Code takes the message, or says why it could not start.
+  say(text3) {
+    this.messages.push({ id: randomUUID3(), role: "user", text: text3 });
+    this.status = "working";
+    this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const message = { type: "user", message: { role: "user", content: text3 } };
+    if (this.turn) {
+      this.open++;
+      this.write(message);
+      this.changed();
+      return Promise.resolve();
+    }
+    const turn = this.turn = spawn3(
+      "claude",
+      [
+        "-p",
+        "--input-format",
+        "stream-json",
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--permission-prompt-tool",
+        "stdio",
+        ...this.saved ? ["--resume", this.id] : ["--session-id", this.id]
+      ],
+      { cwd: this.cwd, stdio: "pipe", shell: process.platform === "win32" }
+    );
+    this.open = 1;
+    let errors = "";
+    turn.stdin.on("error", () => {
+    });
+    turn.stderr.on("data", (chunk) => {
+      errors = (errors + String(chunk)).slice(-2e3);
+    });
+    const started = new Promise((resolve3, reject) => {
+      createInterface3({ input: turn.stdout }).on("line", (line) => {
+        if (this.receive(line)) resolve3();
+      });
+      const end = (reason) => {
+        reject(new Error(reason));
+        if (this.turn !== turn) return;
+        this.turn = void 0;
+        this.open = 0;
+        this.approvals.clear();
+        this.status = "idle";
+        this.changed();
+      };
+      turn.once("error", () => end("Claude Code is not installed on this computer"));
+      turn.once("exit", () => end(errors.trim() || "Claude Code stopped before starting"));
+    });
+    this.write(message);
+    this.changed();
+    return started;
+  }
+  // Handles one line of Claude Code's output, and says whether it started the session.
+  receive(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return false;
+    }
+    const init = message.type === "system" && message.subtype === "init";
+    if (init) this.saved = true;
+    else if (message.type === "assistant") {
+      const text3 = (Array.isArray(message.message?.content) ? message.message.content : []).filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n\n");
+      if (!text3) return false;
+      this.messages.push({ id: String(message.message?.id ?? 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)
+      });
+      this.status = "attention";
+    } else if (message.type === "result") {
+      if (--this.open <= 0) this.turn?.stdin.end();
+    } else return false;
+    this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.changed();
+    return init;
+  }
+  live() {
+    return {
+      id: this.id,
+      cwd: this.cwd,
+      title: this.title,
+      harness: "claude",
+      updatedAt: this.updatedAt,
+      status: this.status,
+      messages: [...this.messages],
+      approvals: [...this.approvals.values()].map((pending) => pending.approval),
+      send: (requestId, text3) => this.once(requestId, () => this.say(text3)),
+      stop: this.turn ? (requestId) => this.once(requestId, async () => {
+        if (!this.turn) throw new Error("Nothing is running in this Claude Code session");
+        this.write({
+          type: "control_request",
+          request_id: randomUUID3(),
+          request: { subtype: "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." }
+          }
+        });
+        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() {
+    return [...this.sessions.values()].map((session) => session.live());
+  }
+  stop() {
+    clearTimeout(this.notify);
+    for (const session of this.sessions.values()) session.end();
+  }
+};
+
+// src/harness/claude.ts
+import { join as join5 } from "node:path";
+import { connect as connect2 } from "node:net";
+import { watch as watch2 } from "node:fs";
+import { lstat, readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
+var PEER_PROTOCOL = 1;
+var MAX_SESSIONS2 = 100;
+var REQUEST_MS2 = 4e3;
+var MAX_REQUESTS2 = 1e3;
+var ENVELOPE = "cross-session-message";
+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);
+        return [value2];
+      } catch {
+        return [];
+      }
+    })
+  );
+  return found.flat();
+}
+async function post(session, path, text3) {
+  const file = await lstat(path);
+  if (!file.isSocket() || process.getuid && file.uid !== process.getuid())
+    throw new Error("Claude Code inbox is not owned by this user");
+  const body2 = text3.replace(new RegExp(`<(?=/?${ENVELOPE})`, "gi"), "<\\");
+  const line = JSON.stringify({
+    type: "user",
+    session_id: session.sessionId,
+    priority: "next",
+    message: { role: "user", content: `<${ENVELOPE} from-name="Dashup">
+${body2}
+</${ENVELOPE}>` }
+  });
+  await new Promise((resolve3, reject) => {
+    const socket = connect2(path);
+    socket.setTimeout(REQUEST_MS2, () => socket.destroy(new Error("timed out")));
+    socket.once("error", () => reject(new Error("Claude Code is not accepting messages")));
+    socket.end(`${line}
+`, resolve3);
+  });
+}
+var Claude = class {
+  constructor(changed) {
+    this.changed = changed;
+  }
+  changed;
+  watcher;
+  notify;
+  requests = /* @__PURE__ */ new Map();
+  async refresh() {
+    this.watch();
+    return (await registrations()).map((session) => {
+      const path = session.peerProtocol === PEER_PROTOCOL ? session.messagingSocketPath : void 0;
+      return {
+        id: session.sessionId,
+        harness: "claude",
+        cwd: session.cwd,
+        updatedAt: new Date(session.updatedAt ?? 0).toISOString(),
+        status: STATUS[session.status ?? ""] ?? "unknown",
+        messages: [],
+        approvals: [],
+        send: path ? (requestId, text3) => this.once(requestId, () => post(session, path, text3)) : void 0
+      };
+    });
+  }
+  once(id, action) {
+    const known = this.requests.get(id);
+    if (known) return known;
+    if (this.requests.size >= MAX_REQUESTS2) 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;
+  }
+};
+
 // src/harness/vscode.ts
 import Socket3 from "ws";
 import { homedir as homedir5 } from "node:os";
-import { connect as connect2 } from "node:net";
-import { promisify as promisify3 } from "node:util";
+import { connect as connect3 } from "node:net";
+import { promisify as promisify4 } from "node:util";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { execFile as execFile3 } from "node:child_process";
-import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
-import { stat as stat2, readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
-import { join as join5, dirname as dirname3, basename as basename2, isAbsolute as isAbsolute3 } from "node:path";
+import { execFile as execFile4 } from "node:child_process";
+import { createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
+import { stat as stat2, readdir as readdir3, readFile as readFile3 } from "node:fs/promises";
+import { join as join6, dirname as dirname4, basename as basename2, 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";
-var REQUEST_MS2 = 4e3;
+var REQUEST_MS3 = 4e3;
 var MAX_BYTES2 = 8 * 1024 * 1024;
 var MAX_METADATA = 64 * 1024;
 var MAX_HOSTS = 16;
-var MAX_SESSIONS2 = 100;
+var MAX_SESSIONS3 = 100;
 var ROOT_CHANNEL = "ahp-root://";
-var run2 = promisify3(execFile3);
+var run2 = promisify4(execFile4);
 var CONFIRMATION_CHOICES = [
   { id: "approve", label: "Allow once", kind: "approve" },
   { id: "deny", label: "Reject", kind: "deny" }
@@ -16757,10 +17241,10 @@ 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" ? dirname3(override) : override] : [];
+    return override ? [basename2(override) === "User" ? dirname4(override) : override] : [];
   if (process.env.DASHUP_LIVE_DISCOVERY === "0") return [];
-  const base = process.platform === "darwin" ? join5(homedir5(), "Library/Application Support") : process.platform === "win32" ? process.env.APPDATA ?? join5(homedir5(), "AppData/Roaming") : process.env.XDG_CONFIG_HOME ?? join5(homedir5(), ".config");
-  return ["Code", "Code - Insiders"].map((name) => join5(base, name));
+  const base = process.platform === "darwin" ? join6(homedir5(), "Library/Application Support") : process.platform === "win32" ? process.env.APPDATA ?? join6(homedir5(), "AppData/Roaming") : process.env.XDG_CONFIG_HOME ?? join6(homedir5(), ".config");
+  return ["Code", "Code - Insiders"].map((name) => join6(base, name));
 }
 async function privateFile(path, limit) {
   const file = await stat2(path).catch(() => void 0);
@@ -16777,7 +17261,7 @@ async function privateFile(path, limit) {
           "-EncodedCommand",
           Buffer.from(script, "utf16le").toString("base64")
         ],
-        { timeout: REQUEST_MS2, maxBuffer: MAX_METADATA }
+        { timeout: REQUEST_MS3, maxBuffer: MAX_METADATA }
       );
       return stdout.trim().toLowerCase() === "true";
     } catch {
@@ -16789,16 +17273,16 @@ async function privateFile(path, limit) {
 async function entries() {
   const result = /* @__PURE__ */ new Map();
   for (const root of roots()) {
-    const registry2 = join5(root, "agent-host/local-endpoint");
-    const files2 = (await readdir2(join5(registry2, "entries")).catch(() => [])).filter((name) => name.endsWith(".json")).slice(0, MAX_HOSTS);
+    const registry2 = join6(root, "agent-host/local-endpoint");
+    const files2 = (await readdir3(join6(registry2, "entries")).catch(() => [])).filter((name) => name.endsWith(".json")).slice(0, MAX_HOSTS);
     const sources = [
-      ...files2.map((name) => join5(registry2, "entries", name)),
-      join5(registry2, "metadata.json")
+      ...files2.map((name) => join6(registry2, "entries", name)),
+      join6(registry2, "metadata.json")
     ];
     for (const path of sources) {
       try {
         if (!await privateFile(path, MAX_METADATA)) continue;
-        const parsed = JSON.parse(await readFile2(path, "utf8"));
+        const parsed = JSON.parse(await readFile3(path, "utf8"));
         const rows = basename2(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))
@@ -16818,7 +17302,7 @@ async function entries() {
             if (!socket?.isSocket() || process.getuid && socket.uid !== process.getuid())
               continue;
           }
-          if (!await privateFile(dirname3(path), MAX_BYTES2)) continue;
+          if (!await privateFile(dirname4(path), MAX_BYTES2)) continue;
           const key = `${root}\0${identity2}`;
           if (!result.has(key))
             result.set(key, {
@@ -16931,7 +17415,7 @@ var Host = class {
   client;
   connecting;
   stopped = false;
-  clientId = `dashup-${randomUUID3()}`;
+  clientId = `dashup-${randomUUID4()}`;
   resources = /* @__PURE__ */ new Map();
   subscriptions = /* @__PURE__ */ new Set();
   receipts = /* @__PURE__ */ new Map();
@@ -16983,9 +17467,9 @@ var Host = class {
     if (this.connecting) return this.connecting;
     this.connecting = (async () => {
       const socket = new Socket3(`ws://localhost/?tkn=${encodeURIComponent(this.entry.token)}`, {
-        createConnection: () => connect2(this.entry.path),
+        createConnection: () => connect3(this.entry.path),
         maxPayload: MAX_BYTES2,
-        handshakeTimeout: REQUEST_MS2
+        handshakeTimeout: REQUEST_MS3
       });
       socket.on("error", () => {
       });
@@ -17018,7 +17502,7 @@ var Host = class {
         }
       };
       const client = this.client = new AhpClient(transport, {
-        requestTimeoutMs: REQUEST_MS2,
+        requestTimeoutMs: REQUEST_MS3,
         subscriptionBuffer: 1024
       });
       this.resources.clear();
@@ -17082,7 +17566,7 @@ var Host = class {
       const timer = setTimeout(() => {
         this.receipts.delete(handle.clientSeq);
         reject(new Error("Native AHP action was not acknowledged; delivery is unknown"));
-      }, REQUEST_MS2);
+      }, REQUEST_MS3);
       this.receipts.set(handle.clientSeq, { resolve: resolve3, reject, timer });
     });
     this.requests.set(requestId, pending);
@@ -17092,12 +17576,12 @@ var Host = class {
     await this.connect();
     const catalog = await this.client.request("listSessions", {
       channel: ROOT_CHANNEL,
-      limit: MAX_SESSIONS2
+      limit: MAX_SESSIONS3
     });
     if (!Array.isArray(catalog.items)) return [];
     const result = [];
     const active = /* @__PURE__ */ new Set();
-    for (const summary of catalog.items.slice(0, MAX_SESSIONS2)) {
+    for (const summary of catalog.items.slice(0, MAX_SESSIONS3)) {
       try {
         const session = await this.subscribe(summary.resource);
         if (!session || session.lifecycle !== "ready" || !Array.isArray(session.chats)) continue;
@@ -17159,7 +17643,7 @@ var Host = class {
                 message: { text: value2, origin: { kind: "user" } }
               });
             } : void 0,
-            approve: approvals.some((approval2) => approval2.choices.length) ? (requestId, approvalId, choice) => {
+            approve: approvals.some((approval3) => approval3.choices.length) ? (requestId, approvalId, choice) => {
               const prior = this.requests.get(requestId);
               if (prior) return prior;
               const current = this.resources.get(summary.resource)?.state;
@@ -17230,15 +17714,15 @@ var VSCode = class {
 };
 
 // src/harness/opencode.ts
-import { join as join6 } from "node:path";
-import { promisify as promisify4 } from "node:util";
+import { join as join7 } from "node:path";
+import { promisify as promisify5 } from "node:util";
 import { createHash as createHash4 } from "node:crypto";
-import { execFile as execFile4 } from "node:child_process";
-import { stat as stat3, readlink, readdir as readdir3, readFile as readFile3 } from "node:fs/promises";
-var run3 = promisify4(execFile4);
-var REQUEST_MS3 = 4e3;
+import { execFile as execFile5, spawn as spawn4 } from "node:child_process";
+import { stat as stat3, readlink, readdir as readdir4, readFile as readFile4 } from "node:fs/promises";
+var run3 = promisify5(execFile5);
+var REQUEST_MS4 = 4e3;
 var MAX_BYTES3 = 8 * 1024 * 1024;
-var MAX_SESSIONS3 = 100;
+var MAX_SESSIONS4 = 100;
 var MAX_PROCESSES2 = 4096;
 var MAX_ENDPOINTS = 32;
 var EVENT_DELAY_MS = 100;
@@ -17261,10 +17745,10 @@ function authorization(environment) {
 }
 async function linuxEndpoints() {
   const result = [];
-  const processes = (await readdir3("/proc")).filter((id) => /^\d+$/.test(id)).slice(0, MAX_PROCESSES2);
+  const processes = (await readdir4("/proc")).filter((id) => /^\d+$/.test(id)).slice(0, MAX_PROCESSES2);
   const listeners = /* @__PURE__ */ new Map();
   for (const name of ["tcp", "tcp6"]) {
-    const table = await readFile3(`/proc/net/${name}`, "utf8").catch(() => "");
+    const table = await readFile4(`/proc/net/${name}`, "utf8").catch(() => "");
     for (const line of table.split("\n").slice(1)) {
       const columns = line.trim().split(/\s+/);
       if (columns[3] !== "0A") continue;
@@ -17280,16 +17764,16 @@ async function linuxEndpoints() {
       const directory2 = `/proc/${pid}`;
       const owner = await stat3(directory2);
       if (process.getuid && owner.uid !== process.getuid()) continue;
-      const command2 = (await readFile3(join6(directory2, "cmdline"), "utf8")).slice(0, 4096);
+      const command2 = (await readFile4(join7(directory2, "cmdline"), "utf8")).slice(0, 4096);
       if (!/(?:^|[\/\0 ])opencode(?:[\0 .]|$)/.test(command2)) continue;
       const environment = Object.fromEntries(
-        (await readFile3(join6(directory2, "environ"), "utf8")).split("\0").map((entry) => {
+        (await readFile4(join7(directory2, "environ"), "utf8")).split("\0").map((entry) => {
           const split = entry.indexOf("=");
           return [entry.slice(0, split), entry.slice(split + 1)];
         })
       );
-      for (const fd of (await readdir3(join6(directory2, "fd"))).slice(0, 1024)) {
-        const target = await readlink(join6(directory2, "fd", fd)).catch(() => "");
+      for (const fd of (await readdir4(join7(directory2, "fd"))).slice(0, 1024)) {
+        const target = await readlink(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) });
@@ -17318,7 +17802,7 @@ async function endpoints() {
     const { stdout } = await run3(
       "lsof",
       ["-nP", "-a", "-c", "opencode", "-iTCP", "-sTCP:LISTEN", "-Fn"],
-      { timeout: REQUEST_MS3, maxBuffer: MAX_BYTES3 }
+      { timeout: REQUEST_MS4, maxBuffer: MAX_BYTES3 }
     );
     return stdout.split("\n").flatMap((line) => {
       const port = /^n(?:127\.0\.0\.1|\[::1\]|\*):(\d+)$/.exec(line)?.[1];
@@ -17335,7 +17819,7 @@ async function endpoints() {
     const { stdout } = await run3(
       "powershell.exe",
       ["-NoProfile", "-NonInteractive", "-Command", script],
-      { timeout: REQUEST_MS3, maxBuffer: MAX_BYTES3 }
+      { timeout: REQUEST_MS4, maxBuffer: MAX_BYTES3 }
     );
     return stdout.split(/\r?\n/).filter((port) => /^\d+$/.test(port)).slice(0, MAX_ENDPOINTS).map((port) => ({
       url: localEndpoint(`http://127.0.0.1:${port}`),
@@ -17389,7 +17873,7 @@ function permissionApproval(permission, history, cwd) {
   const command2 = typeof input?.command === "string" ? input.command : metadata2?.command;
   const path = typeof metadata2?.filepath === "string" ? metadata2.filepath : input?.filePath;
   const diff = typeof metadata2?.diff === "string" ? metadata2.diff : "";
-  const change = typeof path === "string" && path.trim() && diff.trim() ? { path, diff } : void 0;
+  const change2 = typeof path === "string" && path.trim() && diff.trim() ? { path, diff } : void 0;
   const patterns = Array.isArray(permission.patterns) ? permission.patterns.filter((value2) => typeof value2 === "string") : [];
   const always = Array.isArray(permission.always) ? permission.always.filter((value2) => typeof value2 === "string") : [];
   let detail = [
@@ -17397,7 +17881,7 @@ function permissionApproval(permission, history, cwd) {
 ${command2}` : "",
     hasInput ? `Tool input:
 ${JSON.stringify(input, null, 2)}` : "",
-    diff && !change ? `Proposed diff:
+    diff && !change2 ? `Proposed diff:
 ${diff}` : "",
     `Working directory: ${cwd}`,
     patterns.length ? `Permission scope:
@@ -17406,10 +17890,10 @@ ${patterns.join("\n")}` : "",
 ${always.join("\n")}` : ""
   ].filter(Boolean).join("\n\n");
   const oversized = Buffer.byteLength(detail) > MAX_PREVIEW || Buffer.byteLength(diff) > MAX_PREVIEW;
-  const unavailable = !(hasInput || change || typeof command2 === "string" && command2.trim()) || oversized;
+  const unavailable = !(hasInput || change2 || typeof command2 === "string" && command2.trim()) || oversized;
   if (oversized) {
     detail = Buffer.from(detail).subarray(0, MAX_PREVIEW).toString("utf8");
-    if (change) change.diff = Buffer.from(diff).subarray(0, MAX_PREVIEW).toString("utf8");
+    if (change2) change2.diff = Buffer.from(diff).subarray(0, MAX_PREVIEW).toString("utf8");
   }
   if (unavailable) detail += `
 
@@ -17419,7 +17903,7 @@ ${SCREEN_PREVIEW}`;
     title: `Allow ${String(permission.permission ?? "tool")}?`,
     detail,
     choices: PERMISSION_CHOICES.filter((choice) => !unavailable || choice.id === "reject").map((choice) => ({ ...choice })),
-    ...change ? { change } : {}
+    ...change2 ? { change: change2 } : {}
   };
 }
 function promptContext(history) {
@@ -17455,7 +17939,7 @@ var Server = class {
     };
   }
   async request(path, directory2, payload) {
-    const signal = AbortSignal.timeout(REQUEST_MS3);
+    const signal = AbortSignal.timeout(REQUEST_MS4);
     const response = await fetch(this.endpoint.url + path, {
       method: payload === void 0 ? "GET" : "POST",
       headers: {
@@ -17482,15 +17966,31 @@ var Server = class {
     this.requests.set(id, pending);
     return pending;
   }
+  // A message to one of this folder's sessions, in the agent and model it last used; a new
+  // session takes OpenCode's defaults.
+  async prompt(id, cwd, text3) {
+    const existing = await this.request(`/session/${encodeURIComponent(id)}/message?limit=200`, cwd);
+    await this.request(`/session/${encodeURIComponent(id)}/prompt_async`, cwd, {
+      ...promptContext(existing),
+      parts: [{ type: "text", text: text3 }]
+    });
+    this.changed();
+  }
+  async start(cwd, text3) {
+    const id = (await this.request("/session", cwd, {}))?.id;
+    if (typeof id !== "string") throw new Error("OpenCode did not start a session");
+    await this.prompt(id, cwd, text3);
+    return id;
+  }
   async read() {
     const health = await this.request("/global/health");
     if (health?.healthy !== true || typeof health.version !== "string") return [];
     this.listen();
-    const sessions = await this.request(`/session?limit=${MAX_SESSIONS3}`);
+    const sessions = await this.request(`/session?limit=${MAX_SESSIONS4}`);
     if (!Array.isArray(sessions)) return [];
     const result = [];
     const states = /* @__PURE__ */ new Map();
-    for (const session of sessions.slice(0, MAX_SESSIONS3)) {
+    for (const session of sessions.slice(0, MAX_SESSIONS4)) {
       if (typeof session?.id !== "string" || typeof session.directory !== "string" || !session.directory)
         continue;
       try {
@@ -17566,7 +18066,7 @@ var Server = class {
             });
             this.changed();
           }),
-          approve: approvals.some((approval2) => approval2.choices.length) ? (requestId, approvalId, choice) => this.once(requestId, async () => {
+          approve: approvals.some((approval3) => approval3.choices.length) ? (requestId, approvalId, choice) => this.once(requestId, async () => {
             if (this.stopped) throw new Error("OpenCode is disconnected");
             if (approvalId.startsWith("question:")) {
               const requestID = approvalId.slice("question:".length);
@@ -17615,7 +18115,7 @@ var Server = class {
   listen() {
     if (this.stream || this.retry || this.stopped) return;
     const controller = this.stream = new AbortController();
-    const connectTimer = setTimeout(() => controller.abort(), REQUEST_MS3);
+    const connectTimer = setTimeout(() => controller.abort(), REQUEST_MS4);
     connectTimer.unref();
     void (async () => {
       const response = await fetch(this.endpoint.url + "/global/event", {
@@ -17684,15 +18184,64 @@ var Server = class {
     clearTimeout(this.notify);
   }
 };
+function serve(cwd) {
+  const child = spawn4("opencode", ["serve", "--hostname", "127.0.0.1", "--port", "0"], {
+    cwd,
+    stdio: ["ignore", "pipe", "ignore"],
+    shell: process.platform === "win32"
+  });
+  const endpoint = new Promise((resolve3, reject) => {
+    let output = "";
+    child.stdout.on("data", (chunk) => {
+      output = (output + String(chunk)).slice(-4096);
+      const port = /https?:\/\/(?:127\.0\.0\.1|localhost):(\d+)/.exec(output)?.[1];
+      if (port)
+        resolve3({
+          url: localEndpoint(`http://127.0.0.1:${port}`),
+          authorization: authorization(process.env)
+        });
+    });
+    child.once("error", () => reject(new Error("OpenCode is not installed on this computer")));
+    child.once("exit", () => reject(new Error("OpenCode stopped before it started serving")));
+  });
+  return { process: child, endpoint };
+}
 var OpenCode = class {
   constructor(changed) {
     this.changed = changed;
   }
   changed;
   servers = /* @__PURE__ */ new Map();
+  // Servers this connector started, by folder.
+  started = /* @__PURE__ */ new Map();
+  // The server this connector runs for a folder, started when first needed.
+  async served(cwd) {
+    let served = this.started.get(cwd);
+    if (!served) this.started.set(cwd, served = serve(cwd));
+    const endpoint = await served.endpoint.catch((error) => {
+      this.started.delete(cwd);
+      throw error;
+    });
+    let server = this.servers.get(endpoint.url);
+    if (!server) {
+      server = new Server(endpoint, this.changed);
+      this.servers.set(endpoint.url, server);
+    }
+    return server;
+  }
+  async start(cwd, text3) {
+    return (await this.served(cwd)).start(cwd, text3);
+  }
+  async resume(id, cwd, text3) {
+    await (await this.served(cwd)).prompt(id, cwd, text3);
+  }
   async refresh() {
     const discovered = await endpoints().catch(() => []);
     const current = new Map(discovered.map((endpoint) => [endpoint.url, endpoint]));
+    for (const served of this.started.values()) {
+      const endpoint = await served.endpoint.catch(() => void 0);
+      if (endpoint) current.set(endpoint.url, endpoint);
+    }
     for (const [url2, server] of this.servers)
       if (!current.has(url2)) {
         server.stop();
@@ -17713,6 +18262,8 @@ var OpenCode = class {
   stop() {
     for (const server of this.servers.values()) server.stop();
     this.servers.clear();
+    for (const served of this.started.values()) served.process.kill();
+    this.started.clear();
   }
 };
 
@@ -17721,6 +18272,8 @@ var DISCOVERY_MS = 1e4;
 var LiveHarnesses = class {
   listeners = /* @__PURE__ */ new Set();
   codex = new Codex(() => this.changed());
+  headless = new Headless(() => this.changed());
+  claude = new Claude(() => this.changed());
   vscode = new VSCode(() => this.changed());
   opencode = new OpenCode(() => this.changed());
   timer;
@@ -17734,8 +18287,10 @@ var LiveHarnesses = class {
     if (this.refreshing) return this.refreshing;
     this.refreshing = (async () => {
       const results = await Promise.allSettled([
+        this.headless.refresh(),
         this.opencode.refresh(),
         this.codex.refresh(),
+        this.claude.refresh(),
         this.vscode.refresh()
       ]);
       const sessions = /* @__PURE__ */ new Map();
@@ -17751,6 +18306,35 @@ var LiveHarnesses = class {
     });
     return this.refreshing;
   }
+  // The agents whose own command runs on this computer.
+  async agents() {
+    const harnesses = ["claude", "codex", "opencode"];
+    const runs = await Promise.all(
+      harnesses.map((harness) => promisify6(execFile6)(harness, ["--version"], {
+        timeout: 1e4,
+        shell: process.platform === "win32"
+      }).then(
+        () => true,
+        () => false
+      ))
+    );
+    return harnesses.filter((_, index) => runs[index]);
+  }
+  // Starts a session in `cwd` with its first message, and resolves with the session's native id.
+  start(harness, cwd, text3) {
+    return { claude: this.headless, codex: this.codex, opencode: this.opencode }[harness].start(
+      cwd,
+      text3
+    );
+  }
+  // Continues a saved session with a message, and resolves once its agent takes it.
+  resume(harness, id, cwd, text3) {
+    return { claude: this.headless, codex: this.codex, opencode: this.opencode }[harness].resume(
+      id,
+      cwd,
+      text3
+    );
+  }
   watch(onChange) {
     this.listeners.add(onChange);
     if (!this.timer && process.env.DASHUP_LIVE_DISCOVERY !== "0") {
@@ -17769,20 +18353,22 @@ var LiveHarnesses = class {
     this.stopped = true;
     clearInterval(this.timer);
     this.listeners.clear();
+    this.headless.stop();
     this.opencode.stop();
     this.codex.stop();
+    this.claude.stop();
     this.vscode.stop();
   }
 };
 
 // src/harness/queue.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-import { spawn as spawn3 } from "node:child_process";
+import { randomUUID as randomUUID5 } from "node:crypto";
+import { spawn as spawn5 } from "node:child_process";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
-import { join as join7, dirname as dirname4, basename as basename3 } from "node:path";
-import { statSync as statSync2, existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync3, readlinkSync, realpathSync as realpathSync2 } from "node:fs";
+import { join as join8, dirname as dirname5, basename as basename3 } from "node:path";
+import { statSync as statSync2, existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync4, readlinkSync, realpathSync as realpathSync2 } from "node:fs";
 var CODEX_VERSION = "0.160.1";
-var REQUEST_MS4 = 1e4;
+var REQUEST_MS5 = 1e4;
 var MAX_BYTES4 = 1024 * 1024;
 var MAX_PROCESSES3 = 4096;
 var MAX_FILES = 4096;
@@ -17798,11 +18384,11 @@ function sameFile(left, right) {
   return left.path === right.path && left.device === right.device && left.inode === right.inode;
 }
 function packageVersion(executable) {
-  let directory2 = dirname4(executable);
-  for (let depth = 0; depth < 8; depth++, directory2 = dirname4(directory2)) {
-    const path = join7(directory2, "package.json");
+  let directory2 = dirname5(executable);
+  for (let depth = 0; depth < 8; depth++, directory2 = dirname5(directory2)) {
+    const path = join8(directory2, "package.json");
     if (!existsSync5(path)) continue;
-    const value2 = JSON.parse(readFileSync3(path, "utf8"));
+    const value2 = JSON.parse(readFileSync4(path, "utf8"));
     if (value2.name?.startsWith("@openai/codex-")) return value2.version;
   }
   return void 0;
@@ -17810,40 +18396,40 @@ function packageVersion(executable) {
 function processOwners(pid) {
   const root = `/proc/${pid}`;
   if (process.getuid && statSync2(root).uid !== process.getuid()) return [];
-  const executable = realpathSync2.native(join7(root, "exe"));
+  const executable = realpathSync2.native(join8(root, "exe"));
   if (basename3(executable) !== "codex" || packageVersion(executable) !== CODEX_VERSION) return [];
-  const status2 = readFileSync3(join7(root, "stat"), "utf8");
+  const status2 = readFileSync4(join8(root, "stat"), "utf8");
   const start = status2.slice(status2.lastIndexOf(")") + 2).split(" ")[19];
   if (!start || !/^\d+$/.test(start)) return [];
-  const fds = readdirSync3(join7(root, "fd")).slice(0, MAX_FILES);
+  const fds = readdirSync3(join8(root, "fd")).slice(0, MAX_FILES);
   const files2 = fds.flatMap((fd) => {
     try {
-      return [{ fd, path: readlinkSync(join7(root, "fd", fd)) }];
+      return [{ fd, path: readlinkSync(join8(root, "fd", fd)) }];
     } catch {
       return [];
     }
   });
   return files2.flatMap(({ fd, path }) => {
-    if (basename3(dirname4(path)) !== "thread-writer-locks" || !path.endsWith(".lock")) return [];
+    if (basename3(dirname5(path)) !== "thread-writer-locks" || !path.endsWith(".lock")) return [];
     const thread = basename3(path, ".lock");
     if (!THREAD_ID.test(thread)) return [];
     try {
-      const lock = readFileSync3(join7(root, "fdinfo", fd), "utf8");
+      const lock = readFileSync4(join8(root, "fdinfo", fd), "utf8");
       if (!/FLOCK\s+ADVISORY\s+WRITE/.test(lock)) return [];
-      const home = realpathSync2.native(dirname4(dirname4(path)));
+      const home = realpathSync2.native(dirname5(dirname5(path)));
       const directory2 = statSync2(home);
       if (process.getuid && directory2.uid !== process.getuid()) return [];
-      const queue = identity(join7(home, "queue_1.sqlite"));
+      const queue = identity(join8(home, "queue_1.sqlite"));
       if (!files2.some((file) => {
         try {
-          return sameFile(identity(join7(root, "fd", file.fd)), queue);
+          return sameFile(identity(join8(root, "fd", file.fd)), queue);
         } catch {
           return false;
         }
       }))
         return [];
       const rollout = files2.find(
-        (file) => file.path.startsWith(join7(home, "sessions") + "/") && file.path.endsWith(`-${thread}.jsonl`)
+        (file) => file.path.startsWith(join8(home, "sessions") + "/") && file.path.endsWith(`-${thread}.jsonl`)
       );
       if (!rollout) return [];
       return [
@@ -17855,7 +18441,7 @@ function processOwners(pid) {
           thread,
           queue,
           version: CODEX_VERSION,
-          cwd: realpathSync2.native(join7(root, "cwd")),
+          cwd: realpathSync2.native(join8(root, "cwd")),
           rollout: identity(rollout.path)
         }
       ];
@@ -17901,7 +18487,7 @@ function validateOwner(owner) {
 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))
     throw new Error("The original native history storage changed");
-  const path = join7(owner.home, "thread_history_1.sqlite");
+  const path = join8(owner.home, "thread_history_1.sqlite");
   if (existsSync5(path) && identity(path).path !== path)
     throw new Error("Native history is outside the original home");
 }
@@ -17918,7 +18504,7 @@ function nativeReceipt(owner, clientId) {
   } finally {
     queue.close();
   }
-  const path = join7(owner.home, "thread_history_1.sqlite");
+  const path = join8(owner.home, "thread_history_1.sqlite");
   if (!existsSync5(path)) return { queueId };
   const history = new DatabaseSync3(path, { readOnly: true });
   try {
@@ -17974,7 +18560,7 @@ var Writer = class {
   tail = "";
   pending = /* @__PURE__ */ new Map();
   constructor(owner) {
-    this.process = spawn3(owner.executable, ["app-server", "--listen", "stdio://"], {
+    this.process = spawn5(owner.executable, ["app-server", "--listen", "stdio://"], {
       cwd: owner.cwd,
       env: { ...process.env, CODEX_HOME: owner.home },
       stdio: ["pipe", "pipe", "ignore"]
@@ -18014,7 +18600,7 @@ var Writer = class {
         this.pending.delete(id);
         reject(new Error("Native queue acknowledgement was not received"));
         this.close();
-      }, REQUEST_MS4);
+      }, REQUEST_MS5);
       this.pending.set(id, { resolve: resolve3, reject, timer });
       this.process.stdin.write(JSON.stringify({ id, method, params }) + "\n");
     });
@@ -18061,7 +18647,7 @@ var NativeQueue = class {
     if (existing) return existing;
     if (this.stopped) throw new Error("The connector is stopping");
     validateOwner(scope2.owner);
-    const clientUserMessageId = randomUUID4();
+    const clientUserMessageId = randomUUID5();
     const request2 = { ...scope2, receipt: { state: "unknown", clientUserMessageId } };
     let writer;
     try {
@@ -18146,7 +18732,13 @@ var Command = z2.object({
     z2.object({ kind: z2.literal("thread.stop") }).strict(),
     z2.object({ kind: z2.literal("approval.respond"), approvalId: z2.string(), choice: z2.string() }).strict(),
     z2.object({ kind: z2.literal("screen.start"), sessionId: z2.string().min(1).max(128) }).strict(),
-    z2.object({ kind: z2.literal("screen.stop"), sessionId: z2.string().min(1).max(128) }).strict()
+    z2.object({ kind: z2.literal("screen.stop"), sessionId: z2.string().min(1).max(128) }).strict(),
+    z2.object({
+      kind: z2.literal("session.start"),
+      harness: z2.enum(["claude", "codex", "opencode"]),
+      text: z2.string().min(1).max(1e5),
+      folder: z2.object({ parent: z2.string().min(1), name: z2.string().min(1).max(255) }).strict().optional()
+    }).strict()
   ])
 }).strict();
 var Connector = class {
@@ -18208,6 +18800,8 @@ var Connector = class {
   listed = /* @__PURE__ */ new Map();
   listedProjects = /* @__PURE__ */ new Map();
   overviewQueued = false;
+  // The agents that can start sessions here.
+  startable = [];
   snapshots = /* @__PURE__ */ new Set();
   nativeSnapshots = /* @__PURE__ */ new Map();
   queueReceipts = /* @__PURE__ */ new Map();
@@ -18221,6 +18815,8 @@ var Connector = class {
       this.nativeSnapshots.set(thread.id, structuredClone(this.threadState(project, thread)));
     }
     this.refreshQueues();
+    this.refreshResumes();
+    void this.findAgents().then(() => this.queueChange());
     this.stopWatching = this.discovery.watch(this.rescan);
     this.releases.push(this.harnesses.watch(this.rescan));
     this.releases.push(
@@ -18259,15 +18855,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 approval2 = native?.approvals[0];
-                if (!approval2) continue;
+                const approval3 = native?.approvals[0];
+                if (!approval3) continue;
                 await this.thread(pair, project, thread);
                 await this.send(pair, {
                   type: "attention",
                   projectId: project.id,
                   threadId: thread.id,
-                  title: approval2.title,
-                  body: approval2.detail,
+                  title: approval3.title,
+                  body: approval3.detail,
                   reason: "approval"
                 });
               }
@@ -18435,6 +19031,10 @@ var Connector = class {
     }
     return {
       type: "projects",
+      version,
+      screen: this.discovery.capabilities.screen,
+      agents: this.startable,
+      folders: this.discovery.folders(),
       projects: [...this.listedProjects.values()],
       sessions: [
         ...sessions.filter(busy),
@@ -18442,6 +19042,10 @@ var Connector = class {
       ]
     };
   }
+  // Agents change only when someone installs or removes one, so a refresh asks again.
+  async findAgents() {
+    this.startable = await this.harnesses.agents();
+  }
   async listProjects(pair) {
     const overview = this.overview();
     const text3 = JSON.stringify(overview);
@@ -18471,6 +19075,7 @@ var Connector = class {
     const native = await this.harnesses.refresh();
     const live = native.map((session) => ({ ...this.discovery.observe(session), session }));
     this.refreshQueues();
+    this.refreshResumes();
     for (const agent of this.agents.values()) if (!agent.socket.destroyed) this.adopt(agent);
     const current = new Set(live.map(({ thread }) => thread.id));
     for (const [id, snapshot] of this.nativeSnapshots) {
@@ -18507,9 +19112,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 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");
+      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");
       if (prior?.thread.status === "working" && thread.status === "idle")
         await this.attention(
           project.id,
@@ -18522,6 +19127,17 @@ var Connector = class {
     for (const pair of this.activePairs()) await this.listProjects(pair);
     await this.publishQueueReceipts();
   }
+  // A saved session nothing else has open continues headless when its agent runs here. One a
+  // native process owns takes queued messages instead.
+  refreshResumes() {
+    for (const project of this.discovery.projects.values())
+      for (const thread of project.threads) {
+        const location2 = this.discovery.locations.get(thread.id);
+        const harness = thread.agent?.harness;
+        if (location2?.history && !location2.live && !project.remote && !thread.capabilities.queue && harness && harness !== "other" && this.startable.includes(harness))
+          thread.capabilities = { ...thread.capabilities, send: true };
+      }
+  }
   refreshQueues() {
     this.nativeQueue.refresh();
     for (const project of this.discovery.projects.values())
@@ -18591,18 +19207,21 @@ var Connector = class {
   async execute(pair, content, envelope) {
     let queue = void 0;
     try {
-      if (["screen.start", "approval.respond", "thread.stop"].includes(content.action.kind) && Math.abs(Date.now() - Date.parse(envelope.sentAt)) > EPHEMERAL_TTL_MS)
+      if (["screen.start", "approval.respond", "thread.stop", "session.start"].includes(
+        content.action.kind
+      ) && Math.abs(Date.now() - Date.parse(envelope.sentAt)) > EPHEMERAL_TTL_MS)
         throw new Error("Command expired. Try again while this computer is online.");
-      queue = await this.command(pair, content);
+      const outcome = await this.command(pair, content);
       delete this.config.unconfirmed[content.requestId];
-      if (queue) {
+      if (outcome && "state" in outcome) {
+        queue = outcome;
         await this.queueResult(pair, content.requestId, content.projectId, queue);
         this.queueReceipts.set(content.requestId, JSON.stringify(queue));
         return;
       }
       await this.send(
         pair,
-        { type: "result", requestId: content.requestId, ok: true },
+        { type: "result", requestId: content.requestId, ok: true, ...outcome ? { started: outcome } : {} },
         content.projectId
       );
     } catch (error) {
@@ -18637,7 +19256,7 @@ var Connector = class {
     }
   }
   attach(socket) {
-    const sessions = bridgeAcp(socket, (session, approval2) => {
+    const sessions = bridgeAcp(socket, (session, approval3) => {
       this.agents.set(session.id, session);
       const { project, thread } = this.adopt(session);
       if (!this.snapshots.has(session.id)) {
@@ -18652,15 +19271,15 @@ var Connector = class {
           }
         }).catch((error) => this.report(error));
       }
-      if (approval2)
+      if (approval3)
         this.work = this.work.then(async () => {
-          if (this.agents.get(session.id) !== session || ![...session.approvals.values()].includes(approval2))
+          if (this.agents.get(session.id) !== session || ![...session.approvals.values()].includes(approval3))
             return;
           await this.attention(
             project.id,
             thread.id,
-            approval2.title,
-            approval2.detail,
+            approval3.title,
+            approval3.detail,
             "approval"
           );
         }).catch((error) => this.report(error));
@@ -18729,9 +19348,12 @@ var Connector = class {
   }
   async command(pair, command2) {
     if (command2.action.kind === "projects.refresh") {
+      await this.findAgents();
       await this.changed();
       return this.publishProjects(pair);
     }
+    if (command2.action.kind === "session.start")
+      return this.startSession(command2.projectId, command2.action);
     const project = this.discovery.projects.get(command2.projectId);
     if (!project) throw new Error("Project is no longer open on this computer");
     const thread = project.threads.find((item) => item.id === command2.threadId);
@@ -18747,9 +19369,15 @@ var Connector = class {
           throw new Error(
             "This session has no live reply connection. Open Screen to use the existing agent."
           );
-        const native = this.discovery.locations.get(thread.id)?.live;
-        if (native?.send) return native.send(command2.requestId, command2.action.text);
+        const location2 = this.discovery.locations.get(thread.id);
+        if (location2?.live?.send) return location2.live.send(command2.requestId, command2.action.text);
         const agent = this.attached(thread);
+        const saved = thread.agent;
+        if (!agent && location2?.history && saved && saved.harness !== "other") {
+          await this.harnesses.resume(saved.harness, saved.sessionId, project.path, command2.action.text);
+          await this.changed();
+          return;
+        }
         if (!agent || agent.socket.destroyed || agent.status === "working")
           throw new Error("Wait for the current ACP turn to finish");
         return commandAcp(agent, command2.requestId, { kind: "prompt", text: command2.action.text });
@@ -18788,15 +19416,15 @@ var Connector = class {
         const action = command2.action;
         const native = this.discovery.locations.get(thread.id)?.live;
         if (native?.approve) {
-          const approval3 = native.approvals.find((item) => item.id === action.approvalId);
-          if (!approval3?.choices.some((choice) => choice.id === action.choice))
+          const approval4 = native.approvals.find((item) => item.id === action.approvalId);
+          if (!approval4?.choices.some((choice) => choice.id === action.choice))
             throw new Error("Approval is no longer available");
-          return native.approve(command2.requestId, approval3.id, action.choice);
+          return native.approve(command2.requestId, approval4.id, action.choice);
         }
         const agent = this.attached(thread);
         if (!agent) throw new Error("Approval requires an attached ACP session. Use Screen.");
-        const [request2, approval2] = [...agent.approvals].find(([, item]) => item.id === action.approvalId) ?? [];
-        if (!approval2?.choices.some((choice) => choice.id === action.choice))
+        const [request2, approval3] = [...agent.approvals].find(([, item]) => item.id === action.approvalId) ?? [];
+        if (!approval3?.choices.some((choice) => choice.id === action.choice))
           throw new Error("Approval is no longer available");
         return commandAcp(agent, command2.requestId, {
           kind: "approval",
@@ -18812,6 +19440,37 @@ var Connector = class {
         return;
     }
   }
+  // Starts an agent in a project, or in a new folder inside one this computer offers. Commands run
+  // in the work queue, so this refreshes directly rather than queueing a change behind itself.
+  async startSession(projectId, { harness, text: text3, folder }) {
+    if (!this.startable.includes(harness))
+      throw new Error(`${HARNESSES[harness]} doesn't run on this computer`);
+    let cwd;
+    if (folder) {
+      const name = folder.name.trim();
+      if (!this.discovery.folders().includes(folder.parent))
+        throw new Error("That folder is no longer offered for new projects");
+      if (!name || name === "." || name === ".." || /[\\/:*?"<>|\x00-\x1f]/.test(name))
+        throw new Error("Name the folder without slashes or special characters");
+      cwd = join9(folder.parent, name);
+      await mkdir(cwd).catch((error) => {
+        throw new Error(error.code === "EEXIST" ? `${name} already exists` : `Couldn't create ${name}`);
+      });
+    } else {
+      const project = this.discovery.projects.get(projectId);
+      if (!project) throw new Error("Project is no longer open on this computer");
+      if (project.remote)
+        throw new Error(`Install -up on ${project.remote.host} to start sessions there`);
+      cwd = project.path;
+    }
+    const session = await this.harnesses.start(harness, cwd, text3);
+    await this.changed();
+    for (const project of this.discovery.projects.values())
+      for (const thread of project.threads)
+        if (thread.agent?.harness === harness && thread.agent.sessionId === session)
+          return { projectId: project.id, threadId: thread.id };
+    throw new Error(`${HARNESSES[harness]} started, but this computer hasn't listed it yet`);
+  }
   report(error) {
     process.stderr.write(`${error instanceof Error ? error.message : "Dashup operation failed"}
 `);
@@ -18821,18 +19480,18 @@ var Connector = class {
 // src/install.ts
 import { existsSync as existsSync6 } from "node:fs";
 import { homedir as homedir6, userInfo } from "node:os";
-import { promisify as promisify5 } from "node:util";
+import { promisify as promisify7 } from "node:util";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { execFile as execFile5, spawn as spawn4 } from "node:child_process";
-import { cp, mkdir, rm, writeFile } from "node:fs/promises";
-import { dirname as dirname5, join as join8, relative, sep } from "node:path";
-var run4 = promisify5(execFile5);
+import { execFile as execFile7, spawn as spawn6 } from "node:child_process";
+import { cp, mkdir as mkdir2, rm, writeFile } from "node:fs/promises";
+import { dirname as dirname6, join as join10, relative, sep } from "node:path";
+var run4 = promisify7(execFile7);
 var xml = (value2) => value2.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var NODE_FLAGS = ["--disable-warning=ExperimentalWarning"];
-var serviceFile = () => process.platform === "darwin" ? join8(homedir6(), "Library/LaunchAgents/com.dashup.connector.plist") : process.platform === "win32" ? join8(
-  process.env.APPDATA ?? join8(homedir6(), "AppData/Roaming"),
+var serviceFile = () => process.platform === "darwin" ? join10(homedir6(), "Library/LaunchAgents/com.dashup.connector.plist") : process.platform === "win32" ? join10(
+  process.env.APPDATA ?? join10(homedir6(), "AppData/Roaming"),
   "Microsoft/Windows/Start Menu/Programs/Startup/Dashup.vbs"
-) : join8(homedir6(), ".config/systemd/user/dashup.service");
+) : join10(homedir6(), ".config/systemd/user/dashup.service");
 var startupInstalled = () => existsSync6(serviceFile());
 function service(platform, node, entry, config2) {
   const command2 = [node, ...NODE_FLAGS, entry];
@@ -18868,17 +19527,17 @@ async function durableEntry() {
     );
   if (!["_npx", "dlx"].some((cache2) => entry.includes(`${sep}${cache2}${sep}`))) return entry;
   const root = entry.slice(0, entry.indexOf(`${sep}node_modules${sep}`));
-  const app = join8(dirname5(configPath()), "app");
+  const app = join10(dirname6(configPath()), "app");
   await rm(app, { recursive: true, force: true });
-  await cp(join8(root, "node_modules"), join8(app, "node_modules"), {
+  await cp(join10(root, "node_modules"), join10(app, "node_modules"), {
     recursive: true,
     verbatimSymlinks: true
   });
-  return join8(app, relative(root, entry));
+  return join10(app, relative(root, entry));
 }
 async function installStartup() {
   const path = serviceFile();
-  await mkdir(dirname5(path), { recursive: true });
+  await mkdir2(dirname6(path), { recursive: true });
   await writeFile(
     path,
     service(process.platform, process.execPath, await durableEntry(), configPath())
@@ -18888,7 +19547,7 @@ async function installStartup() {
     });
     await run4("launchctl", ["load", path]);
   } else if (process.platform === "win32") {
-    spawn4("wscript.exe", [path], { detached: true, stdio: "ignore" }).unref();
+    spawn6("wscript.exe", [path], { detached: true, stdio: "ignore" }).unref();
   } else {
     await run4("systemctl", ["--user", "daemon-reload"]);
     await run4("systemctl", ["--user", "enable", "dashup.service"]);
@@ -18908,7 +19567,7 @@ async function uninstallStartup() {
     await run4("systemctl", ["--user", "disable", "dashup.service"]).catch(() => {
     });
   await rm(path, { force: true });
-  await rm(join8(dirname5(configPath()), "app"), { recursive: true, force: true });
+  await rm(join10(dirname6(configPath()), "app"), { recursive: true, force: true });
 }
 
 // src/index.ts