jeo-code 0.8.34 → 0.8.36

package/CHANGELOG.md

@@ -6,6 +6,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 The README mirrors the latest 5 entries — regenerate with `bun run changelog:sync`.
 
+## [0.8.36] - 2026-07-21
+_First full audit of gjc v0.11.5's actual ~65-PR "What's Changed" list (prior passes had used release-note prose or direct-source structural diffs — this is the first time every individual PR was read and triaged against jeo's own codebase)._
+
+### Fixed
+- **A raw stdin chunk boundary landing mid multi-byte UTF-8 sequence corrupted the composer's input** (`src/commands/launch.ts`'s `kfDataHandler`) — gjc parity (#2591 "preserve supplementary Unicode input"). The live stdin `"data"` handler did `chunk.toString("utf8")` on EACH raw `Buffer` chunk independently; real terminals/ptys never guarantee byte-aligned-to-character delivery (more likely under load, over SSH, or during a fast paste), so a split sequence produced the Unicode replacement character (`U+FFFD`) on BOTH sides of the split instead of the real character — corrupting any non-ASCII input: Korean/CJK IME text, emoji, accented Latin. Quantified the exact corruption before fixing: a 4-byte emoji (`😀`) split after 2 bytes decoded to `"\uFFFD" + "\uFFFD\uFFFD"`, never the original character. Fixed with a persistent `node:string_decoder` `StringDecoder` that buffers an incomplete trailing byte sequence across chunks and only emits complete characters — the standard fix for streaming UTF-8, and exactly what Node's own string-mode streams do internally. `filterPromptInputChunk`'s own separate ASCII-level carry logic (bracketed-paste markers, CRLF splits) is unaffected and unchanged; the two are complementary, not overlapping.
+
+### Verified
+- `test/stdin-utf8-decode.test.ts` — 5 pass (new): quantifies the OLD per-chunk `toString("utf8")` bug directly (a split 4-byte emoji really does decode to two replacement characters), proves the `StringDecoder` fix reassembles both a split 4-byte emoji AND a split 3-byte Hangul character correctly, confirms complete ASCII-only chunks are unaffected (no behavior change for the common case), and asserts the real wiring in `launch.ts`'s source (not a naive `chunk.toString("utf8")`).
+- Real (unmocked) live verification: booted a real `jeo --tmux` session and typed real Korean + emoji text (`안녕하세요 테스트 😀🎉 한글입력`) via `tmux send-keys`, real UTF-8 bytes over a real pty — rendered correctly and completely, no corruption, no regression.
+- Full `bun test` — 3119 pass / 0 fail across 307 files.
+- `bun run typecheck` — no errors.
+
+### Audit status (answering "is everything through gjc v0.11.5 covered?")
+- **No** — not fully verified as of this entry. This pass read all ~65 PRs in v0.11.5's actual "What's Changed" list for the first time (prior passes used release-note prose for v0.10.2-v0.11.4, and direct-source structural diffs — not a PR-by-PR read — for v0.11.5's provider catalog and tool surface). Only the one fixed above was confirmed both applicable and safely portable so far; the rest of v0.11.5's list is still being triaged in-session.
+
+## [0.8.35] - 2026-07-21
+_Deeper gjc-parity pass: re-cloned the real, public `Yeachan-Heo/gajae-code` source and, this time, structurally compared its actual tool implementations (`packages/coding-agent/src/tools/`) against jeo's own tool surface, not just the provider catalog._
+
+### Added
+- **`calc` tool** (`src/agent/calc-tool.ts`) — a new native tool evaluating one or more arithmetic expressions, each optionally wrapped in prefix/suffix text (e.g. `{expression:"3*7", prefix:"total: "}` → `"total: 21"`). Faithful port of gjc's `packages/coding-agent/src/tools/calculator.ts` tokenizer/recursive-descent-parser/evaluator (read directly, not inferred) — jeo's own `ToolResult` contract and tool-registration conventions, not gjc's bespoke TUI renderer. Supports `+ - * / % **` (exponentiation, right-associative), parentheses, unary +/-, and decimal/hex(`0x`)/binary(`0b`)/octal(`0o`)/scientific-notation numeric literals. Wired as tool 19 in `TOOL_PROTOCOL` (tool 8 in the read-only-subagent `READONLY_TOOL_PROTOCOL` — it has no side effects, so it survives `subagentToolset`'s mutating-tool filter automatically), registered in `DEFAULT_TOOLS`/`READONLY_TOOL_NAMES`, and given a full native function-calling schema in `tool-schemas.ts` (gjc doesn't expose its own `bisect`-equivalent tool on that path, but `calc`'s parameters are simple enough that leaving it native-schema-less would have been a needless gap).
+
+### Investigated but not ported (with reasons)
+- Compared the rest of `packages/coding-agent/src/tools/` against jeo's tool surface: `archive-reader`/`sqlite-reader` (jeo's own `read` tool already handles both — see its docstring), `image-gen` (jeo's `generate_image` tool is the equivalent), `ast-edit`/`ast-grep`/`irc`/`job`/`subagent`/`todo-write`/`skill`/`debug` (already ported under matching names in earlier passes). `gh`/`review`/`ssh`/`cron`/`render-mermaid`/`checkpoint`/`json-tree`/`monitor`/`ask`/`vim` are genuinely new capabilities gjc has that jeo doesn't — each is a real, separately-scoped feature (GitHub CLI integration, remote SSH execution, scheduled tasks, diagram rendering, git-based checkpoints, a full Vim-mode composer, etc.), not a one-file port, and deferred rather than rushed into this pass.
+
+### Verified
+- `test/calc-tool.test.ts` — 12 pass (new): precedence/associativity (including right-associative `**` and left-associative `-`/`/`), unary chaining, hex/binary/octal/scientific literals, `-0` normalization, syntax/empty/non-finite error paths, tokenizer shape, and END-TO-END wiring through the REAL `DEFAULT_TOOLS.calc`, the native schema registry, both `TOOL_PROTOCOL` texts, and read-only `subagentToolset` filtering (not mocks).
+- `bun run typecheck` clean; full `bun test` 3114 pass / 0 fail across 306 files.
+
 ## [0.8.34] - 2026-07-21
 _Provider/model-catalog sync against gjc's actual current source (a shallow clone of the real, public `Yeachan-Heo/gajae-code` repo at v0.11.5 — direct `packages/ai/src/models.json` comparison, not inference from release notes). The system prompt's philosophy, the `/route` command, and the `tencent` provider were explicitly out of scope and are unchanged._
 

package/README.ja.md

@@ -283,11 +283,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.36]** (2026-07-21) — First full audit of gjc v0.11.5's actual ~65-PR "What's Changed" list (prior passes had used release-note prose or direct-source structural diffs — this is the first time every individual PR was read and triaged against jeo's own codebase).
+- **[0.8.35]** (2026-07-21) — Deeper gjc-parity pass: re-cloned the real, public `Yeachan-Heo/gajae-code` source and, this time, structurally compared its actual tool implementations (`packages/coding-agent/src/tools/`) against jeo's own tool surface, not just the provider catalog.
 - **[0.8.34]** (2026-07-21) — Provider/model-catalog sync against gjc's actual current source (a shallow clone of the real, public `Yeachan-Heo/gajae-code` repo at v0.11.5 — direct `packages/ai/src/models.json` comparison, not inference from release notes). The system prompt's philosophy, the `/route` command, and the `tencent` provider were explicitly out of scope and are unchanged.
 - **[0.8.33]** (2026-07-20) — Real terminal-resize testing (repeated tmux resize-window + keystroke reproductions, byte-for-byte ANSI replay outside jeo/tmux to isolate root causes deterministically) uncovered and closed a progressive screen-corruption bug: resizing down to a narrow terminal (e.g. a ~20-column tmux pane) produced a growing stack of duplicate status-bar lines on every subsequent keystroke, and a separate, independently-reproducible scroll bug in the mid-turn live renderer.
 - **[0.8.32]** (2026-07-20) — gjc parity: TUI display-width/wrapping is now grapheme-cluster-aware for emoji sequences (VS16 presentation, skin-tone modifiers, keycaps, ZWJ-joined emoji like family/profession glyphs), fixing box-border and wrap misalignment ("깨짐") that the old per-code-point width summation produced whenever such a sequence appeared in a message — Korean/CJK-only text was already correctly handled and is unaffected.
-- **[0.8.31]** (2026-07-20) — `web_search` no longer silently degrades every non-Anthropic model to keyless DuckDuckGo scraping — OpenAI and Gemini sessions now get their own native, hosted search tool (matching the same active-model-gated, credential-required design Anthropic already had), with DuckDuckGo remaining the always-on terminal fallback for everyone else.
-- **[0.8.30]** (2026-07-20) — `bun run build` (the host-only dev binary build) has been silently broken for every user who ran it — a drift between the plain `package.json` `build` script and the actual working release-binary build command (`scripts/ci-release-build-binaries.ts`), which had already documented and fixed the exact same crash.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -284,11 +284,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.36]** (2026-07-21) — First full audit of gjc v0.11.5's actual ~65-PR "What's Changed" list (prior passes had used release-note prose or direct-source structural diffs — this is the first time every individual PR was read and triaged against jeo's own codebase).
+- **[0.8.35]** (2026-07-21) — Deeper gjc-parity pass: re-cloned the real, public `Yeachan-Heo/gajae-code` source and, this time, structurally compared its actual tool implementations (`packages/coding-agent/src/tools/`) against jeo's own tool surface, not just the provider catalog.
 - **[0.8.34]** (2026-07-21) — Provider/model-catalog sync against gjc's actual current source (a shallow clone of the real, public `Yeachan-Heo/gajae-code` repo at v0.11.5 — direct `packages/ai/src/models.json` comparison, not inference from release notes). The system prompt's philosophy, the `/route` command, and the `tencent` provider were explicitly out of scope and are unchanged.
 - **[0.8.33]** (2026-07-20) — Real terminal-resize testing (repeated tmux resize-window + keystroke reproductions, byte-for-byte ANSI replay outside jeo/tmux to isolate root causes deterministically) uncovered and closed a progressive screen-corruption bug: resizing down to a narrow terminal (e.g. a ~20-column tmux pane) produced a growing stack of duplicate status-bar lines on every subsequent keystroke, and a separate, independently-reproducible scroll bug in the mid-turn live renderer.
 - **[0.8.32]** (2026-07-20) — gjc parity: TUI display-width/wrapping is now grapheme-cluster-aware for emoji sequences (VS16 presentation, skin-tone modifiers, keycaps, ZWJ-joined emoji like family/profession glyphs), fixing box-border and wrap misalignment ("깨짐") that the old per-code-point width summation produced whenever such a sequence appeared in a message — Korean/CJK-only text was already correctly handled and is unaffected.
-- **[0.8.31]** (2026-07-20) — `web_search` no longer silently degrades every non-Anthropic model to keyless DuckDuckGo scraping — OpenAI and Gemini sessions now get their own native, hosted search tool (matching the same active-model-gated, credential-required design Anthropic already had), with DuckDuckGo remaining the always-on terminal fallback for everyone else.
-- **[0.8.30]** (2026-07-20) — `bun run build` (the host-only dev binary build) has been silently broken for every user who ran it — a drift between the plain `package.json` `build` script and the actual working release-binary build command (`scripts/ci-release-build-binaries.ts`), which had already documented and fixed the exact same crash.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -291,11 +291,11 @@ Huge thanks to [gajae-code](https://github.com/Yeachan-Heo/gajae-code) for the i
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.36]** (2026-07-21) — First full audit of gjc v0.11.5's actual ~65-PR "What's Changed" list (prior passes had used release-note prose or direct-source structural diffs — this is the first time every individual PR was read and triaged against jeo's own codebase).
+- **[0.8.35]** (2026-07-21) — Deeper gjc-parity pass: re-cloned the real, public `Yeachan-Heo/gajae-code` source and, this time, structurally compared its actual tool implementations (`packages/coding-agent/src/tools/`) against jeo's own tool surface, not just the provider catalog.
 - **[0.8.34]** (2026-07-21) — Provider/model-catalog sync against gjc's actual current source (a shallow clone of the real, public `Yeachan-Heo/gajae-code` repo at v0.11.5 — direct `packages/ai/src/models.json` comparison, not inference from release notes). The system prompt's philosophy, the `/route` command, and the `tencent` provider were explicitly out of scope and are unchanged.
 - **[0.8.33]** (2026-07-20) — Real terminal-resize testing (repeated tmux resize-window + keystroke reproductions, byte-for-byte ANSI replay outside jeo/tmux to isolate root causes deterministically) uncovered and closed a progressive screen-corruption bug: resizing down to a narrow terminal (e.g. a ~20-column tmux pane) produced a growing stack of duplicate status-bar lines on every subsequent keystroke, and a separate, independently-reproducible scroll bug in the mid-turn live renderer.
 - **[0.8.32]** (2026-07-20) — gjc parity: TUI display-width/wrapping is now grapheme-cluster-aware for emoji sequences (VS16 presentation, skin-tone modifiers, keycaps, ZWJ-joined emoji like family/profession glyphs), fixing box-border and wrap misalignment ("깨짐") that the old per-code-point width summation produced whenever such a sequence appeared in a message — Korean/CJK-only text was already correctly handled and is unaffected.
-- **[0.8.31]** (2026-07-20) — `web_search` no longer silently degrades every non-Anthropic model to keyless DuckDuckGo scraping — OpenAI and Gemini sessions now get their own native, hosted search tool (matching the same active-model-gated, credential-required design Anthropic already had), with DuckDuckGo remaining the always-on terminal fallback for everyone else.
-- **[0.8.30]** (2026-07-20) — `bun run build` (the host-only dev binary build) has been silently broken for every user who ran it — a drift between the plain `package.json` `build` script and the actual working release-binary build command (`scripts/ci-release-build-binaries.ts`), which had already documented and fixed the exact same crash.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -283,11 +283,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.36]** (2026-07-21) — First full audit of gjc v0.11.5's actual ~65-PR "What's Changed" list (prior passes had used release-note prose or direct-source structural diffs — this is the first time every individual PR was read and triaged against jeo's own codebase).
+- **[0.8.35]** (2026-07-21) — Deeper gjc-parity pass: re-cloned the real, public `Yeachan-Heo/gajae-code` source and, this time, structurally compared its actual tool implementations (`packages/coding-agent/src/tools/`) against jeo's own tool surface, not just the provider catalog.
 - **[0.8.34]** (2026-07-21) — Provider/model-catalog sync against gjc's actual current source (a shallow clone of the real, public `Yeachan-Heo/gajae-code` repo at v0.11.5 — direct `packages/ai/src/models.json` comparison, not inference from release notes). The system prompt's philosophy, the `/route` command, and the `tencent` provider were explicitly out of scope and are unchanged.
 - **[0.8.33]** (2026-07-20) — Real terminal-resize testing (repeated tmux resize-window + keystroke reproductions, byte-for-byte ANSI replay outside jeo/tmux to isolate root causes deterministically) uncovered and closed a progressive screen-corruption bug: resizing down to a narrow terminal (e.g. a ~20-column tmux pane) produced a growing stack of duplicate status-bar lines on every subsequent keystroke, and a separate, independently-reproducible scroll bug in the mid-turn live renderer.
 - **[0.8.32]** (2026-07-20) — gjc parity: TUI display-width/wrapping is now grapheme-cluster-aware for emoji sequences (VS16 presentation, skin-tone modifiers, keycaps, ZWJ-joined emoji like family/profession glyphs), fixing box-border and wrap misalignment ("깨짐") that the old per-code-point width summation produced whenever such a sequence appeared in a message — Korean/CJK-only text was already correctly handled and is unaffected.
-- **[0.8.31]** (2026-07-20) — `web_search` no longer silently degrades every non-Anthropic model to keyless DuckDuckGo scraping — OpenAI and Gemini sessions now get their own native, hosted search tool (matching the same active-model-gated, credential-required design Anthropic already had), with DuckDuckGo remaining the always-on terminal fallback for everyone else.
-- **[0.8.30]** (2026-07-20) — `bun run build` (the host-only dev binary build) has been silently broken for every user who ran it — a drift between the plain `package.json` `build` script and the actual working release-binary build command (`scripts/ci-release-build-binaries.ts`), which had already documented and fixed the exact same crash.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.8.34",
+  "version": "0.8.36",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/agent/calc-tool.ts

@@ -0,0 +1,247 @@
+/**
+ * `calc` tool — evaluate one or more arithmetic expressions (gjc parity:
+ * `packages/coding-agent/src/tools/calculator.ts`, ported for jeo's plain
+ * `ToolResult` contract; the tokenizer/parser/evaluator below are a faithful
+ * port of gjc's recursive-descent implementation, verified against a direct
+ * read of the real, public gajae-code source — TUI rendering is jeo's own,
+ * gjc's bespoke `Component`/`Theme` renderer doesn't apply here).
+ *
+ * Supports: decimal (123, 3.14, .5), scientific notation (1e10, 2.5E-3),
+ * hex (0xFF), binary (0b1010), octal (0o755) literals; +, -, *, /, %, and
+ * right-associative ** (exponentiation); parentheses; unary +/-.
+ */
+import type { ToolResult } from "./tools";
+
+/** Supported arithmetic operators (** is exponentiation). */
+type Operator = "+" | "-" | "*" | "/" | "%" | "**";
+
+type Token =
+  | { type: "number"; value: number; raw: string }
+  | { type: "operator"; value: Operator }
+  | { type: "paren"; value: "(" | ")" };
+
+export interface CalcRequest {
+  expression: string;
+  /** Prefix text prepended to the formatted result (e.g. "total: "). */
+  prefix?: string;
+  /** Suffix text appended to the formatted result (e.g. " USD"). */
+  suffix?: string;
+}
+
+function isDigit(ch: string): boolean {
+  return ch >= "0" && ch <= "9";
+}
+function isHexDigit(ch: string): boolean {
+  return (ch >= "0" && ch <= "9") || (ch >= "a" && ch <= "f") || (ch >= "A" && ch <= "F");
+}
+function isBinaryDigit(ch: string): boolean {
+  return ch === "0" || ch === "1";
+}
+function isOctalDigit(ch: string): boolean {
+  return ch >= "0" && ch <= "7";
+}
+
+/**
+ * Tokenize a math expression into numbers, operators, and parentheses.
+ * Number formats: decimal, scientific (1e10), hex (0x), binary (0b), octal (0o).
+ */
+export function tokenizeExpression(expression: string): Token[] {
+  const tokens: Token[] = [];
+  let i = 0;
+
+  while (i < expression.length) {
+    const ch = expression[i]!;
+
+    if (ch.trim() === "") { i += 1; continue; }
+
+    if (ch === "(" || ch === ")") {
+      tokens.push({ type: "paren", value: ch });
+      i += 1;
+      continue;
+    }
+
+    // Check ** before single * to handle exponentiation.
+    if (ch === "*" && expression[i + 1] === "*") {
+      tokens.push({ type: "operator", value: "**" });
+      i += 2;
+      continue;
+    }
+
+    if (ch === "+" || ch === "-" || ch === "*" || ch === "/" || ch === "%") {
+      tokens.push({ type: "operator", value: ch });
+      i += 1;
+      continue;
+    }
+
+    // Number parsing: starts with a digit, or a decimal point followed by one.
+    const next = expression[i + 1];
+    const numberStart = isDigit(ch) || (ch === "." && next !== undefined && isDigit(next));
+    if (!numberStart) {
+      throw new Error(`Invalid character "${ch}" in expression`);
+    }
+
+    const start = i;
+
+    // Prefixed literals: 0x (hex), 0b (binary), 0o (octal).
+    if (ch === "0" && next !== undefined) {
+      const prefix = next.toLowerCase();
+      if (prefix === "x" || prefix === "b" || prefix === "o") {
+        i += 2;
+        let hasDigit = false;
+        while (i < expression.length) {
+          const digit = expression[i]!;
+          const valid = prefix === "x" ? isHexDigit(digit) : prefix === "b" ? isBinaryDigit(digit) : isOctalDigit(digit);
+          if (!valid) break;
+          hasDigit = true;
+          i += 1;
+        }
+        if (!hasDigit) throw new Error(`Invalid numeric literal starting at "${expression.slice(start, i)}"`);
+        const raw = expression.slice(start, i);
+        const value = Number(raw); // JS Number() handles 0x/0b/0o natively.
+        if (!Number.isFinite(value)) throw new Error(`Invalid number "${raw}"`);
+        tokens.push({ type: "number", value, raw });
+        continue;
+      }
+    }
+
+    // Decimal integer part.
+    let hasDigits = false;
+    while (i < expression.length && isDigit(expression[i]!)) { hasDigits = true; i += 1; }
+
+    // Fractional part.
+    if (expression[i] === ".") {
+      i += 1;
+      while (i < expression.length && isDigit(expression[i]!)) { hasDigits = true; i += 1; }
+    }
+
+    if (!hasDigits) throw new Error(`Invalid number starting at "${expression.slice(start, i + 1)}"`);
+
+    // Scientific notation exponent (1e10, 2.5E-3).
+    if (expression[i] === "e" || expression[i] === "E") {
+      i += 1;
+      if (expression[i] === "+" || expression[i] === "-") i += 1;
+      let hasExponentDigits = false;
+      while (i < expression.length && isDigit(expression[i]!)) { hasExponentDigits = true; i += 1; }
+      if (!hasExponentDigits) throw new Error(`Invalid exponent in "${expression.slice(start, i)}"`);
+    }
+
+    const raw = expression.slice(start, i);
+    const value = Number(raw);
+    if (!Number.isFinite(value)) throw new Error(`Invalid number "${raw}"`);
+    tokens.push({ type: "number", value, raw });
+  }
+
+  return tokens;
+}
+
+/**
+ * Recursive-descent parser. Precedence (lowest to highest): +/-, then
+ * `* / %`, then unary +/-, then `**` (right-associative), then parens/literals.
+ */
+class ExpressionParser {
+  #index = 0;
+  constructor(private readonly tokens: Token[]) {}
+
+  parse(): number {
+    const value = this.#parseExpression();
+    if (this.#index < this.tokens.length) throw new Error("Unexpected token in expression");
+    return value;
+  }
+
+  /** Left-associative: 1 - 2 - 3 = (1 - 2) - 3. */
+  #parseExpression(): number {
+    let value = this.#parseTerm();
+    for (;;) {
+      if (this.#matchOperator("+")) { value += this.#parseTerm(); continue; }
+      if (this.#matchOperator("-")) { value -= this.#parseTerm(); continue; }
+      break;
+    }
+    return value;
+  }
+
+  /** Left-associative: 8 / 4 / 2 = (8 / 4) / 2. */
+  #parseTerm(): number {
+    let value = this.#parseUnary();
+    for (;;) {
+      if (this.#matchOperator("*")) { value *= this.#parseUnary(); continue; }
+      if (this.#matchOperator("/")) { value /= this.#parseUnary(); continue; }
+      if (this.#matchOperator("%")) { value %= this.#parseUnary(); continue; }
+      break;
+    }
+    return value;
+  }
+
+  /** Recursive to handle chained unary: --x, +-x. */
+  #parseUnary(): number {
+    if (this.#matchOperator("+")) return this.#parseUnary();
+    if (this.#matchOperator("-")) return -this.#parseUnary();
+    return this.#parsePower();
+  }
+
+  /** Right-associative: 2 ** 3 ** 2 = 2 ** (3 ** 2) = 512, via recursion on the RHS. */
+  #parsePower(): number {
+    let value = this.#parsePrimary();
+    if (this.#matchOperator("**")) value = value ** this.#parsePower();
+    return value;
+  }
+
+  #parsePrimary(): number {
+    const token = this.#peek();
+    if (!token) throw new Error("Unexpected end of expression");
+    if (token.type === "number") { this.#index += 1; return token.value; }
+    if (token.type === "paren" && token.value === "(") {
+      this.#index += 1;
+      const value = this.#parseExpression();
+      if (!this.#matchParen(")")) throw new Error("Missing closing parenthesis");
+      return value;
+    }
+    throw new Error("Unexpected token in expression");
+  }
+
+  #matchOperator(value: Operator): boolean {
+    const token = this.tokens[this.#index];
+    if (token && token.type === "operator" && token.value === value) { this.#index += 1; return true; }
+    return false;
+  }
+
+  #matchParen(value: "(" | ")"): boolean {
+    const token = this.tokens[this.#index];
+    if (token && token.type === "paren" && token.value === value) { this.#index += 1; return true; }
+    return false;
+  }
+
+  #peek(): Token | undefined {
+    return this.tokens[this.#index];
+  }
+}
+
+/** Evaluate a math expression string. Throws on syntax errors, empty
+ *  expressions, or non-finite results (Infinity/NaN, e.g. `1/0`). */
+export function evaluateExpression(expression: string): number {
+  const tokens = tokenizeExpression(expression);
+  if (tokens.length === 0) throw new Error("Expression is empty");
+  const value = new ExpressionParser(tokens).parse();
+  if (!Number.isFinite(value)) throw new Error("Expression result is not a finite number");
+  return Object.is(value, -0) ? 0 : value; // normalize -0 to 0
+}
+
+function formatResult(value: number): string {
+  return String(value);
+}
+
+/** `calc` tool entrypoint: evaluate one or more expressions, each optionally
+ *  wrapped in prefix/suffix text (e.g. `{expression:"3*7", prefix:"total: "}`). */
+export async function calcTool(calculations: CalcRequest[]): Promise<ToolResult> {
+  if (!Array.isArray(calculations) || calculations.length === 0) {
+    return { success: false, output: "", error: "calc: 'calculations' must be a non-empty array of { expression }" };
+  }
+  try {
+    const lines = calculations.map(calc => {
+      const value = evaluateExpression(calc.expression);
+      return `${calc.prefix ?? ""}${formatResult(value)}${calc.suffix ?? ""}`;
+    });
+    return { success: true, output: lines.join("\n") };
+  } catch (e) {
+    return { success: false, output: "", error: `calc: ${e instanceof Error ? e.message : String(e)}` };
+  }
+}

package/src/agent/engine.ts

@@ -13,6 +13,7 @@ import type { Message } from "./loop";
 import { extractJsonObjectWithSpan, tryExtractJsonObject } from "./json";
 import { nativeToolSchemasFor, normalizeNativeToolName } from "./tool-schemas";
 import { readTool, writeTool, editTool, bashTool, findTool, searchTool, lsTool, mkdirTool, deleteTool, bisectTool, type ToolResult } from "./tools";
+import { calcTool } from "./calc-tool";
 import { webSearchTool, setWebSearchActiveModel } from "./web-search";
 import { executeComputerAction } from "../commands/computer";
 import { computerSupervisor } from "./computer-supervisor";
@@ -107,6 +108,7 @@ export const DEFAULT_TOOLS: Record<string, ToolHandler> = {
   debug: createDebugTool(),
   browser: createBrowserTool(),
   bisect: (a, cwd) => bisectTool(a.good, a.bad, a.run, !!a.invert, a.maxSteps, a.stepTimeoutMs, cwd),
+  calc: a => calcTool(Array.isArray(a.calculations) ? a.calculations : []),
 };
 
 /** Tool names whose calls have no workspace side effects. Shared by execution,
@@ -117,6 +119,7 @@ const READONLY_TOOL_NAMES: Record<string, true> = {
   search: true,
   ls: true,
   web_search: true,
+  calc: true,
 };
 /** Tool-protocol description injected into the system prompt. */
 export const TOOL_PROTOCOL = [
@@ -139,7 +142,8 @@ export const TOOL_PROTOCOL = [
   "16. debug {action, ...} — Node.js debugging (launch/set_breakpoint/continue/step_over/step_in/step_out/pause/evaluate/stack_trace/scopes/variables/threads/output/terminate); one active session, 'launch' spawns 'node --inspect-brk' and pauses at start",
   "17. browser {action:\"open\"|\"close\"|\"run\"|\"act\", name?, url?, actions?} — headless Chromium automation (Playwright); 'act' runs structured steps (navigate/click/type/fill/select/press/scroll/back/wait/observe/extract/screenshot/verify) addressing elements by numeric id from 'observe' or a CSS selector; 'verify' {goal, selector?, fullPage?, design_tokens?, prior_screenshot?} screenshots and asks an INDEPENDENT vision model to judge it against 'goal' -> {verdict:\"PASS\"|\"MISMATCH\", detail} — prefer this over eyeballing a screenshot yourself for UI/visual work; 'run' executes JS with page/browser/tab/display/assert/wait in scope",
   "18. bisect {good, bad?, run, invert?, maxSteps?, stepTimeoutMs?} — binary-search git history to find the commit that introduced a regression; 'good' is a known-good commit, 'bad' defaults to HEAD, 'run' is a test command (exit 0=good, non-zero=bad, 125=skip), 'invert' finds a FIX instead of a regression",
-  "19. done   {reason?}                  — call when the task is fully implemented AND verified",
+  "19. calc  {calculations:[{expression, prefix?, suffix?}]} — evaluate arithmetic expressions (+ - * / % **, parens, hex 0x/binary 0b/octal 0o literals, scientific notation); each result is prefix+value+suffix, one per line — use this instead of doing arithmetic in your head for anything beyond trivial",
+  "20. done   {reason?}                  — call when the task is fully implemented AND verified",
   "",
   "Reply with STRICT JSON only — no code fences. You MAY include an optional leading",
   '"reasoning" string (one short sentence on your plan) before "tool":',
@@ -165,7 +169,8 @@ export const READONLY_TOOL_PROTOCOL = [
   "5. lsp {action, file, line?, symbol?} — TypeScript/JavaScript definition/references/hover/symbols/diagnostics (read-only; cross-file rename is not available to this role)",
   "6. ls     {dirPath}                   — list a directory's entries",
   "7. web_search {query, recency?, limit?} — search the web (answer + sources + citations)",
-  "8. done   {reason?}                   — call when your review/analysis is complete",
+  "8. calc   {calculations:[{expression, prefix?, suffix?}]} — evaluate arithmetic expressions (+ - * / % **, parens, hex/binary/octal literals)",
+  "9. done   {reason?}                   — call when your review/analysis is complete",
   "",
   "Reply with STRICT JSON only — no prose, no code fences:",
   '{ "tool": "<name>", "arguments": { ... } }',

package/src/agent/tool-schemas.ts

@@ -98,6 +98,24 @@ const SCHEMAS: Record<string, NativeToolSchema> = {
       required: ["action"],
     },
   },
+  calc: {
+    name: "calc",
+    description: "Evaluate one or more arithmetic expressions (+ - * / % **, parens, hex/binary/octal literals, scientific notation). Each result is prefix+value+suffix.",
+    parameters: {
+      type: "object",
+      properties: {
+        calculations: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: { expression: STRING, prefix: STRING, suffix: STRING },
+            required: ["expression"],
+          },
+        },
+      },
+      required: ["calculations"],
+    },
+  },
   done: {
     name: "done",
     description: "Call when the task is fully implemented AND verified. The reason is shown to the user as your message.",

package/src/commands/launch.ts

@@ -1,5 +1,6 @@
 import { createInterface } from "node:readline/promises";
 import { emitKeypressEvents } from "node:readline";
+import { StringDecoder } from "node:string_decoder";
 import { PassThrough } from "node:stream";
 import { runAgentLoop, DEFAULT_TOOLS, TOOL_PROTOCOL, WORKING_DISCIPLINE, OUTPUT_DISCIPLINE, VERIFICATION_DIRECTIVE, isSafetyFallbackBail, stripSafetyFallbackTag, type AgentLoopEvents } from "../agent/engine";
 import { computerSupervisor } from "../agent/computer-supervisor";
@@ -2395,8 +2396,19 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // lives in `filterPromptInputChunk` (pure + exported) so the full keystroke wiring is
     // testable without a live readline/PTY; this handler is the thin live adapter.
     const kfState = { inPaste: false };
+    // gjc parity (#2591 "preserve supplementary Unicode input"): a raw stdin "data"
+    // chunk boundary can land MID multi-byte UTF-8 sequence (real terminals/ptys do not
+    // guarantee byte-aligned-to-character delivery, especially under load or over
+    // SSH/tmux) — naive per-chunk `chunk.toString("utf8")` then replaces the split
+    // sequence's incomplete tail/head with U+FFFD on EACH side of the split, corrupting
+    // any non-ASCII input (Korean/CJK IME text, emoji, ...) whenever this happens. A
+    // persistent `StringDecoder` buffers an incomplete trailing byte sequence across
+    // `write()` calls and only emits complete characters, exactly like Node's own
+    // string-mode streams do internally — this is the standard fix for streaming UTF-8.
+    const kfUtf8Decoder = new StringDecoder("utf8");
     const kfDataHandler = (chunk: Buffer) => {
-      const data = chunk.toString("utf8");
+      const data = kfUtf8Decoder.write(chunk);
+      if (!data) return; // an incomplete sequence is buffered inside the decoder; wait for the rest
       const result = filterPromptInputChunk(
         data,
         activeRl ? (activeRl as unknown as { line: string; cursor: number }) : null,