@giovannijecha/jecode 0.7.3 → 0.7.4

package/README.md

@@ -53,10 +53,32 @@
 
 Jecode requires **Node.js 22.18+ on the 22.x line, or Node.js 24+**, and npm.
 
+### Install or update
+
+Install the current stable release. Running the same command again updates an
+existing installation:
+
+```console
+npm install --global @giovannijecha/jecode@latest
+```
+
+Confirm the installed version:
+
 ```console
-npm install --global @giovannijecha/jecode
 jecode --version
+```
+
+### Start Jecode
+
+Open the project you want Jecode to work on:
+
+```console
 cd path/to/your/project
+```
+
+Then start Jecode:
+
+```console
 jecode
 ```
 
@@ -71,33 +93,41 @@ change to improve startup performance.
 Use `jecode --root path/to/project` to select another workspace, or
 `jecode --ephemeral` when the conversation must stay memory-only.
 
-Resume a saved conversation for the current workspace with a searchable picker:
+### Resume a conversation
+
+Open the searchable resume picker for the current workspace:
 
 ```console
 jecode resume
-jecode resume --latest
 ```
 
-Run `jecode --help` for every startup option. Windows, Ubuntu, and macOS are
-covered by the project test matrix.
+Resume the most recently updated conversation directly:
 
-### Prereleases
+```console
+jecode resume --latest
+```
 
-The stable npm package is the supported installation artifact. To try an
-opt-in prerelease:
+List every startup option:
 
 ```console
-npm install --global @giovannijecha/jecode@next
+jecode --help
 ```
 
+Windows, Ubuntu, and macOS are covered by the project test matrix.
+
+### Prereleases
+
+Prereleases exist only during an announced release-candidate cycle. When one is
+active, its GitHub release provides the exact installation command. Outside an
+active cycle, the stable npm package is the only supported installation
+artifact.
+
 Git URL installs are intentionally unsupported: the source tree contains no
 generated runtime and defines no install-time build hook.
 
-### Update and uninstall
+### Uninstall
 
 ```console
-npm install --global @giovannijecha/jecode
-jecode --version
 npm uninstall --global @giovannijecha/jecode
 ```
 
@@ -105,12 +135,19 @@ Uninstalling the command preserves `~/.jecode`. Remove that directory only when
 you intentionally want to erase saved settings, credentials, accounts, and
 sessions.
 
-If an older GitHub installation still owns the `jecode` executable, remove the
-legacy unscoped package before installing the scoped package:
+### Replace a legacy installation
+
+If an older GitHub installation still owns the `jecode` executable, first
+remove the legacy unscoped package:
 
 ```console
 npm uninstall --global jecode
-npm install --global @giovannijecha/jecode
+```
+
+Then install the current scoped package:
+
+```console
+npm install --global @giovannijecha/jecode@latest
 ```
 
 Do not work around the resulting `EEXIST` error with `--force`.
@@ -119,14 +156,39 @@ Do not work around the resulting `EEXIST` error with `--force`.
 
 WSL uses its own Node.js installation and `PATH`; the Node.js version installed
 on Windows does not apply inside it. Keep user-installed npm commands in the
-Linux user path:
+Linux user path. Set the user-level npm prefix:
 
 ```console
 npm config set prefix "$HOME/.local"
+```
+
+Add it to the current shell's `PATH`:
+
+```console
 export PATH="$HOME/.local/bin:$PATH"
-npm install --global @giovannijecha/jecode
+```
+
+Install or update Jecode:
+
+```console
+npm install --global @giovannijecha/jecode@latest
+```
+
+Refresh the command cache:
+
+```console
 hash -r
+```
+
+Confirm which executable will run:
+
+```console
 command -v jecode
+```
+
+Verify the installed version:
+
+```console
 jecode --version
 ```
 
@@ -347,7 +409,8 @@ fixtures. `npm run bench:transcript` and `npm run bench:search` provide manual
 probes for long-session rendering and workspace search. Architecture and
 security boundaries are documented in
 [docs/architecture.md](docs/architecture.md); brand assets and usage rules live
-in [docs/brand.md](docs/brand.md).
+in [docs/brand.md](docs/brand.md). The maintainer release procedure lives in
+[docs/releasing.md](docs/releasing.md).
 
 ## Community
 

package/dist/atomic.js

@@ -8,20 +8,29 @@ export async function atomicWrite(file, content, options = {}) {
     let handle;
     let identity;
     try {
+        throwIfAborted(options.signal);
         await options.validate?.("before-open");
+        throwIfAborted(options.signal);
         const permissions = options.mode ?? (await existingMode(file));
+        throwIfAborted(options.signal);
         handle = await open(temporary, "wx", permissions);
         identity = fileIdentity(await handle.stat());
+        throwIfAborted(options.signal);
         await options.validate?.("before-write");
+        throwIfAborted(options.signal);
         await assertNamedFile(temporary, identity);
         await handle.writeFile(content, "utf8");
+        throwIfAborted(options.signal);
         if (permissions !== undefined && process.platform !== "win32") {
             await handle.chmod(permissions);
         }
         await handle.sync();
+        throwIfAborted(options.signal);
         identity = fileIdentity(await handle.stat());
         await options.validate?.("before-rename");
+        throwIfAborted(options.signal);
         await assertNamedFile(temporary, identity);
+        throwIfAborted(options.signal);
         await rename(temporary, file);
         const completed = handle;
         handle = undefined;
@@ -38,6 +47,11 @@ export async function atomicWrite(file, content, options = {}) {
         throw error;
     }
 }
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("interrupted");
+}
 async function assertNamedFile(file, expected) {
     const details = await lstat(file);
     if (details.isSymbolicLink() || !sameFile(expected, fileIdentity(details))) {

package/dist/batch.js

@@ -13,7 +13,7 @@ import { handleCommand } from "./commands.js";
 import { renderBatch } from "./batch-view.js";
 import { columns } from "./ui/render.js";
 import { terminalText } from "./ui/terminal-text.js";
-import { recordAuxiliaryUsage, recordUsage } from "./usage.js";
+import { recordAuxiliaryUsage, recordRequestInput, recordUsage } from "./usage.js";
 export async function runBatch(session, environment = {}) {
     const rl = environment.lines === undefined ? readline.createInterface({ input: stdin }) : undefined;
     const lines = environment.lines ?? rl;
@@ -167,5 +167,8 @@ function events(emit, session) {
         onUsage(usage) {
             recordUsage(session.usage, usage);
         },
+        onRequestInput(inputTokens) {
+            recordRequestInput(session.usage, inputTokens);
+        },
     };
 }

package/dist/context/policy.js

@@ -42,16 +42,16 @@ export function planCompaction(context, turn, coveredMessages, lastInputTokens,
     };
 }
 export function policyForContextWindow(context, compactionPercent) {
-    const windowTokens = validWindow(context?.tokens)
-        ? context.tokens
-        : FALLBACK_CONTEXT_WINDOW_TOKENS;
+    const windowTokens = context === undefined
+        ? FALLBACK_CONTEXT_WINDOW_TOKENS
+        : requireWindow(context.tokens);
     const percent = validPercent(compactionPercent)
         ? compactionPercent
         : DEFAULT_COMPACTION_PERCENT;
     const percentageLimit = Math.floor(windowTokens * percent / 100);
-    const providerLimit = validWindow(context?.compactAtTokens)
-        ? context.compactAtTokens
-        : windowTokens;
+    const providerLimit = context?.compactAtTokens === undefined
+        ? windowTokens
+        : requireWindow(context.compactAtTokens);
     const requestLimitTokens = Math.floor(Math.min(providerLimit, windowTokens) * (100 - REQUEST_ESTIMATE_HEADROOM_PERCENT) / 100);
     const triggerTokens = Math.min(percentageLimit, requestLimitTokens - MIN_REQUEST_OUTPUT_TOKENS);
     const targetTokens = Math.max(512, Math.min(Math.floor(windowTokens / 4), Math.floor(triggerTokens / 2)));
@@ -114,7 +114,14 @@ function validPolicy(policy) {
         policy.targetTokens < policy.triggerTokens && policy.recentTokens < policy.triggerTokens;
 }
 function validWindow(value) {
-    return value !== undefined && Number.isSafeInteger(value) && value >= 4_096 && value <= 10_000_000;
+    // Adapters validate raw capacities at 4K before applying their own usable
+    // headroom. The resulting safe capacity can therefore be slightly smaller.
+    return value !== undefined && Number.isSafeInteger(value) && value >= 1_024 && value <= 10_000_000;
+}
+function requireWindow(value) {
+    if (validWindow(value))
+        return value;
+    throw new Error(`provider reported an invalid usable context window: ${value}`);
 }
 function validPercent(value) {
     return Number.isSafeInteger(value) &&

package/dist/controller-request.js

@@ -24,7 +24,7 @@ export async function requestAssistant(history, current, specs, options, events,
                 onStream: (event) => events.onStream(event),
                 onStatus: (status) => events.onStatus?.(status),
             });
-            return { message, context };
+            return { message, context, inputTokens: budget.inputTokens };
         }
         catch (error) {
             if (recovered)

package/dist/controller.js

@@ -45,10 +45,13 @@ export async function runTurn(history, options, events, signal, modelHistory = h
             throw new Error(`provider returned ${calls.length} tool calls in one step (maximum ${MAX_TOOL_CALLS_PER_STEP})`);
         }
         assertToolCallIds(calls);
+        if (assistant.usage !== undefined)
+            events.onUsage?.(assistant.usage);
+        events.onRequestInput?.(assistant.usage !== undefined && assistant.usage.inputTokens > 0
+            ? assistant.usage.inputTokens
+            : response.inputTokens);
         append(assistant);
         if (calls.length === 0) {
-            if (assistant.usage !== undefined)
-                events.onUsage?.(assistant.usage);
             await checkpoint("completed");
             return; // the model is done — hand back to the user
         }
@@ -58,8 +61,6 @@ export async function runTurn(history, options, events, signal, modelHistory = h
         const results = [];
         const announced = new Set();
         try {
-            if (assistant.usage !== undefined)
-                events.onUsage?.(assistant.usage);
             while (results.length < calls.length) {
                 const start = results.length;
                 const batch = nextBatch(calls, start, options.tools);

package/dist/oauth-http.js

@@ -2,6 +2,7 @@
 //
 // These requests never redirect, never retry, and never retain an unbounded
 // response. Authorization codes and refresh tokens must not leak into errors.
+import { leadingText } from "./text-boundary.js";
 const AUTH_ORIGIN = "https://auth.openai.com";
 const TIMEOUT_MS = 15_000;
 const MAX_BODY_CHARS = 64_000;
@@ -96,7 +97,7 @@ function errorDetail(value, secrets) {
     let safe = detail.replace(/[\r\n]+/g, " ");
     for (const secret of secrets)
         safe = safe.replaceAll(secret, "[credential redacted]");
-    return ` · ${safe.slice(0, 300)}`;
+    return ` · ${leadingText(safe, 300)}`;
 }
 function bodySecrets(body) {
     const values = body.contentType === "application/x-www-form-urlencoded"

package/dist/openai-oauth-callback.js

@@ -2,6 +2,7 @@
 import { timingSafeEqual } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { createServer } from "node:http";
+import { leadingText } from "./text-boundary.js";
 const CALLBACK_PORTS = [1455, 1457];
 export const OPENAI_CALLBACK_PATH = "/auth/callback";
 export async function openAICallback(state) {
@@ -42,7 +43,7 @@ export async function openAICallback(state) {
         const authError = incoming.searchParams.get("error_description") ?? incoming.searchParams.get("error");
         const authorizationCode = incoming.searchParams.get("code");
         if (authError !== null) {
-            rejectCode(new Error(`ChatGPT sign-in was rejected · ${authError.slice(0, 300)}`));
+            rejectCode(new Error(`ChatGPT sign-in was rejected · ${leadingText(authError, 300)}`));
         }
         else if (authorizationCode === null || authorizationCode === "") {
             rejectCode(new Error("ChatGPT sign-in returned no authorization code"));

package/dist/providers/http.js

@@ -1,6 +1,7 @@
 // The entire HTTP layer: one bounded request, then either a JSON body or an
 // event stream. Only idempotent reads retry. Once a POST starts or response
 // bytes flow, a failure is surfaced rather than silently replayed.
+import { leadingText } from "../text-boundary.js";
 import { readSseJson } from "./sse.js";
 import { sseStreamCharacterLimit } from "./stream-limits.js";
 const RETRYABLE = new Set([408, 409, 429, 500, 502, 503, 504]);
@@ -31,7 +32,7 @@ async function asJson(url, res) {
         return JSON.parse(text);
     }
     catch {
-        throw httpError(`${url} returned non-JSON`, res.status, text.slice(0, 500));
+        throw httpError(`${url} returned non-JSON`, res.status, leadingText(text, 500));
     }
 }
 export async function postSse(url, headers, body, maxOutputTokens, signal, onStatus) {
@@ -107,13 +108,13 @@ async function boundedText(url, res, max) {
             if (done) {
                 text += decoder.decode();
                 return text.length > max
-                    ? { text: text.slice(0, max), truncated: true }
+                    ? { text: leadingText(text, max), truncated: true }
                     : { text, truncated: false };
             }
             text += decoder.decode(value, { stream: true });
             if (text.length > max) {
                 await reader.cancel().catch(() => undefined);
-                return { text: text.slice(0, max), truncated: true };
+                return { text: leadingText(text, max), truncated: true };
             }
         }
     }

package/dist/providers/openai-codex.js

@@ -152,8 +152,6 @@ function modelContextWindow(entry) {
         return undefined;
     const percent = percentage(entry["effective_context_window_percent"]) ?? 95;
     const tokens = Math.floor(resolved * percent / 100);
-    if (!validTokenCount(tokens))
-        return undefined;
     const automatic = Math.floor(resolved * 9 / 10);
     const advertised = tokenCount(entry["auto_compact_token_limit"]);
     return Object.freeze({

package/dist/providers/sse.js

@@ -7,37 +7,26 @@ import { addBounded, MAX_SSE_EVENT_CHARS, } from "./stream-limits.js";
 export async function* readSseJson(body, maximumChars) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
-    let buffer = "";
+    const parser = new SseEventParser();
     let finished = false;
     let total = 0;
-    const append = (text) => {
-        total = addBounded(total, text.length, maximumChars, "SSE stream");
-        buffer += text;
-    };
     try {
         for (;;) {
             const { done, value } = await reader.read();
             if (done)
                 break;
-            append(decoder.decode(value, { stream: true }));
-            for (;;) {
-                const boundary = findBoundary(buffer);
-                if (boundary === undefined)
-                    break;
-                assertEventSize(boundary.start);
-                const chunk = buffer.slice(0, boundary.start);
-                buffer = buffer.slice(boundary.end);
-                const payload = parseData(chunk);
-                if (payload !== undefined)
-                    yield payload;
-            }
-            assertEventSize(buffer.length);
+            const text = decoder.decode(value, { stream: true });
+            total = addBounded(total, text.length, maximumChars, "SSE stream");
+            for (const payload of parser.push(text))
+                yield payload;
         }
         // A stream that ends without a trailing blank line still owes us its last
         // event.
-        append(decoder.decode());
-        assertEventSize(buffer.length);
-        const payload = parseData(buffer);
+        const text = decoder.decode();
+        total = addBounded(total, text.length, maximumChars, "SSE stream");
+        for (const payload of parser.push(text))
+            yield payload;
+        const payload = parser.finish();
         if (payload !== undefined)
             yield payload;
         finished = true;
@@ -48,28 +37,116 @@ export async function* readSseJson(body, maximumChars) {
         reader.releaseLock();
     }
 }
+// Keep fragments in bounded groups. A provider may split one SSE line into
+// hundreds of thousands of tiny chunks; repeatedly flattening the growing line
+// would make parsing quadratic even if boundary scanning itself were linear.
+class TextParts {
+    #groups = [];
+    #pieces = [];
+    #lastCodeUnit = "";
+    length = 0;
+    append(text) {
+        if (text === "")
+            return;
+        this.#pieces.push(text);
+        this.#lastCodeUnit = text.at(-1);
+        this.length += text.length;
+        if (this.#pieces.length >= 256)
+            this.#flush();
+    }
+    take() {
+        this.#flush();
+        const text = this.#groups.length === 1 ? this.#groups[0] : this.#groups.join("");
+        this.#groups.length = 0;
+        this.#lastCodeUnit = "";
+        this.length = 0;
+        return text;
+    }
+    endsWithCarriageReturn() {
+        return this.#lastCodeUnit === "\r";
+    }
+    #flush() {
+        if (this.#pieces.length === 0)
+            return;
+        this.#groups.push(this.#pieces.length === 1 ? this.#pieces[0] : this.#pieces.join(""));
+        this.#pieces = [];
+    }
+}
+export class SseEventParser {
+    #line = new TextParts();
+    #data = [];
+    #eventLength = 0;
+    #hasLine = false;
+    #pendingTerminatorLength = 0;
+    *push(text) {
+        let start = 0;
+        for (;;) {
+            const newline = text.indexOf("\n", start);
+            if (newline === -1) {
+                this.#line.append(text.slice(start));
+                this.#assertPendingLineSize();
+                return;
+            }
+            this.#line.append(text.slice(start, newline));
+            const rawLine = this.#line.take();
+            const crlf = rawLine.endsWith("\r");
+            const line = crlf ? rawLine.slice(0, -1) : rawLine;
+            if (line === "") {
+                const payload = this.#finishEvent();
+                if (payload !== undefined)
+                    yield payload;
+            }
+            else {
+                this.#appendLine(line, crlf ? 2 : 1);
+            }
+            start = newline + 1;
+        }
+    }
+    finish() {
+        const line = this.#line.take();
+        if (line !== "") {
+            this.#appendLine(line, 0);
+        }
+        else if (this.#hasLine) {
+            // A single trailing line terminator is part of an unterminated event.
+            assertEventSize(this.#eventLength + this.#pendingTerminatorLength);
+        }
+        return this.#finishEvent();
+    }
+    #appendLine(line, terminatorLength) {
+        const separatorLength = this.#hasLine ? this.#pendingTerminatorLength : 0;
+        assertEventSize(this.#eventLength + separatorLength + line.length);
+        this.#eventLength += separatorLength + line.length;
+        this.#hasLine = true;
+        this.#pendingTerminatorLength = terminatorLength;
+        if (line.startsWith("data:")) {
+            this.#data.push(line.slice("data:".length).trimStart());
+        }
+    }
+    #assertPendingLineSize() {
+        const separatorLength = this.#hasLine ? this.#pendingTerminatorLength : 0;
+        const remaining = MAX_SSE_EVENT_CHARS - this.#eventLength - separatorLength;
+        // One trailing CR may turn out to be part of a split CRLF terminator.
+        const splitCrlf = this.#line.length === remaining + 1 && this.#line.endsWithCarriageReturn();
+        if (this.#line.length > remaining && !splitCrlf) {
+            assertEventSize(MAX_SSE_EVENT_CHARS + 1);
+        }
+    }
+    #finishEvent() {
+        const data = this.#data.join("\n");
+        this.#data = [];
+        this.#eventLength = 0;
+        this.#hasLine = false;
+        this.#pendingTerminatorLength = 0;
+        return parseData(data);
+    }
+}
 function assertEventSize(length) {
     if (length > MAX_SSE_EVENT_CHARS) {
         throw new Error(`SSE event exceeded ${MAX_SSE_EVENT_CHARS} characters`);
     }
 }
-// Handles both LF and CRLF framing without normalising the buffer first — a
-// normalising pass would have to cope with a \r\n split across two chunks.
-function findBoundary(buffer) {
-    const lf = buffer.indexOf("\n\n");
-    const crlf = buffer.indexOf("\r\n\r\n");
-    if (lf === -1 && crlf === -1)
-        return undefined;
-    if (crlf !== -1 && (lf === -1 || crlf < lf))
-        return { start: crlf, end: crlf + 4 };
-    return { start: lf, end: lf + 2 };
-}
-function parseData(chunk) {
-    const data = chunk
-        .split(/\r?\n/)
-        .filter((line) => line.startsWith("data:"))
-        .map((line) => line.slice("data:".length).trimStart())
-        .join("\n");
+function parseData(data) {
     if (data === "" || data === "[DONE]")
         return undefined;
     try {

package/dist/sessions/store.js

@@ -8,6 +8,7 @@ import { chmod, lstat, mkdir, open, opendir, readFile, readdir, realpath, rename
 import * as path from "node:path";
 import { atomicWrite } from "../atomic.js";
 import { CONVERSATION_LIMITS, ConversationTree } from "../conversation.js";
+import { leadingText } from "../text-boundary.js";
 import { userDataPath } from "../user-data.js";
 import { decodeHead, decodeMeta, decodeNode, encodeHead, encodeMeta, encodeNode, SESSION_FILE_LIMITS, SESSION_SCHEMA, } from "./codec.js";
 import { leaseOwner, leaseToken, pidIsAlive, removeLease, sessionLease, } from "./lease.js";
@@ -367,7 +368,7 @@ function firstUserText(conversation) {
         const text = message.content.find((block) => block.kind === "text")?.text
             .replace(/\s+/gu, " ").trim();
         if (text !== undefined && text !== "")
-            return text.slice(0, 160);
+            return leadingText(text, 160);
     }
     return "Untitled session";
 }

package/dist/text-boundary.js

@@ -0,0 +1,47 @@
+// Shared grapheme boundaries for every projection of user-visible text.
+const SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+export function segmentGraphemes(text) {
+    return SEGMENTER.segment(text);
+}
+export function graphemes(text) {
+    const out = [];
+    for (const { segment } of segmentGraphemes(text))
+        out.push(segment);
+    return out;
+}
+/** Largest complete grapheme boundary no greater than a UTF-16 offset. */
+export function graphemeFloor(text, offset) {
+    const target = Math.max(0, Math.min(text.length, offset));
+    if (target === 0 || target === text.length)
+        return target;
+    const containing = segmentGraphemes(text).containing(target);
+    if (containing === undefined || containing.index === target)
+        return target;
+    return containing.index;
+}
+/** Smallest complete grapheme boundary no less than a UTF-16 offset. */
+export function graphemeCeiling(text, offset) {
+    const target = Math.max(0, Math.min(text.length, offset));
+    if (target === 0 || target === text.length)
+        return target;
+    const containing = segmentGraphemes(text).containing(target);
+    if (containing === undefined || containing.index === target)
+        return target;
+    return containing.index + containing.segment.length;
+}
+/** Keep a bounded prefix without returning part of a user-perceived character. */
+export function leadingText(text, maxCodeUnits) {
+    if (maxCodeUnits <= 0)
+        return "";
+    if (text.length <= maxCodeUnits)
+        return text;
+    return text.slice(0, graphemeFloor(text, maxCodeUnits));
+}
+/** Keep a bounded suffix without returning part of a user-perceived character. */
+export function trailingText(text, maxCodeUnits) {
+    if (maxCodeUnits <= 0)
+        return "";
+    if (text.length <= maxCodeUnits)
+        return text;
+    return text.slice(graphemeCeiling(text, text.length - maxCodeUnits));
+}

package/dist/timeline.js

@@ -3,6 +3,7 @@
 // Selecting a node changes only the in-memory path. The next real user turn
 // is what persists a branch, so opening or cancelling this control plane can
 // never create empty history.
+import { leadingText } from "./text-boundary.js";
 import { usageFromHistory } from "./usage.js";
 import { heading } from "./tui/picker.js";
 export function timelinePicker(conversation, palette) {
@@ -83,7 +84,7 @@ function preview(node) {
         const text = message.content.find((block) => block.kind === "text")?.text
             .replace(/\s+/gu, " ").trim();
         if (text !== undefined && text !== "")
-            return text.slice(0, 160);
+            return leadingText(text, 160);
     }
     return "Untitled turn";
 }

package/dist/tools/fs.js

@@ -120,15 +120,18 @@ export const writeFile = {
     },
 };
 export async function runWriteFile(args, ctx, dependencies = DEFAULT_MUTATION_DEPENDENCIES) {
+    throwIfAborted(ctx.signal);
     const root = await resolveExistingInRoot(ctx.root, ".");
     const target = await resolveDirectWritableInRoot(root, requireString(args, "path"));
     const content = requireString(args, "content", true);
     assertEditableText(content);
     await fs.mkdir(path.dirname(target), { recursive: true });
+    throwIfAborted(ctx.signal);
     await assertDirectWritableInRoot(root, target);
     const before = await current(target);
     assertApproved(before, ctx.preview, "write");
     await dependencies.atomicWrite(target, content, {
+        signal: ctx.signal,
         async validate(phase) {
             await assertDirectWritableInRoot(root, target);
             if (phase === "before-rename") {
@@ -181,12 +184,14 @@ export const editFile = {
     },
 };
 export async function runEditFile(args, ctx, dependencies = DEFAULT_MUTATION_DEPENDENCIES) {
+    throwIfAborted(ctx.signal);
     const root = await resolveExistingInRoot(ctx.root, ".");
     const target = await resolveDirectWritableInRoot(root, requireString(args, "path"), true);
     const before = await current(target, true);
     assertApproved(before, ctx.preview, "edit");
     const { after, made } = applied(before.text, args);
     await dependencies.atomicWrite(target, after, {
+        signal: ctx.signal,
         async validate(phase) {
             await assertDirectWritableInRoot(root, target, true);
             if (phase === "before-rename") {

package/dist/tools/text-boundary.js

@@ -1,41 +1,11 @@
 // Shared size and truncation boundaries for text handled by workspace tools.
 import { constants } from "node:fs";
 import { lstat, open } from "node:fs/promises";
+export { leadingText, trailingText } from "../text-boundary.js";
 export const MAX_EDITABLE_BYTES = 4_000_000;
 export const MAX_EDITABLE_CHARS = 1_000_000;
 export const MAX_EDITABLE_LINES = 20_000;
 const READ_CHUNK_BYTES = 64 * 1024;
-const GRAPHEME_SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
-/** Keep a bounded prefix without returning part of a user-perceived character. */
-export function leadingText(text, maxCodeUnits) {
-    if (maxCodeUnits <= 0)
-        return "";
-    if (text.length <= maxCodeUnits)
-        return text;
-    let end = 0;
-    for (const { index, segment } of GRAPHEME_SEGMENTER.segment(text)) {
-        const next = index + segment.length;
-        if (next > maxCodeUnits)
-            break;
-        end = next;
-    }
-    return text.slice(0, end);
-}
-/** Keep a bounded suffix without returning part of a user-perceived character. */
-export function trailingText(text, maxCodeUnits) {
-    if (maxCodeUnits <= 0)
-        return "";
-    if (text.length <= maxCodeUnits)
-        return text;
-    let start = text.length;
-    for (const { index } of GRAPHEME_SEGMENTER.segment(text)) {
-        if (text.length - index <= maxCodeUnits) {
-            start = index;
-            break;
-        }
-    }
-    return text.slice(start);
-}
 /** Read a regular UTF-8 file without allowing an unbounded allocation. */
 export async function readEditableText(file, options = {}) {
     const label = options.label ?? "file";

package/dist/tui/app-workflows.js

@@ -7,7 +7,7 @@ import { compactSession } from "../context/manual.js";
 import { isContextOverflow } from "../context/policy.js";
 import { updateSettings } from "../settings.js";
 import { saveTranscript } from "../transcript-export.js";
-import { recordAuxiliaryUsage, recordUsage } from "../usage.js";
+import { recordAuxiliaryUsage, recordRequestInput, recordUsage } from "../usage.js";
 import { selectTimeline } from "../timeline.js";
 import { answerAt } from "./approve.js";
 import * as edit from "./editor.js";
@@ -160,6 +160,7 @@ export function appWorkflows(options) {
                 state.status = text;
             },
             usage: (usage) => recordUsage(session.usage, usage),
+            requestInput: (inputTokens) => recordRequestInput(session.usage, inputTokens),
         });
         const persist = async (checkpoint, settlement, failure) => {
             const next = session.conversation.commit({

package/dist/tui/components/messages.js

@@ -1,3 +1,4 @@
+import { trailingText } from "../../text-boundary.js";
 import { blank, row } from "../../ui/render.js";
 import { markdown } from "../../ui/markdown.js";
 const PAD = 1;
@@ -42,9 +43,5 @@ export function reasoningPreviewSource(text, width) {
         return { text, truncated: false };
     // A compact view only needs its visible tail. The complete text remains on
     // the block for expansion after the reasoning stream is sealed.
-    let start = text.length - limit;
-    const code = text.charCodeAt(start);
-    if (code >= 0xdc00 && code <= 0xdfff)
-        start--;
-    return { text: text.slice(start), truncated: true };
+    return { text: trailingText(text, limit), truncated: true };
 }

package/dist/tui/components/tool.js

@@ -1,5 +1,6 @@
 // A compact execution trace: state and identity on one rail, evidence below.
 import { hasColor, row } from "../../ui/render.js";
+import { graphemeCeiling, graphemeFloor } from "../../text-boundary.js";
 const OUTPUT_ROWS = 8;
 const LIVE_OUTPUT_ROWS = 6;
 const DIFF_ROWS = 15;
@@ -73,8 +74,12 @@ function renderDetail(detail, tone, width, pal) {
 function emphasized(text, emphasis, fg) {
     if (emphasis === undefined || emphasis.length <= 0)
         return [{ text, fg }];
-    const start = Math.max(0, Math.min(text.length, emphasis.start));
-    const end = Math.max(start, Math.min(text.length, start + emphasis.length));
+    const requestedStart = Math.max(0, Math.min(text.length, emphasis.start));
+    const requestedEnd = Math.max(requestedStart, Math.min(text.length, requestedStart + emphasis.length));
+    const start = graphemeFloor(text, requestedStart);
+    const end = graphemeCeiling(text, requestedEnd);
+    if (start === end)
+        return [{ text, fg }];
     return [
         ...(start === 0 ? [] : [{ text: text.slice(0, start), fg }]),
         { text: text.slice(start, end), fg, inverse: true },

package/dist/tui/turn.js

@@ -3,6 +3,7 @@
 // The controller speaks in stream events and tool results; the screen speaks in
 // blocks. This is the whole of the translation, kept out of the shell so that
 // neither has to know how the other is built.
+import { graphemes } from "../text-boundary.js";
 import { condense, diff } from "../ui/diff.js";
 import { promptFor } from "./approve.js";
 // Semantic activity labels feed the footer's compact state and timer while
@@ -57,6 +58,9 @@ export function transcribe(stage) {
         onUsage(usage) {
             stage.usage?.(usage);
         },
+        onRequestInput(inputTokens) {
+            stage.requestInput?.(inputTokens);
+        },
         onStatus(status) {
             stage.status(status);
             stage.render();
@@ -249,18 +253,35 @@ function emphasizePairs(rows) {
             continue;
         if (rows[index - 1]?.kind === "del" || rows[index + 2]?.kind === "add")
             continue;
+        const removedClusters = graphemes(removed.text);
+        const addedClusters = graphemes(added.text);
+        let prefix = 0;
         let start = 0;
-        while (start < removed.text.length && start < added.text.length && removed.text[start] === added.text[start])
-            start++;
+        while (prefix < removedClusters.length &&
+            prefix < addedClusters.length &&
+            removedClusters[prefix] === addedClusters[prefix]) {
+            start += removedClusters[prefix].length;
+            prefix++;
+        }
         let suffix = 0;
-        while (suffix < removed.text.length - start &&
-            suffix < added.text.length - start &&
-            removed.text[removed.text.length - 1 - suffix] === added.text[added.text.length - 1 - suffix])
+        let removedSuffix = 0;
+        let addedSuffix = 0;
+        while (suffix < removedClusters.length - prefix &&
+            suffix < addedClusters.length - prefix &&
+            removedClusters[removedClusters.length - 1 - suffix] ===
+                addedClusters[addedClusters.length - 1 - suffix]) {
+            removedSuffix += removedClusters[removedClusters.length - 1 - suffix].length;
+            addedSuffix += addedClusters[addedClusters.length - 1 - suffix].length;
             suffix++;
-        while (suffix > 0 && (!wordBoundary(removed.text, suffix) || !wordBoundary(added.text, suffix)))
+        }
+        while (suffix > 0 &&
+            (!wordBoundary(removed.text, removedSuffix) || !wordBoundary(added.text, addedSuffix))) {
+            removedSuffix -= removedClusters[removedClusters.length - suffix].length;
+            addedSuffix -= addedClusters[addedClusters.length - suffix].length;
             suffix--;
-        const removedLength = removed.text.length - start - suffix;
-        const addedLength = added.text.length - start - suffix;
+        }
+        const removedLength = removed.text.length - start - removedSuffix;
+        const addedLength = added.text.length - start - addedSuffix;
         if (removedLength > 0)
             removed.emphasis = { start, length: removedLength };
         if (addedLength > 0)

package/dist/ui/diff.js

@@ -8,24 +8,37 @@
  * Above this many cells the table stops being worth building.
  *
  * The diff is quadratic in the two line counts, and it is drawn between two
- * keystrokes. Past the ceiling the honest answer is the coarse one — all of
- * the old, then all of the new — rather than a frame the user waits for.
+ * keystrokes. Common edges are removed before this limit is applied, so a
+ * local edit in a large file stays local. If the changed middle itself crosses
+ * the ceiling, the honest answer is the coarse one rather than a frame the
+ * user waits for.
  */
 const CEILING = 250_000;
 export function diff(before, after) {
     const a = lines(before);
     const b = lines(after);
-    if (a.length * b.length > CEILING) {
-        return [...a.map(del), ...b.map(add)];
+    const prefix = commonPrefix(a, b);
+    const suffix = commonSuffix(a, b, prefix);
+    const aEnd = a.length - suffix;
+    const bEnd = b.length - suffix;
+    const middleA = a.slice(prefix, aEnd);
+    const middleB = b.slice(prefix, bEnd);
+    const rows = a.slice(0, prefix).map(keep);
+    if (middleA.length * middleB.length > CEILING) {
+        for (const line of middleA)
+            rows.push(del(line));
+        for (const line of middleB)
+            rows.push(add(line));
+        appendSuffix(rows, a, aEnd);
+        return rows;
     }
-    const table = common(a, b);
-    const rows = [];
+    const table = common(middleA, middleB);
     let i = 0;
     let j = 0;
-    const width = b.length + 1;
-    while (i < a.length && j < b.length) {
-        if (a[i] === b[j]) {
-            rows.push({ kind: "keep", text: a[i] });
+    const width = middleB.length + 1;
+    while (i < middleA.length && j < middleB.length) {
+        if (middleA[i] === middleB[j]) {
+            rows.push(keep(middleA[i]));
             i++;
             j++;
             continue;
@@ -33,20 +46,39 @@ export function diff(before, after) {
         // Deletions first on a tie, so a replaced line reads old-then-new — the
         // order the eye expects, and the order every other diff prints.
         if (table[(i + 1) * width + j] >= table[i * width + j + 1]) {
-            rows.push(del(a[i]));
+            rows.push(del(middleA[i]));
             i++;
         }
         else {
-            rows.push(add(b[j]));
+            rows.push(add(middleB[j]));
             j++;
         }
     }
-    while (i < a.length)
-        rows.push(del(a[i++]));
-    while (j < b.length)
-        rows.push(add(b[j++]));
+    while (i < middleA.length)
+        rows.push(del(middleA[i++]));
+    while (j < middleB.length)
+        rows.push(add(middleB[j++]));
+    appendSuffix(rows, a, aEnd);
     return rows;
 }
+function commonPrefix(a, b) {
+    const limit = Math.min(a.length, b.length);
+    let length = 0;
+    while (length < limit && a[length] === b[length])
+        length++;
+    return length;
+}
+function commonSuffix(a, b, prefix) {
+    const limit = Math.min(a.length, b.length) - prefix;
+    let length = 0;
+    while (length < limit && a[a.length - length - 1] === b[b.length - length - 1])
+        length++;
+    return length;
+}
+function appendSuffix(rows, source, start) {
+    for (let index = start; index < source.length; index++)
+        rows.push(keep(source[index]));
+}
 /**
  * Drop the unchanged stretches, keeping `context` rows either side.
  *
@@ -109,3 +141,6 @@ function add(text) {
 function del(text) {
     return { kind: "del", text };
 }
+function keep(text) {
+    return { kind: "keep", text };
+}

package/dist/ui/render.js

@@ -1,7 +1,7 @@
 // Composing a terminal row out of styled segments. Pure: every function here
 // returns a string or rows of segments, none of them write anywhere.
 import { terminalText } from "./terminal-text.js";
-import { elide, textWidth, wrapText } from "./width.js";
+import { elide, splitByCells, textWidth, wrapText } from "./width.js";
 // Built rather than written literally: a raw escape byte in the source is
 // invisible in a diff and in a code review, which is how they survive.
 const ESC = String.fromCharCode(27);
@@ -166,13 +166,13 @@ export function flow(segs, max, continuation = []) {
     let used = 0;
     let pending;
     const room = () => Math.max(1, max - (rows.length === 0 ? 0 : lead));
-    const add = (tok) => {
+    const add = (tok, width = textWidth(tok.text)) => {
         const last = current[current.length - 1];
         if (last !== undefined && sameStyle(last, tok.seg))
             last.text += tok.text;
         else
             current.push({ ...tok.seg, text: tok.text });
-        used += textWidth(tok.text);
+        used += width;
     };
     const flush = () => {
         rows.push(rows.length === 0 ? current : [...continuation.map(copy), ...current]);
@@ -191,39 +191,31 @@ export function flow(segs, max, continuation = []) {
             continue;
         }
         const space = pending === undefined ? 0 : textWidth(pending.text);
-        let word = tok.text;
-        if (used + space + textWidth(word) > room() && current.length > 0)
+        const wordWidth = textWidth(tok.text);
+        if (used + space + wordWidth > room() && current.length > 0)
             flush();
         else if (pending !== undefined) {
-            add(pending);
+            add(pending, space);
             pending = undefined;
         }
         // A word wider than any row is spent across rows: with autowrap off, what
         // overflows is not ugly, it is gone.
-        while (textWidth(word) > room() - used) {
-            const head = clipTo(word, room() - used);
-            if (head === "")
-                break;
-            add({ ...tok, text: head });
-            word = word.slice(head.length);
-            flush();
+        if (wordWidth > room() - used) {
+            const chunks = splitByCells(tok.text, room() - used, Math.max(1, max - lead));
+            for (const [index, chunk] of chunks.entries()) {
+                add({ ...tok, text: chunk.text }, chunk.width);
+                if (index + 1 < chunks.length)
+                    flush();
+            }
+            continue;
         }
-        if (word !== "")
-            add({ ...tok, text: word });
+        if (tok.text !== "")
+            add(tok, wordWidth);
     }
     if (current.length > 0 || rows.length === 0)
         flush();
     return rows;
 }
-function clipTo(text, cols) {
-    let out = "";
-    for (const char of text) {
-        if (textWidth(out + char) > cols)
-            break;
-        out += char;
-    }
-    return out;
-}
 function copy(seg) {
     return { ...seg };
 }

package/dist/ui/width.js

@@ -6,6 +6,8 @@
 // cell at all. Every alignment in the UI depends on this file being right:
 // the right-hand column, a ground band, the cursor. Nothing measures with
 // `.length`.
+import { graphemes, segmentGraphemes } from "../text-boundary.js";
+export { graphemes } from "../text-boundary.js";
 /** Ranges the terminal draws two cells wide (East Asian Wide and Fullwidth). */
 const WIDE = [
     [0x1100, 0x115f],
@@ -93,16 +95,6 @@ function inRanges(code, ranges) {
 // in source is a byte nobody reviews.
 const VS15 = String.fromCodePoint(0xfe0e);
 const VS16 = String.fromCodePoint(0xfe0f);
-// Grapheme segmentation is in the standard library, so a family emoji built
-// out of five code points and three joiners counts as the one thing the
-// terminal actually draws.
-const SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
-export function graphemes(text) {
-    const out = [];
-    for (const { segment } of SEGMENTER.segment(text))
-        out.push(segment);
-    return out;
-}
 /**
  * Cells taken by one grapheme cluster.
  *
@@ -126,17 +118,38 @@ export function charWidth(cluster) {
 }
 export function textWidth(text) {
     let total = 0;
-    for (const cluster of SEGMENTER.segment(text))
+    for (const cluster of segmentGraphemes(text))
         total += charWidth(cluster.segment);
     return total;
 }
+/** Split text into grapheme-safe chunks without rescanning any suffix. */
+export function splitByCells(text, firstCols, followingCols = firstCols) {
+    if (text === "")
+        return [{ text, width: 0 }];
+    const chunks = [];
+    let start = 0;
+    let used = 0;
+    let room = Math.max(1, firstCols);
+    for (const { index, segment } of segmentGraphemes(text)) {
+        const width = charWidth(segment);
+        if (index > start && used + width > room) {
+            chunks.push({ text: text.slice(start, index), width: used });
+            start = index;
+            used = 0;
+            room = Math.max(1, followingCols);
+        }
+        used += width;
+    }
+    chunks.push({ text: text.slice(start), width: used });
+    return chunks;
+}
 /** The longest prefix of `text` that fits in `cols` cells. */
 export function clip(text, cols) {
     if (cols <= 0)
         return "";
     let out = "";
     let used = 0;
-    for (const { segment } of SEGMENTER.segment(text)) {
+    for (const { segment } of segmentGraphemes(text)) {
         const w = charWidth(segment);
         if (used + w > cols)
             break;
@@ -214,17 +227,13 @@ export function wrapText(text, max, continuation = "") {
                 flush();
             if (w > room()) {
                 // Too long for any row: spend whole rows on it until it fits.
-                let rest = word;
-                while (textWidth(rest) > room()) {
-                    const head = clip(rest, room() - (line === "" ? 0 : width + 1));
-                    if (head === "")
-                        break;
-                    line = line === "" ? head : `${line} ${head}`;
-                    rest = rest.slice(head.length);
-                    flush();
+                const chunks = splitByCells(word, room(), Math.max(1, max - lead));
+                for (const [index, chunk] of chunks.entries()) {
+                    line = chunk.text;
+                    width = chunk.width;
+                    if (index + 1 < chunks.length)
+                        flush();
                 }
-                line = rest;
-                width = textWidth(rest);
                 continue;
             }
             line = line === "" ? word : `${line} ${word}`;

package/dist/usage.js

@@ -12,9 +12,12 @@ export function emptyUsage() {
 }
 export function recordUsage(total, next) {
     total.requests += 1;
-    total.lastInputTokens = next.inputTokens;
     addUsage(total, next);
 }
+/** Replace context pressure without inventing provider-reported usage. */
+export function recordRequestInput(total, inputTokens) {
+    total.lastInputTokens = inputTokens;
+}
 /** Account for an internal request without replacing the main context signal. */
 export function recordAuxiliaryUsage(total, next) {
     total.requests += 1;
@@ -32,6 +35,7 @@ export function usageFromHistory(messages) {
     for (const message of messages) {
         if (message.role === "assistant" && message.usage !== undefined) {
             recordUsage(total, message.usage);
+            recordRequestInput(total, message.usage.inputTokens);
         }
     }
     return total;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {