@ocis/myagent-cli 0.2.0 → 0.2.2

package/README.md

@@ -36,15 +36,15 @@ local repo (cwd)                                  remote myagent
 ## Install
 
 ```bash
-npm install -g @ocis/myagent-cli   # global (Node ≥22.19)
-bunx @ocis/myagent-cli             # one-off, no install (Bun)
+bunx @ocis/myagent-cli             # one-off, no install
+npm install -g @ocis/myagent-cli   # global
 ```
 
-The CLI runs on **Node.js ≥22.19** or **Bun ≥1.0** — it detects the runtime it was
-launched with. The published bin uses a Node shebang, so `bun install -g` also runs
-it under Node; use `bunx` (or `bun <path-to-bin>`) to run it on Bun. Configure
-credentials with `myagent config`, or set `MYAGENT_BASE_URL` /
-`MYAGENT_INTEGRATION_ID` / `MYAGENT_API_KEY`.
+The CLI runs on **Bun ≥1.0** or **Node.js ≥22.19**. The published bin is a small
+launcher that prefers Bun and falls back to Node, so `bunx` and `npm install -g`
+both work with whichever runtime you have. Configure credentials with
+`myagent config`, or set `MYAGENT_BASE_URL` / `MYAGENT_INTEGRATION_ID` /
+`MYAGENT_API_KEY`.
 
 ## Plan / Coding / Cowork modes
 

package/bin/myagent.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+// Runtime launcher for the myagent CLI.
+//
+// dist/index.js runs on Bun or Node >= 22.19, but a bin shebang names exactly
+// one interpreter — and `bunx` honors it, so a plain Node shebang would run
+// the CLI under whatever Node happens to be on PATH (often too old for
+// pi-tui). This wrapper prefers Bun and falls back to Node.
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const entry = fileURLToPath(new URL("../dist/index.js", import.meta.url));
+const args = process.argv.slice(2);
+
+// Ctrl+C reaches the whole foreground process group, so the CLI handles it
+// itself; the launcher must not exit before that shutdown finishes. SIGTERM /
+// SIGHUP sent to the launcher PID alone are forwarded.
+process.on("SIGINT", () => {});
+
+let child;
+for (const sig of ["SIGTERM", "SIGHUP"]) {
+  process.on(sig, () => { try { child?.kill(sig); } catch { /* already gone */ } });
+}
+
+/** pi-tui's regex needs the `v` flag, which Node only has from 22.19. */
+function nodeTooOld() {
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  return major < 22 || (major === 22 && minor < 19);
+}
+
+function launch(runtime) {
+  child = spawn(runtime, [entry, ...args], { stdio: "inherit" });
+
+  child.once("error", (err) => {
+    if (err.code === "ENOENT" && runtime !== process.execPath) {
+      if (nodeTooOld()) {
+        console.error(
+          `myagent requires Bun or Node.js >= 22.19 (found Node ${process.versions.node}).\n` +
+            "Install Bun: https://bun.sh",
+        );
+        process.exit(1);
+      }
+      launch(process.execPath);
+      return;
+    }
+    console.error(`myagent: failed to start ${runtime}: ${err.message}`);
+    process.exit(1);
+  });
+
+  child.once("exit", (code) => process.exit(code ?? 1));
+}
+
+launch("bun");

package/dist/agent/sessions.js

@@ -5,9 +5,8 @@
 // remembers which thread belongs to which working directory so `-c`/`-r`
 // resume the right conversation. Never contains credentials.
 // ---------------------------------------------------------------------------
-import { mkdir, rename } from "node:fs/promises";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { fileExists, readJsonFile, writeFile } from "../runtime.js";
 export class SessionIndex {
     path;
     data;
@@ -17,9 +16,7 @@ export class SessionIndex {
     }
     static async load(path) {
         try {
-            if (!(await fileExists(path)))
-                return new SessionIndex(path);
-            const parsed = await readJsonFile(path);
+            const parsed = JSON.parse(await readFile(path, "utf8"));
             if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
                 return new SessionIndex(path);
             // Normalize instead of trusting the persisted shape: a truncated write

package/dist/agent/turn.js

@@ -850,6 +850,11 @@ export class AgentRunner {
             if (adopted) {
                 live.push({ ...output, tool_call_id: adopted.id });
                 unmatched.delete(adopted.id);
+                // The original id is never submitted (its result was re-attached to
+                // the retry), so it must leave the pending set — otherwise the run-end
+                // sweep announces a release for a call that was answered.
+                if (call)
+                    this.pendingSubmission.delete(call.id);
                 cb.onNotice(`Re-attached the result of ${call?.name ?? "a tool call"} to the agent's retry.`, "info");
                 continue;
             }

package/dist/approval/policy.js

@@ -142,7 +142,7 @@ export class ApprovalPolicy {
         try {
             // A cancel/timeout while queued settles immediately — no card, no wait.
             if (wait)
-                await Promise.race([previous.catch(() => { }), deadline.promise]);
+                await Promise.race([previous, deadline.promise]);
             if (settled)
                 return await deadline.promise;
             return await Promise.race([this.prompt(request, controller.signal), deadline.promise]);

package/dist/config.js

@@ -7,8 +7,7 @@
 // -------------------------------------------------------------------
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { mkdir, chmod, rename, stat } from "node:fs/promises";
-import { fileExists, readJsonFile, writeFile } from "./runtime.js";
+import { mkdir, chmod, readFile, rename, stat, writeFile } from "node:fs/promises";
 export const EMPTY_CONFIG = {
     baseUrl: "",
     integrationId: "",
@@ -54,10 +53,7 @@ export async function migrateLegacyConfigDir() {
 }
 export async function loadConfig() {
     try {
-        const path = configPath();
-        if (!(await fileExists(path)))
-            return { ...EMPTY_CONFIG };
-        const data = await readJsonFile(path);
+        const data = JSON.parse(await readFile(configPath(), "utf8"));
         const merged = { ...EMPTY_CONFIG, ...data };
         // Legacy field: autoApprove:false used to mean "ask" — honour it once.
         if (data.approvalDefault === undefined && data.autoApprove === false) {

package/dist/git/status.js

@@ -118,7 +118,7 @@ export function mergeGitStatus(porcelain, unstaged, staged) {
 const MAX_GIT_OUTPUT_CHARS = 512 * 1024;
 async function gitOutput(workspace, args, signal, okExitCodes) {
     try {
-        const proc = spawnProcess(["git", "-C", workspace, ...args], { stdout: "pipe", stderr: "ignore", stdin: "ignore" });
+        const proc = spawnProcess(["git", "-C", workspace, ...args], { stdout: "pipe", stderr: "ignore" });
         const onAbort = () => { try {
             proc.kill();
         }

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 import { type StoredConfig } from "./config.js";
 import { type AgentMode } from "./agent/modes.js";
 import { type OutputFormat } from "./headless.js";

package/dist/index.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 // ---------------------------------------------------------------------------
 // myagent CLI — entry point.
 //
@@ -10,7 +9,7 @@ import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import pkg from "../package.json" with { type: "json" };
 import { IntegrationClient } from "./protocol/client.js";
 import { ToolRegistry } from "./tools/registry.js";
 import { combinedIntegrationUrl, configDir, isConfigured, loadConfig, migrateLegacyConfigDir, resolveConfig, saveConfig, sessionsPath, splitIntegrationUrl, } from "./config.js";
@@ -20,20 +19,13 @@ import { runTui } from "./ui/app.js";
 import { failureDoneEvent, failureResult, runHeadless } from "./headless.js";
 import { discoverSkills, formatSkillList, resolveSkillDirs } from "./skills/discovery.js";
 import { sanitizeForTerminal } from "./sanitize.js";
-import { isMainModule, readJsonFile, readStdinText } from "./runtime.js";
+import { isMainModule, readStdinText } from "./runtime.js";
 /**
- * Package version, read from package.json so npm releases never drift from
- * `--version`. Resolves to the package root from both src/ (dev) and dist/.
+ * Package version, bundled from package.json so npm releases and the compiled
+ * binary never drift from `--version` (a runtime read cannot resolve inside
+ * `bun build --compile`'s virtual filesystem).
  */
-async function readVersion() {
-    try {
-        const pkg = await readJsonFile(fileURLToPath(new URL("../package.json", import.meta.url)));
-        return pkg.version ?? "0.0.0";
-    }
-    catch {
-        return "0.0.0";
-    }
-}
+const VERSION = pkg.version;
 const HELP = `myagent — a coding agent for your local repository, powered by MyAgent
 
 Usage:
@@ -305,7 +297,7 @@ async function main() {
         return 0;
     }
     if (args.command === "version") {
-        process.stdout.write(`${await readVersion()}\n`);
+        process.stdout.write(`${VERSION}\n`);
         return 0;
     }
     const stored = await loadConfig();

package/dist/runtime.d.ts

@@ -1,10 +1,3 @@
-export declare const isBun: boolean;
-export declare function fileExists(path: string): Promise<boolean>;
-export declare function readTextFile(path: string): Promise<string>;
-export declare function readJsonFile<T>(path: string): Promise<T>;
-export declare function writeFile(path: string, data: string): Promise<void>;
-/** Resolve an executable on PATH (Bun.which on Bun, a PATH scan on Node). */
-export declare function which(cmd: string): string | null;
 /** Read all of stdin as UTF-8 text. Callers check `process.stdin.isTTY` first. */
 export declare function readStdinText(): Promise<string>;
 /**
@@ -14,25 +7,25 @@ export declare function readStdinText(): Promise<string>;
  * comparing the resolved entry path (realpath, so npm/bun bin symlinks match).
  */
 export declare function isMainModule(meta: ImportMeta): boolean;
-export interface ProcessStdin {
-    write(data: Uint8Array): void;
-    end(): void;
-}
 export interface ProcessHandle {
     pid: number;
     stdout: ReadableStream<Uint8Array>;
     stderr: ReadableStream<Uint8Array>;
-    stdin: ProcessStdin;
     exited: Promise<number>;
     kill(signal?: number | NodeJS.Signals): void;
 }
 export interface SpawnOptions {
     cwd?: string;
-    env?: Record<string, string>;
-    stdin?: "pipe" | "ignore";
     stdout?: "pipe" | "ignore";
     stderr?: "pipe" | "ignore";
     /** POSIX: run in a new process group so `process.kill(-pid)` reaches the tree. */
     detached?: boolean;
 }
 export declare function spawnProcess(args: string[], opts?: SpawnOptions): ProcessHandle;
+/**
+ * Exit code for a child that ended, matching Bun's convention: a signal death
+ * is 128 + signal number (SIGKILL → 137). Node's `close` reports `code: null`
+ * with the signal name, so without this the same kill reads as 0 on Node and
+ * 137 on Bun — abort paths key on the code.
+ */
+export declare function exitCodeFromClose(code: number | null, signal: NodeJS.Signals | null): number;

package/dist/runtime.js

@@ -1,74 +1,19 @@
 // ---------------------------------------------------------------------------
-// Runtime shims: Bun APIs on Bun, node: equivalents on Node.
+// Runtime shims: the few places where Bun and Node genuinely differ.
 //
-// The CLI runs on both runtimes. Bun's file/spawn/stdin/which globals have no
-// Node counterpart, so every call site goes through this module instead of
-// touching `Bun.*` directly. The Bun branches are guarded by `typeof Bun`, so
-// the emitted JS never touches the `Bun` global on Node.
-//
-// The subprocess shim normalizes both runtimes to one `ProcessHandle` (Web
-// ReadableStreams for stdout/stderr, a FileSink-like stdin, `.pid`, `.kill()`,
-// `.exited`) — the same shape `Bun.spawn` returns, so the shell/git/grep tools
-// run unchanged on either runtime.
+// Everything else uses node: builtins, which Bun implements natively — only
+// subprocess spawning (Bun.spawn vs node:child_process), stdin (Bun.stdin) and
+// entry-point detection (import.meta.main) need a runtime branch. The Bun
+// branches are guarded by `typeof Bun`, so the emitted JS never touches the
+// `Bun` global on Node.
 // ---------------------------------------------------------------------------
 import { spawn } from "node:child_process";
-import { realpathSync, statSync } from "node:fs";
-import { readFile, stat, writeFile as writeFileFs } from "node:fs/promises";
+import { realpathSync } from "node:fs";
 import { Buffer } from "node:buffer";
-import { delimiter, join } from "node:path";
+import { constants as osConstants } from "node:os";
 import { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
-export const isBun = typeof Bun !== "undefined";
-// --- files -----------------------------------------------------------------
-export async function fileExists(path) {
-    if (isBun)
-        return Bun.file(path).exists();
-    try {
-        return (await stat(path)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-export async function readTextFile(path) {
-    if (isBun)
-        return Bun.file(path).text();
-    return readFile(path, "utf8");
-}
-export async function readJsonFile(path) {
-    return JSON.parse(await readTextFile(path));
-}
-export async function writeFile(path, data) {
-    if (isBun) {
-        await Bun.write(path, data);
-        return;
-    }
-    await writeFileFs(path, data);
-}
-// --- which -----------------------------------------------------------------
-/** Resolve an executable on PATH (Bun.which on Bun, a PATH scan on Node). */
-export function which(cmd) {
-    if (isBun && Bun.which)
-        return Bun.which(cmd);
-    const dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
-    const exts = process.platform === "win32"
-        ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean)
-        : [""];
-    const names = cmd.includes(".") ? [cmd] : exts.map((ext) => cmd + ext);
-    for (const dir of dirs) {
-        for (const name of names) {
-            const candidate = join(dir, name);
-            try {
-                if (statSync(candidate).isFile())
-                    return candidate;
-            }
-            catch {
-                /* keep looking */
-            }
-        }
-    }
-    return null;
-}
+const isBun = typeof Bun !== "undefined";
 // --- stdin -----------------------------------------------------------------
 /** Read all of stdin as UTF-8 text. Callers check `process.stdin.isTTY` first. */
 export async function readStdinText() {
@@ -103,23 +48,51 @@ export function isMainModule(meta) {
 export function spawnProcess(args, opts) {
     return isBun ? spawnBun(args, opts) : spawnNode(args, opts);
 }
+/** An already-ended stream, for pipes that were not requested. */
+function emptyStream() {
+    return new ReadableStream();
+}
+/**
+ * Exit code for a child that ended, matching Bun's convention: a signal death
+ * is 128 + signal number (SIGKILL → 137). Node's `close` reports `code: null`
+ * with the signal name, so without this the same kill reads as 0 on Node and
+ * 137 on Bun — abort paths key on the code.
+ */
+export function exitCodeFromClose(code, signal) {
+    if (code !== null)
+        return code;
+    if (!signal)
+        return 0;
+    return 128 + (osConstants.signals[signal] ?? 0);
+}
 function spawnBun(args, opts) {
-    const proc = Bun.spawn(args, {
-        cwd: opts?.cwd,
-        env: opts?.env ? { ...process.env, ...opts.env } : undefined,
-        stdin: opts?.stdin === "pipe" ? "pipe" : "ignore",
-        stdout: opts?.stdout === "pipe" ? "pipe" : "ignore",
-        stderr: opts?.stderr === "pipe" ? "pipe" : "ignore",
-        detached: opts?.detached,
-    });
+    let proc;
+    try {
+        proc = Bun.spawn(args, {
+            cwd: opts?.cwd,
+            stdin: "ignore",
+            stdout: opts?.stdout === "pipe" ? "pipe" : "ignore",
+            stderr: opts?.stderr === "pipe" ? "pipe" : "ignore",
+            detached: opts?.detached,
+        });
+    }
+    catch (err) {
+        // Bun throws synchronously for a missing binary; Node reports it through
+        // `exited` = -1. Normalize so callers see one contract on both runtimes.
+        if (err?.code !== "ENOENT")
+            throw err;
+        return {
+            pid: 0,
+            stdout: emptyStream(),
+            stderr: emptyStream(),
+            exited: Promise.resolve(-1),
+            kill: () => { },
+        };
+    }
     return {
         pid: proc.pid,
-        stdout: proc.stdout,
-        stderr: proc.stderr,
-        stdin: {
-            write: (data) => { proc.stdin.write(data); },
-            end: () => { proc.stdin.end(); },
-        },
+        stdout: opts?.stdout === "pipe" ? proc.stdout : emptyStream(),
+        stderr: opts?.stderr === "pipe" ? proc.stderr : emptyStream(),
         exited: proc.exited,
         kill: (signal) => { try {
             proc.kill(signal);
@@ -130,9 +103,8 @@ function spawnBun(args, opts) {
 function spawnNode(args, opts) {
     const child = spawn(args[0], args.slice(1), {
         cwd: opts?.cwd,
-        env: opts?.env ? { ...process.env, ...opts.env } : process.env,
         stdio: [
-            opts?.stdin === "pipe" ? "pipe" : "ignore",
+            "ignore",
             opts?.stdout === "pipe" ? "pipe" : "ignore",
             opts?.stderr === "pipe" ? "pipe" : "ignore",
         ],
@@ -140,23 +112,17 @@ function spawnNode(args, opts) {
     });
     // First of close/error wins: a spawn failure (ENOENT) may emit only `error`.
     const exited = new Promise((resolve) => {
-        child.once("close", (code) => resolve(code ?? 0));
+        child.once("close", (code, signal) => resolve(exitCodeFromClose(code, signal)));
         child.once("error", () => resolve(-1));
     });
     return {
         pid: child.pid ?? 0,
         stdout: child.stdout
             ? Readable.toWeb(child.stdout)
-            : new ReadableStream(),
+            : emptyStream(),
         stderr: child.stderr
             ? Readable.toWeb(child.stderr)
-            : new ReadableStream(),
-        stdin: {
-            write: (data) => { if (child.stdin)
-                child.stdin.write(Buffer.from(data)); },
-            end: () => { if (child.stdin)
-                child.stdin.end(); },
-        },
+            : emptyStream(),
         exited,
         kill: (signal) => { try {
             child.kill(signal);

package/dist/skills/discovery.js

@@ -8,9 +8,8 @@
 //   2. <workspace>/.myagent/skills
 //   3. <configDir>/skills (created on first run so there's always a home)
 // -------------------------------------------------------------------
-import { mkdir, readdir, stat } from "node:fs/promises";
+import { mkdir, readFile, readdir, stat } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { readTextFile } from "../runtime.js";
 /** Parse the leading `--- ... ---` frontmatter for name/description. */
 export function parseFrontmatter(md) {
     const match = md.match(/^---\r?\n([\s\S]*?)\r?\n---/);
@@ -27,7 +26,7 @@ export function parseFrontmatter(md) {
 async function loadSkillDir(dir, fallbackName) {
     let md;
     try {
-        md = await readTextFile(join(dir, "SKILL.md"));
+        md = await readFile(join(dir, "SKILL.md"), "utf8");
     }
     catch {
         return null;

package/dist/tools/grep.js

@@ -8,7 +8,7 @@ import { readdir, readFile, stat } from "node:fs/promises";
 import { join, relative } from "node:path";
 import { defineTool, optionalString, requireString } from "./types.js";
 import { resolveToolPath } from "./paths.js";
-import { spawnProcess, which } from "../runtime.js";
+import { spawnProcess } from "../runtime.js";
 const MAX_MATCHES = 100;
 /**
  * Wall-clock budget for the JS fallback walk. The pattern is LLM-authored and
@@ -31,7 +31,9 @@ function formatMatches(matches, workspace) {
     return lines.join("\n") + (truncated ? `\n… (results capped at ${MAX_MATCHES} matches)` : "");
 }
 /**
- * Search with ripgrep when available. Returns null when rg is unavailable.
+ * Search with ripgrep when available. Returns null when rg is unavailable
+ * (missing binary, rejected pattern, spawn failure) so the caller falls back
+ * to the JS walk.
  *
  * The cap is enforced HERE, on the parse: rg's `--max-count` is per FILE, so
  * on a large tree it can still produce a huge JSON stream. The output is read
@@ -39,9 +41,6 @@ function formatMatches(matches, workspace) {
  * buffer nor the child outlives the cap.
  */
 async function searchWithRipgrep(pattern, searchPath, include, signal) {
-    const rg = which("rg");
-    if (!rg)
-        return null;
     // --max-count bounds the per-file work rg does; the global cap is ours.
     const args = ["--json", "--max-count", String(MAX_MATCHES), "--no-ignore", "-e", pattern];
     if (include)
@@ -50,7 +49,7 @@ async function searchWithRipgrep(pattern, searchPath, include, signal) {
         args.push("--glob", `!**/${dir}/**`);
     args.push(searchPath);
     try {
-        const proc = spawnProcess([rg, ...args], { stdout: "pipe", stderr: "ignore" });
+        const proc = spawnProcess(["rg", ...args], { stdout: "pipe", stderr: "ignore" });
         const onAbort = () => { try {
             proc.kill();
         }
@@ -106,10 +105,10 @@ async function searchWithRipgrep(pattern, searchPath, include, signal) {
             if (buffer)
                 consume(buffer);
             const code = await proc.exited;
-            // rg exits 1 for "no matches" (an answer); any other non-zero exit is a
-            // failure — e.g. a JS-valid pattern (backreference, lookahead) its engine
-            // rejects — and must fall back to the JS walk rather than read as "none".
-            if (code > 1)
+            // rg exits 0 (matches) or 1 (no matches); anything else — a rejected
+            // pattern, a spawn failure (-1) — falls back to the JS walk rather than
+            // reading as "none".
+            if (code !== 0 && code !== 1)
                 return null;
             return matches;
         }

package/dist/tools/shell.js

@@ -69,10 +69,8 @@ const shellTool = defineTool({
         const detached = process.platform !== "win32";
         const proc = spawnProcess(shell, {
             cwd: ctx.workspace,
-            env: process.env,
             stdout: "pipe",
             stderr: "pipe",
-            stdin: "ignore",
             // POSIX: a new process group lets us kill the whole pipeline (a bare
             // proc.kill() only signals the shell, and grandchildren keep the pipes
             // open, delaying the timeout unwind).

package/dist/ui/app.js

@@ -5,6 +5,7 @@
 // Owns the slash commands, keybindings, approvals, resume/render of remote
 // history and the git status polling that feeds the right panel.
 // ---------------------------------------------------------------------------
+import { writeFile } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import { CombinedAutocompleteProvider, Box, Container, HStack, isViewportTUI, matchesKey, MouseRegion, ProcessTerminal, ScrollView, SelectList, Spacer, TuiAltScreen, VStack, visibleWidth, } from "@earendil-works/pi-tui";
 import { AgentRunner, usageFromSession } from "../agent/turn.js";
@@ -14,7 +15,6 @@ import { deriveTitle } from "../agent/sessions.js";
 import { TodoStore } from "../agent/todo.js";
 import { ApprovalPolicy } from "../approval/policy.js";
 import { collectFileDiff, collectGitStatus, EMPTY_GIT_STATUS } from "../git/status.js";
-import { writeFile } from "../runtime.js";
 import { bgRgb, isColorEnabled, modeBorder, overlayBackgroundRgb, panelBackgroundRgb, style, userMessageBackgroundRgb } from "./colors.js";
 import { helpLines } from "./help.js";
 import { buildModelItems, currentModelId } from "./model-list.js";

package/dist/ui/components.d.ts

@@ -42,6 +42,9 @@ export declare class AssistantMessageComponent implements Component {
     /** Raw stream (unsanitized) — the sanitizing pass needs the whole text. */
     private raw;
     private text;
+    /** Set once any delta carried a control char: from then on the accumulated
+     *  text must be re-sanitized (a sequence can span deltas). */
+    private dirty;
     constructor();
     append(delta: string): void;
     get content(): string;
@@ -51,6 +54,7 @@ export declare class AssistantMessageComponent implements Component {
 export declare class ReasoningBlockComponent implements Component {
     private raw;
     private text;
+    private dirty;
     expanded: boolean;
     append(delta: string): void;
     toggle(): void;

package/dist/ui/components.js

@@ -84,11 +84,21 @@ export class UserMessageComponent {
         ];
     }
 }
+/**
+ * Characters `sanitizeForTerminal` would change (ESC and C0/C1 controls; tab
+ * and newline are kept). While a stream has never contained one, the sanitizer
+ * is the identity — re-running it over the whole accumulated text on every
+ * delta is O(n²) for no effect.
+ */
+const CONTROL_CHARS = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/;
 export class AssistantMessageComponent {
     md;
     /** Raw stream (unsanitized) — the sanitizing pass needs the whole text. */
     raw = "";
     text = "";
+    /** Set once any delta carried a control char: from then on the accumulated
+     *  text must be re-sanitized (a sequence can span deltas). */
+    dirty = false;
     constructor() {
         this.md = new Markdown("", 0, 0, markdownTheme, { color: assistantColor });
     }
@@ -97,9 +107,16 @@ export class AssistantMessageComponent {
         // material (file bodies, fetched pages) verbatim — strip terminal
         // sequences, like tool output and headless deltas do. Sanitizing the
         // ACCUMULATED text, not the delta: a sequence split across two deltas
-        // would slip through a per-delta pass.
+        // would slip through a per-delta pass. The clean fast path is exact: with
+        // no control char anywhere, the sanitizer returns the input unchanged.
         this.raw += delta;
-        this.text = sanitizeForTerminal(this.raw);
+        if (!this.dirty && !CONTROL_CHARS.test(delta)) {
+            this.text = this.raw;
+        }
+        else {
+            this.dirty = true;
+            this.text = sanitizeForTerminal(this.raw);
+        }
         this.md.setText(this.text);
     }
     get content() {
@@ -164,12 +181,19 @@ export class AssistantMessageComponent {
 export class ReasoningBlockComponent {
     raw = "";
     text = "";
+    dirty = false;
     expanded = false;
     append(delta) {
         // Same rule as assistant text: reasoning is model output rendered to the
         // real terminal, and it quotes tool output freely.
         this.raw += delta;
-        this.text = sanitizeForTerminal(this.raw);
+        if (!this.dirty && !CONTROL_CHARS.test(delta)) {
+            this.text = this.raw;
+        }
+        else {
+            this.dirty = true;
+            this.text = sanitizeForTerminal(this.raw);
+        }
     }
     toggle() {
         this.expanded = !this.expanded;

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@ocis/myagent-cli",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Terminal coding agent for your local repository, powered by a remote MyAgent server",
   "type": "module",
   "bin": {
-    "myagent": "./dist/index.js"
+    "myagent": "./bin/myagent.js"
   },
   "files": [
+    "bin",
     "dist/**/*.js",
     "dist/**/*.d.ts",
     "skills"