@dashup/connector 0.1.10 → 0.1.12

package/README.md

@@ -37,7 +37,7 @@ Dashup discovers existing local OpenCode listeners, Codex control sockets, and V
 - **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.
 - **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. Direct control of an ordinary foreground Claude process is not advertised when it exposes no supported attach interface.
+- **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.
 
 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.
 
-Stop interrupts the running turn through each live interface: OpenCode's session abort, Codex `turn/interrupt`, the AHP client's turn cancellation, and ACP `session/cancel`. It refuses when nothing is running and expires with other commands after 60 seconds, so a late stop cannot end a newer turn.
+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.
 
 Live discovery is bounded to 100 sessions per endpoint. OpenCode supplies the latest 200 messages; the VS Code host supplies its current chat snapshot. Paged history prefers the native saved store when available and otherwise uses the existing live snapshot. Approvals whose actual commands or file contents cannot be previewed are approved on the computer; rejection remains available when the native protocol supports it.
 

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

@@ -0,0 +1,5 @@
+{
+  "name": "dashup",
+  "owner": { "name": "Dashup" },
+  "plugins": [{ "name": "dashup", "source": "./" }]
+}

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

@@ -0,0 +1,4 @@
+{
+  "name": "dashup",
+  "description": "Takes what you send this session from the Dashup app as your own words"
+}

package/claude/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.ts"] }

package/claude/hooks/register.ts

@@ -0,0 +1,69 @@
+import type { EngineInterface, Register } from 'claude-code';
+
+// =============================================================================
+// Replies from the Dashup app
+// =============================================================================
+
+// Claude Code reads what other processes post to a session's inbox as another session's request,
+// never the person's. Dashup's connector instead streams what the person sends this session from
+// their phone, one delivery per line, and the session takes each message as their own. `now`
+// first ends the running turn, so a delivery without text only stops it.
+type Delivery = { text?: string; now?: true };
+
+const RETRY_MS = 10_000;
+
+export const register: Register = (on) => {
+  let turnId: string | undefined;
+  let stream: AsyncGenerator<unknown, unknown> | undefined;
+  on('turn.start', ($, e, next) => {
+    if (e.agentId === undefined) turnId = e.turnId;
+    return next(e);
+  });
+  // `/clear` starts another conversation in this process, which streams under its own id.
+  on('session.end', ($, e, next) => {
+    void stream?.return(undefined);
+    return next(e);
+  });
+  on('session.start', async ($, e, next) => {
+    const started = await next(e);
+    void (async () => {
+      const socketPath = `${await $.env.get('HOME')}/.dashup/claude.sock`;
+      for (;;) {
+        // A request held open here would hold the session's queue; a child's stream does not.
+        const lines = (stream = $.process.spawn({
+          argv: [
+            'curl',
+            '-sfN',
+            '--unix-socket',
+            socketPath,
+            `http://dashup/sessions/${await $.session.id()}`,
+          ],
+        }));
+        let buffer = '';
+        try {
+          for await (const { stream: name, text } of lines) {
+            if (name !== 'stdout') continue;
+            buffer += text;
+            for (let end = buffer.indexOf('\n'); end !== -1; end = buffer.indexOf('\n')) {
+              await take($, JSON.parse(buffer.slice(0, end)) as Delivery, turnId);
+              buffer = buffer.slice(end + 1);
+            }
+          }
+        } catch {
+          // curl is missing, or the stream broke off mid-line.
+        }
+        // Dashup is not running on this computer, or is restarting.
+        await $.clock.sleep(RETRY_MS);
+      }
+    })();
+    return started;
+  });
+};
+
+// A message runs once the session is idle; the stream must not wait for that.
+async function take($: EngineInterface, { text, now }: Delivery, turnId?: string): Promise<void> {
+  if (now && turnId) await $.turn.abort({ turnId }).catch(() => {});
+  const command = text?.match(/^\/(\S+)\s*([\s\S]*)$/);
+  if (command) void $.command.run({ command: command[1]!, args: command[2] }).catch(() => {});
+  else if (text) void $.prompt.submit({ text, asUser: true }).catch(() => {});
+}

package/dist/index.js

@@ -2149,15 +2149,15 @@ var require_short_unique_id = __commonJS({
                 this.lowerBound = this.dictRange[0];
                 this.upperBound = this.dictRange[1];
                 const isAscending = this.lowerBound <= this.upperBound;
-                const start = this.lowerBound;
+                const start2 = this.lowerBound;
                 const end = this.upperBound;
                 if (isAscending) {
-                  for (let i = start; i < end; i++) {
+                  for (let i = start2; i < end; i++) {
                     finalDict[dictIdx++] = String.fromCharCode(i);
                     this.dictIndex = i;
                   }
                 } else {
-                  for (let i = start; i > end; i--) {
+                  for (let i = start2; i > end; i--) {
                     finalDict[dictIdx++] = String.fromCharCode(i);
                     this.dictIndex = i;
                   }
@@ -2706,7 +2706,7 @@ var require_pluralize = __commonJS({
 
 // src/index.ts
 import { randomBytes as randomBytes5, timingSafeEqual } from "node:crypto";
-import { createServer as createServer2 } from "node:http";
+import { createServer as createServer3 } from "node:http";
 import * as ui2 from "@clack/prompts";
 import { z as z3 } from "zod";
 
@@ -2728,6 +2728,7 @@ var PROTOCOL_VERSION = 1;
 var MAX_ENVELOPE_BYTES = 8 * 1024 * 1024;
 var HISTORY_PAGE_ITEMS = 30;
 var HISTORY_TEXT_CHARS = 4e3;
+var HISTORY_TOOL_CHARS = 500;
 var HISTORY_PAGE_BYTES = 256 * 1024;
 var HISTORY_BATCH_ITEMS = 50;
 var HISTORY_BATCH_BYTES = HISTORY_PAGE_BYTES;
@@ -2741,9 +2742,11 @@ var MESSAGE_ROLES = ["user", "assistant", "system", "tool"];
 var HARNESSES = {
   claude: "Claude Code",
   codex: "Codex",
+  kimi: "Kimi",
   opencode: "OpenCode",
   other: "Agent"
 };
+var isStartHarness = (harness) => harness !== "other" && harness !== "kimi";
 
 // ../../node_modules/.pnpm/@noble+ciphers@2.4.0/node_modules/@noble/ciphers/utils.js
 function isBytes(a) {
@@ -3868,16 +3871,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 connect4 = request({
+    const connect3 = request({
       hostname: "127.0.0.1",
       port: connectorPort(),
       method: "CONNECT",
       path: "/acp",
       headers: { Authorization: `Bearer ${config2.localSecret}` }
     });
-    connect4.on("connect", (response, stream) => response.statusCode === 200 ? resolve3(stream) : reject(new Error("Dashup ACP connection was rejected")));
-    connect4.on("error", reject);
-    connect4.end();
+    connect3.on("connect", (response, stream) => response.statusCode === 200 ? resolve3(stream) : reject(new Error("Dashup ACP connection was rejected")));
+    connect3.on("error", reject);
+    connect3.end();
   });
   const child = spawn(executable, args2, { stdio: ["pipe", "pipe", "inherit"], windowsHide: true });
   const local = /* @__PURE__ */ new Set();
@@ -4045,7 +4048,7 @@ import * as ui from "@clack/prompts";
 import { z } from "zod";
 
 // package.json
-var version = "0.1.10";
+var version = "0.1.12";
 
 // src/pair.ts
 var Invitation = z.object({
@@ -4199,6 +4202,7 @@ var sessionKey = (session) => `${session.harness}\0${session.id}`;
 function agentHarness(name) {
   if (/claude/i.test(name)) return "claude";
   if (/codex/i.test(name)) return "codex";
+  if (/kimi/i.test(name)) return "kimi";
   if (/opencode/i.test(name)) return "opencode";
   return void 0;
 }
@@ -4239,13 +4243,13 @@ function records(buffer) {
 function unchanged(left, right) {
   return left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs;
 }
-function readRange(path, start, length) {
+function readRange(path, start2, length) {
   const fd = openSync2(path, "r");
   try {
     const buffer = Buffer.alloc(length);
     let offset = 0;
     while (offset < length) {
-      const count = readSync(fd, buffer, offset, length - offset, start + offset);
+      const count = readSync(fd, buffer, offset, length - offset, start2 + offset);
       if (!count) break;
       offset += count;
     }
@@ -4273,12 +4277,12 @@ function described(path, until, describe2) {
   }
   let tail = [];
   for (let bytes = SAMPLE_BYTES; stamp.size > head.length; bytes *= 2) {
-    const start = Math.max(head.length, stamp.size - bytes);
-    const buffer = readRange(path, start, stamp.size - start);
+    const start2 = Math.max(head.length, stamp.size - bytes);
+    const buffer = readRange(path, start2, stamp.size - start2);
     tail = records(
-      readRange(path, start - 1, 1)[0] === 10 ? buffer : buffer.subarray(buffer.indexOf(10) + 1)
+      readRange(path, start2 - 1, 1)[0] === 10 ? buffer : buffer.subarray(buffer.indexOf(10) + 1)
     );
-    if (start === head.length || tail.some(until)) break;
+    if (start2 === head.length || tail.some(until)) break;
   }
   const value2 = describe2([...records(head), ...tail], stamp);
   metadata.set(path, { stamp, value: value2 });
@@ -4295,8 +4299,8 @@ function journal(path, latest = false) {
     return tail2 ? [...saved.rows, tail2] : saved.rows;
   }
   if (!saved || saved.stamp.ino !== stamp.ino || stamp.size <= saved.offset || latest && stamp.size - saved.start > 2 * LATEST_BYTES) {
-    const start = latest ? Math.max(0, stamp.size - LATEST_BYTES) : 0;
-    saved = { stamp, start, offset: start, tail: Buffer.alloc(0), rows: [] };
+    const start2 = latest ? Math.max(0, stamp.size - LATEST_BYTES) : 0;
+    saved = { stamp, start: start2, offset: start2, tail: Buffer.alloc(0), rows: [] };
   }
   while (saved.offset < stamp.size) {
     const chunk = readRange(path, saved.offset, Math.min(READ_BYTES, stamp.size - saved.offset));
@@ -4390,7 +4394,6 @@ function prose(id, role, content) {
   const files2 = attachments(id, content);
   return value2 || files2.length ? [{ id, role, text: value2, ...files2.length ? { attachments: files2 } : {} }] : [];
 }
-var SUMMARY_LIMIT = 200;
 var SUMMARY_FIELDS = [
   "command",
   "cmd",
@@ -4412,11 +4415,15 @@ function describe(input) {
   );
   const value2 = typeof input === "string" ? input : named2 ?? (fields && Object.keys(fields).length ? JSON.stringify(fields) : "");
   const paths = [...value2.matchAll(PATCH_FILE)].map((match) => match[2]).join(", ");
-  const first = value2.split("\n").find((line) => line.trim());
-  return (paths || first?.trim())?.slice(0, SUMMARY_LIMIT);
+  return (paths || value2.trim()).slice(0, HISTORY_TOOL_CHARS) || void 0;
+}
+function said(input, summary) {
+  const value2 = object(input)?.description;
+  const line = typeof value2 === "string" ? value2.trim().split("\n")[0] : "";
+  return line && line !== summary ? line.slice(0, HISTORY_TOOL_CHARS) : void 0;
 }
-function elapsed(start, end) {
-  const ms = instant(end) - instant(start);
+function elapsed(start2, end) {
+  const ms = instant(end) - instant(start2);
   return Number.isFinite(ms) ? Math.max(0, Math.round(ms)) : void 0;
 }
 function added(path, content) {
@@ -4429,18 +4436,22 @@ function added(path, content) {
   ].join("\n");
 }
 var binary = (diff) => diff.slice(0, 8e3).includes("\0");
-function step(id, name, input, result) {
+function step(id, name, input, result, started) {
   const summary = describe(input);
+  const label = said(input, summary);
+  const at = instant(started);
   const diff = result?.status === "ok" && result.diff && !binary(result.diff) ? result.diff : void 0;
   return {
     id,
     role: "tool",
     text: diff || result?.text || "",
     tool: {
-      name: typeof name === "string" && name ? name.slice(0, SUMMARY_LIMIT) : "Tool",
+      name: typeof name === "string" && name ? name.slice(0, HISTORY_TOOL_CHARS) : "Tool",
+      ...label ? { label } : {},
       ...summary ? { summary } : {},
       ...result?.status ? { status: result.status } : {},
       ...result?.status && result.ms !== void 0 ? { ms: result.ms } : {},
+      ...!result?.status && Number.isFinite(at) ? { at: new Date(at).toISOString() } : {},
       ...diff ? { diff: true } : {}
     },
     ...result?.attachments?.length ? { attachments: result.attachments } : {}
@@ -4511,7 +4522,8 @@ function claudeConversation(conversation, rows) {
               ms: elapsed(row.timestamp, result.row.timestamp),
               diff: claudeChange(object(result.row.toolUseResult)),
               attachments: attachments(call, result.part.content)
-            }
+            },
+            row.timestamp
           )
         ];
       })
@@ -4600,7 +4612,8 @@ function codexMessages(path) {
           ms: elapsed(row.timestamp, output.timestamp),
           diff: patch && applyPatch(patch),
           attachments: attachments(call, output.payload.output)
-        }
+        },
+        row.timestamp
       )
     ];
   });
@@ -4699,7 +4712,8 @@ function openCodeParts(id, role, parts2) {
           ms: elapsed(state.time?.start, state.time?.end),
           diff: openCodeChange(state),
           attachments: attachments(key, state.attachments)
-        }
+        },
+        state.time?.start
       )
     ];
   });
@@ -5060,6 +5074,7 @@ var Discovery = class {
         read: true,
         send: Boolean(session.send),
         stop: Boolean(session.stop),
+        now: Boolean(session.now),
         approve: Boolean(session.approve)
       }
     });
@@ -5276,7 +5291,7 @@ 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 { mkdir as mkdir2 } 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
@@ -7421,10 +7436,10 @@ var Decoder = class _Decoder extends Emitter {
       throw new Error("unknown packet type " + p.type);
     }
     if (p.type === PacketType.BINARY_EVENT || p.type === PacketType.BINARY_ACK) {
-      const start = i + 1;
+      const start2 = i + 1;
       while (str.charAt(++i) !== "-" && i != str.length) {
       }
-      const buf = str.substring(start, i);
+      const buf = str.substring(start2, i);
       if (buf != Number(buf) || str.charAt(i) !== "-") {
         throw new Error("Illegal attachments");
       }
@@ -7437,7 +7452,7 @@ var Decoder = class _Decoder extends Emitter {
       p.attachments = n;
     }
     if ("/" === str.charAt(i + 1)) {
-      const start = i + 1;
+      const start2 = i + 1;
       while (++i) {
         const c = str.charAt(i);
         if ("," === c)
@@ -7445,13 +7460,13 @@ var Decoder = class _Decoder extends Emitter {
         if (i === str.length)
           break;
       }
-      p.nsp = str.substring(start, i);
+      p.nsp = str.substring(start2, i);
     } else {
       p.nsp = "/";
     }
     const next = str.charAt(i + 1);
     if ("" !== next && Number(next) == next) {
-      const start = i + 1;
+      const start2 = i + 1;
       while (++i) {
         const c = str.charAt(i);
         if (null == c || Number(c) != c) {
@@ -7461,7 +7476,7 @@ var Decoder = class _Decoder extends Emitter {
         if (i === str.length)
           break;
       }
-      p.id = Number(str.substring(start, i + 1));
+      p.id = Number(str.substring(start2, i + 1));
     }
     if (str.charAt(++i)) {
       const payload = this.tryParse(str.substr(i));
@@ -9671,7 +9686,7 @@ var putShortMSB = (s, b) => {
   s.pending_buf[s.pending++] = b >>> 8 & 255;
   s.pending_buf[s.pending++] = b & 255;
 };
-var read_buf = (strm, buf, start, size) => {
+var read_buf = (strm, buf, start2, size) => {
   let len = strm.avail_in;
   if (len > size) {
     len = size;
@@ -9680,11 +9695,11 @@ var read_buf = (strm, buf, start, size) => {
     return 0;
   }
   strm.avail_in -= len;
-  buf.set(strm.input.subarray(strm.next_in, strm.next_in + len), start);
+  buf.set(strm.input.subarray(strm.next_in, strm.next_in + len), start2);
   if (strm.state.wrap === 1) {
-    strm.adler = adler32_1(strm.adler, buf, len, start);
+    strm.adler = adler32_1(strm.adler, buf, len, start2);
   } else if (strm.state.wrap === 2) {
-    strm.adler = crc32_1(strm.adler, buf, len, start);
+    strm.adler = crc32_1(strm.adler, buf, len, start2);
   }
   strm.next_in += len;
   strm.total_in += len;
@@ -11049,7 +11064,7 @@ var deflate_1$1 = {
 };
 var BAD$1 = 16209;
 var TYPE$1 = 16191;
-var inffast = function inflate_fast(strm, start) {
+var inffast = function inflate_fast(strm, start2) {
   let _in;
   let last;
   let _out;
@@ -11079,7 +11094,7 @@ var inffast = function inflate_fast(strm, start) {
   last = _in + (strm.avail_in - 5);
   _out = strm.next_out;
   output = strm.output;
-  beg = _out - (start - strm.avail_out);
+  beg = _out - (start2 - strm.avail_out);
   end = _out + (strm.avail_out - 257);
   dmax = state.dmax;
   wsize = state.wsize;
@@ -16172,12 +16187,13 @@ var ID = /^[a-f0-9]{64}$/;
 var ROLES = new Set(MESSAGE_ROLES);
 var ROUTING_FIELDS = ["pairing", "sender", "recipient", "project", "thread"];
 var MIME = /^[\w.+-]{1,64}\/[\w.+-]{1,64}$/;
-var TOOL_TEXT = 500;
 function validAttachment(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2) && typeof value2.id === "string" && ID.test(value2.id) && typeof value2.mime === "string" && MIME.test(value2.mime) && Number.isSafeInteger(value2.bytes) && value2.bytes >= 0 && (value2.name === void 0 || typeof value2.name === "string" && value2.name.length <= ATTACHMENT_NAME_CHARS);
 }
 function validTool(value2) {
-  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2) && typeof value2.name === "string" && value2.name.length <= TOOL_TEXT && (value2.summary === void 0 || typeof value2.summary === "string" && value2.summary.length <= TOOL_TEXT) && (value2.status === void 0 || value2.status === "ok" || value2.status === "error") && (value2.ms === void 0 || Number.isSafeInteger(value2.ms) && value2.ms >= 0) && (value2.diff === void 0 || typeof value2.diff === "boolean");
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2) && typeof value2.name === "string" && value2.name.length <= HISTORY_TOOL_CHARS && [value2.label, value2.summary].every(
+    (text3) => text3 === void 0 || typeof text3 === "string" && text3.length <= HISTORY_TOOL_CHARS
+  ) && (value2.at === void 0 || typeof value2.at === "string" && !Number.isNaN(Date.parse(value2.at))) && (value2.status === void 0 || value2.status === "ok" || value2.status === "error") && (value2.ms === void 0 || Number.isSafeInteger(value2.ms) && value2.ms >= 0) && (value2.diff === void 0 || typeof value2.diff === "boolean");
 }
 function validMessage(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2) && typeof value2.id === "string" && ID.test(value2.id) && ROLES.has(value2.role) && typeof value2.text === "string" && value2.text.length <= HISTORY_TEXT_CHARS && Number.isSafeInteger(value2.part) && Number.isSafeInteger(value2.parts) && value2.part >= 0 && value2.parts > value2.part && (value2.tool === void 0 || value2.part === 0 && validTool(value2.tool)) && (value2.full === void 0 || value2.part === 0 && validAttachment(value2.full)) && (value2.attachments === void 0 || value2.part === 0 && Array.isArray(value2.attachments) && value2.attachments.length <= HISTORY_ATTACHMENTS && value2.attachments.every(validAttachment));
@@ -16186,14 +16202,14 @@ var preview = (text3) => text3.split("\n", OUTPUT_PREVIEW.lines).join("\n").slic
 function splitHistoryMessages(messages5, opaqueId2) {
   return messages5.flatMap((message) => {
     const text3 = [];
-    let start = 0;
+    let start2 = 0;
     do {
-      let end = Math.min(start + HISTORY_TEXT_CHARS, message.text.length);
+      let end = Math.min(start2 + HISTORY_TEXT_CHARS, message.text.length);
       const code = message.text.charCodeAt(end - 1);
       if (end < message.text.length && code >= 55296 && code <= 56319) end--;
-      text3.push(message.text.slice(start, end));
-      start = end;
-    } while (start < message.text.length);
+      text3.push(message.text.slice(start2, end));
+      start2 = end;
+    } while (start2 < message.text.length);
     const id = opaqueId2(message.id);
     return text3.map((part, index) => ({
       id,
@@ -16290,9 +16306,9 @@ async function publishHistory(config2, pair, project, thread, messages5) {
   const generation = ++local.sequence;
   saveConfig(config2);
   const all = historyMessages(local.key, project, thread.id, messages5);
-  let start = Math.max(0, all.length - HISTORY_KEPT);
-  while (start < all.length && (all[start].part ?? 0) > 0) start++;
-  const fragments = start ? [...historyMessages(local.key, project, thread.id, [EARLIER]), ...all.slice(start)] : all;
+  let start2 = Math.max(0, all.length - HISTORY_KEPT);
+  while (start2 < all.length && (all[start2].part ?? 0) > 0) start2++;
+  const fragments = start2 ? [...historyMessages(local.key, project, thread.id, [EARLIER]), ...all.slice(start2)] : all;
   const summary = { generation, total: fragments.length, updatedAt: thread.updatedAt };
   const batch = {
     pairing: pair.id,
@@ -16346,8 +16362,8 @@ function kept(message) {
     files2.push(attached(`${message.id}@${at}`, mime, data));
     return "";
   });
-  const start = message.role === "tool" && !message.tool?.diff ? preview(text3) : text3;
-  const full = start.length < text3.length ? {
+  const start2 = message.role === "tool" && !message.tool?.diff ? preview(text3) : text3;
+  const full = start2.length < text3.length ? {
     id: `${message.id}:full`,
     mime: "text/plain",
     bytes: Buffer.byteLength(text3),
@@ -16355,7 +16371,7 @@ function kept(message) {
   } : void 0;
   return {
     ...message,
-    text: start,
+    text: start2,
     ...full ? { full } : {},
     ...files2.length ? { attachments: files2 } : {}
   };
@@ -16494,6 +16510,8 @@ var Client = class {
   pending = /* @__PURE__ */ new Map();
   approvals = /* @__PURE__ */ new Map();
   requests = /* @__PURE__ */ new Map();
+  // The reply each thread is writing, as far as it has streamed, and the item it belongs to.
+  typing = /* @__PURE__ */ new Map();
   async connect() {
     if (this.socket?.readyState === WebSocket2.OPEN) return;
     if (this.connecting) return this.connecting;
@@ -16528,13 +16546,20 @@ var Client = class {
           return;
         }
         if (typeof message.method !== "string") return;
+        const params = message.params;
+        if (message.method === "item/agentMessage/delta" && typeof params?.threadId === "string" && typeof params.delta === "string") {
+          const known = this.typing.get(params.threadId);
+          this.typing.set(params.threadId, {
+            item: params.itemId,
+            text: (known && known.item === params.itemId ? known.text : "") + params.delta
+          });
+        }
         if (message.method === "serverRequest/resolved") {
           for (const [id, pending] of this.approvals)
             if (pending.requestId === message.params?.requestId) this.approvals.delete(id);
         }
         if ((message.method === "item/commandExecution/requestApproval" || message.method === "item/fileChange/requestApproval") && (typeof message.id === "string" || typeof message.id === "number") && typeof message.params?.threadId === "string") {
           const id = randomUUID2();
-          const params = message.params;
           this.approvals.set(id, {
             requestId: message.id,
             threadId: params.threadId,
@@ -16644,6 +16669,7 @@ var Client = class {
           updatedAt: new Date(Number(thread.updatedAt ?? 0) * 1e3).toISOString(),
           status: approvals.length ? "attention" : status(thread),
           messages: messages2(thread),
+          typing: this.typing.get(id)?.text,
           approvals,
           // An interrupt for a finished turn is never answered, so the active turn is read first.
           stop: this.controls ? (requestId) => this.once(requestId, async () => {
@@ -16766,17 +16792,17 @@ 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 start2 = 0;
+  while (start2 < old.length && start2 < next.length && old[start2] === next[start2]) start2++;
   let end = 0;
-  while (end < old.length - start && end < next.length - start && old[old.length - 1 - end] === next[next.length - 1 - end])
+  while (end < old.length - start2 && end < next.length - start2 && 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);
+  const removed = old.slice(start2, old.length - end);
+  const added2 = next.slice(start2, 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}`),
+      `@@ -${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}`)
@@ -16851,12 +16877,21 @@ var Session = class {
   turn;
   // Messages written to this turn's process that Claude Code has not finished answering.
   open = 0;
+  // The text Claude Code is writing, as far as it has streamed.
+  typing = "";
   approvals = /* @__PURE__ */ new Map();
   requests = /* @__PURE__ */ new Map();
   write(value2) {
     this.turn?.stdin.write(`${JSON.stringify(value2)}
 `);
   }
+  interrupt() {
+    this.write({
+      type: "control_request",
+      request_id: randomUUID3(),
+      request: { subtype: "interrupt" }
+    });
+  }
   once(id, action) {
     const known = this.requests.get(id);
     if (known) return known;
@@ -16866,13 +16901,16 @@ var Session = class {
     this.requests.set(id, result);
     return result;
   }
-  // Resolves once Claude Code takes the message, or says why it could not start.
-  say(text3) {
+  // Resolves once Claude Code takes the message, or says why it could not start. `now` stops the
+  // turn under way, so Claude Code takes the message at once.
+  say(text3, now = false) {
     this.messages.push({ id: randomUUID3(), role: "user", text: text3 });
+    this.typing = "";
     this.status = "working";
     this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     const message = { type: "user", message: { role: "user", content: text3 } };
     if (this.turn) {
+      if (now) this.interrupt();
       this.open++;
       this.write(message);
       this.changed();
@@ -16887,6 +16925,7 @@ var Session = class {
         "--output-format",
         "stream-json",
         "--verbose",
+        "--include-partial-messages",
         "--permission-prompt-tool",
         "stdio",
         ...this.saved ? ["--resume", this.id] : ["--session-id", this.id]
@@ -16944,6 +16983,14 @@ var Session = class {
       this.status = "attention";
     } else if (message.type === "result") {
       if (--this.open <= 0) this.turn?.stdin.end();
+    } else if (message.type === "stream_event" && !message.parent_tool_use_id) {
+      const event = message.event;
+      if (event?.type === "content_block_start") this.typing = "";
+      else if (event?.type === "content_block_delta" && event.delta?.type === "text_delta")
+        this.typing += String(event.delta.text ?? "");
+      else return false;
+      this.changed();
+      return false;
     } else return false;
     this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.changed();
@@ -16958,15 +17005,13 @@ var Session = class {
       updatedAt: this.updatedAt,
       status: this.status,
       messages: [...this.messages],
+      typing: this.typing,
       approvals: [...this.approvals.values()].map((pending) => pending.approval),
-      send: (requestId, text3) => this.once(requestId, () => this.say(text3)),
+      send: (requestId, text3, now) => this.once(requestId, () => this.say(text3, now)),
+      now: true,
       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" }
-        });
+        this.interrupt();
       }) : void 0,
       approve: this.approvals.size ? (requestId, approvalId, choice) => this.once(requestId, async () => {
         const pending = this.approvals.get(approvalId);
@@ -17040,15 +17085,13 @@ var Headless = class {
 };
 
 // src/harness/claude.ts
-import { join as join5 } from "node:path";
-import { connect as connect2 } from "node:net";
+import { dirname as dirname4, join as join5 } from "node:path";
 import { watch as watch2 } from "node:fs";
-import { lstat, readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
-var PEER_PROTOCOL = 1;
+import { mkdir, readdir as readdir2, readFile as readFile2, rm } from "node:fs/promises";
+import { createServer as createServer2 } from "node:http";
 var MAX_SESSIONS2 = 100;
-var REQUEST_MS2 = 4e3;
 var MAX_REQUESTS2 = 1e3;
-var ENVELOPE = "cross-session-message";
+var SESSION = /^\/sessions\/([\w-]{1,100})$/;
 var STATUS = {
   busy: "working",
   idle: "idle",
@@ -17073,39 +17116,22 @@ async function registrations() {
   );
   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) {
+  constructor(changed, socket = join5(dirname4(configPath()), "claude.sock")) {
     this.changed = changed;
+    this.socket = socket;
   }
   changed;
+  socket;
   watcher;
   notify;
+  server;
+  streams = /* @__PURE__ */ new Map();
   requests = /* @__PURE__ */ new Map();
   async refresh() {
     this.watch();
     return (await registrations()).map((session) => {
-      const path = session.peerProtocol === PEER_PROTOCOL ? session.messagingSocketPath : void 0;
+      const plugin = this.streams.has(session.sessionId);
       return {
         id: session.sessionId,
         harness: "claude",
@@ -17114,14 +17140,47 @@ var Claude = class {
         status: STATUS[session.status ?? ""] ?? "unknown",
         messages: [],
         approvals: [],
-        send: path ? (requestId, text3) => this.once(requestId, () => post(session, path, text3)) : 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
       };
     });
   }
+  // Only the connector serves the plugin; one-off commands such as `dashup doctor` read alone.
+  async listen() {
+    if (this.server || process.env.DASHUP_LIVE_DISCOVERY === "0") return;
+    const server = this.server = createServer2((request2, response) => {
+      const id = request2.method === "GET" ? SESSION.exec(request2.url ?? "")?.[1] : void 0;
+      if (!id) return void response.writeHead(404).end();
+      this.streams.get(id)?.end();
+      this.streams.set(id, response);
+      response.once("close", () => {
+        if (this.streams.get(id) === response) this.streams.delete(id);
+        this.changed();
+      });
+      response.writeHead(200, { "Content-Type": "application/x-ndjson" }).flushHeaders();
+      this.changed();
+    });
+    await mkdir(dirname4(this.socket), { recursive: true, mode: 448 });
+    await rm(this.socket, { force: true });
+    if (this.server !== server) return;
+    await new Promise((resolve3, reject) => {
+      server.once("error", reject);
+      server.listen(this.socket, resolve3);
+    });
+  }
+  deliver(id, delivery) {
+    const stream = this.streams.get(id);
+    if (!stream) return Promise.reject(new Error("Claude Code is not taking messages"));
+    return new Promise((resolve3, reject) => stream.write(`${JSON.stringify(delivery)}
+`, (error) => error ? reject(error) : resolve3()));
+  }
+  // Each request delivers at most once.
   once(id, action) {
     const known = this.requests.get(id);
     if (known) return known;
-    if (this.requests.size >= MAX_REQUESTS2) this.requests.delete(this.requests.keys().next().value);
+    if (this.requests.size >= MAX_REQUESTS2)
+      this.requests.delete(this.requests.keys().next().value);
     const result = action();
     this.requests.set(id, result);
     return result;
@@ -17148,23 +17207,26 @@ var Claude = class {
     clearTimeout(this.notify);
     this.watcher?.close();
     this.watcher = void 0;
+    this.server?.closeAllConnections();
+    this.server?.close();
+    this.server = void 0;
   }
 };
 
 // src/harness/vscode.ts
 import Socket3 from "ws";
 import { homedir as homedir5 } from "node:os";
-import { connect as connect3 } from "node:net";
+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 { 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 { join as join6, dirname as dirname5, 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_MS3 = 4e3;
+var REQUEST_MS2 = 4e3;
 var MAX_BYTES2 = 8 * 1024 * 1024;
 var MAX_METADATA = 64 * 1024;
 var MAX_HOSTS = 16;
@@ -17178,7 +17240,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" ? dirname4(override) : override] : [];
+    return override ? [basename2(override) === "User" ? dirname5(override) : override] : [];
   if (process.env.DASHUP_LIVE_DISCOVERY === "0") return [];
   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));
@@ -17198,7 +17260,7 @@ async function privateFile(path, limit) {
           "-EncodedCommand",
           Buffer.from(script, "utf16le").toString("base64")
         ],
-        { timeout: REQUEST_MS3, maxBuffer: MAX_METADATA }
+        { timeout: REQUEST_MS2, maxBuffer: MAX_METADATA }
       );
       return stdout.trim().toLowerCase() === "true";
     } catch {
@@ -17239,7 +17301,7 @@ async function entries() {
             if (!socket?.isSocket() || process.getuid && socket.uid !== process.getuid())
               continue;
           }
-          if (!await privateFile(dirname4(path), MAX_BYTES2)) continue;
+          if (!await privateFile(dirname5(path), MAX_BYTES2)) continue;
           const key = `${root}\0${identity2}`;
           if (!result.has(key))
             result.set(key, {
@@ -17403,9 +17465,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: () => connect3(this.entry.path),
+        createConnection: () => connect2(this.entry.path),
         maxPayload: MAX_BYTES2,
-        handshakeTimeout: REQUEST_MS3
+        handshakeTimeout: REQUEST_MS2
       });
       socket.on("error", () => {
       });
@@ -17438,7 +17500,7 @@ var Host = class {
         }
       };
       const client = this.client = new AhpClient(transport, {
-        requestTimeoutMs: REQUEST_MS3,
+        requestTimeoutMs: REQUEST_MS2,
         subscriptionBuffer: 1024
       });
       this.resources.clear();
@@ -17502,7 +17564,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_MS3);
+      }, REQUEST_MS2);
       this.receipts.set(handle.clientSeq, { resolve: resolve3, reject, timer });
     });
     this.requests.set(requestId, pending);
@@ -17656,7 +17718,7 @@ import { createHash as createHash4 } from "node:crypto";
 import { execFile as execFile4, spawn as spawn3 } from "node:child_process";
 import { stat as stat3, readlink, readdir as readdir4, readFile as readFile4 } from "node:fs/promises";
 var run2 = promisify4(execFile4);
-var REQUEST_MS4 = 4e3;
+var REQUEST_MS3 = 4e3;
 var MAX_BYTES3 = 8 * 1024 * 1024;
 var MAX_SESSIONS4 = 100;
 var MAX_PROCESSES2 = 4096;
@@ -17738,7 +17800,7 @@ async function endpoints() {
     const { stdout } = await run2(
       "lsof",
       ["-nP", "-a", "-c", "opencode", "-iTCP", "-sTCP:LISTEN", "-Fn"],
-      { timeout: REQUEST_MS4, maxBuffer: MAX_BYTES3 }
+      { timeout: REQUEST_MS3, maxBuffer: MAX_BYTES3 }
     );
     return stdout.split("\n").flatMap((line) => {
       const port = /^n(?:127\.0\.0\.1|\[::1\]|\*):(\d+)$/.exec(line)?.[1];
@@ -17755,7 +17817,7 @@ async function endpoints() {
     const { stdout } = await run2(
       "powershell.exe",
       ["-NoProfile", "-NonInteractive", "-Command", script],
-      { timeout: REQUEST_MS4, maxBuffer: MAX_BYTES3 }
+      { timeout: REQUEST_MS3, 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}`),
@@ -17875,7 +17937,7 @@ var Server = class {
     };
   }
   async request(path, directory2, payload) {
-    const signal = AbortSignal.timeout(REQUEST_MS4);
+    const signal = AbortSignal.timeout(REQUEST_MS3);
     const response = await fetch(this.endpoint.url + path, {
       method: payload === void 0 ? "GET" : "POST",
       headers: {
@@ -18051,7 +18113,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_MS4);
+    const connectTimer = setTimeout(() => controller.abort(), REQUEST_MS3);
     connectTimer.unref();
     void (async () => {
       const response = await fetch(this.endpoint.url + "/global/event", {
@@ -18273,6 +18335,10 @@ var LiveHarnesses = class {
   }
   watch(onChange) {
     this.listeners.add(onChange);
+    this.claude.listen().catch((error) => process.stderr.write(
+      `Claude Code sessions cannot take replies: ${error instanceof Error ? error.message : error}
+`
+    ));
     if (!this.timer && process.env.DASHUP_LIVE_DISCOVERY !== "0") {
       this.timer = setInterval(() => this.changed(), DISCOVERY_MS);
       this.timer.unref();
@@ -18301,10 +18367,10 @@ var LiveHarnesses = class {
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { spawn as spawn4 } from "node:child_process";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
-import { join as join8, dirname as dirname5, basename as basename3 } from "node:path";
+import { join as join8, dirname as dirname6, basename as basename3 } from "node:path";
 import { statSync as statSync2, existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync4, readlinkSync, realpathSync as realpathSync2 } from "node:fs";
 var CODEX_VERSION = "0.160.1";
-var REQUEST_MS5 = 1e4;
+var REQUEST_MS4 = 1e4;
 var MAX_BYTES4 = 1024 * 1024;
 var MAX_PROCESSES3 = 4096;
 var MAX_FILES = 4096;
@@ -18320,8 +18386,8 @@ function sameFile(left, right) {
   return left.path === right.path && left.device === right.device && left.inode === right.inode;
 }
 function packageVersion(executable) {
-  let directory2 = dirname5(executable);
-  for (let depth = 0; depth < 8; depth++, directory2 = dirname5(directory2)) {
+  let directory2 = dirname6(executable);
+  for (let depth = 0; depth < 8; depth++, directory2 = dirname6(directory2)) {
     const path = join8(directory2, "package.json");
     if (!existsSync4(path)) continue;
     const value2 = JSON.parse(readFileSync4(path, "utf8"));
@@ -18335,8 +18401,8 @@ function processOwners(pid) {
   const executable = realpathSync2.native(join8(root, "exe"));
   if (basename3(executable) !== "codex" || packageVersion(executable) !== CODEX_VERSION) return [];
   const status2 = readFileSync4(join8(root, "stat"), "utf8");
-  const start = status2.slice(status2.lastIndexOf(")") + 2).split(" ")[19];
-  if (!start || !/^\d+$/.test(start)) return [];
+  const start2 = status2.slice(status2.lastIndexOf(")") + 2).split(" ")[19];
+  if (!start2 || !/^\d+$/.test(start2)) return [];
   const fds = readdirSync3(join8(root, "fd")).slice(0, MAX_FILES);
   const files2 = fds.flatMap((fd) => {
     try {
@@ -18346,13 +18412,13 @@ function processOwners(pid) {
     }
   });
   return files2.flatMap(({ fd, path }) => {
-    if (basename3(dirname5(path)) !== "thread-writer-locks" || !path.endsWith(".lock")) return [];
+    if (basename3(dirname6(path)) !== "thread-writer-locks" || !path.endsWith(".lock")) return [];
     const thread = basename3(path, ".lock");
     if (!THREAD_ID.test(thread)) return [];
     try {
       const lock = readFileSync4(join8(root, "fdinfo", fd), "utf8");
       if (!/FLOCK\s+ADVISORY\s+WRITE/.test(lock)) return [];
-      const home = realpathSync2.native(dirname5(dirname5(path)));
+      const home = realpathSync2.native(dirname6(dirname6(path)));
       const directory2 = statSync2(home);
       if (process.getuid && directory2.uid !== process.getuid()) return [];
       const queue = identity(join8(home, "queue_1.sqlite"));
@@ -18371,7 +18437,7 @@ function processOwners(pid) {
       return [
         {
           pid,
-          start,
+          start: start2,
           executable,
           home,
           thread,
@@ -18536,7 +18602,7 @@ var Writer = class {
         this.pending.delete(id);
         reject(new Error("Native queue acknowledgement was not received"));
         this.close();
-      }, REQUEST_MS5);
+      }, REQUEST_MS4);
       this.pending.set(id, { resolve: resolve3, reject, timer });
       this.process.stdin.write(JSON.stringify({ id, method, params }) + "\n");
     });
@@ -18655,7 +18721,7 @@ var NativeQueue = class {
 // src/connector.ts
 var EPHEMERAL_TTL_MS = 6e4;
 var HOME_RECENT = 20;
-var FOLLOW_MS = 5 * 6e4;
+var FOLLOW_MS = 2 * 6e4;
 var RESCAN_MS = 1e3;
 var Command = z2.object({
   type: z2.literal("command"),
@@ -18665,7 +18731,12 @@ var Command = z2.object({
   action: z2.discriminatedUnion("kind", [
     z2.object({ kind: z2.literal("projects.refresh") }).strict(),
     z2.object({ kind: z2.literal("thread.read") }).strict(),
-    z2.object({ kind: z2.literal("thread.send"), text: z2.string().min(1).max(1e5) }).strict(),
+    z2.object({ kind: z2.literal("thread.follow") }).strict(),
+    z2.object({
+      kind: z2.literal("thread.send"),
+      text: z2.string().min(1).max(1e5),
+      now: z2.boolean().optional()
+    }).strict(),
     z2.object({ kind: z2.literal("thread.queue"), text: z2.string().min(1).max(1e5) }).strict(),
     z2.object({ kind: z2.literal("thread.stop") }).strict(),
     z2.object({ kind: z2.literal("approval.respond"), approvalId: z2.string(), choice: z2.string() }).strict(),
@@ -19059,6 +19130,27 @@ var Connector = class {
     for (const pair of this.activePairs()) await this.listProjects(pair);
     await this.publishQueueReceipts();
   }
+  // Publishes a conversation for the phone, which then gets what changes in it.
+  async read(pair, project, thread) {
+    const messages5 = this.discovery.read(thread, this.attached(thread)?.messages);
+    const history = await publishHistory(this.config, pair, project.id, thread, messages5);
+    this.follows.set(`${pair.id}:${thread.id}`, {
+      pair,
+      project: project.id,
+      thread: thread.id,
+      until: Date.now() + FOLLOW_MS,
+      copy: copy(messages5),
+      updatedAt: thread.updatedAt,
+      typing: ""
+    });
+    return this.thread(pair, project, thread, history);
+  }
+  // The reply an agent this computer runs is still writing, until the conversation holds it.
+  typing(thread, messages5) {
+    const typing = this.discovery.locations.get(thread.id)?.live?.typing ?? "";
+    const last = messages5.filter((message) => message.role === "assistant").at(-1);
+    return typing && !last?.text.startsWith(typing) ? typing : "";
+  }
   // A phone reading a conversation gets its messages as they change, before anything that says the
   // conversation changed, so it never asks for a copy it already has.
   async stream() {
@@ -19067,18 +19159,19 @@ var Connector = class {
       let messages5;
       try {
         if (thread && follow.until > Date.now() && activePair(this.config, follow.pair))
-          messages5 = changes(
-            follow.copy,
-            this.discovery.read(thread, this.attached(thread)?.messages)
-          );
+          messages5 = this.discovery.read(thread, this.attached(thread)?.messages);
       } catch {
       }
       if (!thread || !messages5) {
         this.follows.delete(key);
         continue;
       }
-      if (!messages5.length && thread.updatedAt === follow.updatedAt) continue;
+      const changed = changes(follow.copy, messages5);
+      const typing = this.typing(thread, messages5);
+      if (!changed.length && thread.updatedAt === follow.updatedAt && typing === follow.typing)
+        continue;
       follow.updatedAt = thread.updatedAt;
+      follow.typing = typing;
       await this.send(follow.pair, {
         type: "thread-tail",
         projectId: follow.project,
@@ -19088,8 +19181,9 @@ var Connector = class {
           this.config.pairs[follow.pair.id].key,
           follow.project,
           follow.thread,
-          messages5
-        )
+          changed
+        ),
+        ...typing ? { typing } : {}
       });
     }
   }
@@ -19100,7 +19194,7 @@ var Connector = class {
       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))
+        if (location2?.history && !location2.live && !project.remote && !thread.capabilities.queue && harness && isStartHarness(harness) && this.startable.includes(harness))
           thread.capabilities = { ...thread.capabilities, send: true };
       }
   }
@@ -19164,6 +19258,7 @@ var Connector = class {
         throw new Error("Command expired. Try again while this computer is online.");
       const outcome = await this.command(pair, content);
       delete this.config.unconfirmed[content.requestId];
+      if (content.action.kind === "thread.follow") return;
       if (outcome && "state" in outcome) {
         queue = outcome;
         await this.queueResult(pair, content.requestId, content.projectId, queue);
@@ -19177,6 +19272,7 @@ var Connector = class {
       );
     } catch (error) {
       delete this.config.unconfirmed[content.requestId];
+      if (content.action.kind === "thread.follow") return;
       if (queue) {
         await this.queueResult(pair, content.requestId, content.projectId, queue);
         return;
@@ -19309,19 +19405,15 @@ var Connector = class {
     if (!project) throw new Error("Project is no longer open on this computer");
     const thread = project.threads.find((item) => item.id === command2.threadId);
     switch (command2.action.kind) {
-      case "thread.read": {
+      case "thread.read":
         if (!thread) throw new Error("Thread not found");
-        const messages5 = this.discovery.read(thread, this.attached(thread)?.messages);
-        const history = await publishHistory(this.config, pair, project.id, thread, messages5);
-        this.follows.set(`${pair.id}:${thread.id}`, {
-          pair,
-          project: project.id,
-          thread: thread.id,
-          until: Date.now() + FOLLOW_MS,
-          copy: copy(messages5),
-          updatedAt: thread.updatedAt
-        });
-        return this.thread(pair, project, thread, history);
+        return this.read(pair, project, thread);
+      case "thread.follow": {
+        if (!thread) throw new Error("Thread not found");
+        const follow = this.follows.get(`${pair.id}:${thread.id}`);
+        if (!follow) return this.read(pair, project, thread);
+        follow.until = Date.now() + FOLLOW_MS;
+        return;
       }
       case "attachment.read": {
         if (!thread) throw new Error("Thread not found");
@@ -19341,11 +19433,17 @@ var Connector = class {
             "This session has no live reply connection. Use the existing agent on your computer."
           );
         const location2 = this.discovery.locations.get(thread.id);
-        if (location2?.live?.send) return location2.live.send(command2.requestId, command2.action.text);
+        if (location2?.live?.send)
+          return location2.live.send(command2.requestId, command2.action.text, command2.action.now);
         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);
+        if (!agent && location2?.history && saved && isStartHarness(saved.harness)) {
+          await this.harnesses.resume(
+            saved.harness,
+            saved.sessionId,
+            project.path,
+            command2.action.text
+          );
           await this.changed();
           return;
         }
@@ -19419,7 +19517,7 @@ var Connector = class {
       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) => {
+      await mkdir2(cwd).catch((error) => {
         throw new Error(error.code === "EEXIST" ? `${name} already exists` : `Couldn't create ${name}`);
       });
     } else {
@@ -19449,8 +19547,8 @@ import { homedir as homedir6, userInfo } from "node:os";
 import { promisify as promisify6 } from "node:util";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { execFile as execFile6, spawn as spawn5 } 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";
+import { cp, mkdir as mkdir3, rm as rm2, writeFile } from "node:fs/promises";
+import { dirname as dirname7, join as join10, relative, sep } from "node:path";
 var run3 = promisify6(execFile6);
 var xml = (value2) => value2.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var NODE_FLAGS = ["--disable-warning=ExperimentalWarning"];
@@ -19496,21 +19594,34 @@ 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 = join10(dirname6(configPath()), "app");
-  await rm(app, { recursive: true, force: true });
+  const app = join10(dirname7(configPath()), "app");
+  await rm2(app, { recursive: true, force: true });
   await cp(join10(root, "node_modules"), join10(app, "node_modules"), {
     recursive: true,
     verbatimSymlinks: true
   });
   return join10(app, relative(root, entry));
 }
+var claude2 = (...args2) => run3("claude", ["plugin", ...args2], { timeout: 6e4 });
+async function installClaude(entry) {
+  if (process.platform === "win32") return false;
+  try {
+    await claude2("marketplace", "add", join10(dirname7(entry), "..", "claude"));
+    await claude2("install", "dashup@dashup", "--scope", "user");
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function installStartup() {
   const path = serviceFile();
-  await mkdir2(dirname6(path), { recursive: true });
-  await writeFile(
-    path,
-    service(process.platform, process.execPath, await durableEntry(), configPath())
-  );
+  const entry = await durableEntry();
+  await mkdir3(dirname7(path), { recursive: true });
+  await writeFile(path, service(process.platform, process.execPath, entry, configPath()));
+  const restart = await installClaude(entry) ? "Restart Claude Code sessions that are already open to answer them from your phone." : void 0;
+  return [await start(path), restart].filter(Boolean).join(" ") || void 0;
+}
+async function start(path) {
   if (process.platform === "darwin") {
     await run3("launchctl", ["unload", path]).catch(() => {
     });
@@ -19530,13 +19641,17 @@ async function installStartup() {
 }
 async function uninstallStartup() {
   const path = serviceFile();
+  await claude2("uninstall", "dashup@dashup").catch(() => {
+  });
+  await claude2("marketplace", "remove", "dashup").catch(() => {
+  });
   if (process.platform === "darwin") await run3("launchctl", ["unload", path]).catch(() => {
   });
   else if (process.platform !== "win32")
     await systemctl("disable", "dashup.service").catch(() => {
     });
-  await rm(path, { force: true });
-  await rm(join10(dirname6(configPath()), "app"), { recursive: true, force: true });
+  await rm2(path, { force: true });
+  await rm2(join10(dirname7(configPath()), "app"), { recursive: true, force: true });
 }
 
 // src/index.ts
@@ -19739,7 +19854,7 @@ async function main() {
       "To pair this computer, run dashup pair in a terminal, or add --account with your Dashup email."
     );
   let connector;
-  const server = createServer2(async (request2, response) => {
+  const server = createServer3(async (request2, response) => {
     if (!authorized(request2)) {
       response.writeHead(403).end();
       return;

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@dashup/connector",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "type": "module",
   "bin": {
     "dashup": "dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "claude"
   ],
   "publishConfig": {
     "access": "public"
@@ -29,11 +30,11 @@
     "tsup": "^8.5.1",
     "tsx": "^4.22.4",
     "typescript": "^5.9.3",
-    "@dashup/typescript-config": "0.0.0",
-    "@dashup/protocol": "0.1.0",
+    "@dashup/models": "0.1.0",
     "@parcae/lynx": "0.1.0",
     "@parcae/sdk": "0.8.1",
-    "@dashup/models": "0.1.0"
+    "@dashup/typescript-config": "0.0.0",
+    "@dashup/protocol": "0.1.0"
   },
   "scripts": {
     "dashup": "tsx src/index.ts",