@buzzni/saycode-cli 0.1.1 → 0.1.2

package/README.md

@@ -103,15 +103,22 @@ saycode chat -s <session>         # 기존 세션 이어서 대화 (직전 20개
 
 ## 대화에서 나가기
 
-에이전트가 작업 중일 때 **`Ctrl+C`를 누르면 선택지가 뜹니다.**
+채팅 하단 상태가 현재 입력 가능 여부를 그대로 나타냅니다.
 
 ```
-⏳ working — Ctrl+C for options
+● Ready — you can type
+› 다음 작업을 진행해줘
+● Agent is responding — input locked · Ctrl+C for options
 ⏺ Bash(npm test)
   │ running tests...
 ^C  [Enter] keep watching · [d] detach, agent keeps working · [s] stop the response
 ```
 
+`Agent is responding` 동안 stdin은 raw/no-echo로 잠겨 일반 문자와 Enter가 화면에 나타나거나 다음
+프롬프트에 쌓이지 않습니다. 권한 요청 때만 `◆ Action required — permission response only`로 바뀌고
+해당 선택 입력을 받습니다. 에이전트 턴이 끝나 `Ready`가 표시된 뒤에만 일반 프롬프트가 열립니다.
+
+에이전트가 작업 중일 때 **`Ctrl+C`를 누르면 선택지가 뜹니다.**
 한 글자만 누르면 됩니다 (Enter 불필요). `Ctrl+C`를 한 번 더 누르면 `d`와 같습니다 —
 반복해서 누르는 건 "빨리 나가자"는 뜻이고, 나가는 건 되돌릴 수 있지만 작업을 죽이는 건
 되돌릴 수 없기 때문입니다.
@@ -128,9 +135,17 @@ saycode chat -s <session>         # 기존 세션 이어서 대화 (직전 20개
 **어느 경우에도 원격 세션은 죽지 않습니다.** 데스크탑이나 다른 터미널에서 하던 작업을
 CLI를 닫았다는 이유로 파괴하지 않습니다.
 
-응답이 오래 걸릴 때 `/detach`로 빠져나와 `saycode watch`로 진행만 지켜보다가,
+응답이 오래 걸릴 때 `Ctrl+C` → `d`로 빠져나와 `saycode watch`로 진행만 지켜보다가,
 끝나면 `saycode chat -s <id>`로 돌아오는 흐름을 의도했습니다.
 
+## 답변 표시
+
+에이전트 답변의 제목·목록·인용·굵게·기울임·취소선·인라인 코드·링크·fenced code block을
+터미널 표현으로 바꾸고, 현재 터미널 폭에서 좌우 여백을 뺀 최대 100열로 줄바꿈합니다. 한글과
+emoji의 표시 폭도 반영합니다. 링크는 파이프 출력에서도 목적지를 잃지 않도록 URL을 함께 남깁니다.
+긴 도구 stdout은 첫 3줄까지만 표시하고 종료 시 생략한 줄 수와 마지막 줄을 요약하며, stderr는
+숨기지 않습니다. `NO_COLOR`이거나 파이프로 출력해도 `◆`, `•`, `│`, `┌─` 같은 구조 표시는 남습니다.
+
 ## 권한 승인
 
 에이전트가 권한을 요청하면 인라인으로 물어봅니다.
@@ -154,11 +169,11 @@ GitHub Actions 가 태그로 발행합니다 (`.github/workflows/publish-saycode
 
 ```bash
 # 1. 버전 올리기 — 데스크탑 앱 버전과 무관합니다
-vi cli/manifest.json          # "version": "0.1.1"
+vi cli/manifest.json          # "version": "0.1.2"
 
 # 2. 커밋하고 태그를 밀면 끝
-git tag saycode-cli-v0.1.1
-git push origin saycode-cli-v0.1.1
+git tag saycode-cli-v0.1.2
+git push origin saycode-cli-v0.1.2
 ```
 
 워크플로는 발행 전에 이 순서로 막습니다:

package/index.mjs

@@ -37,7 +37,7 @@ function _mergeNamespaces(n, m) {
   }
   return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
 }
-const version = "0.1.1";
+const version = "0.1.2";
 const manifest = {
   version
 };
@@ -23565,7 +23565,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 ?? [];
   }
@@ -23625,17 +23625,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 +23871,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 +24058,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 +24066,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 +24107,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);
+  }
+  flush() {
+    return this.markdown.flush();
   }
-  if (content.role === "session") {
-    return renderSessionEvent(content.content.ev, content.content.role);
+  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];
   }
-  return [];
+}
+function createSessionEventRenderer(width = 100) {
+  return new SessionEventRenderer(width);
 }
 function record(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
@@ -23952,10 +24172,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 +24184,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 +24221,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 +24257,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 +24308,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;
@@ -24312,32 +24659,6 @@ 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 replyToPermission(transport, sessionId, request, answer) {
   const approved = answer !== "deny";
   await transport.rpc(sessionId, "permission", {
@@ -24414,50 +24735,22 @@ async function runChat(context, options, providedTransport) {
   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("During a response, typing is locked. Ctrl+C opens response options.");
     context.out.raw("At the prompt: /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();
     const seenThroughSeq = await prerollHistory(
       context,
       transport,
       sessionId,
-      resumeHistoryCount({ resuming, ...options.since !== void 0 ? { since: options.since } : {} })
+      resumeHistoryCount({ resuming, ...options.since !== void 0 ? { since: options.since } : {} }),
+      (content) => chat.apply({ type: "content", content }),
+      renderer
     );
-    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;
-        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 });
-        }
-      }
-    });
     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();
-    });
+    const input = new ChatInputController(rl, process.stdin);
     let menuOpen = false;
     const onSigint = () => {
       if (interruptDecision(chat.current) === "exit-cli") {
@@ -24469,7 +24762,7 @@ Leaving. Reattach with \`saycode chat -s ${sessionId}\`.`);
       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) => {
+      void input.readKey().then((key) => {
         menuOpen = false;
         const choice = interruptMenuChoice(key);
         if (choice === "detach") {
@@ -24484,12 +24777,72 @@ Leaving. Reattach with \`saycode chat -s ${sessionId}\`.`);
         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();
+        }
+      }
+    });
     process.on("SIGINT", onSigint);
     let outcome = "exited";
     try {
       for (; ; ) {
-        const line = await ask(rl, "› ", stdinState);
-        if (line === null) break;
+        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;
+        }
+        const ready = chatPresentation(chat.current);
+        context.out.line({ style: "status", text: ready.status });
+        const line = await input.ask(ready.prompt);
+        if (line === null) {
+          if (chat.current.phase !== "idle") continue;
+          break;
+        }
         const prompt = line.trim();
         if (prompt === "/exit" || prompt === "/quit") break;
         if (prompt === DETACH_COMMAND) {
@@ -24497,30 +24850,14 @@ Leaving. Reattach with \`saycode chat -s ${sessionId}\`.`);
           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" });
-        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");
-          }
-          answered.add(request.requestId);
-          await replyToPermission(transport, sessionId, request, answer);
-          chat.apply({ type: "permission-answered" });
-        }
-        if (chat.isDetached) {
-          outcome = "detached";
-          break;
-        }
+        input.lock(onSigint);
+        ownLocalIds.add(await sendPrompt(context, sessionId, prompt));
       }
     } finally {
       stopFollowing();
       process.off("SIGINT", onSigint);
+      input.close();
       rl.close();
     }
     context.out.raw(outcome === "detached" ? `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buzzni/saycode-cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Drive Saycode sessions across your machines from the terminal.",
   "type": "module",
   "bin": {