@standardagents/code 0.9.5 → 0.9.6

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import os10, { homedir } from 'os';
+import os7, { homedir } from 'os';
 import path3 from 'path';
 import readline2 from 'readline/promises';
 import { stdout, stdin } from 'process';
@@ -10,7 +10,140 @@ import { spawn, execFileSync, spawnSync, execFile } from 'child_process';
 import readline from 'readline';
 import { fileURLToPath } from 'url';
 
+// src/shared-messaging.ts
+var SHARED_MESSAGING_ROUTE = "/standard-code/messaging";
+var SHARED_MESSAGING_EVENT = "standard_code_messaging_changed";
+function isInlineSharedAttachment(value) {
+  return "data" in value;
+}
+function isSharedAttachmentRef(value) {
+  return "type" in value && value.type === "file";
+}
+var EMPTY_ORIGIN = {
+  originClientId: "",
+  originClientKind: "unknown"
+};
+function emptySharedMessagingSnapshot() {
+  return {
+    version: 1,
+    pending: { version: 1, revision: 0, items: [] },
+    draft: {
+      version: 1,
+      revision: 0,
+      content: "",
+      attachments: [],
+      updatedAt: 0,
+      ...EMPTY_ORIGIN
+    }
+  };
+}
+function mergeSharedMessagingSnapshot(current, incoming) {
+  return {
+    version: 1,
+    pending: incoming.pending.revision >= current.pending.revision ? incoming.pending : current.pending,
+    draft: incoming.draft.revision >= current.draft.revision ? incoming.draft : current.draft
+  };
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function finiteNumber(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new TypeError(`invalid shared messaging ${label}`);
+  }
+  return value;
+}
+function clientKind(value) {
+  return value === "tui" || value === "web" || value === "mac" || value === "ios" ? value : "unknown";
+}
+function origin(value) {
+  return {
+    originClientId: typeof value?.originClientId === "string" ? value.originClientId : "",
+    originClientKind: clientKind(value?.originClientKind)
+  };
+}
+function attachments(value) {
+  if (!Array.isArray(value)) throw new TypeError("invalid shared messaging attachments");
+  const parsed = [];
+  for (const raw of value) {
+    const item = record(raw);
+    if (!item || typeof item.name !== "string" || typeof item.mimeType !== "string") {
+      throw new TypeError("invalid shared messaging attachment");
+    }
+    const dimensions = {
+      ...typeof item.width === "number" && Number.isFinite(item.width) ? { width: item.width } : {},
+      ...typeof item.height === "number" && Number.isFinite(item.height) ? { height: item.height } : {}
+    };
+    if (typeof item.data === "string") {
+      parsed.push({ name: item.name, mimeType: item.mimeType, data: item.data, ...dimensions });
+    } else if (item.type === "file" && typeof item.id === "string" && typeof item.path === "string" && typeof item.size === "number" && Number.isFinite(item.size)) {
+      parsed.push({
+        id: item.id,
+        type: "file",
+        path: item.path,
+        name: item.name,
+        mimeType: item.mimeType,
+        size: item.size,
+        ...typeof item.description === "string" ? { description: item.description } : {},
+        ...dimensions
+      });
+    } else {
+      throw new TypeError("invalid shared messaging attachment");
+    }
+  }
+  return parsed;
+}
+function pendingInput(value) {
+  const item = record(value);
+  if (!item || typeof item.id !== "string" || typeof item.content !== "string") {
+    throw new TypeError("invalid shared messaging pending item");
+  }
+  return {
+    id: item.id,
+    content: item.content,
+    attachments: attachments(item.attachments),
+    createdAt: finiteNumber(item.createdAt, "pending createdAt"),
+    updatedAt: finiteNumber(item.updatedAt, "pending updatedAt"),
+    ...origin(item)
+  };
+}
+function parseSharedMessagingSnapshot(value) {
+  const root = record(value);
+  const pending = record(root?.pending);
+  const draft = record(root?.draft);
+  if (!root || root.version !== 1 || !pending || pending.version !== 1 || !draft || draft.version !== 1) {
+    throw new TypeError("unsupported or malformed shared messaging snapshot");
+  }
+  if (!Array.isArray(pending.items) || typeof draft.content !== "string") {
+    throw new TypeError("malformed shared messaging snapshot");
+  }
+  return {
+    version: 1,
+    pending: {
+      version: 1,
+      revision: finiteNumber(pending.revision, "pending revision"),
+      items: pending.items.map(pendingInput)
+    },
+    draft: {
+      version: 1,
+      revision: finiteNumber(draft.revision, "draft revision"),
+      content: draft.content,
+      attachments: attachments(draft.attachments),
+      updatedAt: finiteNumber(draft.updatedAt, "draft updatedAt"),
+      ...origin(draft)
+    }
+  };
+}
+
 // src/api.ts
+var ApiHttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ApiHttpError";
+  }
+  status;
+};
 function classifyConnectError(err, endpoint) {
   const host = endpoint.replace(/^https?:\/\//, "").replace(/\/.*$/, "");
   const codes = /* @__PURE__ */ new Set();
@@ -102,7 +235,10 @@ var ApiClient = class {
     });
     const text = await res.text();
     if (!res.ok) {
-      throw new Error(`${init?.method || "GET"} ${pathname} -> ${res.status}: ${text.slice(0, 300)}`);
+      throw new ApiHttpError(
+        res.status,
+        `${init?.method || "GET"} ${pathname} -> ${res.status}: ${text.slice(0, 300)}`
+      );
     }
     try {
       return JSON.parse(text);
@@ -183,21 +319,36 @@ var ApiClient = class {
    */
   async listThreads(agentId, requireTags) {
     const ids = Array.isArray(agentId) ? agentId : [agentId];
-    const pages = await Promise.all(
-      ids.map(
+    const [me, ...pages] = await Promise.all([
+      this.currentUserId(),
+      ...ids.map(
         (id) => this.json(
           `/api/threads?agent_id=${encodeURIComponent(id)}&limit=100`
         ).catch(() => [])
       )
-    );
+    ]);
     const arr = pages.flatMap((res) => Array.isArray(res) ? res : res.threads || []);
     return arr.map((t) => ({
       id: t.id,
       tags: Array.isArray(t.tags) ? t.tags : [],
       created_at: t.created_at,
       title: t.title,
-      preview: t.preview || t.last_message
-    })).filter((t) => requireTags.every((tag) => t.tags.includes(tag)));
+      preview: t.preview || t.last_message,
+      user_id: t.user_id ?? null
+    })).filter((t) => !me || !t.user_id || t.user_id === me).filter((t) => requireTags.every((tag) => t.tags.includes(tag)));
+  }
+  /** The authenticated user's id (cached). Null when the instance doesn't
+   *  report one (super-admin sessions, very old instances). */
+  meUserId;
+  async currentUserId() {
+    if (this.meUserId !== void 0) return this.meUserId;
+    try {
+      const res = await this.json(`/api/auth/me`);
+      this.meUserId = typeof res?.user?.id === "string" && res.user.id ? res.user.id : null;
+    } catch {
+      this.meUserId = null;
+    }
+    return this.meUserId;
   }
   /**
    * Subagent child threads of a thread, each with its current lifecycle status
@@ -225,14 +376,85 @@ var ApiClient = class {
    * `mimeType` — which the server stores in the thread filesystem and injects
    * into the LLM's vision context as real image content blocks.
    */
-  async sendMessage(threadId, content, attachments) {
+  async sendMessage(threadId, content, attachments2) {
     const body = { role: "user", content };
-    if (attachments && attachments.length > 0) body.attachments = attachments;
+    if (attachments2 && attachments2.length > 0) body.attachments = attachments2;
     await this.json(`/api/threads/${threadId}/messages`, {
       method: "POST",
       body: JSON.stringify(body)
     });
   }
+  // ── portable Standard Code shared messaging endpoints ────────────────────
+  messagingPath(threadId, suffix = "") {
+    return `/api/threads/${threadId}${SHARED_MESSAGING_ROUTE}${suffix}`;
+  }
+  async getSharedMessaging(threadId) {
+    return parseSharedMessagingSnapshot(await this.json(this.messagingPath(threadId)));
+  }
+  async appendPendingInput(threadId, mutation) {
+    return parseSharedMessagingSnapshot(
+      await this.json(this.messagingPath(threadId, "/pending"), {
+        method: "POST",
+        body: JSON.stringify(mutation)
+      })
+    );
+  }
+  async steerInput(threadId, mutation) {
+    return parseSharedMessagingSnapshot(
+      await this.json(this.messagingPath(threadId, "/steer"), {
+        method: "POST",
+        body: JSON.stringify(mutation)
+      })
+    );
+  }
+  async updatePendingInput(threadId, pendingId, mutation) {
+    return parseSharedMessagingSnapshot(
+      await this.json(this.messagingPath(threadId, `/pending/${encodeURIComponent(pendingId)}`), {
+        method: "PATCH",
+        body: JSON.stringify(mutation)
+      })
+    );
+  }
+  async dismissPendingInput(threadId, pendingId, origin2) {
+    return parseSharedMessagingSnapshot(
+      await this.json(this.messagingPath(threadId, `/pending/${encodeURIComponent(pendingId)}`), {
+        method: "DELETE",
+        body: JSON.stringify(origin2)
+      })
+    );
+  }
+  async steerPendingInput(threadId, pendingId, origin2) {
+    return parseSharedMessagingSnapshot(
+      await this.json(this.messagingPath(threadId, `/pending/${encodeURIComponent(pendingId)}/steer`), {
+        method: "POST",
+        body: JSON.stringify(origin2)
+      })
+    );
+  }
+  async putSharedDraft(threadId, mutation) {
+    return parseSharedMessagingSnapshot(
+      await this.json(this.messagingPath(threadId, "/draft"), {
+        method: "PUT",
+        body: JSON.stringify(mutation)
+      })
+    );
+  }
+  async clearSharedDraft(threadId, origin2) {
+    return parseSharedMessagingSnapshot(
+      await this.json(this.messagingPath(threadId, "/draft"), {
+        method: "DELETE",
+        body: JSON.stringify(origin2)
+      })
+    );
+  }
+  async requestSharedStop(threadId, origin2) {
+    return parseSharedMessagingSnapshot(
+      await this.json(this.messagingPath(threadId, "/stop"), {
+        method: "POST",
+        body: JSON.stringify(origin2)
+      })
+    );
+  }
   async getMessages(threadId, limit = 50, order) {
     const orderParam = order ? `&order=${order}` : "";
     const res = await this.json(
@@ -240,6 +462,14 @@ var ApiClient = class {
     );
     return Array.isArray(res) ? res : res.messages || [];
   }
+  /**
+   * One server-derived projection for busy/idle, current tool, conversation,
+   * goal, and live children. Streams provide immediacy; this snapshot settles
+   * state after reconnects and prevents each UI from inventing lifecycle rules.
+   */
+  async getSessionState(threadId, limit = 500) {
+    return this.json(`/api/threads/${threadId}/session_state?limit=${limit}`);
+  }
   async getLogs(threadId, limit = 100) {
     const res = await this.json(
       `/api/threads/${threadId}/logs?limit=${limit}&order=desc`
@@ -403,12 +633,6 @@ var ApiClient = class {
   async compact(threadId) {
     await this.json(`/api/threads/${threadId}/compact`, { method: "POST" });
   }
-  async stop(threadId) {
-    try {
-      await this.json(`/api/threads/${threadId}/stop`, { method: "POST" });
-    } catch {
-    }
-  }
   /**
    * Run a user-typed `!command` on the thread's execution owner (wherever the
    * session runs — e.g. a remote VPS daemon). The instance forwards it over
@@ -504,6 +728,7 @@ var Heartbeat = class {
     this.onDead = onDead;
     this.intervalMs = options.intervalMs ?? HEARTBEAT_INTERVAL_MS;
     this.silenceMs = options.silenceMs ?? CONNECTION_SILENCE_TIMEOUT_MS;
+    this.request = options.request ?? "ping";
   }
   ws;
   onDead;
@@ -511,6 +736,7 @@ var Heartbeat = class {
   lastRecvAt = 0;
   intervalMs;
   silenceMs;
+  request;
   start() {
     this.stop();
     this.lastRecvAt = Date.now();
@@ -520,6 +746,10 @@ var Heartbeat = class {
   markAlive() {
     this.lastRecvAt = Date.now();
   }
+  /** Change the heartbeat frame without restarting the connection timer. */
+  setRequest(request) {
+    this.request = request;
+  }
   stop() {
     if (this.timer) {
       clearInterval(this.timer);
@@ -532,7 +762,7 @@ var Heartbeat = class {
       return;
     }
     try {
-      if (this.ws.readyState === WebSocket.OPEN) this.ws.send("ping");
+      if (this.ws.readyState === WebSocket.OPEN) this.ws.send(this.request);
       else this.fail();
     } catch {
       this.fail();
@@ -554,6 +784,56 @@ var DIM = "\x1B[2m";
 var ADD_BG = "\x1B[48;5;22m\x1B[38;5;254m";
 var DEL_BG = "\x1B[48;5;52m\x1B[38;5;254m";
 var MAX_SIDE_LINES = 4;
+function terminalGlyphWidth(ch) {
+  const cp = ch.codePointAt(0);
+  return cp >= 4352 && cp <= 4447 || cp >= 11904 && cp <= 42191 || cp >= 44032 && cp <= 55203 || cp >= 63744 && cp <= 64255 || cp >= 65072 && cp <= 65103 || cp >= 65280 && cp <= 65376 || cp >= 65504 && cp <= 65510 || cp >= 127744 && cp <= 129791 || cp >= 131072 ? 2 : 1;
+}
+function truncateMiddle(text, maxColumns) {
+  const limit = Math.max(0, Math.floor(maxColumns));
+  if (limit === 0) return "";
+  const chars = [...text];
+  const totalWidth = chars.reduce((width, ch) => width + terminalGlyphWidth(ch), 0);
+  if (totalWidth <= limit) return text;
+  if (limit === 1) return "\u2026";
+  const available = limit - 1;
+  const headBudget = Math.ceil(available / 2);
+  const tailBudget = Math.floor(available / 2);
+  const head = [];
+  const tail = [];
+  let headWidth = 0;
+  let tailWidth = 0;
+  for (let i = 0; i < chars.length; i++) {
+    const width = terminalGlyphWidth(chars[i]);
+    if (headWidth + width > headBudget) break;
+    head.push(chars[i]);
+    headWidth += width;
+  }
+  for (let i = chars.length - 1; i >= head.length; i--) {
+    const width = terminalGlyphWidth(chars[i]);
+    if (tailWidth + width > tailBudget) break;
+    tail.unshift(chars[i]);
+    tailWidth += width;
+  }
+  const isSeparator = (ch) => ch === "/" || ch === "\\";
+  let headEnd = head.length;
+  let tailStart = chars.length - tail.length;
+  for (let i = headEnd - 1; i >= 0; i--) {
+    if (isSeparator(chars[i])) {
+      headEnd = i + 1;
+      break;
+    }
+  }
+  for (let i = tailStart; i < chars.length; i++) {
+    if (isSeparator(chars[i])) {
+      tailStart = i;
+      break;
+    }
+  }
+  if (headEnd < tailStart && headEnd > 0 && tailStart < chars.length) {
+    return `${chars.slice(0, headEnd).join("")}\u2026${chars.slice(tailStart).join("")}`;
+  }
+  return `${head.join("")}\u2026${tail.join("")}`;
+}
 function clamp(s, max) {
   return s.length > max ? s.slice(0, Math.max(0, max - 1)) + "\u2026" : s;
 }
@@ -727,6 +1007,7 @@ var Bridge = class {
   ws = null;
   closed = false;
   heartbeat = null;
+  activeToolRequests = 0;
   reconnectAttempt = 0;
   reconnectTimer = null;
   resolveConnected = null;
@@ -850,9 +1131,14 @@ var Bridge = class {
   }
   startHeartbeat(ws) {
     this.stopHeartbeat();
-    this.heartbeat = new Heartbeat(ws, () => this.handleDrop(ws));
+    this.heartbeat = new Heartbeat(ws, () => this.handleDrop(ws), {
+      request: this.activeToolRequests > 0 ? "ping" : "stream_ping"
+    });
     this.heartbeat.start();
   }
+  updateHeartbeatMode() {
+    this.heartbeat?.setRequest(this.activeToolRequests > 0 ? "ping" : "stream_ping");
+  }
   stopHeartbeat() {
     if (this.heartbeat) {
       this.heartbeat.stop();
@@ -938,7 +1224,14 @@ var Bridge = class {
     if (msg.type !== "tool_request") return;
     if (!this.owner) return;
     const req = msg;
-    await this.handleToolRequest(req);
+    this.activeToolRequests++;
+    this.updateHeartbeatMode();
+    try {
+      await this.handleToolRequest(req);
+    } finally {
+      this.activeToolRequests = Math.max(0, this.activeToolRequests - 1);
+      this.updateHeartbeatMode();
+    }
   }
   /**
    * Reply to a tool request. Durable calls (the agent parked them) deliver the
@@ -1112,7 +1405,7 @@ function detailSuffix(tool, result) {
   const lines = result.split("\n").length;
   return ` (${lines} line${lines === 1 ? "" : "s"})`;
 }
-var LOG_DIR = path3.join(os10.homedir(), ".standardagents", "process-logs");
+var LOG_DIR = path3.join(os7.homedir(), ".standardagents", "process-logs");
 var KEY2 = "bg_processes";
 function isAlive(pid) {
   try {
@@ -1189,7 +1482,7 @@ var ProcessRegistry = class {
   }
 };
 function configFile() {
-  return process.env.STANDARDAGENTS_MCP_CONFIG || path3.join(os10.homedir(), ".standardagents", "mcp.json");
+  return process.env.STANDARDAGENTS_MCP_CONFIG || path3.join(os7.homedir(), ".standardagents", "mcp.json");
 }
 function loadMcpConfig() {
   try {
@@ -1491,7 +1784,7 @@ var HostTools = class {
       }
     }
     const hash = crypto.createHash("sha256").update(JSON.stringify(files)).digest("hex").slice(0, 12);
-    const skillDir = path3.join(os10.tmpdir(), "standardcode-skills", `${skill}-${hash}`);
+    const skillDir = path3.join(os7.tmpdir(), "standardcode-skills", `${skill}-${hash}`);
     for (const f of files) {
       const dest = path3.resolve(skillDir, f.path);
       if (path3.relative(skillDir, dest).startsWith("..")) {
@@ -2418,6 +2711,7 @@ var MessageStream = class {
     ws.addEventListener("open", () => {
       this.reconnectAttempt = 0;
       this.startHeartbeat(ws);
+      this.hooks.onOpen?.();
       this.resolveConnected?.();
     });
     ws.addEventListener("message", (ev) => {
@@ -2435,7 +2729,7 @@ var MessageStream = class {
   }
   startHeartbeat(ws) {
     this.stopHeartbeat();
-    this.heartbeat = new Heartbeat(ws, () => this.handleDrop(ws));
+    this.heartbeat = new Heartbeat(ws, () => this.handleDrop(ws), { request: "stream_ping" });
     this.heartbeat.start();
   }
   stopHeartbeat() {
@@ -2484,10 +2778,11 @@ var MessageStream = class {
     }
     if (msg.type === "message_data" && (msg.depth ?? 0) === 0) {
       const data = msg.data || {};
+      this.hooks.onMessage?.(data);
       if (data.role === "assistant" && typeof data.content === "string" && data.content.trim()) {
         const tc = data.tool_calls;
-        const hasToolCalls2 = Array.isArray(tc) ? tc.length > 0 : typeof tc === "string" && tc.trim() !== "" && tc.trim() !== "null" && tc.trim() !== "[]";
-        this.hooks.onAssistantText(data.content, hasToolCalls2);
+        const hasToolCalls = Array.isArray(tc) ? tc.length > 0 : typeof tc === "string" && tc.trim() !== "" && tc.trim() !== "null" && tc.trim() !== "[]";
+        this.hooks.onAssistantText(data.content, hasToolCalls);
       }
       if (data.role === "assistant" && data.status === "failed" && data.error) {
         this.hooks.onError(String(data.error));
@@ -2537,7 +2832,7 @@ var SystemEvents = class {
   }
   startHeartbeat(ws) {
     this.stopHeartbeat();
-    this.heartbeat = new Heartbeat(ws, () => this.handleDrop(ws));
+    this.heartbeat = new Heartbeat(ws, () => this.handleDrop(ws), { request: "stream_ping" });
     this.heartbeat.start();
   }
   stopHeartbeat() {
@@ -2670,6 +2965,664 @@ var SubagentActivity = class {
   }
 };
 
+// src/session-state.ts
+var emptyLiveDraft = () => ({ version: 1, text: "", messageIds: [] });
+function normalizeLiveDraft(state) {
+  return {
+    version: 1,
+    text: typeof state?.text === "string" ? state.text : "",
+    messageIds: Array.isArray(state?.messageIds) ? [...new Set(state.messageIds.filter((id) => typeof id === "string" && !!id))] : []
+  };
+}
+function appendLiveDraft(state, chunks) {
+  const current = normalizeLiveDraft(state);
+  const nextIds = [...current.messageIds];
+  let text = current.text;
+  for (const chunk of Array.isArray(chunks) ? chunks : [chunks]) {
+    if (typeof chunk?.text !== "string" || !chunk.text) continue;
+    text += chunk.text;
+    if (typeof chunk.messageId === "string" && chunk.messageId && !nextIds.includes(chunk.messageId)) {
+      nextIds.push(chunk.messageId);
+    }
+  }
+  return { version: 1, text, messageIds: nextIds.slice(-64) };
+}
+var createdAt = (message) => Number(message.created_at ?? message.createdAt ?? 0);
+function messageText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((block) => typeof block === "string" ? block : typeof block?.text === "string" ? block.text : "").join("");
+  }
+  return "";
+}
+function parseObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) return value;
+  if (typeof value !== "string" || !value.trim()) return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function parseToolCalls(message) {
+  if (Array.isArray(message.toolCalls)) return message.toolCalls;
+  let raw = message.tool_calls;
+  if (typeof raw === "string") {
+    try {
+      raw = JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  if (!Array.isArray(raw)) return [];
+  return raw.flatMap((item) => {
+    const id = typeof item?.id === "string" ? item.id : "";
+    const nameValue = item?.function?.name ?? item?.name;
+    const name = typeof nameValue === "string" ? nameValue : "";
+    if (!id || !name) return [];
+    return [{ id, name, arguments: parseObject(item?.function?.arguments ?? item?.arguments ?? item?.args) }];
+  });
+}
+function deriveSessionActivity(messages) {
+  const visible = messages.filter((message) => message.silent !== true && message.metadata?.silent !== true).sort((a, b) => createdAt(a) - createdAt(b));
+  if (visible.some((message) => message.status === "pending")) return { busy: true, currentTool: unresolvedTool(visible) };
+  const last = visible.at(-1);
+  if (!last) return { busy: false, currentTool: null };
+  const currentTool = unresolvedTool(visible);
+  if (currentTool) return { busy: true, currentTool };
+  if (last.role === "user" || last.role === "tool") return { busy: true, currentTool: null };
+  if (last.role === "assistant" && last.status !== "failed" && !messageText(last.content).trim()) {
+    return { busy: true, currentTool: null };
+  }
+  return { busy: false, currentTool: null };
+}
+function threadBusy(messages) {
+  return deriveSessionActivity(messages).busy;
+}
+function unresolvedTool(messages) {
+  const resultIds = new Set(messages.flatMap((message) => {
+    const id = message.tool_call_id ?? message.toolCallId;
+    return message.role === "tool" && typeof id === "string" ? [id] : [];
+  }));
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    if (messages[i].role === "user") return null;
+    if (messages[i].role !== "assistant") continue;
+    const calls = parseToolCalls(messages[i]);
+    if (!calls.length) return null;
+    return calls.find((tool) => !resultIds.has(tool.id)) ?? null;
+  }
+  return null;
+}
+
+// src/transcript-delivery.ts
+function transcriptMessageReady(message, text) {
+  if (message.status === "pending") return false;
+  if (message.role === "assistant" && message.status !== "failed" && !text.trim()) return false;
+  return true;
+}
+
+// src/progressive-markdown.ts
+var punctuation = /[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/;
+var isWhitespace = (value) => value === void 0 || /\s/.test(value);
+var isPunctuation = (value) => value !== void 0 && punctuation.test(value);
+function runLength(source, start, marker) {
+  let end = start;
+  while (source[end] === marker) end++;
+  return end - start;
+}
+function delimiterFlanking(source, at, length, marker) {
+  const previous = at > 0 && source[at - 1] !== "\n" ? source[at - 1] : void 0;
+  const next = at + length < source.length && source[at + length] !== "\n" ? source[at + length] : void 0;
+  const previousWhitespace = isWhitespace(previous);
+  const nextWhitespace = isWhitespace(next);
+  const previousPunctuation = isPunctuation(previous);
+  const nextPunctuation = isPunctuation(next);
+  const leftFlanking = !nextWhitespace && (!nextPunctuation || previousWhitespace || previousPunctuation);
+  const rightFlanking = !previousWhitespace && (!previousPunctuation || nextWhitespace || nextPunctuation);
+  if (marker === "_") {
+    return {
+      canOpen: leftFlanking && (!rightFlanking || previousPunctuation),
+      canClose: rightFlanking && (!leftFlanking || nextPunctuation)
+    };
+  }
+  return { canOpen: leftFlanking, canClose: rightFlanking };
+}
+function sameStyles(a, b) {
+  return a.length === b.length && a.every((style, index) => style === b[index]);
+}
+function parseProgressiveInline(source, baseOffset = 0) {
+  const runs = [];
+  const stack = [];
+  let inlineTicks = 0;
+  let i = 0;
+  const styles = () => [
+    ...stack.map((frame) => frame.style),
+    ...inlineTicks > 0 ? ["code"] : []
+  ];
+  const append = (text, at, href) => {
+    if (!text) return;
+    const active = styles();
+    const last = runs.at(-1);
+    if (last && last._end === at && last.href === href && sameStyles(last.styles, active)) {
+      last.text += text;
+      last._end = at + text.length;
+      return;
+    }
+    runs.push({ id: `i:${baseOffset + at}`, text, styles: active, ...{}, _end: at + text.length });
+  };
+  while (i < source.length) {
+    const character = source[i];
+    if (character === "\\") {
+      if (i + 1 < source.length && isPunctuation(source[i + 1])) {
+        append(source[i + 1], i + 1);
+        i += 2;
+        continue;
+      }
+      if (i + 1 === source.length) {
+        i++;
+        continue;
+      }
+    }
+    if (inlineTicks > 0) {
+      if (character === "`") {
+        const length = runLength(source, i, "`");
+        if (length === inlineTicks) {
+          inlineTicks = 0;
+          i += length;
+          continue;
+        }
+        if (i + length === source.length) {
+          i += length;
+          continue;
+        }
+        append("`".repeat(length), i);
+        i += length;
+        continue;
+      }
+      append(character, i);
+      i++;
+      continue;
+    }
+    if (character === "`") {
+      const length = runLength(source, i, "`");
+      if (i + length < source.length) inlineTicks = length;
+      i += length;
+      continue;
+    }
+    if (character === "[") {
+      const destinationAt = source.indexOf("](", i + 1);
+      if (destinationAt >= 0) {
+        const destinationEnd = source.indexOf(")", destinationAt + 2);
+        const end = destinationEnd >= 0 ? destinationEnd : source.length;
+        const href = source.slice(destinationAt + 2, end);
+        const labelStart = i + 1;
+        const labelRuns = parseProgressiveInline(source.slice(labelStart, destinationAt), baseOffset + labelStart);
+        for (const run3 of labelRuns) {
+          runs.push({
+            ...run3,
+            styles: run3.styles.includes("link") ? run3.styles : [...run3.styles, "link"],
+            ...destinationEnd >= 0 && href ? { href } : {},
+            _end: run3.id.startsWith("i:") ? Number(run3.id.slice(2)) - baseOffset + run3.text.length : end
+          });
+        }
+        i = destinationEnd >= 0 ? destinationEnd + 1 : source.length;
+        continue;
+      }
+    }
+    if (character === "*" || character === "_" || character === "~") {
+      const run3 = runLength(source, i, character);
+      const usable = character === "~" ? run3 - run3 % 2 : run3;
+      if (usable > 0) {
+        const { canOpen, canClose } = delimiterFlanking(source, i, run3, character);
+        const frames = [];
+        if (character === "~") {
+          for (let n = 0; n < usable; n += 2) frames.push({ marker: "~", length: 2, style: "strike" });
+        } else {
+          let remaining = usable;
+          while (remaining >= 2) {
+            frames.push({ marker: character, length: 2, style: "strong" });
+            remaining -= 2;
+          }
+          if (remaining) frames.push({ marker: character, length: 1, style: "emphasis" });
+        }
+        let consumed = 0;
+        let closed = 0;
+        if (canClose) {
+          for (const frame of [...frames].reverse()) {
+            const top = stack.at(-1);
+            if (top && top.marker === frame.marker && top.length === frame.length) {
+              stack.pop();
+              consumed += frame.length;
+              closed += frame.length;
+            }
+          }
+        }
+        if (canOpen) {
+          for (const frame of frames) {
+            if (consumed >= frame.length) consumed -= frame.length;
+            else stack.push(frame);
+          }
+        }
+        if (canOpen || closed > 0) {
+          i += usable;
+          if (run3 > usable) append(character.repeat(run3 - usable), i);
+          i += run3 - usable;
+          continue;
+        }
+        if (i + run3 === source.length) {
+          i += run3;
+          continue;
+        }
+      }
+      if (usable === 0 && i + run3 === source.length) {
+        i += run3;
+        continue;
+      }
+    }
+    append(character, i);
+    i++;
+  }
+  return runs.map(({ _end: _, ...run3 }) => run3);
+}
+function sourceLines(source) {
+  if (!source) return [];
+  const lines = [];
+  let start = 0;
+  while (start <= source.length) {
+    const newline = source.indexOf("\n", start);
+    if (newline < 0) {
+      lines.push({ text: source.slice(start).replace(/\r$/, ""), start, end: source.length, next: source.length, terminated: false });
+      break;
+    }
+    lines.push({ text: source.slice(start, newline).replace(/\r$/, ""), start, end: newline, next: newline + 1, terminated: true });
+    start = newline + 1;
+    if (start === source.length) {
+      lines.push({ text: "", start, end: start, next: start, terminated: false });
+      break;
+    }
+  }
+  return lines;
+}
+function blockFence(line) {
+  const match = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+  if (!match) return null;
+  const marker = match[1][0];
+  const info = match[2];
+  if (marker === "`" && info.includes("`")) return null;
+  return { marker, length: match[1].length, info: info.trim() };
+}
+var tableSeparator = (line) => /^\s*\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)*\|?\s*$/.test(line) && line.includes("-");
+var partialTableSeparator = (line) => /^\s*\|?\s*:?-*:?\s*(\|\s*:?-*:?\s*)*\|?\s*$/.test(line) && /[-|:]/.test(line);
+function tableCells(line) {
+  let start = 0;
+  let end = line.length;
+  while (start < end && /\s/.test(line[start])) start++;
+  while (end > start && /\s/.test(line[end - 1])) end--;
+  if (line[start] === "|") start++;
+  if (line[end - 1] === "|") end--;
+  const cells = [];
+  let cellStart = start;
+  for (let i = start; i <= end; i++) {
+    if (i === end || line[i] === "|" && (i === 0 || line[i - 1] !== "\\")) {
+      const raw = line.slice(cellStart, i);
+      const leading = raw.match(/^\s*/)?.[0].length ?? 0;
+      cells.push({ text: raw.trim().replace(/\\\|/g, "|"), offset: cellStart + leading });
+      cellStart = i + 1;
+    }
+  }
+  return cells;
+}
+function cell(text, offset) {
+  return { id: `cell:${offset}`, runs: parseProgressiveInline(text, offset) };
+}
+function startsSpecialBlock(lines, index) {
+  const line = lines[index]?.text ?? "";
+  const next = lines[index + 1]?.text;
+  return !!blockFence(line) || /^#{1,6}\s+/.test(line) || /^\s*>\s?/.test(line) || /^\s*[-*+]\s+/.test(line) || /^\s*\d+[.)]\s+/.test(line) || /^\s*([-*_])(\s*\1){2,}\s*$/.test(line) || /^ {0,3}\|/.test(line) || line.includes("|") && next !== void 0 && tableSeparator(next);
+}
+function parseStreamingMarkdown(source) {
+  const lines = sourceLines(source);
+  const blocks = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line.text.trim()) {
+      i++;
+      continue;
+    }
+    const id = `b:${line.start}`;
+    const opening = blockFence(line.text);
+    if (opening) {
+      const codeStart = line.next;
+      let j2 = i + 1;
+      let closing;
+      while (j2 < lines.length) {
+        const candidate = blockFence(lines[j2].text);
+        if (candidate && candidate.marker === opening.marker && candidate.length >= opening.length && !candidate.info) {
+          closing = lines[j2];
+          break;
+        }
+        j2++;
+      }
+      let codeEnd = closing?.start ?? source.length;
+      if (!closing) {
+        const tailStart = Math.max(codeStart, source.lastIndexOf("\n") + 1);
+        const tail = source.slice(tailStart);
+        const pending = /^ {0,3}(`+|~+)[ \t]*$/.exec(tail);
+        if (pending && pending[1][0] === opening.marker && pending[1].length < opening.length) codeEnd = tailStart;
+      }
+      if (codeEnd > codeStart && source[codeEnd - 1] === "\n") codeEnd--;
+      blocks.push({
+        id,
+        kind: "code",
+        start: line.start,
+        end: closing?.next ?? source.length,
+        complete: !!closing && closing.terminated,
+        language: opening.info || "code",
+        text: source.slice(codeStart, codeEnd)
+      });
+      i = closing ? j2 + 1 : lines.length;
+      continue;
+    }
+    const heading = /^(#{1,6})\s+(.*)$/.exec(line.text);
+    if (heading) {
+      const contentAt = line.start + heading[1].length + 1;
+      blocks.push({
+        id,
+        kind: "heading",
+        start: line.start,
+        end: line.end,
+        complete: line.terminated,
+        level: heading[1].length,
+        runs: parseProgressiveInline(heading[2], contentAt)
+      });
+      i++;
+      continue;
+    }
+    if (/^\s*([-*_])(\s*\1){2,}\s*$/.test(line.text)) {
+      blocks.push({ id, kind: "rule", start: line.start, end: line.end, complete: line.terminated });
+      i++;
+      continue;
+    }
+    const separatorNext = line.text.includes("|") && i + 1 < lines.length && tableSeparator(lines[i + 1].text);
+    if (separatorNext) {
+      const separator = tableCells(lines[i + 1].text);
+      const align = separator.map(({ text: text2 }) => text2.startsWith(":") && text2.endsWith(":") ? "center" : text2.endsWith(":") ? "right" : text2.startsWith(":") ? "left" : "");
+      const header = tableCells(line.text).map((entry) => cell(entry.text, line.start + entry.offset));
+      const rows = [];
+      let j2 = i + 2;
+      while (j2 < lines.length && lines[j2].text.trim() && lines[j2].text.includes("|")) {
+        rows.push(tableCells(lines[j2].text).map((entry) => cell(entry.text, lines[j2].start + entry.offset)));
+        j2++;
+      }
+      blocks.push({
+        id,
+        kind: "table",
+        start: line.start,
+        end: lines[Math.max(i + 1, j2 - 1)].end,
+        complete: j2 < lines.length && lines[j2].terminated,
+        header,
+        rows,
+        align
+      });
+      i = j2;
+      continue;
+    }
+    if (/^ {0,3}\|/.test(line.text)) {
+      const streamingSeparator = i + 1 >= lines.length || !lines[i + 1].terminated && (!lines[i + 1].text || partialTableSeparator(lines[i + 1].text));
+      if (streamingSeparator) {
+        const header = tableCells(line.text).map((entry) => cell(entry.text, line.start + entry.offset));
+        if (header.some((entry) => entry.runs.length)) {
+          blocks.push({
+            id,
+            kind: "table",
+            start: line.start,
+            end: lines[Math.min(i + 1, lines.length - 1)].end,
+            complete: false,
+            header,
+            rows: []
+          });
+        } else {
+          blocks.push({ id, kind: "paragraph", start: line.start, end: line.end, complete: false, runs: [] });
+        }
+        i = lines.length;
+        continue;
+      }
+    }
+    const quote = /^\s*>\s?(.*)$/.exec(line.text);
+    if (quote) {
+      const parts = [];
+      let j2 = i;
+      let firstContentAt = line.start + line.text.indexOf(quote[1]);
+      while (j2 < lines.length) {
+        const match = /^\s*>\s?(.*)$/.exec(lines[j2].text);
+        if (!match) break;
+        if (!parts.length) firstContentAt = lines[j2].start + lines[j2].text.indexOf(match[1]);
+        parts.push(match[1]);
+        j2++;
+      }
+      blocks.push({
+        id,
+        kind: "quote",
+        start: line.start,
+        end: lines[j2 - 1].end,
+        complete: j2 < lines.length && lines[j2].terminated,
+        runs: parseProgressiveInline(parts.join("\n"), firstContentAt)
+      });
+      i = j2;
+      continue;
+    }
+    const list = /^(\s*)([-*+]|\d+[.)])\s+(.*)$/.exec(line.text);
+    if (list) {
+      const ordered = /^\d/.test(list[2]);
+      const items = [];
+      let j2 = i;
+      while (j2 < lines.length) {
+        const match = /^(\s*)([-*+]|\d+[.)])\s+(.*)$/.exec(lines[j2].text);
+        if (!match || /^\d/.test(match[2]) !== ordered) break;
+        const contentAt = lines[j2].start + match[1].length + match[2].length + 1;
+        items.push(cell(match[3], contentAt));
+        j2++;
+      }
+      blocks.push({
+        id,
+        kind: "list",
+        start: line.start,
+        end: lines[j2 - 1].end,
+        complete: j2 < lines.length && lines[j2].terminated,
+        ordered,
+        items
+      });
+      i = j2;
+      continue;
+    }
+    if (!line.terminated && (/^ {0,3}#{1,6}\s*$/.test(line.text) || /^\s*[-*_]{1,2}\s*$/.test(line.text))) {
+      blocks.push({ id, kind: "paragraph", start: line.start, end: line.end, complete: false, runs: [] });
+      i++;
+      continue;
+    }
+    const paragraph = [line];
+    let j = i + 1;
+    while (j < lines.length && lines[j].text.trim() && !startsSpecialBlock(lines, j)) {
+      paragraph.push(lines[j]);
+      j++;
+    }
+    const text = paragraph.map((part) => part.text).join("\n");
+    blocks.push({
+      id,
+      kind: "paragraph",
+      start: line.start,
+      end: paragraph.at(-1).end,
+      complete: j < lines.length && lines[j].terminated,
+      runs: parseProgressiveInline(text, line.start)
+    });
+    i = j;
+  }
+  return { version: 3, sourceLength: source.length, blocks };
+}
+
+// src/markdown.ts
+var ESC = "\x1B[";
+var R = ESC + "0m";
+var BOLD = ESC + "1m";
+var DIM3 = ESC + "2m";
+var ITAL = ESC + "3m";
+var UNDER = ESC + "4m";
+var TEAL = ESC + "38;5;37m";
+var CYAN = ESC + "36m";
+var GRAY = ESC + "90m";
+var ANSI = /\x1b\[[0-9;]*m/g;
+function visibleWidth(s) {
+  return s.replace(ANSI, "").length;
+}
+function padEndVisible(s, width) {
+  const pad = width - visibleWidth(s);
+  return pad > 0 ? s + " ".repeat(pad) : s;
+}
+function inline(s) {
+  const codes = [];
+  s = s.replace(/`([^`]+)`/g, (_, code) => {
+    codes.push(code);
+    return "\0" + (codes.length - 1) + "\0";
+  });
+  s = s.replace(
+    /\[([^\]]+)\]\(([^)\s]+)\)/g,
+    (_, text, url) => `${CYAN}${UNDER}${text}${R} ${DIM3}${url}${R}`
+  );
+  s = s.replace(/\*\*([^*]+)\*\*/g, (_, t) => `${BOLD}${t}${R}`);
+  s = s.replace(/\*([^*\n]+)\*/g, (_, t) => `${ITAL}${t}${R}`);
+  s = s.replace(/__([^_]+)__/g, (_, t) => `${BOLD}${t}${R}`);
+  s = s.replace(/(^|[^\w])_([^_\n]+)_($|[^\w])/g, (_, a, t, b) => `${a}${ITAL}${t}${R}${b}`);
+  s = s.replace(/~~([^~]+)~~/g, (_, t) => `${DIM3}${t}${R}`);
+  s = s.replace(/\x00(\d+)\x00/g, (_, i) => `${TEAL}${codes[+i].replace(/ /g, String.fromCharCode(160))}${R}`);
+  return s;
+}
+function wrapStyled(text, width) {
+  if (width < 4 || visibleWidth(text) <= width) return [text];
+  const words = text.split(" ");
+  const lines = [];
+  let cur = "";
+  let curLen = 0;
+  for (const w of words) {
+    const wLen = visibleWidth(w);
+    if (cur === "") {
+      cur = w;
+      curLen = wLen;
+    } else if (curLen + 1 + wLen <= width) {
+      cur += " " + w;
+      curLen += 1 + wLen;
+    } else {
+      lines.push(cur);
+      cur = w;
+      curLen = wLen;
+    }
+  }
+  if (cur !== "" || lines.length === 0) lines.push(cur);
+  return lines;
+}
+function wrapBlock(out, cols2, leadFirst, leadRest, leadWidth, text) {
+  const wrapped = wrapStyled(text, Math.max(8, cols2 - leadWidth));
+  wrapped.forEach((ln, idx) => out.push((idx === 0 ? leadFirst : leadRest) + ln));
+}
+function renderTable(rows) {
+  const cols2 = Math.max(...rows.map((r) => r.length));
+  const widths = [];
+  for (let c4 = 0; c4 < cols2; c4++) {
+    widths[c4] = Math.max(...rows.map((r) => visibleWidth(inline(r[c4] ?? ""))));
+  }
+  const sep = `${GRAY} \u2502 ${R}`;
+  const out = [];
+  rows.forEach((r, ri) => {
+    const cells = [];
+    for (let c4 = 0; c4 < cols2; c4++) {
+      const raw = r[c4] ?? "";
+      const styled = ri === 0 ? `${BOLD}${inline(raw)}${R}` : inline(raw);
+      cells.push(padEndVisible(styled, widths[c4]));
+    }
+    out.push(("  " + cells.join(sep)).replace(/\s+$/, ""));
+    if (ri === 0) {
+      const rule = widths.map((w) => `${GRAY}${"\u2500".repeat(w)}${R}`).join(`${GRAY}\u2500\u253C\u2500${R}`);
+      out.push("  " + rule);
+    }
+  });
+  return out;
+}
+function streamingRun(run3) {
+  let text = run3.styles.includes("code") ? run3.text.replace(/ /g, String.fromCharCode(160)) : run3.text;
+  if (run3.styles.includes("code")) text = `${TEAL}${text}${R}`;
+  if (run3.styles.includes("strike")) text = `${DIM3}${text}${R}`;
+  if (run3.styles.includes("strong")) text = `${BOLD}${text}${R}`;
+  if (run3.styles.includes("emphasis")) text = `${ITAL}${text}${R}`;
+  if (run3.href || run3.styles.includes("link")) text = `${CYAN}${UNDER}${text}${R}`;
+  return text;
+}
+function streamingInline(runs) {
+  return runs.map(streamingRun).join("");
+}
+function plainCell(cell2) {
+  return cell2.runs.map((run3) => run3.text).join("");
+}
+function renderStreamingMarkdown(src, cols2 = 80) {
+  const document = parseStreamingMarkdown(src);
+  const out = [];
+  for (const block of document.blocks) {
+    if (out.length && out.at(-1) !== "") out.push("");
+    switch (block.kind) {
+      case "code": {
+        const lines = (block.text ?? "").split("\n");
+        if (lines.length === 1 && !lines[0]) out.push(`${GRAY}\u2502${R} `);
+        else for (const line of lines) out.push(`${GRAY}\u2502${R} ${line}`);
+        break;
+      }
+      case "heading": {
+        const text = streamingInline(block.runs ?? []);
+        for (const line of wrapStyled(text, cols2)) out.push(`${BOLD}${TEAL}${line}${R}`);
+        break;
+      }
+      case "rule":
+        out.push(`${GRAY}\u2500\u2500\u2500\u2500\u2500\u2500${R}`);
+        break;
+      case "quote": {
+        const text = streamingInline(block.runs ?? []);
+        for (const logical of text.split("\n")) {
+          for (const line of wrapStyled(logical, Math.max(8, cols2 - 2))) out.push(`${GRAY}\u2502${R} ${DIM3}${line}${R}`);
+        }
+        break;
+      }
+      case "list": {
+        for (let index = 0; index < (block.items ?? []).length; index++) {
+          const marker = block.ordered ? `${index + 1}.` : "\u2022";
+          const lead = block.ordered ? `${BOLD}${marker}${R} ` : `${TEAL}${marker}${R} `;
+          wrapBlock(
+            out,
+            cols2,
+            lead,
+            " ".repeat(marker.length + 1),
+            marker.length + 1,
+            streamingInline(block.items[index].runs)
+          );
+        }
+        break;
+      }
+      case "table": {
+        const rows = [
+          (block.header ?? []).map(plainCell),
+          ...(block.rows ?? []).map((row) => row.map(plainCell))
+        ];
+        if (rows[0].length) out.push(...renderTable(rows));
+        break;
+      }
+      case "paragraph": {
+        const text = streamingInline(block.runs ?? []);
+        for (const logical of text.split("\n")) wrapBlock(out, cols2, "", "", 0, logical);
+        break;
+      }
+    }
+  }
+  return out;
+}
+
 // src/wordmill.ts
 var MILL_WORDS = [
   "Working",
@@ -2711,8 +3664,8 @@ var HOLD_MS = 2600;
 var LAZY_MS = 320;
 var LAZY_PERIOD = 200;
 var FAST_PERIOD = 70;
-var BOLD = "\x1B[1m";
-var DIM3 = "\x1B[2m";
+var BOLD2 = "\x1B[1m";
+var DIM4 = "\x1B[2m";
 var OFF = "\x1B[22m";
 function glyphAt(slot, bucket) {
   let h = (slot + 1) * 2654435761 ^ (bucket + 1) * 40503;
@@ -2747,7 +3700,7 @@ var WordMill = class {
     if (this.phaseAt === 0) this.phaseAt = now;
     if (!this.target) {
       if (now - this.phaseAt >= HOLD_MS) this.beginMorph(now);
-      else return `${BOLD}${this.word}${OFF}`;
+      else return `${BOLD2}${this.word}${OFF}`;
     }
     return this.morphFrame(now);
   }
@@ -2773,21 +3726,21 @@ var WordMill = class {
       this.word = target;
       this.target = null;
       this.phaseAt = now;
-      return `${BOLD}${this.word}${OFF}`;
+      return `${BOLD2}${this.word}${OFF}`;
     }
     let out = "";
     for (let i = 0; i < this.slots.length; i++) {
       const s = this.slots[i];
       if (t < s.start) {
         const ch = this.word[i];
-        if (ch) out += `${BOLD}${ch}${OFF}`;
+        if (ch) out += `${BOLD2}${ch}${OFF}`;
       } else if (t < s.land) {
         const age = t - s.start;
         const period = age < LAZY_MS ? LAZY_PERIOD : FAST_PERIOD;
-        out += `${DIM3}${glyphAt(i, Math.floor(t / period))}${OFF}`;
+        out += `${DIM4}${glyphAt(i, Math.floor(t / period))}${OFF}`;
       } else {
         const ch = target[i];
-        if (ch) out += `${BOLD}${ch}${OFF}`;
+        if (ch) out += `${BOLD2}${ch}${OFF}`;
       }
     }
     return out;
@@ -2833,7 +3786,7 @@ function fromFile(filePath) {
   }
 }
 async function readDarwin() {
-  const tmp = path3.join(os10.tmpdir(), `sc-clip-${process.pid}-${Date.now()}.png`);
+  const tmp = path3.join(os7.tmpdir(), `sc-clip-${process.pid}-${Date.now()}.png`);
   const script = [
     `set d to the clipboard as \xABclass PNGf\xBB`,
     `set f to open for access POSIX file "${tmp}" with write permission`,
@@ -2870,7 +3823,7 @@ async function readLinux() {
   return null;
 }
 async function readWindows() {
-  const tmp = path3.join(os10.tmpdir(), `sc-clip-${process.pid}-${Date.now()}.png`);
+  const tmp = path3.join(os7.tmpdir(), `sc-clip-${process.pid}-${Date.now()}.png`);
   const ps = [
     "Add-Type -AssemblyName System.Windows.Forms;",
     "$img = [System.Windows.Forms.Clipboard]::GetImage();",
@@ -2898,6 +3851,11 @@ async function readClipboardImage() {
 function imagePlaceholder(seq) {
   return `[#Image ${seq}]`;
 }
+function ensureImagePlaceholders(text, images) {
+  const missing = images.map((image) => imagePlaceholder(image.seq)).filter((placeholder) => !text.includes(placeholder));
+  if (!missing.length) return text;
+  return [text.trimEnd(), ...missing].filter(Boolean).join(" ");
+}
 var INPUT_BOX_MARGIN = 1;
 function inputBoxBorderColor() {
   return "\x1B[38;5;240m";
@@ -3091,8 +4049,13 @@ var C = {
   gray: themeGray,
   teal: "\x1B[38;5;37m"
 };
+var SYNC_OUTPUT_BEGIN = "\x1B[?2026h";
+var SYNC_OUTPUT_END = "\x1B[?2026l";
+var CURSOR_HIDE = "\x1B[?25l";
+var CURSOR_SHOW = "\x1B[?25h";
 var FRAMES = ["\u28F7", "\u28EF", "\u28DF", "\u287F", "\u28BF", "\u28FB", "\u28FD", "\u28FE"];
-var SPINNER_MS = 70;
+var SPINNER_FRAME_MS = 70;
+var ANIMATION_TICK_MS = 1e3 / 60;
 var SUBAGENT_COLORS = [
   "\x1B[35m",
   // magenta
@@ -3165,6 +4128,7 @@ var Tui = class _Tui {
   // answer text (plain). Bounded to a tail; cleared when the message commits.
   streamThinking = "";
   streamResponse = "";
+  streamDraft = emptyLiveDraft();
   streamMessageId = null;
   // the message currently previewing
   streamRedrawTimer = null;
@@ -3194,7 +4158,7 @@ var Tui = class _Tui {
   // rows re-wrap (a full-width ruler becomes 2+ physical rows when narrowed),
   // so the caret-relative move-up from the last paint is stale. We store the
   // visible width of EVERY region row (not just above the body) plus the caret
-  // row index so moveToRegionTop can recompute physical height under the new
+  // row index so regionTopSequence can recompute physical height under the new
   // wrap. Resize events are debounced — drag-resizing fires dozens of events
   // and redrawing each one desyncs and leaves ghost chrome.
   lastDrawnCols = 0;
@@ -3221,6 +4185,9 @@ var Tui = class _Tui {
   // placeholder at the caret; on submit only images whose placeholder is still
   // present in the text are handed to onSubmit. Cleared with the input.
   pendingImages = [];
+  /** Portable file refs mirrored from another client. Their bytes remain in
+   *  the thread filesystem, so the TUI shows names without decoding them. */
+  externalAttachmentNames = [];
   imagePasteBusy = false;
   // one clipboard read at a time
   // Sent-message history for ↑/↓ recall (oldest → newest). `historyIdx` is the
@@ -3234,6 +4201,9 @@ var Tui = class _Tui {
   // event hooks (wired by index.ts)
   onSubmit = () => {
   };
+  /** Shift+Return sends a steering input through the portable messaging endpoint. */
+  onSteer = () => {
+  };
   onInterrupt = () => {
   };
   /** Up on the top row: return true to consume it (e.g. pull a queued message)
@@ -3242,8 +4212,8 @@ var Tui = class _Tui {
   /** Enter while the `[⚙ n bg]` badge is selected — opens the bg process panel. */
   onBgBadge = () => {
   };
-  /** Fired (deduped) when the input draft text changes — index.ts debounce-writes
-   *  it into the shared cross-surface presence buffer. */
+  /** Fired (deduped) when the composer changes so index.ts can persist the
+   *  shared packed-endpoint draft, including attachments. */
   onDraftChange = () => {
   };
   lastDraftSeen = "";
@@ -3329,7 +4299,7 @@ var Tui = class _Tui {
   dispatch(str, key) {
     const seq = key && key.sequence || str || "";
     if (seq === "\n" || seq === "\x1B[13;2u" || seq === "\x1B[27;2;13~") {
-      this.insertAtCursor("\n");
+      if (!this.takeoverHandler && !this.pasting && !this.paletteOpen()) this.submitInput(true);
       return;
     }
     if (key && key.ctrl && key.name === "c") {
@@ -3398,10 +4368,7 @@ var Tui = class _Tui {
         return;
       }
       if (key.name === "return" || key.name === "enter") {
-        if (key.shift) {
-          this.insertAtCursor("\n");
-          return;
-        }
+        if (key.shift) return;
         if (matches.length) this.runCommand(matches[cur]);
         return;
       }
@@ -3464,23 +4431,15 @@ var Tui = class _Tui {
       return;
     }
     if (key.name === "return" || key.name === "enter") {
-      if (key.shift) {
+      if (key.meta) {
         this.insertAtCursor("\n");
         return;
       }
-      const text = this.inputBuffer;
-      const images = this.pendingImages.filter((img) => text.includes(imagePlaceholder(img.seq)));
-      this.inputBuffer = "";
-      this.cursorPos = 0;
-      this.pendingImages = [];
-      this.historyIdx = null;
-      this.historyDraft = "";
-      this.historyDraftImages = [];
-      this.renderBottom();
-      if (text.trim()) {
-        this.addHistoryEntry(text.trim());
-        this.onSubmit(text.trim(), images);
+      if (key.shift) {
+        this.submitInput(true);
+        return;
       }
+      this.submitInput(false);
       return;
     }
     if (key.ctrl && key.name === "v") {
@@ -3511,6 +4470,23 @@ var Tui = class _Tui {
       this.insertAtCursor(str);
     }
   }
+  submitInput(steer) {
+    const text = this.inputBuffer;
+    const images = this.pendingImages.filter((img) => text.includes(imagePlaceholder(img.seq)));
+    const hasExternalAttachments = this.externalAttachmentNames.length > 0;
+    this.inputBuffer = "";
+    this.cursorPos = 0;
+    this.pendingImages = [];
+    this.externalAttachmentNames = [];
+    this.historyIdx = null;
+    this.historyDraft = "";
+    this.historyDraftImages = [];
+    this.renderBottom();
+    if (!text.trim() && !hasExternalAttachments && images.length === 0) return;
+    if (text.trim()) this.addHistoryEntry(text.trim());
+    if (steer) this.onSteer(text.trim(), images);
+    else this.onSubmit(text.trim(), images);
+  }
   insertAtCursor(text) {
     this.inputBuffer = this.inputBuffer.slice(0, this.cursorPos) + text + this.inputBuffer.slice(this.cursorPos);
     this.cursorPos += text.length;
@@ -3713,7 +4689,7 @@ var Tui = class _Tui {
   }
   spinnerFrame() {
     const now = Date.now();
-    return `${C.bold}${brandCycleColor(now)}${FRAMES[Math.floor(now / SPINNER_MS) % FRAMES.length]}${C.reset}`;
+    return `${C.bold}${brandCycleColor(now)}${FRAMES[Math.floor(now / SPINNER_FRAME_MS) % FRAMES.length]}${C.reset}`;
   }
   /** "↑X ↓Y" cumulative token totals (greyed — low-priority). */
   tokensText() {
@@ -3753,7 +4729,7 @@ var Tui = class _Tui {
   }
   /** Is the `/` command palette currently showing? (input starts with "/".) */
   paletteOpen() {
-    return this.started && !this.takeoverHandler && this.commands.length > 0 && this.inputBuffer.startsWith("/");
+    return this.started && !this.takeoverHandler && this.commands.length > 0 && this.externalAttachmentNames.length === 0 && this.inputBuffer.startsWith("/");
   }
   /** Commands matching the text typed after "/", in declared order. */
   filteredCommands() {
@@ -3812,9 +4788,10 @@ var Tui = class _Tui {
   /** The prompt line prefix (with ANSI colour) that precedes the typed text. */
   promptPrefix() {
     const q = this.queuedCount > 0 ? `${C.yellow}[\u23F3 ${this.queuedCount} queued]${C.reset} ` : "";
+    const attachments2 = this.externalAttachmentNames.length > 0 ? `${C.gray}[\u{1F4CE} ${this.externalAttachmentNames.length}]${C.reset} ` : "";
     const bgText = `[\u2699 ${this.bgCount} bg]`;
     const bg = this.bgCount > 0 ? this.bgBadgeSelected ? `${C.cyan}\x1B[7m${bgText}\x1B[27m${C.reset} ` : `${C.cyan}${bgText}${C.reset} ` : "";
-    return `${q}${bg}${this.levelColor()}\u276F${C.reset} `;
+    return `${q}${attachments2}${bg}${this.levelColor()}\u276F${C.reset} `;
   }
   visibleWidth(s) {
     let w = 0;
@@ -3889,20 +4866,21 @@ var Tui = class _Tui {
     if (matches.length === 0) return [`  ${C.gray}no matching command${C.reset}`];
     const cur = Math.min(this.slashIdx, matches.length - 1);
     const pointerW = 2;
+    const rowCols = Math.max(1, cols2 - 1);
     return matches.map((cmd, i) => {
       const sel = i === cur;
       const hint = (typeof cmd.hint === "function" ? cmd.hint() : cmd.hint) ?? "";
       const hintW = hint.length;
       const name = `/${cmd.name}`;
       let visible = `${name}  ${cmd.label}`;
-      const labelMax = Math.max(6, cols2 - pointerW - (hintW ? hintW + 2 : 0));
+      const labelMax = Math.max(6, rowCols - pointerW - (hintW ? hintW + 2 : 0));
       if (visible.length > labelMax) visible = visible.slice(0, labelMax - 1) + "\u2026";
       const desc = visible.slice(name.length);
       const pointer = sel ? `${C.magenta}\u276F${C.reset} ` : "  ";
       const nameStyled = sel ? `${C.bold}${C.cyan}${name}${C.reset}` : `${C.cyan}${name}${C.reset}`;
       let line = `${pointer}${nameStyled}${C.gray}${desc}${C.reset}`;
       if (hintW) {
-        const gap = Math.max(2, cols2 - pointerW - visible.length - hintW);
+        const gap = Math.max(2, rowCols - pointerW - visible.length - hintW);
         line += `${" ".repeat(gap)}${C.gray}${hint}${C.reset}`;
       }
       return line;
@@ -3924,9 +4902,9 @@ var Tui = class _Tui {
    * the NEW wrap: rows above the caret row + (caret row's rewrap − 1) so we
    * prefer a slight over-move (clean wipe) over under-move (ghost chrome).
    */
-  moveToRegionTop() {
-    process.stdout.write("\r");
-    if (!this.bottomDrawn) return;
+  regionTopSequence() {
+    let sequence = "\r";
+    if (!this.bottomDrawn) return sequence;
     const cols2 = process.stdout.columns || 80;
     let up;
     if (cols2 !== this.lastDrawnCols && this.lastDrawnCols > 0 && this.drawnRegionWidths.length) {
@@ -3943,7 +4921,8 @@ var Tui = class _Tui {
     } else {
       up = this.lastCursorRow;
     }
-    if (up > 0) process.stdout.write(`\x1B[${up}A`);
+    if (up > 0) sequence += `\x1B[${up}A`;
+    return sequence;
   }
   /**
    * Render the bottom region: status + subagents above a side-margined expanding
@@ -3959,14 +4938,15 @@ var Tui = class _Tui {
     if (!this.started || this.takeoverHandler) return;
     if (this.inputBuffer !== this.lastDraftSeen) {
       this.lastDraftSeen = this.inputBuffer;
+      const images = this.pendingImages.filter((img) => this.inputBuffer.includes(imagePlaceholder(img.seq)));
       try {
-        this.onDraftChange(this.inputBuffer);
+        this.onDraftChange(this.inputBuffer, images);
       } catch {
       }
     }
     if (this.resizePending) return;
     const cols2 = process.stdout.columns || 80;
-    this.moveToRegionTop();
+    const moveToTop = this.regionTopSequence();
     const hudWidths = [];
     const hudRows = [];
     const rowCap = Math.max(1, cols2 - 1);
@@ -3987,7 +4967,7 @@ var Tui = class _Tui {
     if (quitLine) writeHudRow(workPad + quitLine);
     const statusLine = this.statusLineText(workCols);
     if (statusLine) writeHudRow(workPad + statusLine);
-    const frame = FRAMES[Math.floor(Date.now() / SPINNER_MS) % FRAMES.length];
+    const frame = FRAMES[Math.floor(Date.now() / SPINNER_FRAME_MS) % FRAMES.length];
     for (const sub of this.subagents) {
       const color = sub.agentName === COMPACTION_AGENT ? COMPACTION_COLOR : SUBAGENT_COLORS[this.subagentColorByID.get(sub.id) ?? 0];
       const budget = workCols - 10;
@@ -4035,18 +5015,21 @@ var Tui = class _Tui {
     this.bottomDrawn = true;
     const totalRows = hudRows.length;
     const up = Math.max(0, totalRows - 1 - caretRegionRow);
-    let out = "\x1B[J" + hudRows.join("\r\n");
+    let out = SYNC_OUTPUT_BEGIN + moveToTop + "\x1B[J" + hudRows.join("\r\n");
     if (totalRows > 0) {
       out += "\r";
       if (up > 0) out += `\x1B[${up}A`;
       if (caretScreenCol > 0) out += `\x1B[${caretScreenCol}C`;
     }
+    out += SYNC_OUTPUT_END;
     process.stdout.write(out);
   }
   clearBottom() {
     if (!this.bottomDrawn) return;
-    this.moveToRegionTop();
-    process.stdout.write("\x1B[J");
+    const moveToTop = this.regionTopSequence();
+    process.stdout.write(
+      SYNC_OUTPUT_BEGIN + CURSOR_HIDE + moveToTop + "\x1B[J" + CURSOR_SHOW + SYNC_OUTPUT_END
+    );
     this.bottomDrawn = false;
   }
   // ── live streaming preview ────────────────────────────────────────────────
@@ -4055,15 +5038,15 @@ var Tui = class _Tui {
   // wipes it right before the finished message is committed to the transcript
   // (which renders full markdown), so there's no double-render.
   static STREAM_TAIL = 20;
-  // How long a preview may sit untouched before it's wiped. The model often
-  // reasons and then calls a tool without ever emitting an answer, so without
-  // this the reasoning tail would linger on screen until the *next* thought (or
-  // message) arrives. Re-armed on every delta → fires this long after the last.
+  // How long a reasoning-only preview may sit untouched before it's wiped. A
+  // visible answer must NEVER expire: it is the only copy until polling
+  // promotes the durable message into terminal scrollback.
   static STREAM_IDLE_MS = 1e4;
-  /** Append a fragment of streamed answer text (rendered plain). */
+  /** Append a fragment of streamed answer text (rendered as progressive Markdown). */
   streamResponseDelta(delta, messageId) {
     this.beginStreamMessage(messageId);
-    this.streamResponse += delta;
+    this.streamDraft = appendLiveDraft(this.streamDraft, { text: delta, messageId });
+    this.streamResponse = this.streamDraft.text;
     this.scheduleStreamRedraw();
     this.armStreamIdleExpiry();
   }
@@ -4083,8 +5066,7 @@ var Tui = class _Tui {
   beginStreamMessage(messageId) {
     if (messageId !== void 0 && messageId !== this.streamMessageId) {
       this.streamMessageId = messageId;
-      this.streamThinking = "";
-      this.streamResponse = "";
+      if (!this.streamResponse) this.streamThinking = "";
     }
   }
   /** Wipe the live preview — call right before committing the final message. */
@@ -4098,6 +5080,7 @@ var Tui = class _Tui {
       this.streamIdleTimer = null;
     }
     this.streamMessageId = null;
+    this.streamDraft = emptyLiveDraft();
     if (!this.streamThinking && !this.streamResponse) return;
     this.streamThinking = "";
     this.streamResponse = "";
@@ -4110,17 +5093,16 @@ var Tui = class _Tui {
       this.renderBottom();
     }, 40);
   }
-  /** Re-armed on every streamed delta: once the model goes quiet for a beat, the
-   *  preview is stale, so wipe it instead of letting it sit until the next
-   *  message. The committed message (if any) still renders in full via
-   *  clearStream(), so nothing is lost. */
+  /** Re-armed for reasoning-only deltas. Once answer prose exists it remains
+   *  visible until clearStream() runs immediately before durable promotion. */
   armStreamIdleExpiry() {
     if (this.streamIdleTimer) clearTimeout(this.streamIdleTimer);
+    this.streamIdleTimer = null;
+    if (this.streamResponse) return;
     this.streamIdleTimer = setTimeout(() => {
       this.streamIdleTimer = null;
-      if (!this.streamThinking && !this.streamResponse) return;
+      if (this.streamResponse || !this.streamThinking) return;
       this.streamThinking = "";
-      this.streamResponse = "";
       this.renderBottom();
     }, _Tui.STREAM_IDLE_MS);
   }
@@ -4136,23 +5118,28 @@ var Tui = class _Tui {
    */
   streamPreviewLines(cols2) {
     const thinkStyle = "\x1B[3m\x1B[38;5;240m";
-    const clamp2 = (s, wrap, lead) => {
-      const max = cols2 - 2;
-      const t = s.length > max ? s.slice(0, Math.max(0, max - 1)) + "\u2026" : s;
-      return wrap ? `${lead}${wrap}${t}${C.reset}` : `${lead}${t}`;
+    const leakedMarkup = /<\/?[|｜]DSML[|｜]|^\s*\[\/?SESSION\]\s*<?\s*$/;
+    const renderedLines = (text) => {
+      const clean2 = text.replace(/\r/g, "").split("\n").filter((line) => !leakedMarkup.test(line)).join("\n");
+      const rows = [];
+      for (const line of renderStreamingMarkdown(clean2, Math.max(8, cols2 - 2))) {
+        const blank = line.replace(/\x1b\[[0-9;]*m/g, "").trim() === "";
+        if (blank && (!rows.length || rows[rows.length - 1] === "")) continue;
+        rows.push(blank ? "" : line);
+      }
+      while (rows.length && rows[rows.length - 1] === "") rows.pop();
+      return rows;
     };
-    const leakedMarkup = /<\/?[|｜]DSML[|｜]|^\s*\[\/?SESSION\]\s*<?\s*$/;
-    const realLines = (text) => text.replace(/\r/g, "").split("\n").filter((l) => l.trim() !== "" && !leakedMarkup.test(l));
     if (this.streamResponse) {
-      const all = realLines(this.streamResponse);
+      const all = renderedLines(this.streamResponse);
       const shown = all.slice(-20);
       const firstVisible = all.length <= _Tui.STREAM_TAIL;
       return shown.map(
-        (l, i) => clamp2(l, "", i === 0 && firstVisible ? `${C.gray}\u2022${C.reset} ` : "  ")
+        (l, i) => `${i === 0 && firstVisible ? `${C.gray}\u2022${C.reset} ` : "  "}${l}`
       );
     }
     if (this.streamThinking) {
-      return realLines(this.streamThinking).slice(-20).map((l) => clamp2(l, thinkStyle, "  "));
+      return renderedLines(this.streamThinking).slice(-20).map((l) => `  ${thinkStyle}${l.replace(/\x1b\[0m/g, `${C.reset}${thinkStyle}`)}${C.reset}`);
     }
     return [];
   }
@@ -4280,6 +5267,7 @@ var Tui = class _Tui {
   }
   // ─── working indicator (turn state) ───────────────────────────────────────
   setWorking(on) {
+    if (on === this.working) return;
     if (on && !this.working) {
       this.working = true;
       this.workingStart = Date.now();
@@ -4295,6 +5283,11 @@ var Tui = class _Tui {
    *  stable, distinct colour for as long as it's active; the compaction agent
    *  is always orange (its colour never comes from the shared pool). */
   setSubagents(subagents) {
+    const unchanged = subagents.length === this.subagents.length && subagents.every((sub, i) => {
+      const current = this.subagents[i];
+      return current?.id === sub.id && current.label === sub.label && current.agentName === sub.agentName;
+    });
+    if (unchanged) return;
     this.subagents = subagents;
     const active = new Set(subagents.map((s) => s.id));
     for (const id of [...this.subagentColorByID.keys()]) {
@@ -4315,7 +5308,7 @@ var Tui = class _Tui {
   syncSpinner() {
     const spinning = this.working || this.subagents.length > 0;
     if (spinning && !this.spinnerTimer) {
-      this.spinnerTimer = setInterval(() => this.renderBottom(), SPINNER_MS);
+      this.spinnerTimer = setInterval(() => this.renderBottom(), ANIMATION_TICK_MS);
     } else if (!spinning && this.spinnerTimer) {
       clearInterval(this.spinnerTimer);
       this.spinnerTimer = null;
@@ -4325,15 +5318,18 @@ var Tui = class _Tui {
     return this.working;
   }
   setBackgroundCount(n) {
+    if (n === this.bgCount) return;
     this.bgCount = n;
     if (n === 0) this.bgBadgeSelected = false;
     this.renderBottom();
   }
   setQueuedCount(n) {
+    if (n === this.queuedCount) return;
     this.queuedCount = n;
     this.renderBottom();
   }
   setConnected(connected) {
+    if (connected === this.connected) return;
     this.connected = connected;
     this.renderBottom();
   }
@@ -4342,15 +5338,25 @@ var Tui = class _Tui {
     return this.inputBuffer;
   }
   /** Replace the input (and any pasted images tied to placeholders in it). */
-  setInput(text, images = []) {
-    this.inputBuffer = text;
-    this.cursorPos = text.length;
+  setInput(text, images = [], notifyDraft = true, restoreExternalImages = false) {
+    this.inputBuffer = restoreExternalImages ? ensureImagePlaceholders(text, images) : text;
+    this.cursorPos = this.inputBuffer.length;
     this.pendingImages = images;
     this.historyIdx = null;
+    if (!notifyDraft) this.lastDraftSeen = this.inputBuffer;
+    this.renderBottom();
+  }
+  setExternalAttachmentNames(names) {
+    if (names.length === this.externalAttachmentNames.length && names.every((name, i) => name === this.externalAttachmentNames[i])) return;
+    this.externalAttachmentNames = [...names];
     this.renderBottom();
   }
+  hasExternalAttachments() {
+    return this.externalAttachmentNames.length > 0;
+  }
   /** Cumulative token totals shown on the prompt line (`outTokens` includes live). */
   setTokens(inTokens, outTokens) {
+    if (inTokens === this.tokensIn && outTokens === this.tokensOut) return;
     this.tokensIn = inTokens;
     this.tokensOut = outTokens;
     this.renderBottom();
@@ -4362,6 +5368,7 @@ var Tui = class _Tui {
    */
   setStep(label, outTokens) {
     const next = label && label.trim() ? label.replace(/\s+/g, " ").trim() : null;
+    if (next === this.step && outTokens === this.stepOut) return;
     if (next !== this.step) {
       this.step = next;
       this.stepStart = Date.now();
@@ -4787,169 +5794,7 @@ function appendHistory(store, threadId, history, text) {
   void store.kvSet(threadId, HISTORY_KEY, [...history]);
   return history;
 }
-
-// src/markdown.ts
-var ESC = "\x1B[";
-var R = ESC + "0m";
-var BOLD2 = ESC + "1m";
-var DIM4 = ESC + "2m";
-var ITAL = ESC + "3m";
-var UNDER = ESC + "4m";
-var TEAL = ESC + "38;5;37m";
-var CYAN = ESC + "36m";
-var GRAY = ESC + "90m";
-var ANSI = /\x1b\[[0-9;]*m/g;
-function visibleWidth(s) {
-  return s.replace(ANSI, "").length;
-}
-function padEndVisible(s, width) {
-  const pad = width - visibleWidth(s);
-  return pad > 0 ? s + " ".repeat(pad) : s;
-}
-function inline(s) {
-  const codes = [];
-  s = s.replace(/`([^`]+)`/g, (_, code) => {
-    codes.push(code);
-    return "\0" + (codes.length - 1) + "\0";
-  });
-  s = s.replace(
-    /\[([^\]]+)\]\(([^)\s]+)\)/g,
-    (_, text, url) => `${CYAN}${UNDER}${text}${R} ${DIM4}${url}${R}`
-  );
-  s = s.replace(/\*\*([^*]+)\*\*/g, (_, t) => `${BOLD2}${t}${R}`);
-  s = s.replace(/\*([^*\n]+)\*/g, (_, t) => `${ITAL}${t}${R}`);
-  s = s.replace(/~~([^~]+)~~/g, (_, t) => `${DIM4}${t}${R}`);
-  s = s.replace(/\x00(\d+)\x00/g, (_, i) => `${TEAL}${codes[+i].replace(/ /g, String.fromCharCode(160))}${R}`);
-  return s;
-}
-function wrapStyled(text, width) {
-  if (width < 4 || visibleWidth(text) <= width) return [text];
-  const words = text.split(" ");
-  const lines = [];
-  let cur = "";
-  let curLen = 0;
-  for (const w of words) {
-    const wLen = visibleWidth(w);
-    if (cur === "") {
-      cur = w;
-      curLen = wLen;
-    } else if (curLen + 1 + wLen <= width) {
-      cur += " " + w;
-      curLen += 1 + wLen;
-    } else {
-      lines.push(cur);
-      cur = w;
-      curLen = wLen;
-    }
-  }
-  if (cur !== "" || lines.length === 0) lines.push(cur);
-  return lines;
-}
-function wrapBlock(out, cols2, leadFirst, leadRest, leadWidth, text) {
-  const wrapped = wrapStyled(text, Math.max(8, cols2 - leadWidth));
-  wrapped.forEach((ln, idx) => out.push((idx === 0 ? leadFirst : leadRest) + ln));
-}
-function tableCells(row) {
-  let r = row.trim();
-  if (r.startsWith("|")) r = r.slice(1);
-  if (r.endsWith("|")) r = r.slice(0, -1);
-  return r.split("|").map((c4) => c4.trim());
-}
-var SEPARATOR = /^[\s|:-]+$/;
-function isTableSeparator(line) {
-  return SEPARATOR.test(line) && line.includes("-") && line.includes("|");
-}
-function renderTable(rows) {
-  const cols2 = Math.max(...rows.map((r) => r.length));
-  const widths = [];
-  for (let c4 = 0; c4 < cols2; c4++) {
-    widths[c4] = Math.max(...rows.map((r) => visibleWidth(inline(r[c4] ?? ""))));
-  }
-  const sep = `${GRAY} \u2502 ${R}`;
-  const out = [];
-  rows.forEach((r, ri) => {
-    const cells = [];
-    for (let c4 = 0; c4 < cols2; c4++) {
-      const raw = r[c4] ?? "";
-      const styled = ri === 0 ? `${BOLD2}${inline(raw)}${R}` : inline(raw);
-      cells.push(padEndVisible(styled, widths[c4]));
-    }
-    out.push(("  " + cells.join(sep)).replace(/\s+$/, ""));
-    if (ri === 0) {
-      const rule = widths.map((w) => `${GRAY}${"\u2500".repeat(w)}${R}`).join(`${GRAY}\u2500\u253C\u2500${R}`);
-      out.push("  " + rule);
-    }
-  });
-  return out;
-}
-function renderMarkdown(src, cols2 = 80) {
-  const lines = src.replace(/\r\n/g, "\n").split("\n");
-  const out = [];
-  let inFence = false;
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i];
-    if (/^\s*```/.test(line)) {
-      inFence = !inFence;
-      i++;
-      continue;
-    }
-    if (inFence) {
-      out.push(`${GRAY}\u2502${R} ${line}`);
-      i++;
-      continue;
-    }
-    if (line.includes("|") && i + 1 < lines.length && isTableSeparator(lines[i + 1])) {
-      const block = [tableCells(line)];
-      i += 2;
-      while (i < lines.length && lines[i].includes("|") && lines[i].trim()) {
-        block.push(tableCells(lines[i]));
-        i++;
-      }
-      out.push(...renderTable(block));
-      continue;
-    }
-    const heading = line.match(/^(#{1,6})\s+(.*)$/);
-    if (heading) {
-      for (const ln of wrapStyled(heading[2].trim(), cols2)) out.push(`${BOLD2}${TEAL}${ln}${R}`);
-      i++;
-      continue;
-    }
-    if (/^\s*([-*_])(\s*\1){2,}\s*$/.test(line)) {
-      out.push(`${GRAY}\u2500\u2500\u2500\u2500\u2500\u2500${R}`);
-      i++;
-      continue;
-    }
-    const quote = line.match(/^\s*>\s?(.*)$/);
-    if (quote) {
-      for (const ln of wrapStyled(inline(quote[1]), Math.max(8, cols2 - 2))) {
-        out.push(`${GRAY}\u2502${R} ${DIM4}${ln}${R}`);
-      }
-      i++;
-      continue;
-    }
-    const bullet = line.match(/^(\s*)[-*+]\s+(.*)$/);
-    if (bullet) {
-      const leadWidth = bullet[1].length + 2;
-      wrapBlock(out, cols2, `${bullet[1]}${TEAL}\u2022${R} `, " ".repeat(leadWidth), leadWidth, inline(bullet[2]));
-      i++;
-      continue;
-    }
-    const numbered = line.match(/^(\s*)(\d+)([.)])\s+(.*)$/);
-    if (numbered) {
-      const marker = `${numbered[2]}${numbered[3]}`;
-      const leadWidth = numbered[1].length + marker.length + 1;
-      wrapBlock(out, cols2, `${numbered[1]}${BOLD2}${marker}${R} `, " ".repeat(leadWidth), leadWidth, inline(numbered[4]));
-      i++;
-      continue;
-    }
-    if (line.trim()) wrapBlock(out, cols2, "", "", 0, inline(line));
-    else out.push("");
-    i++;
-  }
-  return out;
-}
-var DIR = path3.join(os10.homedir(), ".standardagents");
+var DIR = path3.join(os7.homedir(), ".standardagents");
 var FILE = path3.join(DIR, "credentials");
 function normalizeEndpoint(endpoint) {
   let e = endpoint.trim();
@@ -5083,7 +5928,7 @@ function relaxTlsForLocalEndpoint(endpoint) {
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
   return true;
 }
-var dir = () => path3.join(os10.homedir(), ".standardagents");
+var dir = () => path3.join(os7.homedir(), ".standardagents");
 var file = () => path3.join(dir(), "machine.json");
 function loadMachineIdentity() {
   try {
@@ -5153,20 +5998,55 @@ function parseFsRequest(value) {
     requested_at: typeof r.requested_at === "number" ? r.requested_at : Date.now()
   };
 }
+async function writeFsRequest(api, machineId, req) {
+  await api.userKvSet(fsRequestKey(machineId), { ...req, requested_at: Date.now() });
+}
+async function readFsResponse(api, machineId) {
+  const value = await api.userKvGet(fsResponseKey(machineId));
+  if (!value || typeof value !== "object") return null;
+  const r = value;
+  if (typeof r.nonce !== "string" || typeof r.ok !== "boolean") return null;
+  return {
+    nonce: r.nonce,
+    ok: r.ok,
+    result: r.result,
+    error: typeof r.error === "string" ? r.error : void 0,
+    responded_at: typeof r.responded_at === "number" ? r.responded_at : 0
+  };
+}
 async function readFsRequest(api, machineId) {
   return parseFsRequest(await api.userKvGet(fsRequestKey(machineId)));
 }
 async function writeFsResponse(api, machineId, res) {
   await api.userKvSet(fsResponseKey(machineId), { ...res, responded_at: Date.now() });
 }
-function machineIcon(record) {
-  if (record.icon && record.icon.trim()) return record.icon.trim();
-  if (record.platform === "darwin") return "\u{1F4BB}";
-  if (record.platform === "win32") return "\u{1F5A5}\uFE0F";
+async function resolveRemoteProjectPath(api, machineId, typedPath, timeoutMs = 12e3) {
+  const trimmed = typedPath.trim();
+  if (!trimmed.startsWith("~")) return trimmed;
+  const nonce = crypto.randomBytes(8).toString("hex");
+  try {
+    await writeFsRequest(api, machineId, { nonce, op: "list", path: trimmed });
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 700));
+      const res = await readFsResponse(api, machineId).catch(() => null);
+      if (res && res.nonce === nonce) {
+        const resolved = res.result && typeof res.result.path === "string" ? res.result.path : "";
+        return resolved || trimmed;
+      }
+    }
+  } catch {
+  }
+  return trimmed;
+}
+function machineIcon(record2) {
+  if (record2.icon && record2.icon.trim()) return record2.icon.trim();
+  if (record2.platform === "darwin") return "\u{1F4BB}";
+  if (record2.platform === "win32") return "\u{1F5A5}\uFE0F";
   return "\u{1F5B3}";
 }
-function machineDisplayName(record) {
-  return record.name?.trim() || "" || (record.hostname || "") || (record.id || "") || "machine";
+function machineDisplayName(record2) {
+  return record2.name?.trim() || "" || (record2.hostname || "") || (record2.id || "") || "machine";
 }
 async function getMachineName(api, machineId) {
   const v = await api.userKvGet(nameKey(machineId));
@@ -5241,15 +6121,15 @@ async function loadMachine(api, machineId) {
   if (icon) rec.icon = icon;
   return rec;
 }
-function daemonOnline(record, now = Date.now()) {
-  return !!record.daemon && now - record.daemon.last_seen_at < DAEMON_ONLINE_WINDOW_MS;
+function daemonOnline(record2, now = Date.now()) {
+  return !!record2.daemon && now - record2.daemon.last_seen_at < DAEMON_ONLINE_WINDOW_MS;
 }
 function newRecord(identity) {
   const now = Date.now();
   return {
     id: identity.machine_id,
-    name: os10.hostname(),
-    hostname: os10.hostname(),
+    name: os7.hostname(),
+    hostname: os7.hostname(),
     platform: process.platform,
     arch: process.arch,
     version: readVersion() || void 0,
@@ -5261,15 +6141,15 @@ function newRecord(identity) {
 }
 async function updateOwnMachineRecord(api, identity, mutate) {
   const existing = await loadRawMachine(api, identity.machine_id);
-  const record = existing ?? newRecord(identity);
-  record.hostname = os10.hostname();
-  record.platform = process.platform;
-  record.arch = process.arch;
-  record.version = readVersion() || record.version;
-  mutate?.(record);
-  record.updated_at = Date.now();
-  await api.userKvSet(machineKey(identity.machine_id), record);
-  return record;
+  const record2 = existing ?? newRecord(identity);
+  record2.hostname = os7.hostname();
+  record2.platform = process.platform;
+  record2.arch = process.arch;
+  record2.version = readVersion() || record2.version;
+  mutate?.(record2);
+  record2.updated_at = Date.now();
+  await api.userKvSet(machineKey(identity.machine_id), record2);
+  return record2;
 }
 function projectRepository(projectDir) {
   try {
@@ -5283,35 +6163,54 @@ function projectRepository(projectDir) {
     return null;
   }
 }
+function normalizeProjectDir(projectDir) {
+  let p = projectDir.trim();
+  if (!p) return p;
+  if (p === "~") p = os7.homedir();
+  else if (p.startsWith("~/")) p = path3.join(os7.homedir(), p.slice(2));
+  return path3.resolve(p);
+}
 async function registerProject(api, identity, projectDir) {
-  const repository = projectRepository(projectDir);
-  await updateOwnMachineRecord(api, identity, (record) => {
-    record.projects[projectDir] = {
-      name: projectDir.split("/").filter(Boolean).pop() || projectDir,
+  const dir2 = normalizeProjectDir(projectDir);
+  if (!dir2) return;
+  const repository = projectRepository(dir2);
+  await updateOwnMachineRecord(api, identity, (record2) => {
+    for (const existing of Object.keys(record2.projects)) {
+      if (existing !== dir2 && normalizeProjectDir(existing) === dir2) {
+        delete record2.projects[existing];
+      }
+    }
+    record2.projects[dir2] = {
+      name: dir2.split("/").filter(Boolean).pop() || dir2,
       last_used_at: Date.now(),
       repository
     };
   });
 }
 async function unregisterProject(api, identity, projectDir) {
-  await updateOwnMachineRecord(api, identity, (record) => {
-    delete record.projects[projectDir];
+  const dir2 = normalizeProjectDir(projectDir);
+  await updateOwnMachineRecord(api, identity, (record2) => {
+    for (const existing of Object.keys(record2.projects)) {
+      if (existing === projectDir || existing === dir2 || normalizeProjectDir(existing) === dir2) {
+        delete record2.projects[existing];
+      }
+    }
   });
 }
 async function touchDaemon(api, identity, version) {
-  await updateOwnMachineRecord(api, identity, (record) => {
+  await updateOwnMachineRecord(api, identity, (record2) => {
     const now = Date.now();
-    record.daemon = {
+    record2.daemon = {
       version,
-      installed_at: record.daemon?.installed_at ?? now,
+      installed_at: record2.daemon?.installed_at ?? now,
       last_seen_at: now,
       pid: process.pid
     };
   });
 }
 async function clearDaemon(api, identity) {
-  await updateOwnMachineRecord(api, identity, (record) => {
-    record.daemon = null;
+  await updateOwnMachineRecord(api, identity, (record2) => {
+    record2.daemon = null;
   });
 }
 function parseCommands(value) {
@@ -5347,16 +6246,16 @@ async function clearMachineCommands(api, machineId, appliedIds) {
 async function applyMachineCommand(api, identity, cmd) {
   switch (cmd.kind) {
     case "add_project": {
-      const path13 = typeof cmd.args?.path === "string" ? cmd.args.path : "";
-      if (!path13) return "add_project: ignored (no path)";
-      await registerProject(api, identity, path13);
-      return `added project ${path13}`;
+      const path14 = typeof cmd.args?.path === "string" ? cmd.args.path : "";
+      if (!path14) return "add_project: ignored (no path)";
+      await registerProject(api, identity, path14);
+      return `added project ${path14}`;
     }
     case "remove_project": {
-      const path13 = typeof cmd.args?.path === "string" ? cmd.args.path : "";
-      if (!path13) return "remove_project: ignored (no path)";
-      await unregisterProject(api, identity, path13);
-      return `removed project ${path13}`;
+      const path14 = typeof cmd.args?.path === "string" ? cmd.args.path : "";
+      if (!path14) return "remove_project: ignored (no path)";
+      await unregisterProject(api, identity, path14);
+      return `removed project ${path14}`;
     }
     case "update":
       return "update requested";
@@ -5433,7 +6332,7 @@ var PROJECT_MARKERS = [
 ];
 var MAX_ENTRIES2 = 500;
 function resolveBrowsePath(input3) {
-  const home = os10.homedir();
+  const home = os7.homedir();
   let p = (input3 ?? "").trim();
   if (!p) return home;
   if (p === "~") return home;
@@ -5458,7 +6357,7 @@ function markers(dirPath) {
   return { project, repo };
 }
 function browseDirectory(input3, opts = {}) {
-  const home = os10.homedir();
+  const home = os7.homedir();
   const abs = resolveBrowsePath(input3);
   const parent = path3.dirname(abs);
   const base = {
@@ -5712,7 +6611,7 @@ var UPDATE_CHECK_MS = 6 * 60 * 6e4;
 var SWEEP_MS = 10 * 6e4;
 var MAX_WORKERS = 30;
 var LOG_MAX_BYTES = 1e6;
-var LOG_FILE = path3.join(os10.homedir(), ".standardagents", "daemon.log");
+var LOG_FILE = path3.join(os7.homedir(), ".standardagents", "daemon.log");
 function daemonLog(line) {
   try {
     fs4.mkdirSync(path3.dirname(LOG_FILE), { recursive: true });
@@ -5731,13 +6630,13 @@ function pathFromTags(tags) {
   const tag = tags.find((t) => t.startsWith("path:"));
   if (!tag) return null;
   const raw = tag.slice("path:".length);
-  return raw.replace(/^~(?=\/|$)/, os10.homedir());
+  return raw.replace(/^~(?=\/|$)/, os7.homedir());
 }
 var ThreadWorker = class {
-  constructor(api, identity, machineName, threadId, projectDir, createdAt) {
+  constructor(api, identity, machineName, threadId, projectDir, createdAt2) {
     this.threadId = threadId;
     this.projectDir = projectDir;
-    this.createdAt = createdAt;
+    this.createdAt = createdAt2;
     this.perm = { level: 1, alwaysAllow: /* @__PURE__ */ new Set(), allowRisk: /* @__PURE__ */ new Set() };
     this.session = new ExecutionSession({
       api,
@@ -5863,7 +6762,7 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
     process.exit(1);
   }
   let displayName = machineDisplayName(await loadMachine(api, identity.machine_id).catch(() => null) ?? {
-    hostname: os10.hostname(),
+    hostname: os7.hostname(),
     id: identity.machine_id
   });
   const applied = consumeAppliedUpdate(version);
@@ -5877,8 +6776,19 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
   process.on("unhandledRejection", (err) => {
     daemonLog(`unhandledRejection: ${err instanceof Error ? err.stack : String(err)}`);
   });
+  await touchDaemon(api, identity, version).catch(
+    (e) => daemonLog(`heartbeat failed: ${e instanceof Error ? e.message : String(e)}`)
+  );
+  const heartbeat = setInterval(() => {
+    void touchDaemon(api, identity, version).catch(() => {
+    });
+    void getMachineName(api, identity.machine_id).then((n) => {
+      if (n) displayName = n;
+    }).catch(() => {
+    });
+  }, HEARTBEAT_MS);
   const workers = /* @__PURE__ */ new Map();
-  const attach = async (threadId, tags, createdAt = 0) => {
+  const attach = async (threadId, tags, createdAt2 = 0) => {
     if (workers.has(threadId)) return;
     const projectDir = pathFromTags(tags);
     if (!projectDir) return;
@@ -5895,7 +6805,7 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
       daemonLog(`cannot prepare project dir ${projectDir}: ${e instanceof Error ? e.message : String(e)}`);
       return;
     }
-    const worker = new ThreadWorker(api, identity, displayName, threadId, projectDir, createdAt || Date.now());
+    const worker = new ThreadWorker(api, identity, displayName, threadId, projectDir, createdAt2 || Date.now());
     worker.onEvicted = (id) => detach(id);
     workers.set(threadId, worker);
     daemonLog(`attached ${threadId.slice(0, 8)} \u2192 ${projectDir}`);
@@ -5934,17 +6844,6 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
   });
   events.connect();
   await sweep();
-  await touchDaemon(api, identity, version).catch(
-    (e) => daemonLog(`heartbeat failed: ${e instanceof Error ? e.message : String(e)}`)
-  );
-  const heartbeat = setInterval(() => {
-    void touchDaemon(api, identity, version).catch(() => {
-    });
-    void getMachineName(api, identity.machine_id).then((n) => {
-      if (n) displayName = n;
-    }).catch(() => {
-    });
-  }, HEARTBEAT_MS);
   const reclaim = setInterval(() => {
     for (const worker of workers.values()) {
       if (!worker.isOwner) {
@@ -6121,8 +7020,8 @@ function run2(cmd, args) {
   const output4 = `${res.stdout ?? ""}${res.stderr ?? ""}`.trim();
   return { ok: res.status === 0, output: output4 };
 }
-var plistPath = () => path3.join(os10.homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
-var unitPath = () => path3.join(os10.homedir(), ".config", "systemd", "user", SYSTEMD_UNIT);
+var plistPath = () => path3.join(os7.homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+var unitPath = () => path3.join(os7.homedir(), ".config", "systemd", "user", SYSTEMD_UNIT);
 var xmlEscape = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 function installService(command, endpoint) {
   if (process.platform === "darwin") return installLaunchd(command, endpoint);
@@ -6134,7 +7033,7 @@ function installService(command, endpoint) {
   };
 }
 function installLaunchd(command, endpoint) {
-  const logDir = path3.join(os10.homedir(), ".standardagents");
+  const logDir = path3.join(os7.homedir(), ".standardagents");
   fs4.mkdirSync(logDir, { recursive: true });
   fs4.mkdirSync(path3.dirname(plistPath()), { recursive: true });
   const envEntries = [
@@ -6207,10 +7106,10 @@ WantedBy=default.target
   if (!enable.ok) {
     return { ok: false, detail: `systemctl enable failed: ${enable.output}` };
   }
-  const linger = run2("loginctl", ["enable-linger", os10.userInfo().username]);
+  const linger = run2("loginctl", ["enable-linger", os7.userInfo().username]);
   return {
     ok: true,
-    detail: `systemd user unit installed (${unitPath()})` + (linger.ok ? ", lingering enabled" : ` \u2014 enable lingering manually: sudo loginctl enable-linger ${os10.userInfo().username}`)
+    detail: `systemd user unit installed (${unitPath()})` + (linger.ok ? ", lingering enabled" : ` \u2014 enable lingering manually: sudo loginctl enable-linger ${os7.userInfo().username}`)
   };
 }
 function uninstallService() {
@@ -6338,7 +7237,7 @@ async function installCommand(endpointFlag) {
   const api = await ensureSignedIn(endpoint);
   const identity = loadMachineIdentity();
   const existing = await loadMachine(api, identity.machine_id).catch(() => null);
-  const suggested = machineDisplayName(existing ?? { hostname: os10.hostname(), id: identity.machine_id });
+  const suggested = machineDisplayName(existing ?? { hostname: os7.hostname(), id: identity.machine_id });
   const rl = readline2.createInterface({ input: stdin, output: stdout });
   const answer = (await rl.question(
     `${c2.bold}Machine name${c2.reset} ${c2.dim}(shown in the session picker)${c2.reset} [${suggested}]: `
@@ -6362,12 +7261,12 @@ async function installCommand(endpointFlag) {
 `);
   stdout.write(`${c2.dim}Waiting for the daemon's first heartbeat\u2026${c2.reset}
 `);
-  const deadline = Date.now() + 3e4;
+  const deadline = Date.now() + 6e4;
   let alive = false;
   while (Date.now() < deadline) {
     await new Promise((r) => setTimeout(r, 2e3));
-    const record = await loadMachine(api, identity.machine_id);
-    if (record && daemonOnline(record)) {
+    const record2 = await loadMachine(api, identity.machine_id);
+    if (record2 && daemonOnline(record2)) {
       alive = true;
       break;
     }
@@ -6398,7 +7297,7 @@ async function statusCommand() {
   const cred = getCredential(endpoint);
   if (!cred) {
     stdout.write(
-      `${c2.bold}Machine:${c2.reset}  ${os10.hostname()} ${c2.dim}(${identity.machine_id})${c2.reset}
+      `${c2.bold}Machine:${c2.reset}  ${os7.hostname()} ${c2.dim}(${identity.machine_id})${c2.reset}
 `
     );
     stdout.write(`${c2.bold}Account:${c2.reset}  ${c2.yellow}not signed in to ${endpoint}${c2.reset}
@@ -6407,21 +7306,21 @@ async function statusCommand() {
   }
   relaxTlsForLocalEndpoint(endpoint);
   const api = new ApiClient(endpoint, cred.access_token);
-  const record = await loadMachine(api, identity.machine_id).catch(() => null);
+  const record2 = await loadMachine(api, identity.machine_id).catch(() => null);
   stdout.write(
-    `${c2.bold}Machine:${c2.reset}  ${machineDisplayName(record ?? { hostname: os10.hostname(), id: identity.machine_id })} ${c2.dim}(${identity.machine_id})${c2.reset}
+    `${c2.bold}Machine:${c2.reset}  ${machineDisplayName(record2 ?? { hostname: os7.hostname(), id: identity.machine_id })} ${c2.dim}(${identity.machine_id})${c2.reset}
 `
   );
-  if (!record) {
+  if (!record2) {
     stdout.write(`${c2.bold}Registry:${c2.reset} not registered yet
 `);
     return;
   }
-  const online = daemonOnline(record);
-  const seen = record.daemon ? `${Math.round((Date.now() - record.daemon.last_seen_at) / 1e3)}s ago (v${record.daemon.version})` : "never";
+  const online = daemonOnline(record2);
+  const seen = record2.daemon ? `${Math.round((Date.now() - record2.daemon.last_seen_at) / 1e3)}s ago (v${record2.daemon.version})` : "never";
   stdout.write(`${c2.bold}Registry:${c2.reset} ${online ? `${c2.green}online${c2.reset}` : `${c2.yellow}offline${c2.reset}`} \xB7 last heartbeat ${seen}
 `);
-  const projects = Object.keys(record.projects);
+  const projects = Object.keys(record2.projects);
   stdout.write(`${c2.bold}Projects:${c2.reset} ${projects.length ? "" : c2.dim + "none registered" + c2.reset}
 `);
   for (const p of projects.sort()) stdout.write(`  ${c2.dim}${p}${c2.reset}
@@ -6442,8 +7341,8 @@ async function projectCommand(action, target) {
   const endpoint = resolveEndpoint();
   const api = await ensureSignedIn(endpoint);
   const identity = loadMachineIdentity();
-  const record = await loadMachine(api, identity.machine_id).catch(() => null);
-  const displayName = machineDisplayName(record ?? { hostname: os10.hostname(), id: identity.machine_id });
+  const record2 = await loadMachine(api, identity.machine_id).catch(() => null);
+  const displayName = machineDisplayName(record2 ?? { hostname: os7.hostname(), id: identity.machine_id });
   if (action === "add") {
     await registerProject(api, identity, dir2);
     stdout.write(`${c2.green}\u2713${c2.reset} Registered ${dir2} for remote sessions on ${displayName}.
@@ -6601,7 +7500,7 @@ function printAssistant(tui, text) {
   tui.clearStream();
   tui.print("");
   let dotted = false;
-  for (const line of renderMarkdown(text, cols2)) {
+  for (const line of renderStreamingMarkdown(text, cols2)) {
     if (!dotted && line.trim()) {
       tui.print(`${c3.gray}\u2022${c3.reset} ${line}`);
       dotted = true;
@@ -6643,18 +7542,21 @@ ${c3.teal}\u25C7${c3.reset} ${c3.dim}Standard Code \u2014 see you soon.${c3.rese
 `);
 }
 function printWelcome(endpoint, projectDir) {
-  const home = os10.homedir();
+  const home = os7.homedir();
   const dir2 = projectDir.startsWith(home) ? "~" + projectDir.slice(home.length) : projectDir;
   const host = endpoint.replace(/^https?:\/\//, "").replace(/\/$/, "");
   const version = readVersion();
   const pad = "  ";
+  const markWidth = Math.max(...LOGO_MARK.map((l) => [...l].length));
+  const terminalColumns = Math.max(20, process.stdout.columns || 80);
+  const metaWidth = Math.max(1, terminalColumns - pad.length - markWidth - 3 - 1);
+  const displayDir = truncateMiddle(dir2, metaWidth);
   const meta = [
     `${c3.bold}${gradientText("Standard Code")}${c3.reset}${version ? `  ${c3.dim}v${version}${c3.reset}` : ""}`,
     `${c3.dim}terminal coding agent${c3.reset}`,
     ...endpoint === PRODUCTION_ENDPOINT ? [] : [`${c3.teal}${host}${c3.reset}`],
-    `${c3.dim}${dir2}${c3.reset}`
+    `${c3.dim}${displayDir}${c3.reset}`
   ];
-  const markWidth = Math.max(...LOGO_MARK.map((l) => [...l].length));
   const metaTop = Math.floor((LOGO_MARK.length - meta.length) / 2);
   stdout.write("\n");
   for (let i = 0; i < LOGO_MARK.length; i++) {
@@ -6711,7 +7613,7 @@ async function main() {
   const endpointOverride = cliArgs.promptEndpoint || typeof endpointArg === "string" && endpointArg.trim() !== "";
   const dirArg = cliArgs.dir;
   const projectDir = path3.resolve(dirArg || process.cwd());
-  const machine = os10.hostname();
+  const machine = os7.hostname();
   const reader = { rl: null };
   let handoffClosing = false;
   let preflightArmed = false;
@@ -6896,7 +7798,7 @@ ${c3.dim}Press Control-C again to exit${c3.reset}
   void registerProject(api, identity, projectDir).catch(() => {
   });
   const tui = new Tui(1);
-  const home = os10.homedir();
+  const home = os7.homedir();
   const tildeDir = projectDir.startsWith(home) ? "~" + projectDir.slice(home.length) : projectDir;
   const shortDir = tildeDir.length > 38 ? "\u2026" + tildeDir.slice(-37) : tildeDir;
   const session = { mode: "local", identity };
@@ -6919,7 +7821,7 @@ ${c3.dim}Press Control-C again to exit${c3.reset}
         ]
       );
       if (where) {
-        const remotePath = await pickRemoteProject(tui, where);
+        const remotePath = await pickRemoteProject(tui, api, where);
         if (remotePath) {
           session.mode = "remote";
           session.runner = where;
@@ -6955,6 +7857,10 @@ ${c3.dim}Press Control-C again to exit${c3.reset}
     if (session.mode === "remote" && session.runner && session.remotePath) {
       await api.kvSet(id, "session_info", { cwd: session.remotePath, machine: session.runner.name }).catch(() => {
       });
+      void enqueueMachineCommand(api, session.runner.id, "add_project", {
+        path: session.remotePath
+      }).catch(() => {
+      });
     }
     return id;
   };
@@ -6994,7 +7900,7 @@ ${c3.dim}Press Control-C again to exit${c3.reset}
 function shortenPath(p, max = 38) {
   return p.length > max ? "\u2026" + p.slice(-(max - 1)) : p;
 }
-async function pickRemoteProject(tui, runner) {
+async function pickRemoteProject(tui, api, runner) {
   const ENTER_PATH = "__enter_path__";
   const projects = Object.entries(runner.projects).sort(
     (a, b) => (b[1]?.last_used_at ?? 0) - (a[1]?.last_used_at ?? 0)
@@ -7021,7 +7927,7 @@ async function pickRemoteProject(tui, runner) {
     tui.print(`${c3.yellow}Use an absolute path (starting with / or ~).${c3.reset}`);
     return null;
   }
-  return trimmed;
+  return await resolveRemoteProjectPath(api, runner.id, trimmed);
 }
 function isSilentMessage(m) {
   return m?.silent === true || m?.metadata?.silent === true;
@@ -7056,31 +7962,6 @@ function relativeTime(unixSeconds) {
   if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`;
   return `${Math.floor(diff / 86400)}d ago`;
 }
-function hasToolCalls(m) {
-  const tc = m?.tool_calls;
-  if (Array.isArray(tc)) return tc.length > 0;
-  if (typeof tc === "string") {
-    const s = tc.trim();
-    return s.length > 0 && s !== "null" && s !== "[]";
-  }
-  return false;
-}
-function messageText(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.map((b) => typeof b === "string" ? b : typeof b?.text === "string" ? b.text : "").join("");
-  }
-  return "";
-}
-function threadBusy(msgs) {
-  if (!msgs.length) return false;
-  if (msgs.some((m) => m.status === "pending")) return true;
-  const last = [...msgs].sort((a, b) => (b.created_at ?? 0) - (a.created_at ?? 0))[0];
-  if (!last) return false;
-  if (last.role === "user" || last.role === "tool") return true;
-  if (last.role === "assistant") return hasToolCalls(last);
-  return false;
-}
 async function printHistory(api, threadId, tui) {
   let msgs;
   try {
@@ -7139,9 +8020,19 @@ async function runInteractive(tui, api, threadId, projectDir, machine, resumed,
   saveApprovals(api, threadId, perm);
   const attaching = startLoader("Attaching to thread");
   let busy = false;
-  let interrupting = false;
-  const queued = [];
-  let editingQueued = false;
+  let sharedMessaging = emptySharedMessagingSnapshot();
+  let mirroredDraftRefs = [];
+  let sharedMessagingReady = false;
+  let sharedMessagingUnavailableShown = false;
+  const messagingOrigin = {
+    originClientId: `tui:${Math.random().toString(36).slice(2, 10)}`,
+    originClientKind: "tui"
+  };
+  let editingPendingId = null;
+  let reconcileSharedMessaging = async () => {
+  };
+  let refreshSessionProjection = async () => {
+  };
   const shownIds = /* @__PURE__ */ new Set();
   const pendingSent = /* @__PURE__ */ new Map();
   let lastSent = null;
@@ -7239,6 +8130,10 @@ why: ${req.requestPermission}` : ""}`,
     bridge = exec.bridge;
   }
   const stream = new MessageStream(api, threadId, {
+    onOpen: () => {
+      void reconcileSharedMessaging(true);
+      void refreshSessionProjection();
+    },
     // Live streaming preview: answer text and (opt-in) internal reasoning feed
     // the TUI's ephemeral preview; the committed message still renders from
     // polling, which calls tui.clearStream() first so there's no double-render.
@@ -7246,6 +8141,12 @@ why: ${req.requestPermission}` : ""}`,
     onReasoningChunk: (text, mid) => tui.streamThinkingDelta(text, mid),
     onAssistantText: () => {
     },
+    onMessage: (message) => {
+      if (message?.role === "user" || message?.status === "pending") {
+        busy = true;
+        tui.setWorking(true);
+      }
+    },
     onEvent: (eventType, data) => {
       if (eventType === "generation" && typeof data?.outputTokens === "number") {
         liveOut = data.outputTokens;
@@ -7258,6 +8159,8 @@ why: ${req.requestPermission}` : ""}`,
         refreshStatus();
       } else if (eventType === "goal_updated" && data) {
         tui.setGoal(data);
+      } else if (eventType === SHARED_MESSAGING_EVENT) {
+        void reconcileSharedMessaging(true);
       }
     },
     // A failed turn whose message is the lease service's at-limit denial → offer
@@ -7334,7 +8237,7 @@ why: ${req.requestPermission}` : ""}`,
   const sessionEnded = new Promise((r) => endSession = r);
   const quit = async () => {
     tui.end();
-    const stopped2 = bridge?.isOwner ?? false ? api.stop(threadId).catch(() => {
+    const stopped2 = bridge?.isOwner ?? false ? api.requestSharedStop(threadId, messagingOrigin).catch(() => {
     }) : Promise.resolve();
     const procsStopped2 = host ? host.stopAllLocalProcesses().catch(() => 0) : Promise.resolve(0);
     bridge?.close();
@@ -7409,23 +8312,89 @@ why: ${req.requestPermission}` : ""}`,
   };
   const extFor = (mime) => ({ "image/png": "png", "image/jpeg": "jpg", "image/gif": "gif", "image/webp": "webp" })[mime] ?? "bin";
   const toAttachments = (images) => images.map((img) => ({ name: `image-${img.seq}.${extFor(img.mime)}`, mimeType: img.mime, data: img.data }));
-  const sendNow = async (text, images = []) => {
-    lastSent = { text, images };
-    tui.printUserMessage(text);
+  const toSharedAttachments = (images) => toAttachments(images);
+  const fromSharedAttachments = (attachments2) => attachments2.filter(isInlineSharedAttachment).map((attachment, index) => {
+    const namedSequence = /(?:image-|Image\s+)(\d+)/i.exec(attachment.name)?.[1];
+    return {
+      seq: namedSequence ? Number(namedSequence) : index + 1,
+      data: attachment.data,
+      mime: attachment.mimeType
+    };
+  });
+  const applySharedMessaging = (snapshot, mirrorDraft) => {
+    const firstSnapshot = !sharedMessagingReady;
+    const previousDraftRevision = sharedMessaging.draft.revision;
+    sharedMessaging = firstSnapshot ? snapshot : mergeSharedMessagingSnapshot(sharedMessaging, snapshot);
+    sharedMessagingReady = true;
+    sharedMessagingUnavailableShown = false;
+    tui.setQueuedCount(sharedMessaging.pending.items.length);
+    if (mirrorDraft && (firstSnapshot || sharedMessaging.draft.revision > previousDraftRevision) && (firstSnapshot || sharedMessaging.draft.originClientId !== messagingOrigin.originClientId)) {
+      mirroredDraftRefs = sharedMessaging.draft.attachments.filter(isSharedAttachmentRef);
+      tui.setExternalAttachmentNames(mirroredDraftRefs.map((attachment) => attachment.name));
+      tui.setInput(
+        sharedMessaging.draft.content,
+        fromSharedAttachments(sharedMessaging.draft.attachments),
+        false,
+        true
+      );
+    }
+  };
+  reconcileSharedMessaging = async (mirrorDraft = false) => {
+    try {
+      applySharedMessaging(await api.getSharedMessaging(threadId), mirrorDraft);
+    } catch (error) {
+      if (!sharedMessagingReady && !sharedMessagingUnavailableShown) {
+        sharedMessagingUnavailableShown = true;
+        tui.print(`${c3.dim}shared messaging unavailable: ${error instanceof Error ? error.message : String(error)}${c3.reset}`);
+      }
+    }
+  };
+  const onTerminalResume = () => void reconcileSharedMessaging(true);
+  process.on("SIGCONT", onTerminalResume);
+  const applySharedMutation = (promise) => promise.then((snapshot) => {
+    applySharedMessaging(snapshot, false);
+    return true;
+  }).catch((error) => {
+    tui.print(`${c3.dim}shared messaging failed: ${error instanceof Error ? error.message : String(error)}${c3.reset}`);
+    return false;
+  });
+  const appendSharedPending = (text, images, refs = []) => applySharedMutation(api.appendPendingInput(threadId, {
+    content: text,
+    attachments: [...refs, ...toSharedAttachments(images)],
+    ...messagingOrigin
+  }));
+  const steerSharedInput = (text, images, refs = []) => applySharedMutation(api.steerInput(threadId, {
+    content: text,
+    attachments: [...refs, ...toSharedAttachments(images)],
+    ...messagingOrigin
+  }));
+  const editSharedPending = (item, text, images, refs) => applySharedMutation(api.updatePendingInput(threadId, item.id, {
+    content: text,
+    attachments: [
+      ...refs,
+      ...toSharedAttachments(images)
+    ],
+    ...messagingOrigin
+  }));
+  const dismissSharedPending = (item) => applySharedMutation(api.dismissPendingInput(threadId, item.id, messagingOrigin));
+  const promoteSharedPending = (item) => applySharedMutation(api.steerPendingInput(threadId, item.id, messagingOrigin));
+  const sendNow = async (text, images = [], refs = []) => {
+    lastSent = { text, images, refs };
+    tui.printUserMessage(text || `\u{1F4CE} ${refs.length + images.length} attachment(s)`);
     const key = text.trim();
     pendingSent.set(key, (pendingSent.get(key) ?? 0) + 1);
     try {
-      await api.sendMessage(threadId, text, toAttachments(images));
+      await api.sendMessage(threadId, text, [...refs, ...toAttachments(images)]);
     } catch (e) {
       const n = (pendingSent.get(key) ?? 1) - 1;
       if (n > 0) pendingSent.set(key, n);
       else pendingSent.delete(key);
       tui.print(`${c3.dim}failed to send: ${e instanceof Error ? e.message : String(e)}${c3.reset}`);
-      return;
+      return false;
     }
-    interrupting = false;
     busy = true;
     tui.setWorking(true);
+    return true;
   };
   const whereLabel = remote ? runnerName : "this machine";
   let bangRunning = false;
@@ -7446,11 +8415,34 @@ why: ${req.requestPermission}` : ""}`,
       bangRunning = false;
     }
   };
-  const flushQueued = async () => {
-    if (!queued.length) return;
-    const toSend = queued.splice(0);
-    tui.setQueuedCount(0);
-    for (const q of toSend) await sendNow(q.text, q.images);
+  const openPendingMenu = async () => {
+    const items = sharedMessaging.pending.items;
+    if (!items.length) {
+      tui.print(`${c3.dim}No pending messages.${c3.reset}`);
+      return;
+    }
+    const picked = await tui.select("Pending messages", items.map((item, index) => ({
+      label: item.content.replace(/\s+/g, " "),
+      hint: `${index + 1} of ${items.length}`,
+      value: item
+    })));
+    if (!picked) return;
+    const action = await tui.select("Pending message", [
+      { label: "Edit", value: "edit" },
+      { label: "Steer next", value: "steer" },
+      { label: "Dismiss", value: "dismiss" }
+    ]);
+    if (!action) return;
+    if (action === "edit") {
+      editingPendingId = picked.id;
+      mirroredDraftRefs = picked.attachments.filter(isSharedAttachmentRef);
+      tui.setExternalAttachmentNames(mirroredDraftRefs.map((attachment) => attachment.name));
+      tui.setInput(picked.content, fromSharedAttachments(picked.attachments), true, true);
+    } else if (action === "steer") {
+      await promoteSharedPending(picked);
+    } else {
+      await dismissSharedPending(picked);
+    }
   };
   const requestCompaction = async () => {
     try {
@@ -7554,7 +8546,7 @@ ${c3.gray}Close another session (its slot frees within ~90s), then resend your m
       tui.print(`${c3.green}\u2713${c3.reset} ${c3.bold}${gradientText(`You now have ${n} parallel session${n === 1 ? "" : "s"}.`)}${c3.reset}`);
       if (opts.auto && lastSent) {
         tui.print(`${c3.gray}Continuing\u2026${c3.reset}`);
-        await sendNow(lastSent.text, lastSent.images);
+        await sendNow(lastSent.text, lastSent.images, lastSent.refs);
       }
     } finally {
       upgradeInFlight = false;
@@ -7587,6 +8579,15 @@ ${c3.gray}Close another session (its slot frees within ~90s), then resend your m
       hint: () => tui.contextPctLabel() || "free up context",
       run: requestCompaction
     },
+    {
+      name: "queue",
+      label: "Pending messages",
+      hint: () => {
+        const count = sharedMessaging.pending.items.length;
+        return count ? `${count} pending` : "none";
+      },
+      run: openPendingMenu
+    },
     { name: "level", label: "Auto-accept level", hint: () => `level ${tui.level}`, run: () => runLevelMenu(tui, perm) },
     {
       name: "permissions",
@@ -7648,26 +8649,46 @@ ${c3.gray}Close another session (its slot frees within ~90s), then resend your m
   ]);
   const history = await loadHistory(api, threadId, historySeedThreadId);
   tui.setHistory(history);
-  const PRESENCE_KEY = "presence.latest_draft";
-  const presenceSurfaceId = `cli:${Math.random().toString(36).slice(2, 10)}`;
-  let presenceTimer;
-  const clearPresence = () => {
-    if (presenceTimer) clearTimeout(presenceTimer);
-    void api.kvSet(threadId, PRESENCE_KEY, { text: "", images: [], surface: "cli", surface_id: presenceSurfaceId, updated_at: Date.now() }).catch(() => {
-    });
+  await reconcileSharedMessaging(true);
+  let draftTimer;
+  const clearComposerDraft = () => {
+    if (draftTimer) clearTimeout(draftTimer);
+    draftTimer = void 0;
+    mirroredDraftRefs = [];
+    tui.setExternalAttachmentNames([]);
+    if (sharedMessagingReady) void applySharedMutation(api.clearSharedDraft(threadId, messagingOrigin));
   };
-  tui.onDraftChange = (textVal) => {
-    if (presenceTimer) clearTimeout(presenceTimer);
-    presenceTimer = setTimeout(() => {
-      const t = textVal.trim();
-      void api.kvSet(threadId, PRESENCE_KEY, { text: t ? textVal : "", images: [], surface: "cli", surface_id: presenceSurfaceId, updated_at: Date.now() }).catch(() => {
-      });
-    }, 400);
+  tui.onDraftChange = (textVal, images) => {
+    if (draftTimer) clearTimeout(draftTimer);
+    draftTimer = setTimeout(() => {
+      draftTimer = void 0;
+      if (sharedMessagingReady) {
+        const hasDraft = !!textVal.trim() || images.length > 0 || mirroredDraftRefs.length > 0;
+        const mutation = {
+          content: textVal,
+          attachments: [
+            ...hasDraft ? mirroredDraftRefs : [],
+            ...toSharedAttachments(images)
+          ],
+          ...messagingOrigin
+        };
+        void applySharedMutation(
+          hasDraft ? api.putSharedDraft(threadId, mutation) : api.clearSharedDraft(threadId, messagingOrigin)
+        );
+      }
+    }, 150);
   };
-  tui.onSubmit = (text, images) => {
-    clearPresence();
+  const submitComposer = async (text, images, steer) => {
+    const draftRefs = mirroredDraftRefs;
+    if (!sharedMessagingReady && (busy || steer || editingPendingId !== null)) {
+      tui.print(`${c3.dim}Restoring shared message state \u2014 try again in a moment.${c3.reset}`);
+      tui.setExternalAttachmentNames(draftRefs.map((attachment) => attachment.name));
+      tui.setInput(text, images);
+      return;
+    }
+    clearComposerDraft();
     const trimmed = text.trimStart();
-    if (trimmed.startsWith("!") && !trimmed.startsWith("!!")) {
+    if (trimmed.startsWith("!") && !trimmed.startsWith("!!") && images.length === 0 && draftRefs.length === 0) {
       const command = trimmed.slice(1).trim();
       if (command) {
         appendHistory(api, threadId, history, text);
@@ -7676,38 +8697,71 @@ ${c3.gray}Close another session (its slot frees within ~90s), then resend your m
       return;
     }
     const outgoing = trimmed.startsWith("!!") ? text.replace("!!", "!") : text;
-    appendHistory(api, threadId, history, outgoing);
+    if (outgoing.trim()) appendHistory(api, threadId, history, outgoing);
     text = outgoing;
-    if (editingQueued) {
-      editingQueued = false;
-      queued.push({ text, images });
-      tui.setQueuedCount(queued.length);
-      tui.print(`${c3.gray}\u23F3 queued:${c3.reset} ${text}`);
+    if (editingPendingId) {
+      const pendingId = editingPendingId;
+      const item = sharedMessaging.pending.items.find((candidate) => candidate.id === pendingId);
+      editingPendingId = null;
+      if (!item) {
+        tui.print(`${c3.dim}That pending message was already dispatched or dismissed.${c3.reset}`);
+        return;
+      }
+      const updated = await editSharedPending(item, text, images, draftRefs);
+      const promoted = !steer || !updated ? updated : await applySharedMutation(api.steerPendingInput(threadId, pendingId, messagingOrigin));
+      if (!promoted) {
+        mirroredDraftRefs = item.attachments.filter(isSharedAttachmentRef);
+        tui.setExternalAttachmentNames(mirroredDraftRefs.map((attachment) => attachment.name));
+        tui.setInput(text, images);
+      }
+      return;
+    }
+    if (steer) {
+      tui.print(`${c3.yellow}\u21AA steering at the next safe model boundary:${c3.reset} ${text}`);
+      if (!await steerSharedInput(text, images, draftRefs)) {
+        mirroredDraftRefs = draftRefs;
+        tui.setExternalAttachmentNames(draftRefs.map((attachment) => attachment.name));
+        tui.setInput(text, images);
+      }
       return;
     }
     if (busy) {
-      queued.push({ text, images });
-      tui.setQueuedCount(queued.length);
-      tui.print(`${c3.gray}\u23F3 queued:${c3.reset} ${text}  ${c3.dim}(esc to steer now)${c3.reset}`);
+      if (await appendSharedPending(text, images, draftRefs)) {
+        tui.print(`${c3.gray}\u23F3 pending:${c3.reset} ${text}  ${c3.dim}(/queue to edit, steer, or dismiss)${c3.reset}`);
+      } else {
+        mirroredDraftRefs = draftRefs;
+        tui.setExternalAttachmentNames(draftRefs.map((attachment) => attachment.name));
+        tui.setInput(text, images);
+      }
     } else {
-      void sendNow(text, images);
+      if (!await sendNow(text, images, draftRefs)) {
+        mirroredDraftRefs = draftRefs;
+        tui.setExternalAttachmentNames(draftRefs.map((attachment) => attachment.name));
+        tui.setInput(text, images);
+      }
     }
   };
+  tui.onSubmit = (text, images) => {
+    void submitComposer(text, images, false);
+  };
+  tui.onSteer = (text, images) => {
+    void submitComposer(text, images, true);
+  };
   tui.onInterrupt = () => {
-    if (queued.length > 0) {
-      tui.print(`${c3.yellow}\u21AA steering \u2014 stopping current work and sending your message\u2026${c3.reset}`);
-      void api.stop(threadId).catch(() => {
-      }).then(() => flushQueued());
-    } else if (busy) {
-      interrupting = true;
-      busy = false;
-      activeSteps.clear();
-      liveOut = 0;
-      tui.setWorking(false);
-      refreshStatus();
-      tui.print(`${c3.yellow}[interrupted by user]${c3.reset}`);
-      void api.stop(threadId).catch(() => {
-      });
+    const firstPending = sharedMessaging.pending.items[0];
+    if (!busy && firstPending) {
+      tui.print(`${c3.yellow}\u21AA steering the first pending message\u2026${c3.reset}`);
+      void promoteSharedPending(firstPending);
+      return;
+    }
+    if (busy) {
+      if (!sharedMessagingReady) {
+        tui.print(`${c3.dim}Shared messaging is not connected; the session was not stopped.${c3.reset}`);
+        return;
+      }
+      const advancing = sharedMessaging.pending.items.length > 0;
+      tui.print(`${c3.yellow}${advancing ? "[stopping; next pending message will run]" : "[stopping at the next safe boundary]"}${c3.reset}`);
+      void applySharedMutation(api.requestSharedStop(threadId, messagingOrigin));
     }
   };
   tui.onBgBadge = () => {
@@ -7715,11 +8769,13 @@ ${c3.gray}Close another session (its slot frees within ~90s), then resend your m
     });
   };
   tui.onUpArrow = () => {
-    if (tui.getInput().trim() || queued.length === 0) return false;
-    const q = queued.pop();
-    tui.setQueuedCount(queued.length);
-    editingQueued = true;
-    tui.setInput(q.text, q.images);
+    if (tui.getInput().trim() || tui.hasExternalAttachments()) return false;
+    const item = sharedMessaging.pending.items.at(-1);
+    if (!item) return false;
+    editingPendingId = item.id;
+    mirroredDraftRefs = item.attachments.filter(isSharedAttachmentRef);
+    tui.setExternalAttachmentNames(mirroredDraftRefs.map((attachment) => attachment.name));
+    tui.setInput(item.content, fromSharedAttachments(item.attachments), true, true);
     return true;
   };
   events.connect();
@@ -7795,16 +8851,26 @@ ${c3.dim}runs on ${request.machine || runnerName}${c3.reset}`,
   };
   const poll = async () => {
     let msgs;
+    let serverBusy = null;
+    let serverTool = null;
     try {
-      msgs = await api.getMessages(threadId, 60);
+      const snapshot = await api.getSessionState(threadId);
+      msgs = snapshot.messages.slice(-60);
+      serverBusy = snapshot.busy;
+      serverTool = snapshot.current_tool;
     } catch {
-      return;
+      try {
+        msgs = await api.getMessages(threadId, 60);
+      } catch {
+        return;
+      }
     }
     const sorted = [...msgs].sort((a, b) => (a.created_at ?? 0) - (b.created_at ?? 0));
     for (const m of sorted) {
-      if (shownIds.has(m.id) || m.status === "pending") continue;
-      shownIds.add(m.id);
+      if (shownIds.has(m.id)) continue;
       const text = messageText(m.content).trim();
+      if (!transcriptMessageReady(m, text)) continue;
+      shownIds.add(m.id);
       const denial = typeof m.error === "string" && m.error || text;
       if (denial && isSessionLimitError(denial)) {
         void offerUpgrade({ auto: true });
@@ -7831,19 +8897,20 @@ ${c3.dim}runs on ${request.machine || runnerName}${c3.reset}`,
         }
       }
     }
-    const polledBusy = threadBusy(msgs);
-    if (interrupting) {
-      if (!polledBusy) interrupting = false;
-      busy = false;
-    } else {
-      busy = polledBusy;
+    const polledBusy = (serverBusy ?? false) || threadBusy(msgs);
+    if (serverTool && !activeSteps.has(serverTool.id)) {
+      activeSteps.set(serverTool.id, serverTool.name || "working");
+      refreshStatus();
+    } else if (serverBusy !== null && !serverTool && activeSteps.size) {
+      activeSteps.clear();
+      refreshStatus();
     }
+    busy = polledBusy;
     tui.setWorking(busy);
     if (!busy) {
       if (activeSteps.size) activeSteps.clear();
       liveOut = 0;
       refreshStatus();
-      if (queued.length > 0 && !editingQueued) await flushQueued();
     }
     refreshBgCount();
     void relayApprovals().catch(() => {
@@ -7879,12 +8946,17 @@ ${c3.dim}runs on ${request.machine || runnerName}${c3.reset}`,
     } catch {
     }
   };
-  const pollTimer = setInterval(() => void poll().catch(() => {
-  }), 1200);
+  refreshSessionProjection = () => poll().catch(() => {
+  });
+  await refreshSessionProjection();
+  const pollTimer = setInterval(() => {
+    if (busy || approvalPromptOpen) void refreshSessionProjection();
+  }, 1200);
   await sessionEnded;
   clearInterval(pollTimer);
   clearInterval(heartbeatPoll);
-  const stopped = bridge?.isOwner ?? false ? api.stop(threadId).catch(() => {
+  process.off("SIGCONT", onTerminalResume);
+  const stopped = bridge?.isOwner ?? false ? api.requestSharedStop(threadId, messagingOrigin).catch(() => {
   }) : Promise.resolve();
   const procsStopped = host ? host.stopAllLocalProcesses().catch(() => 0) : Promise.resolve(0);
   bridge?.close();
@@ -8084,12 +9156,12 @@ async function manageMachineProjects(tui, api, self, machine, dispatch, applyNot
   );
   if (!picked) return;
   if (picked === ADD) {
-    const path13 = await tui.prompt(
+    const path14 = await tui.prompt(
       `Absolute project path on ${machine.name}`,
       machine.id === self.machine_id ? process.cwd() : "/home/you/project"
     );
-    if (!path13 || !path13.trim()) return;
-    const trimmed = path13.trim();
+    if (!path14 || !path14.trim()) return;
+    const trimmed = path14.trim();
     if (!trimmed.startsWith("/") && !trimmed.startsWith("~")) {
       tui.print(`${c3.yellow}Use an absolute path (starting with / or ~).${c3.reset}`);
       return;