@buzzni/saycode-cli 0.1.1 → 0.1.3

package/index.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { createInterface } from "node:readline";
-import { homedir } from "node:os";
+import { homedir, tmpdir, platform } from "node:os";
 import require$$0$4, { Buffer as Buffer$1 } from "buffer";
 import require$$0 from "crypto";
-import { mkdirSync, writeFileSync, readFileSync, rmSync, chmodSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { readFileSync, mkdirSync, writeFileSync, rmSync, chmodSync, constants as constants$1 } from "node:fs";
+import { dirname, join, basename, extname, delimiter } from "node:path";
 import require$$0$1 from "fs";
 import require$$1 from "url";
 import require$$2 from "child_process";
@@ -18,6 +18,9 @@ import require$$3$1 from "net";
 import require$$4$1 from "tls";
 import require$$0$5 from "stream";
 import require$$0$3 from "zlib";
+import { readFile, stat, mkdtemp, access, rm, mkdir, appendFile, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 function _mergeNamespaces(n, m) {
   for (var i = 0; i < m.length; i++) {
     const e = m[i];
@@ -37,7 +40,7 @@ function _mergeNamespaces(n, m) {
   }
   return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
 }
-const version = "0.1.1";
+const version = "0.1.3";
 const manifest = {
   version
 };
@@ -58,8 +61,11 @@ function takeNumber(argv, index, flag) {
   if (!Number.isFinite(parsed) || parsed < 0) throw new ArgError(`${flag} needs a non-negative number, got "${raw}"`);
   return parsed;
 }
+function hasExplicitNewConversationOptions(flags) {
+  return flags.agent !== void 0 || flags.model !== void 0 || flags.effort !== void 0 || flags.useWorktree === true || flags.worktreeName !== void 0 || flags.worktreeBaseRef !== void 0 || flags.files.length > 0 || flags.voice === true || flags.voiceFile !== void 0;
+}
 function collectFlags(argv, startIndex) {
-  const flags = { all: false };
+  const flags = { all: false, files: [] };
   const positionals = [];
   for (let index = startIndex; index < argv.length; index += 1) {
     const token = argv[index];
@@ -98,6 +104,36 @@ function collectFlags(argv, startIndex) {
         index += 1;
         break;
       }
+      case "--model":
+        flags.model = takeValue(argv, index, token);
+        index += 1;
+        break;
+      case "--effort":
+        flags.effort = takeValue(argv, index, token);
+        index += 1;
+        break;
+      case "--worktree":
+        flags.useWorktree = true;
+        break;
+      case "--worktree-name":
+        flags.worktreeName = takeValue(argv, index, token);
+        index += 1;
+        break;
+      case "--worktree-base":
+        flags.worktreeBaseRef = takeValue(argv, index, token);
+        index += 1;
+        break;
+      case "--file":
+        flags.files.push(takeValue(argv, index, token));
+        index += 1;
+        break;
+      case "--voice":
+        flags.voice = true;
+        break;
+      case "--voice-file":
+        flags.voiceFile = takeValue(argv, index, token);
+        index += 1;
+        break;
       case "--since":
         flags.since = takeNumber(argv, index, token);
         index += 1;
@@ -161,12 +197,35 @@ function parseArgs(argv, interactive = false) {
       case "chat": {
         const agent = flags.agent ?? "claude";
         const since = flags.since !== void 0 ? { since: flags.since } : {};
-        if (flags.sessionId) return { command: "chat", sessionId: flags.sessionId, agent, ...ws, ...since };
-        if (flags.project) return { command: "chat", project: flags.project, agent, ...ws };
+        const hasNewConversationOptions = hasExplicitNewConversationOptions(flags);
+        if ((flags.worktreeName !== void 0 || flags.worktreeBaseRef !== void 0) && !flags.useWorktree) {
+          throw new ArgError("--worktree-name and --worktree-base require --worktree");
+        }
+        if (flags.voice && flags.voiceFile) {
+          throw new ArgError("--voice and --voice-file cannot be used together");
+        }
+        const newConversation = {
+          ...flags.model ? { model: flags.model } : {},
+          ...flags.effort ? { effort: flags.effort } : {},
+          ...flags.useWorktree ? { useWorktree: true } : {},
+          ...flags.worktreeName ? { worktreeName: flags.worktreeName } : {},
+          ...flags.worktreeBaseRef ? { worktreeBaseRef: flags.worktreeBaseRef } : {},
+          ...flags.files.length > 0 ? { files: flags.files } : {},
+          ...flags.voice ? { voice: true } : {},
+          ...flags.voiceFile ? { voiceFile: flags.voiceFile } : {},
+          ...interactive && !hasNewConversationOptions ? { promptForOptions: true } : {}
+        };
+        if (flags.sessionId) {
+          if (hasNewConversationOptions) {
+            throw new ArgError("agent, model, effort, worktree, file, and voice options only apply when starting a new session");
+          }
+          return { command: "chat", sessionId: flags.sessionId, agent, ...ws, ...since };
+        }
+        if (flags.project) return { command: "chat", project: flags.project, agent, ...ws, ...newConversation };
         if (!flags.machine || !flags.directory) {
           throw new ArgError("chat needs -s <session>, -p <project>, or both -m <machine> and -d <directory>");
         }
-        return { command: "chat", machine: flags.machine, directory: flags.directory, agent, ...ws };
+        return { command: "chat", machine: flags.machine, directory: flags.directory, agent, ...ws, ...newConversation };
       }
       case "watch":
         return { command: "watch", intervalSeconds: flags.intervalSeconds ?? DEFAULT_WATCH_INTERVAL_SECONDS, ...ws };
@@ -206,6 +265,14 @@ Options
   -d, --directory <path>    Working directory on that machine
   -s, --session <id>        Session id (see \`saycode ls\`)
       --agent <name>        claude (default), codex, gemini, openclaw, opencode
+      --model <name>        Model for new-session messages (Default if omitted)
+      --effort <level>      Model effort (validated against agent + model)
+      --worktree            Create an isolated worktree for a project chat
+      --worktree-name <n>   Optional worktree/branch label
+      --worktree-base <ref> Base ref for the worktree (default HEAD)
+      --file <path>         Attach a local file to the first prompt (repeatable)
+      --voice               Record and transcribe the first prompt
+      --voice-file <path>   Transcribe an existing audio file as the first prompt
       --since <n>           Replay the last n messages before following
   -i, --interval <seconds>  watch refresh interval (default 10)
   -a, --all                 Include finished sessions
@@ -2438,22 +2505,22 @@ function requireNaclFast() {
         randombytes = fn;
       };
       (function() {
-        var crypto = typeof self !== "undefined" ? self.crypto || self.msCrypto : null;
-        if (crypto && crypto.getRandomValues) {
+        var crypto2 = typeof self !== "undefined" ? self.crypto || self.msCrypto : null;
+        if (crypto2 && crypto2.getRandomValues) {
           var QUOTA = 65536;
           nacl2.setPRNG(function(x, n) {
             var i, v = new Uint8Array(n);
             for (i = 0; i < n; i += QUOTA) {
-              crypto.getRandomValues(v.subarray(i, i + Math.min(n - i, QUOTA)));
+              crypto2.getRandomValues(v.subarray(i, i + Math.min(n - i, QUOTA)));
             }
             for (i = 0; i < n; i++) x[i] = v[i];
             cleanup(v);
           });
         } else if (typeof commonjsRequire !== "undefined") {
-          crypto = require$$0;
-          if (crypto && crypto.randomBytes) {
+          crypto2 = require$$0;
+          if (crypto2 && crypto2.randomBytes) {
             nacl2.setPRNG(function(x, n) {
-              var i, v = crypto.randomBytes(n);
+              var i, v = crypto2.randomBytes(n);
               for (i = 0; i < n; i++) x[i] = v[i];
               cleanup(v);
             });
@@ -2709,6 +2776,7 @@ function parseOpenConversationsPayload(value2) {
     truncated: value2.truncated || rawActive.length > OPEN_CONVERSATION_ACTIVE_LIMIT || rawRecent.length > OPEN_CONVERSATION_RECENT_LIMIT
   };
 }
+const DEFAULT_MODEL_KEY = "default";
 const FLAVOR_TO_AGENT = {
   claude: "claude",
   codex: "codex",
@@ -2734,6 +2802,13 @@ function coerceSessionModels(raw) {
   }
   return out.length ? out : void 0;
 }
+function hasModelCode(models, code) {
+  return Array.isArray(models) && models.some((model) => model?.code === code);
+}
+function normalizeOpencodeModel(selected, models) {
+  if (!selected || selected === DEFAULT_MODEL_KEY) return DEFAULT_MODEL_KEY;
+  return hasModelCode(models, selected) ? selected : DEFAULT_MODEL_KEY;
+}
 const MAX_MAPPING_COUNT = 1e3;
 function buildProjectConversationsPath(projectId) {
   const trimmed = projectId.trim();
@@ -13411,12 +13486,12 @@ function normalizeMachine(row, candidateKeys) {
   const daemonState = decryptJsonWithCandidates(row.daemonState, candidateKeys);
   const resources = row.resources ?? parseMachineResources(daemonState);
   const host = row.host || registry?.host || (typeof decrypted.host === "string" ? decrypted.host : row.id.slice(0, 8));
-  const platform = row.platform || registry?.platform || (typeof decrypted.platform === "string" ? decrypted.platform : "unknown");
+  const platform2 = row.platform || registry?.platform || (typeof decrypted.platform === "string" ? decrypted.platform : "unknown");
   return {
     id: row.id,
     accountId: row.accountId,
     host,
-    platform,
+    platform: platform2,
     online: typeof row.online === "boolean" ? row.online : !!row.active,
     // Unknown last-seen must render as "unknown", not "just now" — a machine the
     // server can't vouch for should never look freshly alive.
@@ -14926,9 +15001,9 @@ function credentialSearchPaths(input) {
     { source: "happy_local", path: joinPath(input.homeDir, ".happy_local", "access.key") }
   ];
 }
-function selectFirstValidCredential(candidates, readFile) {
+function selectFirstValidCredential(candidates, readFile2) {
   for (const candidate of candidates) {
-    const raw = readFile(candidate.path);
+    const raw = readFile2(candidate.path);
     if (raw === null) continue;
     const credential = parseAccessKeyFile(raw);
     if (!credential) continue;
@@ -14995,8 +15070,11 @@ function readConfig(homeDir) {
   try {
     const parsed = JSON.parse(readFileSync(configPath(homeDir), "utf8"));
     if (!parsed || typeof parsed !== "object") return {};
-    const { workspaceId } = parsed;
-    return typeof workspaceId === "string" && workspaceId ? { workspaceId } : {};
+    const { workspaceId, usageAnalyticsEnabled } = parsed;
+    return {
+      ...typeof workspaceId === "string" && workspaceId ? { workspaceId } : {},
+      ...typeof usageAnalyticsEnabled === "boolean" ? { usageAnalyticsEnabled } : {}
+    };
   } catch {
     return {};
   }
@@ -15055,7 +15133,7 @@ function requireXMLHttpRequest() {
   hasRequiredXMLHttpRequest = 1;
   var fs = require$$0$1;
   var Url = require$$1;
-  var spawn = require$$2.spawn;
+  var spawn2 = require$$2.spawn;
   XMLHttpRequest_1 = XMLHttpRequest2;
   XMLHttpRequest2.XMLHttpRequest = XMLHttpRequest2;
   function XMLHttpRequest2(opts) {
@@ -15350,7 +15428,7 @@ function requireXMLHttpRequest() {
         var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
         fs.writeFileSync(syncFile, "", "utf8");
         var execString = "var http = require('http'), https = require('https'), fs = require('fs');var doRequest = http" + (ssl ? "s" : "") + ".request;var options = " + JSON.stringify(options) + ";var responseText = '';var responseData = Buffer.alloc(0);var req = doRequest(options, function(response) {response.on('data', function(chunk) {  var data = Buffer.from(chunk);  responseText += data.toString('utf8');  responseData = Buffer.concat([responseData, data]);});response.on('end', function() {fs.writeFileSync('" + contentFile + "', JSON.stringify({err: null, data: {statusCode: response.statusCode, headers: response.headers, text: responseText, data: responseData.toString('base64')}}), 'utf8');fs.unlinkSync('" + syncFile + "');});response.on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});}).on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});" + (data ? "req.write('" + JSON.stringify(data).slice(1, -1).replace(/'/g, "\\'") + "');" : "") + "req.end();";
-        var syncProc = spawn(process.argv[0], ["-e", execString]);
+        var syncProc = spawn2(process.argv[0], ["-e", execString]);
         while (fs.existsSync(syncFile)) {
         }
         self2.responseText = fs.readFileSync(contentFile, "utf8");
@@ -16115,8 +16193,8 @@ function requireCommon() {
       }
       return debug2;
     }
-    function extend(namespace, delimiter) {
-      const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+    function extend(namespace, delimiter2) {
+      const newDebug = createDebug(this.namespace + (typeof delimiter2 === "undefined" ? ":" : delimiter2) + namespace);
       newDebug.log = this.log;
       return newDebug;
     }
@@ -23536,6 +23614,13 @@ class ApiUnavailableError extends Error {
     ].join("\n"));
   }
 }
+class CliHttpError extends Error {
+  constructor(status, body, message) {
+    super(message);
+    this.status = status;
+    this.body = body;
+  }
+}
 class CliRest {
   constructor(credential, baseUrl = DEFAULT_SERVER_URL) {
     this.credential = credential;
@@ -23550,6 +23635,40 @@ class CliRest {
     if (!apiToken) throw new ApiUnavailableError();
     return this.request(path, { method: "GET" }, apiToken);
   }
+  async createProjectWorktree(projectId, input) {
+    const data = await this.apiMutation(
+      `/api/projects/${encodeURIComponent(projectId)}/worktrees`,
+      { method: "POST", body: buildWorktreeMutationBody(input) }
+    );
+    return data.worktree;
+  }
+  async deleteProjectWorktree(projectId, worktreeId, force) {
+    await this.apiMutation(
+      `/api/projects/${encodeURIComponent(projectId)}/worktrees/${encodeURIComponent(worktreeId)}`,
+      { method: "DELETE", body: JSON.stringify({ force }) }
+    );
+  }
+  async assignSessionToProject(projectId, sessionId, worktreeId) {
+    await this.apiMutation(`/api/projects/${encodeURIComponent(projectId)}/sessions`, {
+      method: "POST",
+      body: JSON.stringify({ sessionId, ...worktreeId ? { worktreeId } : {} })
+    });
+  }
+  async transcribeAudio(audio, options) {
+    const form = new FormData();
+    form.append("audio", audio, options.fileName);
+    form.append("mimeType", options.mimeType);
+    const data = await this.apiMutation(
+      "/api/transcriptions",
+      { method: "POST", body: form }
+    );
+    return { text: (data.text ?? data.transcript ?? data.transcription ?? "").trim() };
+  }
+  async apiMutation(path, init) {
+    const apiToken = this.credential.apiToken;
+    if (!apiToken) throw new ApiUnavailableError();
+    return this.request(path, init, apiToken);
+  }
   /** A sync-boundary client bound to a different workspace identity. */
   withSyncCredential(credential) {
     return new CliRest({ ...credential, ...this.credential.apiToken ? { apiToken: this.credential.apiToken } : {} }, this.baseUrl);
@@ -23565,7 +23684,7 @@ class CliRest {
   /** Newest-last page of a session transcript, used for `attach --since`. */
   async recentMessages(sessionId, limit) {
     const data = await this.get(
-      `/v3/sessions/${encodeURIComponent(sessionId)}/messages?limit=${encodeURIComponent(String(limit))}`
+      `/v3/sessions/${encodeURIComponent(sessionId)}/messages?${new URLSearchParams({ limit: String(limit), before_seq: "2147483647" })}`
     );
     return data.messages ?? [];
   }
@@ -23582,19 +23701,25 @@ class CliRest {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
     try {
+      const inheritedHeaders = new Headers(init.headers);
+      const headers = Object.fromEntries(inheritedHeaders.entries());
+      const isForm = typeof FormData !== "undefined" && init.body instanceof FormData;
+      if (!isForm && !inheritedHeaders.has("Content-Type")) headers["Content-Type"] = "application/json";
+      headers.Authorization = `Bearer ${tokenOverride ?? this.credential.token}`;
       const response = await fetch(`${this.baseUrl}${path}`, {
         ...init,
         signal: controller.signal,
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${tokenOverride ?? this.credential.token}`,
-          ...init.headers
-        }
+        headers
       });
+      const text2 = await response.text();
       if (!response.ok) {
-        throw new Error(`${init.method ?? "GET"} ${path} failed: ${response.status} ${response.statusText}`);
+        throw new CliHttpError(
+          response.status,
+          text2,
+          `${init.method ?? "GET"} ${path} failed: ${response.status} ${response.statusText}`
+        );
       }
-      return await response.json();
+      return text2 ? JSON.parse(text2) : {};
     } finally {
       clearTimeout(timer);
     }
@@ -23625,17 +23750,34 @@ const RESET = "\x1B[0m";
 const STYLE_CODES = {
   user: "\x1B[1;36m",
   thinking: "\x1B[2;37m",
-  tool: "\x1B[33m",
+  tool: "\x1B[2;33m",
   progress: "\x1B[2;37m",
   status: "\x1B[32m",
-  error: "\x1B[31m"
+  error: "\x1B[31m",
+  heading: "\x1B[1;36m",
+  quote: "\x1B[2;37m",
+  code: "\x1B[36m"
   // `text` is intentionally absent: agent prose is the main content and reads
   // best in the terminal's own foreground colour.
 };
+const INLINE_STYLE_CODES = {
+  strong: "\x1B[1m",
+  emphasis: "\x1B[3m",
+  inlineCode: "\x1B[36m",
+  strike: "\x1B[9m",
+  link: "\x1B[4;36m"
+};
+function formatSpans(spans, baseCode) {
+  return spans.map((span) => {
+    if (!span.style) return span.text;
+    return `${INLINE_STYLE_CODES[span.style]}${span.text}${baseCode ?? RESET}`;
+  }).join("");
+}
 function formatLine(line, colour) {
   if (line.style === "divider") return "";
   const code = colour ? STYLE_CODES[line.style] : void 0;
-  return code ? `${code}${line.text}${RESET}` : line.text;
+  const text2 = colour && line.spans ? formatSpans(line.spans, code) : line.text;
+  return code ? `${code}${text2}${RESET}` : text2;
 }
 function colourEnabled(env, isTty) {
   if (env.NO_COLOR !== void 0) return false;
@@ -23854,7 +23996,171 @@ function runLogout(out) {
   }
   out.raw("No stored Saycode credentials. Happy credentials (~/.happy*/access.key) are untouched.");
 }
+function isCombining(codePoint, character) {
+  return codePoint === 8205 || new RegExp("\\p{Mark}", "u").test(character);
+}
+function isWide(codePoint) {
+  return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 129791 || codePoint >= 131072 && codePoint <= 262141);
+}
+function displayWidth(text2) {
+  let width = 0;
+  for (const character of text2) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint < 32 || codePoint >= 127 && codePoint < 160 || isCombining(codePoint, character)) continue;
+    width += isWide(codePoint) ? 2 : 1;
+  }
+  return width;
+}
+function styledToken(source, marker, style) {
+  if (!source.startsWith(marker)) return null;
+  const end = source.indexOf(marker, marker.length);
+  if (end < marker.length + 1) return null;
+  const text2 = source.slice(marker.length, end);
+  if (text2.trim() === "") return null;
+  return { length: end + marker.length, spans: [{ style, text: text2 }] };
+}
+function tokenAt(source) {
+  const escaped = source.match(/^\\([\\`*_[\]~()])/);
+  if (escaped) return { length: escaped[0].length, spans: [{ text: escaped[1] ?? "" }] };
+  const code = source.match(/^`([^`\n]+)`/);
+  if (code) return { length: code[0].length, spans: [{ style: "inlineCode", text: code[1] ?? "" }] };
+  const link = source.match(/^\[([^\]\n]+)]\((https?:\/\/[^\s)\n]+)\)/);
+  if (link) {
+    const text2 = link[1] ?? "";
+    const href = link[2] ?? "";
+    return {
+      length: link[0].length,
+      spans: [{ href, style: "link", text: text2 }, { text: ` (${href})` }]
+    };
+  }
+  return styledToken(source, "**", "strong") ?? styledToken(source, "~~", "strike") ?? (source.startsWith("**") ? null : styledToken(source, "*", "emphasis"));
+}
+function appendSpan(spans, span) {
+  if (span.text === "") return;
+  const previous = spans.at(-1);
+  if (previous && previous.style === span.style && previous.href === span.href) {
+    previous.text += span.text;
+    return;
+  }
+  spans.push({ ...span });
+}
+function parseInlineMarkdown(source) {
+  const spans = [];
+  let offset = 0;
+  while (offset < source.length) {
+    const token = tokenAt(source.slice(offset));
+    if (token) {
+      for (const span of token.spans) appendSpan(spans, span);
+      offset += token.length;
+      continue;
+    }
+    const character = String.fromCodePoint(source.codePointAt(offset) ?? 0);
+    appendSpan(spans, { text: character });
+    offset += character.length;
+  }
+  return spans;
+}
+function finishLine(spans) {
+  while (spans.at(-1)?.text.endsWith(" ")) {
+    const last = spans.at(-1);
+    if (!last) break;
+    last.text = last.text.trimEnd();
+    if (last.text === "") spans.pop();
+  }
+  return { text: spans.map((span) => span.text).join(""), spans };
+}
+function renderInlineMarkdown(source, width) {
+  const parsed = parseInlineMarkdown(source);
+  const lines = [];
+  let current = [];
+  let currentWidth = 0;
+  for (const span of parsed) {
+    for (const character of span.text) {
+      const characterWidth = displayWidth(character);
+      if (current.length > 0 && currentWidth + characterWidth > width) {
+        lines.push(finishLine(current));
+        current = [];
+        currentWidth = 0;
+      }
+      if (current.length === 0 && character === " ") continue;
+      appendSpan(current, { ...span, text: character });
+      currentWidth += characterWidth;
+    }
+  }
+  if (current.length > 0 || lines.length === 0) lines.push(finishLine(current));
+  return lines;
+}
+function withPrefix(style, prefix, line) {
+  if (!line.spans.some((span) => span.style)) return { style, text: `${prefix}${line.text}` };
+  return { style, text: `${prefix}${line.text}`, spans: [...prefix ? [{ text: prefix }] : [], ...line.spans] };
+}
+class TerminalMarkdownRenderer {
+  constructor(width) {
+    this.width = width;
+  }
+  pending = "";
+  inFence = false;
+  get hasPending() {
+    return this.pending !== "";
+  }
+  push(chunk) {
+    const normalized = `${this.pending}${chunk}`.replace(/\r\n?/g, "\n");
+    const sourceLines = normalized.split("\n");
+    this.pending = sourceLines.pop() ?? "";
+    return sourceLines.flatMap((line) => this.renderLine(line));
+  }
+  flush() {
+    const pending = this.pending;
+    this.pending = "";
+    const lines = pending === "" ? [] : this.renderLine(pending);
+    if (!this.inFence) return lines;
+    this.inFence = false;
+    return [...lines, { style: "code", text: "└─" }];
+  }
+  prefixed(style, prefix, content, continuation = "  ") {
+    const firstWidth = Math.max(1, this.width - displayWidth(prefix));
+    const wrapped = renderInlineMarkdown(content, firstWidth);
+    const lines = [withPrefix(style, prefix, wrapped[0] ?? { spans: [], text: "" })];
+    for (const part of wrapped.slice(1)) {
+      lines.push(withPrefix(style, continuation, part));
+    }
+    return lines;
+  }
+  renderLine(source) {
+    const fence = source.match(/^\s*```\s*([^`]*)$/);
+    if (fence) {
+      if (this.inFence) {
+        this.inFence = false;
+        return [{ style: "code", text: "└─" }];
+      }
+      this.inFence = true;
+      const language = fence[1]?.trim();
+      return [{ style: "code", text: language ? `┌─ ${language}` : "┌─" }];
+    }
+    if (this.inFence) return this.prefixed("code", "│ ", source, "│ ");
+    if (source.trim() === "") return [{ style: "divider", text: "" }];
+    const heading = source.match(/^\s{0,3}#{1,6}\s+(.+)$/);
+    if (heading) return this.prefixed("heading", "◆ ", heading[1] ?? "");
+    const quote = source.match(/^\s*>\s?(.*)$/);
+    if (quote) return this.prefixed("quote", "│ ", quote[1] ?? "", "│ ");
+    const list = source.match(/^(\s*)([-+*]|\d+\.)\s+(.+)$/);
+    if (list) {
+      const indent = list[1] ?? "";
+      const marker = /^\d/.test(list[2] ?? "") ? list[2] : "•";
+      const prefix = `${indent}${marker} `;
+      return this.prefixed("text", prefix, list[3] ?? "", " ".repeat(displayWidth(prefix)));
+    }
+    return renderInlineMarkdown(source, this.width).map((line) => withPrefix("text", "", line));
+  }
+}
+function createTerminalMarkdownRenderer(width = 100) {
+  return new TerminalMarkdownRenderer(Math.max(8, width));
+}
+function terminalContentWidth(columns) {
+  return Math.max(20, Math.min(100, (columns ?? 104) - 4));
+}
 const TOOL_SUMMARY_MAX_LENGTH = 80;
+const TOOL_PROGRESS_VISIBLE_LINES = 3;
 const TOOL_SUMMARY_KEYS = ["command", "file_path", "path", "pattern", "query", "url", "prompt"];
 function truncate(value2, max) {
   if (value2.length <= max) return value2;
@@ -23877,7 +24183,7 @@ function textLines(text2, style) {
   if (text2.trim() === "") return [];
   return text2.split("\n").map((line) => ({ style, text: line }));
 }
-function renderSessionEvent(ev, envelopeRole) {
+function renderSessionEvent(ev, envelopeRole, progressByCall) {
   switch (ev.t) {
     case "text":
       if (envelopeRole === "user") return textLines(ev.text, "user").map((line) => ({ ...line, text: `› ${line.text}` }));
@@ -23885,16 +24191,35 @@ function renderSessionEvent(ev, envelopeRole) {
     case "service":
       return textLines(ev.text, "status");
     case "tool-call-start": {
+      progressByCall.set(ev.call, { shown: 0, hidden: 0, lastHidden: null });
       const summary = summarizeToolArgs(ev.args) ?? (ev.description?.trim() || null);
       return [{ style: "tool", text: summary ? `⏺ ${ev.name}(${summary})` : `⏺ ${ev.name}` }];
     }
-    case "tool-call-progress":
-      return ev.lines.map((line) => ({
-        style: ev.stream === "stderr" ? "error" : "progress",
-        text: `  │ ${line}`
-      }));
-    case "tool-call-end":
-      return [];
+    case "tool-call-progress": {
+      const state = progressByCall.get(ev.call) ?? { shown: 0, hidden: 0, lastHidden: null };
+      progressByCall.set(ev.call, state);
+      const lines = [];
+      for (const line of ev.lines) {
+        if (ev.stream === "stderr") lines.push({ style: "error", text: `  │ ${line}` });
+        else if (state.shown < TOOL_PROGRESS_VISIBLE_LINES) {
+          state.shown += 1;
+          lines.push({ style: "progress", text: `  │ ${line}` });
+        } else {
+          state.hidden += 1;
+          state.lastHidden = line;
+        }
+      }
+      return lines;
+    }
+    case "tool-call-end": {
+      const state = progressByCall.get(ev.call);
+      progressByCall.delete(ev.call);
+      if (!state?.hidden || !state.lastHidden) return [];
+      return [{
+        style: "progress",
+        text: `  └ ${state.hidden} more lines hidden · last: ${truncate(state.lastHidden, TOOL_SUMMARY_MAX_LENGTH)}`
+      }];
+    }
     case "file":
       return [{ style: "status", text: `📎 ${ev.name} (${formatBytes(ev.size)})` }];
     case "turn-start":
@@ -23907,14 +24232,34 @@ function renderSessionEvent(ev, envelopeRole) {
       return [];
   }
 }
-function renderMessageContent(content) {
-  if (content.role === "user") {
-    return textLines(content.content.text, "user").map((line) => ({ ...line, text: `› ${line.text}` }));
+class SessionEventRenderer {
+  markdown;
+  progressByCall = /* @__PURE__ */ new Map();
+  constructor(width) {
+    this.markdown = createTerminalMarkdownRenderer(width);
   }
-  if (content.role === "session") {
-    return renderSessionEvent(content.content.ev, content.content.role);
+  flush() {
+    return this.markdown.flush();
   }
-  return [];
+  render(content) {
+    if (content.role === "user") {
+      return [...this.flush(), ...textLines(content.content.text, "user").map((line) => ({ ...line, text: `› ${line.text}` }))];
+    }
+    if (content.role !== "session") return [];
+    const { ev, role } = content.content;
+    if (ev.t === "text" && role === "agent" && !ev.thinking) {
+      if (!this.markdown.hasPending && ev.text.trim() === "") return [];
+      return this.markdown.push(ev.text);
+    }
+    const prefix = this.flush();
+    if (ev.t === "turn-start") this.progressByCall.clear();
+    const rendered = renderSessionEvent(ev, role, this.progressByCall);
+    if (ev.t === "turn-end") this.progressByCall.clear();
+    return [...prefix, ...rendered];
+  }
+}
+function createSessionEventRenderer(width = 100) {
+  return new SessionEventRenderer(width);
 }
 function record(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
@@ -23952,10 +24297,10 @@ function decodeContent(transport, ciphertext) {
     return null;
   }
 }
-function printContent(context, content) {
-  context.out.lines(renderMessageContent(content));
+function printContent(context, content, renderer = createSessionEventRenderer()) {
+  context.out.lines(renderer.render(content));
 }
-async function prerollHistory(context, transport, sessionId, since) {
+async function prerollHistory(context, transport, sessionId, since, onContent, renderer = createSessionEventRenderer()) {
   if (since <= 0) return 0;
   const messages = await context.rest.recentMessages(sessionId, since);
   let highestSeq = 0;
@@ -23964,28 +24309,31 @@ async function prerollHistory(context, transport, sessionId, since) {
     const ciphertext = unwrapEncryptedField(message.content);
     if (!ciphertext) continue;
     const content = decodeContent(transport, ciphertext);
-    if (content) printContent(context, content);
+    if (!content) continue;
+    printContent(context, content, renderer);
+    onContent?.(content);
   }
   return highestSeq;
 }
 function followSession(input) {
   let highestSeq = input.seenThroughSeq;
+  const renderer = input.renderer ?? createSessionEventRenderer();
   return input.transport.onUpdate((update) => {
     input.onUpdate?.(update);
     const message = readNewMessage(update, input.sessionId);
-    if (!message) return;
-    if (message.localId && input.ownLocalIds?.has(message.localId)) return;
+    if (!message || message.localId && input.ownLocalIds?.has(message.localId)) return;
     if (message.seq !== 0 && message.seq <= highestSeq) return;
     highestSeq = Math.max(highestSeq, message.seq);
     const content = decodeContent(input.transport, message.ciphertext);
     if (!content) return;
-    input.onContent ? input.onContent(content) : printContent(input.context, content);
+    input.onContent ? input.onContent(content) : printContent(input.context, content, renderer);
   });
 }
 async function runAttach(context, options) {
   await withTransport(context, async (transport) => {
-    const seenThroughSeq = await prerollHistory(context, transport, options.sessionId, options.since);
-    followSession({ context, transport, sessionId: options.sessionId, seenThroughSeq });
+    const renderer = createSessionEventRenderer(terminalContentWidth(process.stdout.columns));
+    const seenThroughSeq = await prerollHistory(context, transport, options.sessionId, options.since, void 0, renderer);
+    followSession({ context, transport, sessionId: options.sessionId, seenThroughSeq, renderer });
     context.out.raw(`Attached to ${options.sessionId}. Ctrl+C to detach — the session keeps running.`);
     await new Promise((resolve) => {
       process.once("SIGINT", () => {
@@ -23998,17 +24346,20 @@ async function runAttach(context, options) {
 function createChatState() {
   return { phase: "idle", pendingPermission: null };
 }
-function isTurnEnd(content) {
-  if (content.role !== "session") return false;
-  const { t } = content.content.ev;
-  return t === "turn-end" || t === "stop";
+function turnBoundary(content) {
+  if (content.role !== "session") return null;
+  const { role, ev } = content.content;
+  if (role === "agent" && ev.t === "turn-start") return "start";
+  return ev.t === "turn-end" || ev.t === "stop" ? "end" : null;
 }
 function reduceChatState(state, event) {
   switch (event.type) {
     case "message-sent":
       return { phase: "responding", pendingPermission: null };
     case "content": {
-      if (!isTurnEnd(event.content)) return state;
+      const boundary = turnBoundary(event.content);
+      if (boundary === "start") return { phase: "responding", pendingPermission: null };
+      if (boundary !== "end") return state;
       if (state.phase === "idle") return state;
       return { phase: "idle", pendingPermission: null };
     }
@@ -24031,6 +24382,27 @@ function interruptMenuChoice(key) {
   if (first === "s") return "stop";
   return "watch";
 }
+function chatPresentation(state) {
+  if (state.phase === "idle") {
+    return {
+      inputMode: "prompt",
+      status: "● Ready — you can type",
+      prompt: "› "
+    };
+  }
+  if (state.phase === "awaiting-permission") {
+    return {
+      inputMode: "permission",
+      status: "◆ Action required — permission response only",
+      prompt: null
+    };
+  }
+  return {
+    inputMode: "locked",
+    status: "● Agent is responding — input locked · Ctrl+C for options",
+    prompt: null
+  };
+}
 function describePermissionRequest(request) {
   const summary = summarizeToolArgs(request.arguments ?? {});
   if (summary) return `${request.toolName}(${summary})`;
@@ -24061,6 +24433,106 @@ function resumeHistoryCount(input) {
   if (!input.resuming) return 0;
   return input.since ?? DEFAULT_RESUME_HISTORY;
 }
+class ChatInputController {
+  constructor(readline, input) {
+    this.readline = readline;
+    this.input = input;
+    this.readline.once("close", this.handleClose);
+  }
+  closed = false;
+  locked = false;
+  rawBeforeLock = false;
+  onInterrupt = null;
+  suspendedDataListeners = [];
+  keyListener = null;
+  resolveKey = null;
+  questionAbort = null;
+  handleClose = () => {
+    this.closed = true;
+    this.cancelQuestion();
+    this.unlock();
+  };
+  handleLockedData = (chunk) => {
+    const value2 = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    if (value2.includes("")) this.onInterrupt?.();
+  };
+  lock(onInterrupt) {
+    this.onInterrupt = onInterrupt;
+    if (this.locked || this.closed) return;
+    this.cancelQuestion();
+    this.locked = true;
+    this.rawBeforeLock = this.input.isRaw === true;
+    this.readline.pause();
+    this.suspendedDataListeners = this.input.listeners("data");
+    for (const listener of this.suspendedDataListeners) this.input.off("data", listener);
+    if (this.input.isTTY) this.input.setRawMode?.(true);
+    this.input.resume();
+    this.input.on("data", this.handleLockedData);
+  }
+  unlock() {
+    if (!this.locked) return;
+    this.locked = false;
+    this.input.off("data", this.handleLockedData);
+    if (this.keyListener) {
+      this.input.off("data", this.keyListener);
+      this.keyListener = null;
+      const resolve = this.resolveKey;
+      this.resolveKey = null;
+      resolve?.("");
+    }
+    if (this.input.isTTY) this.input.setRawMode?.(this.rawBeforeLock);
+    for (const listener of this.suspendedDataListeners) this.input.on("data", listener);
+    this.suspendedDataListeners = [];
+    this.readline.resume();
+  }
+  ask(prompt) {
+    this.unlock();
+    if (this.closed) return Promise.resolve(null);
+    const abort = new AbortController();
+    this.questionAbort = abort;
+    return new Promise((resolve) => {
+      let settled = false;
+      const finish = (answer) => {
+        if (settled) return;
+        settled = true;
+        this.readline.off("close", onClose);
+        abort.signal.removeEventListener("abort", onAbort);
+        if (this.questionAbort === abort) this.questionAbort = null;
+        resolve(answer);
+      };
+      const onClose = () => finish(null);
+      const onAbort = () => finish(null);
+      this.readline.once("close", onClose);
+      abort.signal.addEventListener("abort", onAbort, { once: true });
+      this.readline.question(prompt, { signal: abort.signal }, (answer) => finish(answer));
+    });
+  }
+  cancelQuestion() {
+    this.questionAbort?.abort();
+  }
+  readKey() {
+    if (!this.locked || this.closed) return Promise.resolve("");
+    this.input.off("data", this.handleLockedData);
+    return new Promise((resolve) => {
+      this.resolveKey = resolve;
+      this.keyListener = (chunk) => {
+        if (!this.keyListener) return;
+        this.input.off("data", this.keyListener);
+        this.keyListener = null;
+        this.resolveKey = null;
+        if (this.locked) this.input.on("data", this.handleLockedData);
+        resolve(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+      };
+      this.input.on("data", this.keyListener);
+    });
+  }
+  close() {
+    this.cancelQuestion();
+    this.unlock();
+    this.closed = true;
+    this.readline.off("close", this.handleClose);
+  }
+}
 function readString$1(source, key) {
   const value2 = source?.[key];
   return typeof value2 === "string" && value2 ? value2 : void 0;
@@ -24303,6 +24775,1166 @@ async function runProjectConversations(context, query, all) {
 ! Some conversations could not be resolved${payload.warnings.length ? `: ${payload.warnings.join(", ")}` : "."}`);
   }
 }
+const claudeEffortOptions = [
+  { key: "low", label: "Low" },
+  { key: "medium", label: "Medium" },
+  { key: "high", label: "High" },
+  { key: "max", label: "Max" }
+];
+const claudeFableEffortOptions = [
+  { key: "low", label: "Low" },
+  { key: "medium", label: "Medium" },
+  { key: "high", label: "High" },
+  { key: "xhigh", label: "Xhigh" },
+  { key: "max", label: "Max" }
+];
+const codexEffortOptions = [
+  { key: "low", label: "Low" },
+  { key: "medium", label: "Medium" },
+  { key: "high", label: "High" },
+  { key: "xhigh", label: "Xhigh" }
+];
+const codexMaxEffortOptions = [
+  ...codexEffortOptions,
+  { key: "max", label: "Max" }
+];
+const codexUltraEffortOptions = [
+  ...codexMaxEffortOptions,
+  { key: "ultra", label: "Ultra" }
+];
+function getEffortOptionsForAgent(agent, model) {
+  if (model === "default") return [];
+  if (agent === "codex") {
+    if (model === "gpt-5.6-sol" || model === "gpt-5.6-terra") return codexUltraEffortOptions;
+    if (model === "gpt-5.6-luna") return codexMaxEffortOptions;
+    return codexEffortOptions;
+  }
+  if (agent === "gemini" || agent === "opencode") return [];
+  if (model === "claude-fable-5") return claudeFableEffortOptions;
+  return claudeEffortOptions;
+}
+function defaultEffortForAgent(agent, model) {
+  const options = getEffortOptionsForAgent(agent, model);
+  if (options.length === 0) return null;
+  if (agent === "codex") {
+    if (model === "gpt-5.6-sol") return "low";
+    if (model === "gpt-5.6-terra" || model === "gpt-5.6-luna") return "medium";
+  }
+  return options.some((option) => option.key === "high") ? "high" : options[options.length - 1].key;
+}
+const newSessionAgents = [
+  { id: "claude", label: "Claude", provider: "Anthropic" },
+  { id: "codex", label: "Codex", provider: "OpenAI" },
+  { id: "opencode", label: "opencode", provider: "opencode" }
+];
+const claudeModelOptions = [
+  { key: "default", label: "Default" },
+  { key: "claude-fable-5", label: "Fable 5" },
+  { key: "claude-opus-5", label: "Opus 5" },
+  { key: "claude-sonnet-5", label: "Sonnet 5" },
+  { key: "claude-haiku-4-5", label: "Haiku 4.5" }
+];
+const codexModelOptions = [
+  { key: "default", label: "Default" },
+  { key: "gpt-5.6-sol", label: "GPT-5.6 Sol" },
+  { key: "gpt-5.6-terra", label: "GPT-5.6 Terra" },
+  { key: "gpt-5.6-luna", label: "GPT-5.6 Luna" },
+  { key: "gpt-5.5", label: "gpt-5.5" },
+  { key: "gpt-5.4", label: "gpt-5.4" },
+  { key: "gpt-5.3-codex", label: "gpt-5.3-codex" },
+  { key: "gpt-5.2-codex", label: "gpt-5.2-codex" },
+  { key: "gpt-5.1-codex-max", label: "gpt-5.1-codex-max" },
+  { key: "gpt-5.2", label: "gpt-5.2" },
+  { key: "gpt-5.1-codex-mini", label: "gpt-5.1-codex-mini" }
+];
+const geminiModelOptions = [
+  { key: "gemini-3.1-pro-preview", label: "gemini 3.1 pro" },
+  { key: "gemini-3-flash-preview", label: "gemini 3 flash" },
+  { key: "gemini-3.1-flash-lite-preview", label: "gemini 3.1 flash lite" },
+  { key: "gemini-2.5-pro", label: "gemini 2.5 pro" },
+  { key: "gemini-2.5-flash", label: "gemini 2.5 flash" },
+  { key: "gemini-2.5-flash-lite", label: "gemini 2.5 flash lite" }
+];
+const opencodeModelOptions = [
+  { key: "default", label: "Default" }
+];
+function getModelsForAgent(agent) {
+  if (agent === "codex") return codexModelOptions;
+  if (agent === "gemini") return geminiModelOptions;
+  if (agent === "opencode") return opencodeModelOptions;
+  return claudeModelOptions;
+}
+function normalizeModelForAgent(agent, model) {
+  if (agent === "opencode") return model || "default";
+  const models = getModelsForAgent(agent);
+  return models.some((option) => option.key === model) ? model : models[0]?.key ?? "default";
+}
+function normalizeModelSelectionOptions(agent, current, patch) {
+  const model = normalizeModelForAgent(agent, patch.model ?? current.model);
+  const efforts = getEffortOptionsForAgent(agent, model);
+  const effort = patch.model !== void 0 ? defaultEffortForAgent(agent, model) : patch.effort !== void 0 && efforts.some((option) => option.key === patch.effort) ? patch.effort : current.effort && efforts.some((option) => option.key === current.effort) ? current.effort : defaultEffortForAgent(agent, model);
+  return { model, effort };
+}
+function messageModelOptionsFromSelection(agent, options, availableModels) {
+  if (agent === "opencode") {
+    const model = normalizeOpencodeModel(options.model, availableModels);
+    return { model: model !== "default" ? model : void 0, effort: null };
+  }
+  const normalized = normalizeModelSelectionOptions(agent, options, {});
+  return {
+    model: normalized.model !== "default" ? normalized.model : void 0,
+    effort: normalized.effort
+  };
+}
+const WORKTREE_NAME_ADJECTIVES = [
+  "bright",
+  "calm",
+  "eager",
+  "brave",
+  "swift",
+  "quiet",
+  "clever",
+  "lucky",
+  "gentle",
+  "bold",
+  "fresh",
+  "keen",
+  "merry",
+  "noble",
+  "proud",
+  "witty"
+];
+const WORKTREE_NAME_ANIMALS = [
+  "fox",
+  "otter",
+  "hawk",
+  "lynx",
+  "wolf",
+  "crane",
+  "koala",
+  "panda",
+  "tiger",
+  "whale",
+  "finch",
+  "gecko",
+  "moose",
+  "raven",
+  "seal",
+  "newt"
+];
+function sanitizeWorktreeName(raw) {
+  return raw.trim().toLowerCase().replace(/[^a-z0-9/_-]+/g, "-").replace(/\/{2,}/g, "/").replace(/-{2,}/g, "-").replace(/^[-/]+|[-/]+$/g, "").replace(/\.+/g, ".").slice(0, 60);
+}
+function generateWorktreeName(random = Math.random) {
+  const pick2 = (items) => items[Math.floor(random() * items.length) % items.length];
+  const suffix = Math.floor(random() * 36 ** 4).toString(36).padStart(4, "0").slice(-4);
+  return `${pick2(WORKTREE_NAME_ADJECTIVES)}-${pick2(WORKTREE_NAME_ANIMALS)}-${suffix}`;
+}
+function resolveWorktreeName(input) {
+  const sanitized = input.requested ? sanitizeWorktreeName(input.requested) : "";
+  if (sanitized) return sanitized;
+  return generateWorktreeName(input.random);
+}
+const MANAGED_WORKTREE_SEGMENT = "/.aplus/worktrees/";
+const MAX_MANAGED_WORKTREE_DEPTH = 2;
+function isWorktreePathWithinProjectRoot(projectRoot, worktreePath) {
+  const root = projectRoot.trim().replace(/\/+$/, "");
+  const path = worktreePath.trim().replace(/\/+$/, "");
+  if (!root || !path) return false;
+  if (!path.startsWith(`${root}${MANAGED_WORKTREE_SEGMENT}`)) return false;
+  const segments = path.slice(root.length + MANAGED_WORKTREE_SEGMENT.length).split("/");
+  if (segments.length < 1 || segments.length > MAX_MANAGED_WORKTREE_DEPTH) return false;
+  return segments.every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
+const DEFAULT_CLI_NEW_CONVERSATION_OPTIONS = {
+  agent: "claude",
+  model: "default",
+  effort: null,
+  useWorktree: false,
+  worktreeName: "",
+  worktreeBaseRef: "HEAD",
+  files: [],
+  voice: false,
+  voiceFile: null
+};
+function normalizeNewConversationOptions(current, patch) {
+  const agent = patch.agent ?? current.agent;
+  const agentChanged = patch.agent !== void 0 && patch.agent !== current.agent;
+  const currentSelection = agentChanged ? { model: "default", effort: null } : { model: current.model, effort: current.effort };
+  const modelSelection = normalizeModelSelectionOptions(agent, currentSelection, {
+    ...patch.model !== void 0 ? { model: patch.model } : {}
+  });
+  const efforts = getEffortOptionsForAgent(agent, modelSelection.model);
+  const requestedEffort = patch.effort !== void 0 ? patch.effort : modelSelection.effort;
+  const effort = requestedEffort && efforts.some((option) => option.key === requestedEffort) ? requestedEffort : defaultEffortForAgent(agent, modelSelection.model);
+  return {
+    agent,
+    model: modelSelection.model,
+    effort,
+    useWorktree: patch.useWorktree ?? current.useWorktree,
+    worktreeName: patch.worktreeName !== void 0 ? sanitizeWorktreeName(patch.worktreeName) : current.worktreeName,
+    worktreeBaseRef: (patch.worktreeBaseRef ?? current.worktreeBaseRef).trim() || "HEAD",
+    files: patch.files ? [...patch.files] : [...current.files],
+    voice: patch.voice ?? current.voice,
+    voiceFile: patch.voiceFile !== void 0 ? patch.voiceFile : current.voiceFile
+  };
+}
+function buildCliUserMessage(text2, options) {
+  const modelOptions = messageModelOptionsFromSelection(options.agent, options);
+  return {
+    role: "user",
+    content: { type: "text", text: text2 },
+    meta: {
+      permissionMode: "default",
+      ...modelOptions.model ? { model: modelOptions.model } : {},
+      ...modelOptions.effort ? { effort: modelOptions.effort } : {}
+    }
+  };
+}
+function modelChoices(agent) {
+  return getModelsForAgent(agent);
+}
+function effortChoices(agent, model) {
+  return getEffortOptionsForAgent(agent, normalizeModelForAgent(agent, model));
+}
+function worktreeTargetMismatch(record2, expected) {
+  if (record2.projectId !== expected.projectId) return "project";
+  if (record2.machineId !== expected.machineId) return "machine";
+  if (expected.path !== void 0 && record2.path !== expected.path) return "path";
+  return null;
+}
+async function createWorktreeOnMachine(input) {
+  const record2 = await input.client.createProjectWorktree(input.projectId, {
+    name: input.name,
+    baseRef: input.baseRef,
+    machineId: input.machineId,
+    ...input.confirmRepoRoot ? { confirmRepoRoot: input.confirmRepoRoot } : {}
+  });
+  const targetMismatch = worktreeTargetMismatch(record2, {
+    projectId: input.projectId,
+    machineId: input.machineId
+  });
+  const allowedRoot = input.confirmRepoRoot ?? input.repoCwd;
+  const pathMatches = isWorktreePathWithinProjectRoot(allowedRoot, record2.path);
+  if (!targetMismatch && pathMatches) return record2;
+  await input.client.deleteProjectWorktree(input.projectId, record2.id, true).catch(() => void 0);
+  throw new Error(!pathMatches && input.pathMismatchMessage ? input.pathMismatchMessage(record2.path) : input.targetMismatchMessage);
+}
+const WORKTREE_SUBDIR_CONFIRM_CODE = "worktree-subdir-confirm-required";
+function trimmedString(value2) {
+  if (typeof value2 !== "string") return null;
+  const normalized = value2.trim();
+  return normalized ? normalized : null;
+}
+function withoutTrailingSlash(path) {
+  return path.replace(/\/+$/, "");
+}
+function isStrictAncestorDir(parent, child) {
+  const base = withoutTrailingSlash(parent);
+  const target = withoutTrailingSlash(child);
+  if (!base || !target || base === target) return false;
+  return target.startsWith(`${base}/`);
+}
+function isSafeRelativeDir(dir) {
+  if (dir.startsWith("/") || dir.startsWith("\\") || /^[A-Za-z]:[\\/]/.test(dir)) return false;
+  return !dir.split(/[\\/]+/).some((segment) => segment === "..");
+}
+function parseWorktreeSubdirConfirmRequest(status, body, projectRoot) {
+  if (status !== 409) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const value2 = parsed;
+  if (value2.code !== WORKTREE_SUBDIR_CONFIRM_CODE) return null;
+  const repoRoot = trimmedString(value2.repoRoot);
+  const workspaceDir = trimmedString(value2.workspaceDir);
+  const repoRelativeDir = trimmedString(value2.repoRelativeDir);
+  const root = trimmedString(projectRoot);
+  if (!repoRoot || !workspaceDir || !repoRelativeDir || !root) return null;
+  if (!isStrictAncestorDir(repoRoot, root)) return null;
+  if (!isSafeRelativeDir(repoRelativeDir)) return null;
+  return { repoRoot, workspaceDir, repoRelativeDir };
+}
+async function createCliProjectWorktree(input, deps) {
+  const createInput = {
+    client: {
+      createProjectWorktree: deps.create,
+      deleteProjectWorktree: deps.remove
+    },
+    projectId: input.projectId,
+    machineId: input.machineId,
+    repoCwd: input.projectRoot,
+    name: input.name,
+    baseRef: input.baseRef,
+    targetMismatchMessage: "The worktree does not belong to the selected project and machine.",
+    pathMismatchMessage: () => "The daemon returned a worktree outside the safe project boundary."
+  };
+  try {
+    return await createWorktreeOnMachine(createInput);
+  } catch (error) {
+    if (!(error instanceof CliHttpError)) throw error;
+    const request = parseWorktreeSubdirConfirmRequest(error.status, error.body, input.projectRoot);
+    if (!request) throw error;
+    if (!deps.confirmSubdir || !await deps.confirmSubdir(request)) {
+      throw new Error("Worktree creation was cancelled because the project is a repository subdirectory.");
+    }
+    return createWorktreeOnMachine({ ...createInput, confirmRepoRoot: request.repoRoot });
+  }
+}
+async function sha256HexFromBase64(b64Content) {
+  if (typeof crypto === "undefined" || !crypto.subtle || typeof crypto.subtle.digest !== "function") {
+    throw new Error(translateCurrent("remoteFile.sha256Failed"));
+  }
+  const bytes = new Uint8Array(Buffer$1.from(b64Content, "base64"));
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  const view = new Uint8Array(digest);
+  let hex = "";
+  for (let i = 0; i < view.length; i++) hex += view[i].toString(16).padStart(2, "0");
+  return hex;
+}
+const MEGABYTE = 1024 * 1024;
+const MAX_IMAGE_ATTACHMENT_BYTES = 25 * MEGABYTE;
+const MAX_OTHER_ATTACHMENT_BYTES = 100 * MEGABYTE;
+function attachmentReferenceLabel(file) {
+  return translateCurrent(file.type.startsWith("image/") ? "upload.kindImage" : "upload.kindFile");
+}
+function arrayBufferToBase64(buffer) {
+  return encodeBase64(new Uint8Array(buffer));
+}
+function extensionFor(file) {
+  const fromName = file.name.match(/\.([A-Za-z0-9]{1,12})$/)?.[1];
+  if (fromName) return fromName.toLowerCase();
+  const fromType = file.type.match(/^image\/([A-Za-z0-9.+-]+)$/)?.[1];
+  if (!fromType) return "bin";
+  return fromType.replace(/[^A-Za-z0-9]/g, "").toLowerCase() || "bin";
+}
+function safeFileName(file) {
+  const name = file.name.split(/[\\/]/).pop()?.trim() ?? "";
+  const safe = name.replace(/[^A-Za-z0-9._ -]/g, "_").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^[._-]+|[._-]+$/g, "");
+  if (safe) return safe.slice(0, 120);
+  return `attachment.${extensionFor(file)}`;
+}
+function chatUploadRelPath(file, id) {
+  if (file.type.startsWith("image/")) return `.aplus/uploads/${id}.${extensionFor(file)}`;
+  return `.aplus/uploads/${id}-${safeFileName(file)}`;
+}
+async function uploadChatFileToMachineCore(file, workspaceRoot, deps) {
+  const root = workspaceRoot.trim().replace(/\/+$/, "");
+  if (!root) throw new Error(translateCurrent("upload.noWorkspaceRoot"));
+  const id = (deps.now?.() ?? Date.now()).toString(36) + (deps.random?.() ?? Math.random()).toString(36).slice(2, 8);
+  const absPath = `${root}/${chatUploadRelPath(file, id)}`;
+  const contentBase64 = arrayBufferToBase64(await file.arrayBuffer());
+  let expectedHash = null;
+  const probe = await deps.readFile(absPath);
+  if (probe && probe.success && typeof probe.content === "string") {
+    expectedHash = await sha256HexFromBase64(probe.content);
+  }
+  const res = await deps.writeFile({ path: absPath, content: contentBase64, expectedHash });
+  if (!res || res.success === false) {
+    throw new Error(res?.error || translateCurrent("upload.failed"));
+  }
+  return absPath;
+}
+async function preparePersonalChatMessageWithAttachments(input, deps) {
+  const text2 = input.text.trim();
+  if (input.files.length === 0) return text2;
+  const references = [];
+  for (const file of input.files) {
+    const path = await deps.uploadFile(file);
+    references.push(`${attachmentReferenceLabel(file)}: ${path}`);
+  }
+  const fileReferences = references.join("\n");
+  return text2 ? `${text2}
+
+${fileReferences}` : `${translateCurrent("composer.attachPromptPrefix")}
+${fileReferences}`;
+}
+const MIME_BY_EXTENSION = {
+  ".gif": "image/gif",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".pdf": "application/pdf",
+  ".json": "application/json",
+  ".md": "text/markdown",
+  ".txt": "text/plain"
+};
+function mimeTypeForPath(path) {
+  return MIME_BY_EXTENSION[extname(path).toLowerCase()] ?? "application/octet-stream";
+}
+async function loadCliAttachment(path, deps = { stat, readFile }) {
+  const info = await deps.stat(path);
+  const mimeType = mimeTypeForPath(path);
+  const limit = mimeType.startsWith("image/") ? MAX_IMAGE_ATTACHMENT_BYTES : MAX_OTHER_ATTACHMENT_BYTES;
+  if (info.size > limit) {
+    throw new Error(`${basename(path)} is too large (maximum ${Math.round(limit / 1024 / 1024)} MB).`);
+  }
+  const bytes = await deps.readFile(path);
+  return new File([new Uint8Array(bytes)], basename(path), { type: mimeType });
+}
+function uploadCliAttachment(transport, machineId, workspaceRoot, file, deterministic = {}) {
+  return uploadChatFileToMachineCore(file, workspaceRoot, {
+    readFile: (path) => transport.rpc(machineId, "readFile", { path }),
+    writeFile: (params) => transport.rpc(machineId, "writeFile", params),
+    ...deterministic
+  });
+}
+function prepareCliMessageWithAttachments(text2, files, uploadFile) {
+  return preparePersonalChatMessageWithAttachments({ text: text2, files }, { uploadFile });
+}
+function choiceIndex(answer, length, currentIndex) {
+  const trimmed = answer?.trim() ?? "";
+  if (!trimmed) return Math.max(0, currentIndex);
+  const number = Number.parseInt(trimmed, 10);
+  return Number.isInteger(number) && number >= 1 && number <= length ? number - 1 : Math.max(0, currentIndex);
+}
+function choiceQuestion(label, choices, currentIndex) {
+  const rendered = choices.map((choice, index) => `${index + 1}) ${choice.label}`).join("  ");
+  return `${label} [${rendered}] (${currentIndex + 1}): `;
+}
+function yes(answer, fallback) {
+  const normalized = answer?.trim().toLowerCase() ?? "";
+  if (!normalized) return fallback;
+  return normalized === "y" || normalized === "yes";
+}
+async function promptNewConversationOptions(initial, ask) {
+  let options = initial;
+  const agents = options.agent === "gemini" ? [{ id: "gemini", label: "Gemini", provider: "Google" }, ...newSessionAgents] : newSessionAgents;
+  const agentIndex = Math.max(0, agents.findIndex((entry) => entry.id === options.agent));
+  const selectedAgent = agents[choiceIndex(
+    await ask(choiceQuestion("Agent", agents, agentIndex)),
+    agents.length,
+    agentIndex
+  )]?.id;
+  options = normalizeNewConversationOptions(options, { agent: selectedAgent });
+  const models = modelChoices(options.agent);
+  const modelIndex = Math.max(0, models.findIndex((entry) => entry.key === options.model));
+  const model = models[choiceIndex(
+    await ask(choiceQuestion("Model", models, modelIndex)),
+    models.length,
+    modelIndex
+  )]?.key ?? "default";
+  options = normalizeNewConversationOptions(options, { model });
+  const efforts = effortChoices(options.agent, options.model);
+  if (efforts.length > 0) {
+    const effortIndex = Math.max(0, efforts.findIndex((entry) => entry.key === options.effort));
+    const effort = efforts[choiceIndex(
+      await ask(choiceQuestion("Effort", efforts, effortIndex)),
+      efforts.length,
+      effortIndex
+    )]?.key ?? null;
+    options = normalizeNewConversationOptions(options, { effort });
+  }
+  options = normalizeNewConversationOptions(options, {
+    useWorktree: yes(await ask(`Create isolated worktree? ${options.useWorktree ? "[Y/n]" : "[y/N]"}: `), options.useWorktree)
+  });
+  if (options.files.length === 0) {
+    const files = (await ask("Attach local files (comma-separated, blank for none): "))?.split(",").map((entry) => entry.trim()).filter(Boolean) ?? [];
+    options = normalizeNewConversationOptions(options, { files });
+  }
+  if (!options.voice && !options.voiceFile) {
+    options = normalizeNewConversationOptions(options, {
+      voice: yes(await ask("Record the first prompt by voice? [y/N]: "), false)
+    });
+  }
+  return options;
+}
+const MIN_AUDIO_BYTES = 1600;
+function resolveTranscriptionOutcome(text2) {
+  const cleaned = text2.trim();
+  if (!cleaned) return { errorKind: "no-speech" };
+  return { transcript: cleaned };
+}
+function recorderSpec(platform2, available) {
+  if (platform2 === "linux" && available.has("arecord")) {
+    return { command: "arecord", args: (path) => ["-q", "-f", "S16_LE", "-r", "16000", "-c", "1", path] };
+  }
+  if (available.has("rec")) {
+    return { command: "rec", args: (path) => ["-q", "-c", "1", "-r", "16000", path] };
+  }
+  if (available.has("ffmpeg")) {
+    if (platform2 === "darwin") {
+      return {
+        command: "ffmpeg",
+        args: (path) => ["-nostdin", "-loglevel", "error", "-f", "avfoundation", "-i", ":0", "-ac", "1", "-ar", "16000", "-y", path]
+      };
+    }
+    return {
+      command: "ffmpeg",
+      args: (path) => ["-nostdin", "-loglevel", "error", "-f", "pulse", "-i", "default", "-ac", "1", "-ar", "16000", "-y", path]
+    };
+  }
+  return null;
+}
+async function installedCommands(env) {
+  const result = /* @__PURE__ */ new Set();
+  const directories = (env.PATH ?? "").split(delimiter).filter(Boolean);
+  for (const command of ["arecord", "rec", "ffmpeg"]) {
+    for (const directory of directories) {
+      try {
+        await access(join(directory, command), constants$1.X_OK);
+        result.add(command);
+        break;
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+function waitForSpawn(child) {
+  return new Promise((resolve, reject) => {
+    const onSpawn = () => {
+      cleanup();
+      resolve();
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const cleanup = () => {
+      child.off("spawn", onSpawn);
+      child.off("error", onError);
+    };
+    child.once("spawn", onSpawn);
+    child.once("error", onError);
+  });
+}
+function waitForClose(child) {
+  return new Promise((resolve) => {
+    if (child.exitCode !== null || child.signalCode !== null) {
+      resolve();
+      return;
+    }
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      resolve();
+    }, 5e3);
+    child.once("close", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+async function recordCliVoice(waitForStop, input = {}) {
+  const platform2 = input.platform ?? process.platform;
+  const spec = recorderSpec(platform2, await installedCommands(input.env ?? process.env));
+  if (!spec) {
+    throw new Error("No supported microphone recorder was found. Install ffmpeg/SoX/arecord or use `--voice-file <audio>` instead.");
+  }
+  const directory = await mkdtemp(join(tmpdir(), "saycode-voice-"));
+  const path = join(directory, "prompt.wav");
+  const cleanup = () => rm(directory, { recursive: true, force: true });
+  try {
+    const child = spawn(spec.command, spec.args(path), { stdio: ["ignore", "ignore", "pipe"] });
+    await waitForSpawn(child);
+    await waitForStop();
+    child.kill("SIGINT");
+    await waitForClose(child);
+    const info = await stat(path);
+    if (info.size < MIN_AUDIO_BYTES) throw new Error("No usable speech was recorded.");
+    return { path, cleanup };
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+function audioMimeTypeForPath(path) {
+  switch (extname(path).toLowerCase()) {
+    case ".m4a":
+    case ".mp4":
+      return "audio/mp4";
+    case ".ogg":
+      return "audio/ogg";
+    case ".webm":
+      return "audio/webm";
+    case ".mp3":
+      return "audio/mpeg";
+    default:
+      return "audio/wav";
+  }
+}
+async function transcribeCliVoiceFile(rest, path, read = readFile) {
+  const bytes = await read(path);
+  const mimeType = audioMimeTypeForPath(path);
+  const result = await rest.transcribeAudio(new Blob([new Uint8Array(bytes)], { type: mimeType }), {
+    fileName: basename(path),
+    mimeType
+  });
+  const outcome = resolveTranscriptionOutcome(result.text);
+  if ("errorKind" in outcome) throw new Error("No speech was recognized in that recording.");
+  return outcome.transcript;
+}
+function configurableAgent(agent) {
+  if (agent === "gemini") return agent;
+  return newSessionAgents.some((entry) => entry.id === agent) ? agent : null;
+}
+function hasNewConversationSettings(request) {
+  return request.model !== void 0 || request.effort !== void 0 || request.useWorktree === true || request.worktreeName !== void 0 || request.worktreeBaseRef !== void 0 || request.files !== void 0 || request.voice === true || request.voiceFile !== void 0;
+}
+function validateExplicitSelection(request, agent) {
+  if (request.model !== void 0 && !modelChoices(agent).some((option) => option.key === request.model)) {
+    throw new CliError(`Unknown ${agent} model "${request.model}".`);
+  }
+  if (request.effort !== void 0) {
+    const model = request.model ?? DEFAULT_CLI_NEW_CONVERSATION_OPTIONS.model;
+    if (!effortChoices(agent, model).some((option) => option.key === request.effort)) {
+      throw new CliError(`Effort "${request.effort}" is not available for ${agent} model "${model}".`);
+    }
+  }
+}
+async function resolveCliNewConversationOptions(request, ask) {
+  const agent = configurableAgent(request.agent);
+  if (!agent) {
+    if (hasNewConversationSettings(request)) {
+      throw new CliError(`New-conversation options are not available for agent "${request.agent}".`);
+    }
+    return null;
+  }
+  validateExplicitSelection(request, agent);
+  let resolved = normalizeNewConversationOptions(DEFAULT_CLI_NEW_CONVERSATION_OPTIONS, {
+    agent,
+    ...request.model !== void 0 ? { model: request.model } : {},
+    ...request.effort !== void 0 ? { effort: request.effort } : {},
+    ...request.useWorktree ? { useWorktree: true } : {},
+    ...request.worktreeName !== void 0 ? { worktreeName: request.worktreeName } : {},
+    ...request.worktreeBaseRef !== void 0 ? { worktreeBaseRef: request.worktreeBaseRef } : {},
+    ...request.files ? { files: request.files } : {},
+    ...request.voice ? { voice: true } : {},
+    ...request.voiceFile !== void 0 ? { voiceFile: request.voiceFile } : {}
+  });
+  if (ask) resolved = await promptNewConversationOptions(resolved, ask);
+  return resolved;
+}
+async function captureCliVoicePrompt(context, voiceFile, waitForStop) {
+  if (!context.hasApiAccess) {
+    throw new CliError("Voice transcription needs a Saycode account login. Run `saycode login`, or type the prompt instead.");
+  }
+  if (voiceFile) return transcribeCliVoiceFile(context.rest, voiceFile);
+  context.out.raw("Recording from the microphone…");
+  const recording = await recordCliVoice(waitForStop);
+  try {
+    return await transcribeCliVoiceFile(context.rest, recording.path);
+  } finally {
+    await recording.cleanup();
+  }
+}
+const USAGE_SETTINGS_NAVIGATION_DESTINATIONS = [
+  "settings_profile",
+  "settings_system_prompt",
+  "settings_personal_memory",
+  "settings_notifications",
+  "settings_visual_effects",
+  "settings_language",
+  "settings_shortcuts",
+  "settings_machines",
+  "settings_mobile",
+  "settings_env",
+  "settings_security",
+  "settings_memory",
+  "settings_conversation_search",
+  "settings_connectors",
+  "settings_about"
+];
+const USAGE_ANALYTICS_EVENT_NAMES = [
+  "app_started",
+  "login_success",
+  "logout",
+  "session_created",
+  "message_sent",
+  "command_completed",
+  "navigation_selected",
+  "secondary_action_selected",
+  "first_response_received",
+  "preview_opened",
+  "preview_start_failed",
+  "terminal_opened",
+  "worktree_created",
+  "browser_tab_opened",
+  "update_installed",
+  "client_error_occurred",
+  // Meta event: emitted by the queue itself when the cap forced drops (plan
+  // "리스크와 대응"), so silent loss is visible in the dashboard.
+  "usage_events_dropped"
+];
+const USAGE_ANALYTICS_COMMAND_ACTIONS = [
+  "help",
+  "version",
+  "login",
+  "logout",
+  "workspaces",
+  "browse",
+  "machines",
+  "projects",
+  "ls",
+  "attach",
+  "chat",
+  "watch",
+  "show_status",
+  "open_chat",
+  "send_selection",
+  "create_project",
+  "mount_project"
+];
+const USAGE_NAVIGATION_SURFACES = ["sidebar_primary", "sidebar_more", "workspace_switcher", "settings"];
+const USAGE_NAVIGATION_DESTINATIONS = [
+  "projects",
+  "agent_board",
+  "personal_chats",
+  "all_conversations",
+  "machines",
+  "organization_home",
+  "settings",
+  "organization_admin",
+  "system_admin",
+  ...USAGE_SETTINGS_NAVIGATION_DESTINATIONS
+];
+const USAGE_SECONDARY_ACTION_SURFACES = ["chat_header", "composer"];
+const USAGE_SECONDARY_ACTIONS = [
+  "terminal",
+  "preview",
+  "new_chat",
+  "more",
+  "copy",
+  "complete",
+  "archive",
+  "project_settings",
+  "deploy",
+  "memory",
+  "machine_usage",
+  "workspace_layout",
+  "tool_menu",
+  "model",
+  "voice",
+  "attachment",
+  "work_completion"
+];
+const DEMO_ANALYTICS_USER_ID = "demo-user";
+function isDemoAnalyticsUserId(userId) {
+  return userId === DEMO_ANALYTICS_USER_ID;
+}
+const EVENT_PROPERTY_ALLOWLIST = {
+  app_started: ["mode"],
+  login_success: ["mode"],
+  logout: ["mode"],
+  session_created: ["mode", "worktree", "new_project"],
+  message_sent: ["mode", "length_bucket"],
+  command_completed: ["action"],
+  navigation_selected: ["mode", "surface", "destination"],
+  secondary_action_selected: ["mode", "surface", "action"],
+  first_response_received: ["mode", "duration_bucket"],
+  preview_opened: ["mode"],
+  preview_start_failed: ["mode", "failure_code"],
+  terminal_opened: ["mode"],
+  worktree_created: ["mode"],
+  browser_tab_opened: ["mode"],
+  update_installed: ["mode", "from_version", "to_version"],
+  client_error_occurred: ["mode", "error_kind"],
+  usage_events_dropped: ["mode", "dropped_count"]
+};
+const EVENT_PROPERTY_VALUE_ALLOWLIST = {
+  navigation_selected: {
+    surface: USAGE_NAVIGATION_SURFACES,
+    destination: USAGE_NAVIGATION_DESTINATIONS
+  },
+  secondary_action_selected: {
+    surface: USAGE_SECONDARY_ACTION_SURFACES,
+    action: USAGE_SECONDARY_ACTIONS
+  },
+  command_completed: {
+    action: USAGE_ANALYTICS_COMMAND_ACTIONS
+  }
+};
+const MAX_STRING_PROPERTY_LENGTH = 200;
+function isUsageEventName(value2) {
+  return typeof value2 === "string" && USAGE_ANALYTICS_EVENT_NAMES.includes(value2);
+}
+function sanitizeUsageEvent(name, props) {
+  if (!isUsageEventName(name)) return null;
+  const allowlist = EVENT_PROPERTY_ALLOWLIST[name];
+  const properties = {};
+  if (props && typeof props === "object" && !Array.isArray(props)) {
+    for (const [key, value2] of Object.entries(props)) {
+      if (!allowlist.includes(key)) continue;
+      if (typeof value2 === "string") {
+        const valueAllowlist = EVENT_PROPERTY_VALUE_ALLOWLIST[name]?.[key];
+        if (valueAllowlist && !valueAllowlist.includes(value2)) continue;
+        properties[key] = value2.slice(0, MAX_STRING_PROPERTY_LENGTH);
+      } else if (typeof value2 === "number" && Number.isFinite(value2)) {
+        properties[key] = value2;
+      } else if (typeof value2 === "boolean") {
+        properties[key] = value2;
+      }
+    }
+  }
+  const requiredEnumProperties = EVENT_PROPERTY_VALUE_ALLOWLIST[name];
+  if (requiredEnumProperties && Object.keys(requiredEnumProperties).some((key) => properties[key] === void 0)) return null;
+  return { event: name, properties };
+}
+function buildUsageCommonProperties(input) {
+  return { app: input.service, app_version: input.appVersion, os: input.platform };
+}
+const USAGE_ANALYTICS_QUEUE_FILE = "queue.jsonl";
+const USAGE_ANALYTICS_QUEUE_MAX_EVENTS = 5e3;
+function isQueuedUsageEvent(value2) {
+  if (!value2 || typeof value2 !== "object") return false;
+  const record2 = value2;
+  return typeof record2.uuid === "string" && record2.uuid.length > 0 && typeof record2.event === "string" && record2.event.length > 0 && typeof record2.distinctId === "string" && typeof record2.timestamp === "string" && !!record2.properties && typeof record2.properties === "object";
+}
+function createUsageAnalyticsQueue(options) {
+  const maxEvents = options.maxEvents ?? USAGE_ANALYTICS_QUEUE_MAX_EVENTS;
+  const path = join(options.dir, USAGE_ANALYTICS_QUEUE_FILE);
+  let droppedCount = 0;
+  let knownCount = null;
+  let chain = Promise.resolve();
+  const enqueue = (task) => {
+    const result = chain.then(task);
+    chain = result.then(() => void 0, () => void 0);
+    return result;
+  };
+  const readAll = async () => {
+    let raw;
+    try {
+      raw = await readFile(path, "utf8");
+    } catch {
+      return [];
+    }
+    const records = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (isQueuedUsageEvent(parsed)) records.push(parsed);
+      } catch {
+      }
+    }
+    return records;
+  };
+  const rewrite = async (records) => {
+    if (records.length === 0) {
+      await rm(path, { force: true });
+      return;
+    }
+    await writeFile(path, records.map((r) => JSON.stringify(r)).join("\n") + "\n", { mode: 384 });
+  };
+  return {
+    append(record2) {
+      return enqueue(async () => {
+        try {
+          await mkdir(options.dir, { recursive: true, mode: 448 });
+          await appendFile(path, JSON.stringify(record2) + "\n", { mode: 384 });
+          if (knownCount === null) knownCount = (await readAll()).length;
+          else knownCount += 1;
+          if (knownCount > maxEvents) {
+            const all = await readAll();
+            if (all.length > maxEvents) {
+              droppedCount += all.length - maxEvents;
+              await rewrite(all.slice(all.length - maxEvents));
+            }
+            knownCount = Math.min(all.length, maxEvents);
+          }
+        } catch {
+        }
+      });
+    },
+    readBatch(limit) {
+      return enqueue(async () => (await readAll()).slice(0, limit));
+    },
+    removeSent(uuids) {
+      return enqueue(async () => {
+        try {
+          const sent = new Set(uuids);
+          const kept = (await readAll()).filter((record2) => !sent.has(record2.uuid));
+          await rewrite(kept);
+          knownCount = kept.length;
+        } catch {
+          knownCount = null;
+        }
+      });
+    },
+    clear() {
+      return enqueue(async () => {
+        droppedCount = 0;
+        knownCount = 0;
+        try {
+          await rm(path, { force: true });
+        } catch {
+          knownCount = null;
+        }
+      });
+    },
+    takeDroppedCount() {
+      const count = droppedCount;
+      droppedCount = 0;
+      return count;
+    }
+  };
+}
+const USAGE_ANALYTICS_BATCH_SIZE = 100;
+const USAGE_ANALYTICS_REQUEST_TIMEOUT_MS = 1e4;
+function createUsageAnalyticsSender(options) {
+  const { queue, config, commonProperties } = options;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const batchSize = options.batchSize ?? USAGE_ANALYTICS_BATCH_SIZE;
+  const requestTimeoutMs = options.requestTimeoutMs ?? USAGE_ANALYTICS_REQUEST_TIMEOUT_MS;
+  return {
+    async flush() {
+      if (!config || !config.token) return "disabled";
+      const batch = await queue.readBatch(batchSize);
+      if (batch.length === 0) return "empty";
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), requestTimeoutMs);
+      timeout.unref?.();
+      try {
+        const response = await fetchImpl(`${config.host.replace(/\/$/, "")}/batch/`, {
+          method: "POST",
+          signal: controller.signal,
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            api_key: config.token,
+            batch: batch.map((record2) => ({
+              event: record2.event,
+              distinct_id: record2.distinctId,
+              uuid: record2.uuid,
+              timestamp: record2.timestamp,
+              properties: {
+                ...record2.properties,
+                ...commonProperties,
+                // web-ui(person_profiles:'identified_only') 파리티: 익명 이벤트는
+                // person 을 만들지 않는다 — 같은 프로젝트 공유 시 person 폭증 방지.
+                ...record2.identified === false ? { $process_person_profile: false } : {}
+              }
+            }))
+          })
+        });
+        if (!response.ok) return "failed";
+      } catch {
+        return "failed";
+      } finally {
+        clearTimeout(timeout);
+      }
+      await queue.removeSent(batch.map((record2) => record2.uuid));
+      return "sent";
+    }
+  };
+}
+const USAGE_ANALYTICS_FLUSH_INTERVAL_MS = 3e4;
+function createUsageAnalyticsCoordinator(options) {
+  const now = options.now ?? (() => Date.now());
+  const queue = createUsageAnalyticsQueue({ dir: options.dir, maxEvents: options.queueMaxEvents });
+  const sender2 = createUsageAnalyticsSender({
+    queue,
+    config: options.senderConfig,
+    commonProperties: options.commonProperties,
+    fetchImpl: options.fetchImpl
+  });
+  let timer = null;
+  let forcedDisabled = false;
+  let operationChain = Promise.resolve();
+  const enqueueOperation = (operation) => {
+    const result = operationChain.then(operation);
+    operationChain = result.then(() => void 0, () => void 0);
+    return result;
+  };
+  const append = async (name, props) => {
+    const sanitized = sanitizeUsageEvent(name, props);
+    if (!sanitized) return;
+    try {
+      const distinctId = await options.getDistinctId();
+      const record2 = {
+        uuid: randomUUID(),
+        event: sanitized.event,
+        properties: sanitized.properties,
+        distinctId,
+        timestamp: new Date(now()).toISOString()
+      };
+      if (options.getInstallId) record2.identified = distinctId !== await options.getInstallId();
+      await queue.append(record2);
+    } catch {
+    }
+  };
+  const coordinator = {
+    async record(name, props) {
+      await enqueueOperation(async () => {
+        if (forcedDisabled) return;
+        try {
+          if (!await options.isEnabled()) return;
+        } catch {
+          return;
+        }
+        await append(name, props);
+      });
+    },
+    async recordAlias(input) {
+      await enqueueOperation(async () => {
+        if (forcedDisabled) return;
+        try {
+          if (!await options.isEnabled()) return;
+          if (!input.userId || !input.installId || input.userId === input.installId) return;
+          if (isDemoAnalyticsUserId(input.userId)) return;
+          await queue.append({
+            uuid: randomUUID(),
+            event: "$create_alias",
+            properties: { distinct_id: input.userId, alias: input.installId },
+            distinctId: input.userId,
+            identified: true,
+            timestamp: new Date(now()).toISOString()
+          });
+        } catch {
+        }
+      });
+    },
+    async flushNow() {
+      await enqueueOperation(async () => {
+        if (forcedDisabled) return;
+        const dropped = queue.takeDroppedCount();
+        if (dropped > 0) await append("usage_events_dropped", { dropped_count: dropped });
+        await sender2.flush();
+      });
+    },
+    async setEnabled(enabled) {
+      forcedDisabled = !enabled;
+      await enqueueOperation(async () => {
+        if (!enabled) await queue.clear();
+      });
+    },
+    start() {
+      if (timer) return;
+      timer = setInterval(() => {
+        void coordinator.flushNow();
+      }, options.flushIntervalMs ?? USAGE_ANALYTICS_FLUSH_INTERVAL_MS);
+      timer.unref?.();
+    },
+    dispose() {
+      if (timer) clearInterval(timer);
+      timer = null;
+    },
+    peekQueue(limit) {
+      return queue.readBatch(limit);
+    }
+  };
+  return coordinator;
+}
+const USAGE_ANALYTICS_IDENTITY_FILE = "identity.json";
+function createUsageAnalyticsIdentity(options) {
+  const path = join(options.dir, USAGE_ANALYTICS_IDENTITY_FILE);
+  let pending = null;
+  const resolveInstallId = async () => {
+    try {
+      const parsed = JSON.parse(await readFile(path, "utf8"));
+      if (typeof parsed.installId === "string" && parsed.installId.length > 0) return parsed.installId;
+    } catch {
+    }
+    const installId = randomUUID();
+    try {
+      await mkdir(options.dir, { recursive: true, mode: 448 });
+      await writeFile(path, JSON.stringify({ installId }), { mode: 384 });
+    } catch {
+    }
+    return installId;
+  };
+  const getInstallId = () => {
+    if (!pending) {
+      pending = resolveInstallId();
+      void pending.catch(() => {
+        pending = null;
+      });
+    }
+    return pending;
+  };
+  return {
+    getInstallId,
+    async getDistinctId() {
+      try {
+        const userId = await options.loadUserId();
+        if (userId && !isDemoAnalyticsUserId(userId)) return userId;
+      } catch {
+      }
+      return getInstallId();
+    }
+  };
+}
+async function flushUsageAnalyticsWithin(flush, timeoutMs) {
+  let timer;
+  await Promise.race([
+    flush().catch(() => {
+    }),
+    new Promise((resolve) => {
+      timer = setTimeout(resolve, timeoutMs);
+    })
+  ]);
+  if (timer) clearTimeout(timer);
+}
+function createNodeUsageAnalytics(options) {
+  const identity = createUsageAnalyticsIdentity({ dir: options.dir, loadUserId: async () => null });
+  const coordinator = createUsageAnalyticsCoordinator({
+    dir: options.dir,
+    senderConfig: options.senderConfig,
+    commonProperties: buildUsageCommonProperties({
+      service: options.service,
+      appVersion: options.appVersion,
+      platform: options.platform
+    }),
+    getDistinctId: () => identity.getInstallId(),
+    getInstallId: () => identity.getInstallId(),
+    isEnabled: options.isEnabled,
+    ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
+  });
+  return {
+    record: (name, props = {}) => coordinator.record(name, props),
+    async start() {
+      coordinator.start();
+      await coordinator.record("app_started", {});
+    },
+    async flush() {
+      coordinator.dispose();
+      await coordinator.flushNow();
+    },
+    setEnabled: (enabled) => coordinator.setEnabled(enabled),
+    peekQueue: (limit) => coordinator.peekQueue(limit)
+  };
+}
+function resolvePublicPostHogConfig(input) {
+  const token = input.token?.trim() ?? "";
+  if (!token.startsWith("phc_")) return null;
+  return { token, host: input.host?.trim() || "https://us.i.posthog.com" };
+}
+let analytics = null;
+const CLI_USAGE_ANALYTICS_FLUSH_TIMEOUT_MS = 1500;
+async function initializeCliUsageAnalytics(options = {}) {
+  const homeDir = options.homeDir ?? homedir();
+  const env = options.env ?? process.env;
+  const builtHost = "https://us.i.posthog.com";
+  analytics = createNodeUsageAnalytics({
+    dir: join(homeDir, ".saycode", "usage-analytics"),
+    service: "saycode_cli",
+    appVersion: manifest.version,
+    platform: platform(),
+    senderConfig: resolvePublicPostHogConfig({
+      token: env.APLUS_POSTHOG_TOKEN,
+      host: builtHost
+    }),
+    isEnabled: async () => readConfig(homeDir).usageAnalyticsEnabled !== false
+  });
+  if (readConfig(homeDir).usageAnalyticsEnabled === false) await analytics.setEnabled(false).catch(() => {
+  });
+  await analytics.start().catch(() => {
+  });
+}
+async function recordCliUsage(name, props = {}) {
+  await analytics?.record(name, props).catch(() => {
+  });
+}
+async function flushCliUsageAnalytics() {
+  const current = analytics;
+  analytics = null;
+  if (!current) return;
+  await flushUsageAnalyticsWithin(() => current.flush(), CLI_USAGE_ANALYTICS_FLUSH_TIMEOUT_MS);
+}
 const DETACH_COMMAND = "/detach";
 async function spawnSession(transport, machineId, directory, agent) {
   const result = await transport.rpc(machineId, "spawn-happy-session", { directory, agent }, 6e4);
@@ -24312,31 +25944,15 @@ async function spawnSession(transport, machineId, directory, agent) {
   }
   return result.sessionId;
 }
-function ask(rl, question, state) {
-  if (state.closed) return Promise.resolve(null);
-  return new Promise((resolve) => {
-    const onClose = () => resolve(null);
-    rl.once("close", onClose);
-    rl.question(question, (answer) => {
-      rl.off("close", onClose);
-      resolve(answer);
-    });
-  });
-}
-function readSingleKey(rl, input) {
-  rl.pause();
-  const wasRaw = input.isRaw === true;
-  if (input.isTTY) input.setRawMode(true);
-  input.resume();
-  return new Promise((resolve) => {
-    const onData = (chunk) => {
-      input.off("data", onData);
-      if (input.isTTY) input.setRawMode(wasRaw);
-      rl.resume();
-      resolve(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
-    };
-    input.on("data", onData);
-  });
+async function askTemporaryLine(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const input = new ChatInputController(rl, process.stdin);
+  try {
+    return await input.ask(question);
+  } finally {
+    input.close();
+    rl.close();
+  }
 }
 async function replyToPermission(transport, sessionId, request, answer) {
   const approved = answer !== "deny";
@@ -24347,12 +25963,8 @@ async function replyToPermission(transport, sessionId, request, answer) {
     ...answer === "approve-always" ? { mode: "bypassPermissions" } : {}
   });
 }
-async function sendPrompt(context, sessionId, text2) {
-  const content = {
-    role: "user",
-    content: { type: "text", text: text2 },
-    meta: { permissionMode: "default" }
-  };
+async function sendPrompt(context, sessionId, text2, options) {
+  const content = options ? buildCliUserMessage(text2, options) : { role: "user", content: { type: "text", text: text2 }, meta: { permissionMode: "default" } };
   const key = new Uint8Array(Buffer.from(context.syncCredential.secret, "base64"));
   const localId = `saycode-cli-${process.pid}-${Math.random().toString(36).slice(2)}`;
   await context.rest.sendMessage(sessionId, localId, encodeMessageContent(content, key));
@@ -24401,7 +26013,7 @@ async function resolveSpawnTarget(context, options) {
     if (!project.workspaceDir) {
       throw new CliError(`Project "${project.name}" has no working directory recorded. Use -m and -d instead.`);
     }
-    return { machineId: project.machineId, directory: project.workspaceDir };
+    return { machineId: project.machineId, directory: project.workspaceDir, project };
   }
   if (!options.machine || !options.directory) {
     throw new CliError("Starting a session needs either -p <project> or both -m <machine> and -d <directory>.");
@@ -24410,124 +26022,241 @@ async function resolveSpawnTarget(context, options) {
 }
 async function runChat(context, options, providedTransport) {
   const resuming = !!options.sessionId;
-  const target = resuming ? null : await resolveSpawnTarget(context, options);
-  return withTransport(context, async (transport) => {
-    const sessionId = options.sessionId ?? await spawnSession(transport, target.machineId, target.directory, options.agent);
-    context.out.raw(`Session ${sessionId}`);
-    context.out.raw("While working: Ctrl+C for options (keep watching · detach · stop).");
-    context.out.raw("At the prompt: /detach to leave with the agent still running · /exit to leave.\n");
-    const chat = new ChatSession();
-    const answered = /* @__PURE__ */ new Set();
-    const ownLocalIds = /* @__PURE__ */ new Set();
-    const seenThroughSeq = await prerollHistory(
-      context,
-      transport,
-      sessionId,
-      resumeHistoryCount({ resuming, ...options.since !== void 0 ? { since: options.since } : {} })
-    );
-    const stopFollowing = followSession({
-      context,
-      transport,
-      sessionId,
-      seenThroughSeq,
-      ownLocalIds,
-      onContent: (content) => {
-        printContent(context, content);
-        chat.apply({ type: "content", content });
-      },
-      onUpdate: (update) => {
-        const cipher = readSessionAgentState(update, sessionId);
-        if (!cipher) return;
-        let decoded;
+  let optionPrompter = null;
+  let optionInput = null;
+  if (!resuming && options.promptForOptions) {
+    optionPrompter = createInterface({ input: process.stdin, output: process.stdout });
+    optionInput = new ChatInputController(optionPrompter, process.stdin);
+  }
+  const newConversationOptions = resuming ? null : await resolveCliNewConversationOptions(
+    options,
+    optionInput ? (question) => optionInput.ask(question) : void 0
+  ).finally(() => {
+    optionInput?.close();
+    optionPrompter?.close();
+  });
+  if (newConversationOptions?.voice && process.stdin.isTTY !== true) {
+    throw new CliError("Live voice capture needs a TTY. Use `--voice-file <audio>` for piped or redirected input.");
+  }
+  let target = resuming ? null : await resolveSpawnTarget(context, options);
+  let createdWorktree = null;
+  if (target && newConversationOptions?.useWorktree) {
+    if (!target.project) throw new CliError("An isolated worktree needs a project target. Use `saycode chat -p <project>`.");
+    if (!context.hasApiAccess) throw new CliError("Creating a worktree needs a Saycode account login. Run `saycode login`.");
+    createdWorktree = await createCliProjectWorktree({
+      projectId: target.project.id,
+      machineId: target.machineId,
+      projectRoot: target.directory,
+      name: resolveWorktreeName({ requested: newConversationOptions.worktreeName }),
+      baseRef: newConversationOptions.worktreeBaseRef
+    }, {
+      create: (projectId, input) => context.rest.createProjectWorktree(projectId, input),
+      remove: (projectId, worktreeId, force) => context.rest.deleteProjectWorktree(projectId, worktreeId, force),
+      confirmSubdir: async (request) => {
+        if (process.stdin.isTTY !== true) return false;
+        const answer = await askTemporaryLine(`Project is ${request.repoRelativeDir} inside ${request.repoRoot}. Create the worktree for the whole repository? [y/N]: `);
+        return answer?.trim().toLowerCase() === "y" || answer?.trim().toLowerCase() === "yes";
+      }
+    });
+    target = { ...target, directory: createdWorktree.path };
+  }
+  let sessionSpawned = false;
+  try {
+    return await withTransport(context, async (transport) => {
+      const sessionId = options.sessionId ?? await spawnSession(
+        transport,
+        target.machineId,
+        target.directory,
+        newConversationOptions?.agent ?? options.agent
+      );
+      sessionSpawned = true;
+      if (!resuming) await recordCliUsage("session_created");
+      if (!resuming && target?.project) {
         try {
-          decoded = transport.decodePayload(cipher);
-        } catch {
-          return;
-        }
-        for (const request of pendingPermissionRequestsFromState(decoded)) {
-          if (answered.has(request.requestId)) continue;
-          chat.apply({ type: "permission-requested", request });
+          await context.rest.assignSessionToProject(target.project.id, sessionId, createdWorktree?.id);
+        } catch (error) {
+          context.out.raw(`! Session started, but project assignment failed: ${error instanceof Error ? error.message : String(error)}`);
         }
       }
-    });
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    const stdinState = { closed: false };
-    rl.once("close", () => {
-      stdinState.closed = true;
-    });
-    rl.on("line", (raw) => {
-      if (raw.trim() === DETACH_COMMAND) chat.detach();
-    });
-    let menuOpen = false;
-    const onSigint = () => {
-      if (interruptDecision(chat.current) === "exit-cli") {
-        context.out.raw(`
+      context.out.raw(`Session ${sessionId}`);
+      context.out.raw("During a response, typing is locked. Ctrl+C opens response options.");
+      context.out.raw("At the prompt: /voice to dictate · /detach to leave with the agent still running · /exit to leave.\n");
+      const chat = new ChatSession();
+      const renderer = createSessionEventRenderer(terminalContentWidth(process.stdout.columns));
+      const answered = /* @__PURE__ */ new Set();
+      const ownLocalIds = /* @__PURE__ */ new Set();
+      let pendingFilePaths = [...newConversationOptions?.files ?? []];
+      let pendingVoice = newConversationOptions?.voiceFile ?? (newConversationOptions?.voice ? true : null);
+      const seenThroughSeq = await prerollHistory(
+        context,
+        transport,
+        sessionId,
+        resumeHistoryCount({ resuming, ...options.since !== void 0 ? { since: options.since } : {} }),
+        (content) => chat.apply({ type: "content", content }),
+        renderer
+      );
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const input = new ChatInputController(rl, process.stdin);
+      let menuOpen = false;
+      const onSigint = () => {
+        if (interruptDecision(chat.current) === "exit-cli") {
+          context.out.raw(`
 Leaving. Reattach with \`saycode chat -s ${sessionId}\`.`);
-        rl.close();
-        process.exit(0);
-      }
-      if (menuOpen) return;
-      menuOpen = true;
-      context.out.raw("\n^C  [Enter] keep watching · [d] detach, agent keeps working · [s] stop the response");
-      void readSingleKey(rl, process.stdin).then((key) => {
-        menuOpen = false;
-        const choice = interruptMenuChoice(key);
-        if (choice === "detach") {
-          chat.detach();
-          return;
+          rl.close();
+          process.exit(0);
         }
-        if (choice === "stop") {
-          context.out.raw("Stopping the response…");
-          void transport.rpc(sessionId, "abort", {}).catch(() => void 0);
-          return;
+        if (menuOpen) return;
+        menuOpen = true;
+        context.out.raw("\n^C  [Enter] keep watching · [d] detach, agent keeps working · [s] stop the response");
+        void input.readKey().then((key) => {
+          menuOpen = false;
+          const choice = interruptMenuChoice(key);
+          if (choice === "detach") {
+            chat.detach();
+            return;
+          }
+          if (choice === "stop") {
+            context.out.raw("Stopping the response…");
+            void transport.rpc(sessionId, "abort", {}).catch(() => void 0);
+            return;
+          }
+          context.out.raw("…still working.");
+        });
+      };
+      const stopFollowing = followSession({
+        context,
+        transport,
+        sessionId,
+        seenThroughSeq,
+        ownLocalIds,
+        renderer,
+        onContent: (content) => {
+          printContent(context, content, renderer);
+          chat.apply({ type: "content", content });
+          if (chat.current.phase === "responding") input.lock(onSigint);
+        },
+        onUpdate: (update) => {
+          const cipher = readSessionAgentState(update, sessionId);
+          if (!cipher) return;
+          let decoded;
+          try {
+            decoded = transport.decodePayload(cipher);
+          } catch {
+            return;
+          }
+          for (const request of pendingPermissionRequestsFromState(decoded)) {
+            if (answered.has(request.requestId)) continue;
+            chat.apply({ type: "permission-requested", request });
+            input.cancelQuestion();
+          }
         }
-        context.out.raw("…still working.");
       });
-    };
-    process.on("SIGINT", onSigint);
-    let outcome = "exited";
-    try {
-      for (; ; ) {
-        const line = await ask(rl, "› ", stdinState);
-        if (line === null) break;
-        const prompt = line.trim();
-        if (prompt === "/exit" || prompt === "/quit") break;
-        if (prompt === DETACH_COMMAND) {
-          outcome = "detached";
-          break;
-        }
-        if (prompt === "") continue;
-        ownLocalIds.add(await sendPrompt(context, sessionId, prompt));
-        chat.apply({ type: "message-sent" });
-        context.out.line({ style: "thinking", text: "⏳ working — Ctrl+C for options" });
+      process.on("SIGINT", onSigint);
+      let outcome = "exited";
+      try {
         for (; ; ) {
-          const state = await chat.waitForAttention();
-          if (chat.isDetached) break;
-          if (state.phase !== "awaiting-permission" || !state.pendingPermission) break;
-          const request = state.pendingPermission;
-          let answer = parsePermissionAnswer(await ask(rl, `${permissionPromptText(request)} `, stdinState) ?? "n");
-          while (answer === "unknown") {
-            answer = parsePermissionAnswer(await ask(rl, "Please answer y, n, or a. ", stdinState) ?? "n");
+          if (chat.current.phase !== "idle") {
+            if (chat.current.phase === "responding") {
+              context.out.line({ style: "thinking", text: chatPresentation(chat.current).status });
+              input.lock(onSigint);
+            }
+            for (; ; ) {
+              const state = await chat.waitForAttention();
+              if (chat.isDetached) break;
+              if (state.phase !== "awaiting-permission" || !state.pendingPermission) break;
+              const request = state.pendingPermission;
+              context.out.line({ style: "tool", text: chatPresentation(state).status });
+              let answer = parsePermissionAnswer(await input.ask(`${permissionPromptText(request)} `) ?? "n");
+              while (answer === "unknown") {
+                answer = parsePermissionAnswer(await input.ask("Please answer y, n, or a. ") ?? "n");
+              }
+              answered.add(request.requestId);
+              await replyToPermission(transport, sessionId, request, answer);
+              chat.apply({ type: "permission-answered" });
+              context.out.line({ style: "thinking", text: chatPresentation(chat.current).status });
+              input.lock(onSigint);
+            }
+            if (chat.isDetached) {
+              outcome = "detached";
+              break;
+            }
+            continue;
           }
-          answered.add(request.requestId);
-          await replyToPermission(transport, sessionId, request, answer);
-          chat.apply({ type: "permission-answered" });
-        }
-        if (chat.isDetached) {
-          outcome = "detached";
-          break;
+          const ready = chatPresentation(chat.current);
+          context.out.line({ style: "status", text: ready.status });
+          let prompt = "";
+          if (pendingVoice) {
+            const voiceFile = typeof pendingVoice === "string" ? pendingVoice : null;
+            pendingVoice = null;
+            try {
+              prompt = await captureCliVoicePrompt(context, voiceFile, async () => {
+                await input.ask("Press Enter to stop recording. ");
+              });
+              context.out.raw(`Transcript: ${prompt}`);
+            } catch (error) {
+              context.out.raw(`Voice input failed: ${error instanceof Error ? error.message : String(error)}`);
+              continue;
+            }
+          } else {
+            const line = await input.ask(ready.prompt);
+            if (line === null) {
+              if (chat.current.phase !== "idle") continue;
+              break;
+            }
+            prompt = line.trim();
+          }
+          if (prompt === "/exit" || prompt === "/quit") break;
+          if (prompt === DETACH_COMMAND) {
+            outcome = "detached";
+            break;
+          }
+          if (prompt === "/voice" || prompt.startsWith("/voice ")) {
+            const voiceFile = prompt.slice("/voice".length).trim() || null;
+            try {
+              prompt = await captureCliVoicePrompt(context, voiceFile, async () => {
+                await input.ask("Press Enter to stop recording. ");
+              });
+              context.out.raw(`Transcript: ${prompt}`);
+            } catch (error) {
+              context.out.raw(`Voice input failed: ${error instanceof Error ? error.message : String(error)}`);
+              continue;
+            }
+          }
+          if (pendingFilePaths.length > 0) {
+            try {
+              const files = [];
+              for (const path of pendingFilePaths) files.push(await loadCliAttachment(path));
+              prompt = await prepareCliMessageWithAttachments(prompt, files, (file) => uploadCliAttachment(transport, target.machineId, target.directory, file));
+              pendingFilePaths = [];
+            } catch (error) {
+              pendingFilePaths = [];
+              context.out.raw(`Attachment failed: ${error instanceof Error ? error.message : String(error)}`);
+              continue;
+            }
+          }
+          if (prompt === "") continue;
+          chat.apply({ type: "message-sent" });
+          input.lock(onSigint);
+          ownLocalIds.add(await sendPrompt(context, sessionId, prompt, newConversationOptions));
+          await recordCliUsage("message_sent");
         }
+      } finally {
+        stopFollowing();
+        process.off("SIGINT", onSigint);
+        input.close();
+        rl.close();
       }
-    } finally {
-      stopFollowing();
-      process.off("SIGINT", onSigint);
-      rl.close();
-    }
-    context.out.raw(outcome === "detached" ? `
+      context.out.raw(outcome === "detached" ? `
 Detached — the session keeps running. Reattach with \`saycode chat -s ${sessionId}\`.` : `
 Leaving. Reattach with \`saycode chat -s ${sessionId}\`.`);
-    return outcome;
-  }, providedTransport);
+      return outcome;
+    }, providedTransport);
+  } catch (error) {
+    if (createdWorktree && !sessionSpawned && target?.project) {
+      await context.rest.deleteProjectWorktree(target.project.id, createdWorktree.id, true).catch(() => void 0);
+    }
+    throw error;
+  }
 }
 const ESC = "\x1B";
 const CTRL_C = "";
@@ -24999,7 +26728,7 @@ async function runBrowse(context) {
         try {
           if (isNewConversation(chosen.id)) {
             const projectId = selectedId(state, "project");
-            await runChat(context, { project: projectId, agent: "claude" }, transports2.get(context.syncCredential));
+            await runChat(context, { project: projectId, agent: "claude", promptForOptions: true }, transports2.get(context.syncCredential));
           } else {
             await runChat(context, { sessionId: chosen.id, agent: "claude" }, transports2.get(context.syncCredential));
           }
@@ -25060,14 +26789,17 @@ async function contextFor(workspace) {
   return context;
 }
 async function main(argv) {
+  await initializeCliUsageAnalytics();
   const parsed = parseArgs(argv, process.stdout.isTTY === true && process.stdin.isTTY === true);
   const out = createWriter();
   switch (parsed.command) {
     case "help":
       out.raw(HELP_TEXT);
+      await recordCliUsage("command_completed", { action: "help" });
       return 0;
     case "version":
       out.raw(manifest.version);
+      await recordCliUsage("command_completed", { action: "version" });
       return 0;
     case "error":
       process.stderr.write(`saycode: ${parsed.message}
@@ -25077,36 +26809,47 @@ Run \`saycode --help\` for usage.
       return 2;
     case "login":
       await runLogin(out);
+      await recordCliUsage("login_success");
+      await recordCliUsage("command_completed", { action: "login" });
       return 0;
     case "logout":
       runLogout(out);
+      await recordCliUsage("logout");
+      await recordCliUsage("command_completed", { action: "logout" });
       return 0;
     case "workspaces":
       await runWorkspaces(loadContext(), { ...parsed.use ? { use: parsed.use } : {} });
+      await recordCliUsage("command_completed", { action: "workspaces" });
       return 0;
     case "browse":
       await runBrowse(await contextFor(parsed.workspace));
+      await recordCliUsage("command_completed", { action: "browse" });
       return 0;
     case "machines":
       await runMachines(await contextFor(parsed.workspace));
+      await recordCliUsage("command_completed", { action: "machines" });
       return 0;
     case "projects":
       await runProjects(await contextFor(parsed.workspace), {
         ...parsed.machine ? { machine: parsed.machine } : {}
       });
+      await recordCliUsage("command_completed", { action: "projects" });
       return 0;
     case "ls":
       if (parsed.project) {
         await runProjectConversations(await contextFor(parsed.workspace), parsed.project, parsed.all);
+        await recordCliUsage("command_completed", { action: "ls" });
         return 0;
       }
       await runLs(await contextFor(parsed.workspace), {
         ...parsed.machine ? { machine: parsed.machine } : {},
         all: parsed.all
       });
+      await recordCliUsage("command_completed", { action: "ls" });
       return 0;
     case "attach":
       await runAttach(await contextFor(parsed.workspace), { sessionId: parsed.sessionId, since: parsed.since });
+      await recordCliUsage("command_completed", { action: "attach" });
       return 0;
     case "chat":
       await runChat(await contextFor(parsed.workspace), {
@@ -25115,21 +26858,37 @@ Run \`saycode --help\` for usage.
         ...parsed.directory ? { directory: parsed.directory } : {},
         ...parsed.project ? { project: parsed.project } : {},
         ...parsed.since !== void 0 ? { since: parsed.since } : {},
+        ...parsed.model !== void 0 ? { model: parsed.model } : {},
+        ...parsed.effort !== void 0 ? { effort: parsed.effort } : {},
+        ...parsed.useWorktree ? { useWorktree: true } : {},
+        ...parsed.worktreeName !== void 0 ? { worktreeName: parsed.worktreeName } : {},
+        ...parsed.worktreeBaseRef !== void 0 ? { worktreeBaseRef: parsed.worktreeBaseRef } : {},
+        ...parsed.files ? { files: parsed.files } : {},
+        ...parsed.voice ? { voice: true } : {},
+        ...parsed.voiceFile !== void 0 ? { voiceFile: parsed.voiceFile } : {},
+        ...parsed.promptForOptions ? { promptForOptions: true } : {},
         agent: parsed.agent
       });
+      await recordCliUsage("command_completed", { action: "chat" });
       return 0;
     case "watch":
       await runWatch(await contextFor(parsed.workspace), { intervalSeconds: parsed.intervalSeconds });
+      await recordCliUsage("command_completed", { action: "watch" });
       return 0;
   }
 }
-main(process.argv.slice(2)).then((code) => process.exit(code)).catch((error) => {
+main(process.argv.slice(2)).then(async (code) => {
+  await flushCliUsageAnalytics();
+  process.exit(code);
+}).catch(async (error) => {
   if (error instanceof CliError) {
     process.stderr.write(`${error.message}
 `);
+    await flushCliUsageAnalytics();
     process.exit(2);
   }
   process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}
 `);
+  await flushCliUsageAnalytics();
   process.exit(1);
 });