@giovannijecha/jecode 0.2.1 → 0.2.3

package/dist/accounts.js

@@ -11,8 +11,18 @@ export function openAICodexAccount() {
     return account === undefined ? undefined : { ...account };
 }
 export function accountValues() {
-    const account = store().accounts["openai-codex"];
-    return account === undefined ? [] : [account.accessToken, account.refreshToken];
+    // Keep both snapshots. Another Jecode process may rotate the refresh token
+    // after this process populated its account cache; shell-output redaction
+    // must recognize the newly persisted values without forgetting the old ones.
+    const values = new Set();
+    for (const source of [store(), readStore(accountsPath())]) {
+        const account = source.accounts["openai-codex"];
+        if (account === undefined)
+            continue;
+        values.add(account.accessToken);
+        values.add(account.refreshToken);
+    }
+    return [...values];
 }
 export function accountsPath() {
     return userDataPath("accounts.json");

package/dist/controller.js

@@ -37,47 +37,76 @@ export async function runTurn(history, options, events, signal) {
         if (calls.length > MAX_TOOL_CALLS_PER_STEP) {
             throw new Error(`provider returned ${calls.length} tool calls in one step (maximum ${MAX_TOOL_CALLS_PER_STEP})`);
         }
+        assertToolCallIds(calls);
         history.push(assistant);
-        if (assistant.usage !== undefined)
-            events.onUsage?.(assistant.usage);
-        if (calls.length === 0)
+        if (calls.length === 0) {
+            if (assistant.usage !== undefined)
+                events.onUsage?.(assistant.usage);
             return; // the model is done — hand back to the user
+        }
         // Calls run one after another because approval prompts serialise anyway,
         // but every result from this step goes back in a SINGLE message. Splitting
         // them teaches the model to stop batching its calls.
         const results = [];
         const announced = new Set();
         try {
+            if (assistant.usage !== undefined)
+                events.onUsage?.(assistant.usage);
             for (let index = 0; index < calls.length; index++) {
                 throwIfAborted(signal);
                 const call = calls[index];
                 events.onToolProgress?.(index + 1, calls.length);
                 const preview = await look(call, options, signal);
                 throwIfAborted(signal);
-                events.onToolCall(call, preview);
                 announced.add(call.id);
+                events.onToolCall(call, preview);
                 const { result, summary } = await settle(call, options, events, signal, preview);
-                events.onToolResult(call, result, summary);
                 results.push(result);
+                events.onToolResult(call, result, summary);
             }
         }
         catch (error) {
-            if (signal?.aborted !== true)
-                throw error;
+            const interrupted = signal?.aborted === true;
+            const repairs = [];
             for (const call of calls.slice(results.length)) {
-                const interrupted = refuse(call, "interrupted before completion", "interrupted");
-                if (announced.has(call.id)) {
-                    events.onToolResult(call, interrupted.result, interrupted.summary);
-                }
-                results.push(interrupted.result);
+                const run = interrupted
+                    ? refuse(call, "interrupted before completion", "interrupted")
+                    : refuse(call, "tool processing stopped before completion", "failed");
+                repairs.push({ call, run });
+                results.push(run.result);
             }
             history.push({ role: "user", content: results });
-            throw abortReason(signal);
+            // History repair is the invariant. UI recovery is best-effort and must
+            // never replace the original exception or leave the conversation open.
+            for (const { call, run } of repairs) {
+                if (!announced.has(call.id))
+                    continue;
+                try {
+                    events.onToolResult(call, run.result, run.summary);
+                }
+                catch {
+                    // The surface is already failing; the next turn can still proceed.
+                }
+            }
+            if (interrupted)
+                throw abortReason(signal);
+            throw error;
         }
         history.push({ role: "user", content: results });
     }
     throw new Error(`gave up after ${options.maxSteps} steps without finishing (raise --max-steps)`);
 }
+function assertToolCallIds(calls) {
+    const seen = new Set();
+    for (const call of calls) {
+        if (call.id.trim() === "")
+            throw new Error("provider returned a tool call without an id");
+        if (seen.has(call.id)) {
+            throw new Error("provider returned duplicate tool call ids in one step");
+        }
+        seen.add(call.id);
+    }
+}
 async function settle(call, options, events, signal, preview) {
     const tool = findTool(options.tools, call.name);
     if (tool === undefined) {

package/dist/credential-safety.js

@@ -2,6 +2,12 @@
 import { credentialValues } from "./credentials.js";
 import { accountValues } from "./accounts.js";
 const REDACTED = "[credential redacted]";
+const MIN_HEURISTIC_SECRET_CHARS = 8;
+const EXPLICIT_CREDENTIAL_ENVIRONMENT_NAMES = new Set([
+    "ANTHROPIC_API_KEY",
+    "OLLAMA_API_KEY",
+    "OPENAI_API_KEY",
+]);
 const SENSITIVE_ENVIRONMENT_NAME = /(?:^|_)(?:API_?KEY|ACCESS_?KEY|PRIVATE_?KEY|KEY|TOKEN|SECRET|PASSWORD|PASSWD|PASS|PWD|CREDENTIALS?|AUTH|JWT|COOKIE|PAT)(?:_|$)/i;
 const COMPACT_SENSITIVE_ENVIRONMENT_NAME = /^(?:PGPASSWORD)$/i;
 const SAFE_ENVIRONMENT_NAMES = new Set([
@@ -71,8 +77,12 @@ function sensitiveEnvironmentName(name) {
 function secrets(source) {
     const values = new Set([...credentialValues(), ...accountValues()]);
     for (const [name, value] of Object.entries(source)) {
-        if (value !== undefined && value !== "" && sensitiveEnvironment(name, value))
+        if (value === undefined || value === "")
+            continue;
+        const explicit = EXPLICIT_CREDENTIAL_ENVIRONMENT_NAMES.has(name.toUpperCase());
+        if (explicit || (value.length >= MIN_HEURISTIC_SECRET_CHARS && sensitiveEnvironment(name, value))) {
             values.add(value);
+        }
     }
     return [...values].filter((value) => value !== "").sort((left, right) => right.length - left.length);
 }

package/dist/credentials.js

@@ -31,8 +31,20 @@ export function credentialSource(name) {
 /** Values that must never survive in shell output, regardless of their source. */
 export function credentialValues() {
     const stored = fromDisk();
-    const names = new Set([...held.keys(), ...Object.keys(stored)]);
-    const values = new Set([...held.values(), ...Object.values(stored)]);
+    // A second process can replace the saved store after this session cached it.
+    // Redact both snapshots so neither a stale nor a newly persisted key can
+    // cross the shell boundary.
+    const current = readSavedStore();
+    const names = new Set([
+        ...held.keys(),
+        ...Object.keys(stored),
+        ...Object.keys(current),
+    ]);
+    const values = new Set([
+        ...held.values(),
+        ...Object.values(stored),
+        ...Object.values(current),
+    ]);
     for (const name of names) {
         const environment = use(process.env[name]);
         if (environment !== undefined)
@@ -94,10 +106,13 @@ export function reload() {
 function fromDisk() {
     if (saved !== undefined)
         return saved;
+    saved = readSavedStore();
+    return saved;
+}
+function readSavedStore() {
     const current = readStore(storePath());
     const legacy = legacyUserDataPath("credentials.json");
-    saved = current ?? (legacy === undefined ? undefined : readStore(legacy)) ?? {};
-    return saved;
+    return current ?? (legacy === undefined ? undefined : readStore(legacy)) ?? {};
 }
 function readStore(file) {
     try {

package/dist/providers/ollama-stream.js

@@ -8,6 +8,7 @@ export async function assembleOllama(events, onStream) {
     const calls = new Map();
     let toolArgumentChars = 0;
     let content = "";
+    let reasoning = "";
     let finishReason;
     let usage;
     for await (const raw of events) {
@@ -28,9 +29,12 @@ export async function assembleOllama(events, onStream) {
             continue;
         // Reasoning has no standardized field name across the models Ollama
         // serves, so both spellings in circulation are accepted.
-        const reasoning = delta.reasoning ?? delta.reasoning_content;
-        if (typeof reasoning === "string" && reasoning !== "") {
-            onStream?.({ kind: "thinking", text: reasoning });
+        const reasoningDelta = delta.reasoning ?? delta.reasoning_content;
+        if (typeof reasoningDelta === "string" && reasoningDelta !== "") {
+            // Keep the authoritative copy as well as the display event. Ollama
+            // expects reasoning to accompany an assistant tool call on continuation.
+            reasoning += reasoningDelta;
+            onStream?.({ kind: "thinking", text: reasoningDelta });
         }
         if (typeof delta.content === "string" && delta.content !== "") {
             content += delta.content;
@@ -59,5 +63,5 @@ export async function assembleOllama(events, onStream) {
         // Not every server sends an id, and the loop needs one to pair the result
         // back to its call.
         .map(([index, call]) => (call.id === "" ? { ...call, id: `call_${index}` } : call));
-    return { content, toolCalls, finishReason, usage };
+    return { content, reasoning, toolCalls, finishReason, usage };
 }

package/dist/providers/ollama-wire.js

@@ -40,6 +40,9 @@ export function toWireMessages(system, messages) {
             if (texts.length === 0 && toolCalls.length === 0)
                 continue;
             const turn = { role: "assistant", content: texts.join("\n") };
+            const reasoning = ollamaReasoning(message);
+            if (reasoning !== undefined)
+                turn["reasoning"] = reasoning;
             // An empty tool_calls array is not the same as no tool_calls to every
             // server, so the key is omitted rather than sent empty.
             if (toolCalls.length > 0)
@@ -59,9 +62,22 @@ export function fromWireReply(reply) {
     for (const call of reply.toolCalls) {
         content.push({ kind: "tool_call", id: call.id, name: call.name, input: parseArgs(call.args) });
     }
-    // No `raw`: unlike the other two providers, nothing in this shape has to be
-    // echoed back verbatim, so the normalized blocks are the whole message.
-    return { role: "assistant", content, usage: normalizeUsage(reply) };
+    const raw = reply.reasoning === "" ? undefined : { reasoning: reply.reasoning };
+    return {
+        role: "assistant",
+        content,
+        ...(raw === undefined ? {} : { raw, rawFrom: "ollama" }),
+        usage: normalizeUsage(reply),
+    };
+}
+function ollamaReasoning(message) {
+    if (message.rawFrom !== "ollama" ||
+        typeof message.raw !== "object" ||
+        message.raw === null ||
+        Array.isArray(message.raw))
+        return undefined;
+    const reasoning = message.raw["reasoning"];
+    return typeof reasoning === "string" && reasoning !== "" ? reasoning : undefined;
 }
 function normalizeUsage(reply) {
     if (reply.usage === undefined)

package/dist/tools/fs.js

@@ -1,5 +1,5 @@
 // Filesystem tools: read, list, write, edit.
-import { createReadStream } from "node:fs";
+import { constants } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { optionalBool, optionalInt, requireString } from "./args.js";
@@ -9,9 +9,10 @@ import { atomicWrite } from "../atomic.js";
 const MAX_READ_CHARS = 60_000;
 const MAX_LIST_CHARS = 60_000;
 const MAX_LIST_ENTRIES = 2_000;
+const READ_CHUNK_BYTES = 64 * 1024;
 export const readFile = {
     name: "read_file",
-    description: "Read a UTF-8 text file inside the workspace. Optionally start at a line " +
+    description: "Read a regular UTF-8 text file inside the workspace. Optionally start at a line " +
         "(1-based) and cap how many lines come back. Large files are truncated.",
     dangerous: false,
     input: {
@@ -28,7 +29,7 @@ export const readFile = {
         const target = await resolveExistingInRoot(root, requireString(args, "path"));
         const offset = optionalInt(args, "offset");
         const limit = optionalInt(args, "limit");
-        const { text, truncated } = await readRange(target, offset, limit);
+        const { text, truncated } = await readRange(target, offset, limit, ctx.signal);
         if (truncated) {
             return {
                 output: `${text}\n\n[truncated at ${MAX_READ_CHARS} characters — read a narrower range]`,
@@ -169,13 +170,22 @@ export const editFile = {
         };
     },
 };
-async function readRange(target, offset, limit) {
+async function readRange(target, offset, limit, signal) {
+    throwIfAborted(signal);
     const firstLine = Math.max(1, offset ?? 1);
     const lineCount = limit === undefined ? undefined : Math.max(0, limit);
     const endLine = lineCount === undefined ? Number.POSITIVE_INFINITY : firstLine + lineCount;
     if (lineCount === 0)
         return { text: "", truncated: false };
-    const source = createReadStream(target);
+    if (!(await fs.lstat(target)).isFile())
+        throw new Error("path must be a regular file");
+    // O_NONBLOCK prevents a path swapped to a FIFO between lstat and open from
+    // waiting forever for a writer. The handle stat closes that race before any
+    // content is accepted.
+    const flags = process.platform === "win32"
+        ? "r"
+        : constants.O_RDONLY | (constants.O_NONBLOCK ?? 0);
+    const handle = await fs.open(target, flags);
     const decoder = new TextDecoder();
     let text = "";
     let line = 1;
@@ -216,19 +226,32 @@ async function readRange(target, offset, limit) {
         }
     };
     try {
-        for await (const chunk of source) {
-            consume(decoder.decode(chunk, { stream: true }));
-            if (stopped)
+        if (!(await handle.stat()).isFile())
+            throw new Error("path must be a regular file");
+        let position = 0;
+        const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES);
+        while (!stopped) {
+            throwIfAborted(signal);
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+            throwIfAborted(signal);
+            if (bytesRead === 0)
                 break;
+            position += bytesRead;
+            consume(decoder.decode(buffer.subarray(0, bytesRead), { stream: true }));
         }
         if (!stopped)
             consume(decoder.decode());
     }
     finally {
-        source.destroy();
+        await handle.close();
     }
     return { text, truncated };
 }
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("interrupted");
+}
 /**
  * The edit worked out against a given text — the one place its rules live.
  *

package/dist/tools/search.js

@@ -8,6 +8,7 @@ const MAX_RESULTS = 500;
 const MAX_VISITED = 20_000;
 const MAX_FILE_BYTES = 1_000_000;
 const MAX_MATCH_LINE = 500;
+const MAX_GLOB_CHARS = 512;
 const SKIP = new Set([".git", ".hg", ".svn", "node_modules"]);
 export const findFiles = {
     name: "find_files",
@@ -17,7 +18,10 @@ export const findFiles = {
     input: {
         type: "object",
         properties: {
-            pattern: { type: "string", description: "Glob matched against workspace-relative paths." },
+            pattern: {
+                type: "string",
+                description: "Glob matched against workspace-relative paths. Maximum 512 characters.",
+            },
             path: { type: "string", description: "Directory to search, relative to the workspace root." },
             max_results: { type: "integer", description: "Maximum paths returned. Defaults to 100, caps at 500." },
         },
@@ -52,7 +56,10 @@ export const searchText = {
         properties: {
             query: { type: "string", description: "Literal text to find." },
             path: { type: "string", description: "Directory to search, relative to the workspace root." },
-            pattern: { type: "string", description: "Optional file glob, for example **/*.ts." },
+            pattern: {
+                type: "string",
+                description: "Optional file glob, for example **/*.ts. Maximum 512 characters.",
+            },
             case_sensitive: { type: "boolean", description: "Defaults to false." },
             max_results: { type: "integer", description: "Maximum matching lines. Defaults to 100, caps at 500." },
         },
@@ -166,29 +173,107 @@ function resultLimit(args) {
 }
 function glob(pattern) {
     const normalized = pattern.replace(/\\/g, "/");
-    let source = "";
-    for (let index = 0; index < normalized.length; index++) {
-        const char = normalized[index];
-        if (char === "*" && normalized[index + 1] === "*") {
-            if (normalized[index + 2] === "/") {
-                source += "(?:.*/)?";
-                index += 2;
+    if (normalized.length > MAX_GLOB_CHARS) {
+        throw new Error(`"pattern" must be at most ${MAX_GLOB_CHARS} characters`);
+    }
+    const tokens = tokenizeGlob(normalized.toLowerCase());
+    const basenameOnly = !normalized.includes("/");
+    return (relative) => {
+        const candidate = relative.replace(/\\/g, "/");
+        const target = (basenameOnly ? path.posix.basename(candidate) : candidate).toLowerCase();
+        return matchGlob(tokens, Array.from(target));
+    };
+}
+function tokenizeGlob(pattern) {
+    const chars = Array.from(pattern);
+    const tokens = [];
+    let index = 0;
+    while (index < chars.length) {
+        const char = chars[index];
+        if (char === "*") {
+            let end = index + 1;
+            while (chars[end] === "*")
+                end++;
+            if (end - index >= 2) {
+                if (chars[end] === "/") {
+                    tokens.push({ kind: "globdir-start" }, { kind: "globdir-body" });
+                    index = end + 1;
+                }
+                else {
+                    tokens.push({ kind: "globstar" });
+                    index = end;
+                }
             }
             else {
-                source += ".*";
-                index++;
+                tokens.push({ kind: "star" });
+                index = end;
             }
+            continue;
         }
-        else if (char === "*")
-            source += "[^/]*";
-        else if (char === "?")
-            source += "[^/]";
-        else
-            source += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+        tokens.push(char === "?" ? { kind: "one" } : { kind: "literal", value: char });
+        index++;
     }
-    const expression = new RegExp(`^${source}$`, "i");
-    const basenameOnly = !normalized.includes("/");
-    return (relative) => expression.test(basenameOnly ? path.posix.basename(relative) : relative);
+    return tokens;
+}
+/** Thompson-style wildcard matching: O(pattern × path), with no regex backtracking. */
+function matchGlob(tokens, text) {
+    let states = epsilonClosure(new Set([0]), tokens);
+    for (const char of text) {
+        const next = new Set();
+        for (const state of states) {
+            const token = tokens[state];
+            if (token === undefined)
+                continue;
+            switch (token.kind) {
+                case "literal":
+                    if (token.value === char)
+                        next.add(state + 1);
+                    break;
+                case "one":
+                    if (char !== "/")
+                        next.add(state + 1);
+                    break;
+                case "star":
+                    if (char !== "/")
+                        next.add(state);
+                    break;
+                case "globstar":
+                    next.add(state);
+                    break;
+                case "globdir-body":
+                    next.add(state);
+                    if (char === "/")
+                        next.add(state + 1);
+                    break;
+                case "globdir-start":
+                    break;
+            }
+        }
+        states = epsilonClosure(next, tokens);
+        if (states.size === 0)
+            return false;
+    }
+    return epsilonClosure(states, tokens).has(tokens.length);
+}
+function epsilonClosure(seed, tokens) {
+    const states = new Set(seed);
+    const pending = [...seed];
+    while (pending.length > 0) {
+        const state = pending.pop();
+        const token = tokens[state];
+        const targets = token?.kind === "globdir-start"
+            ? [state + 1, state + 2]
+            : token?.kind === "star" || token?.kind === "globstar"
+                ? [state + 1]
+                : [];
+        for (const target of targets) {
+            if (states.has(target))
+                continue;
+            states.add(target);
+            pending.push(target);
+        }
+    }
+    return states;
 }
 function summary(count, limit, capped, one, many) {
     const noun = count === 1 ? one : many;

package/dist/tools/shell.js

@@ -4,7 +4,9 @@ import { spawn } from "node:child_process";
 import { optionalInt, requireString } from "./args.js";
 import { credentialRedactor, redactCredentials, shellEnvironment } from "../credential-safety.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
+const MAX_TIMEOUT_MS = 2_147_483_647;
 const MAX_OUTPUT_CHARS = 30_000;
+const PIPE_DRAIN_MS = 100;
 export const runCommand = {
     name: "run_command",
     description: "Run a shell command starting in the workspace root and return its combined stdout " +
@@ -24,6 +26,9 @@ export const runCommand = {
         const timeoutMs = optionalInt(args, "timeout_ms") ?? DEFAULT_TIMEOUT_MS;
         if (timeoutMs <= 0)
             throw new Error('"timeout_ms" must be a positive integer');
+        if (timeoutMs > MAX_TIMEOUT_MS) {
+            throw new Error(`"timeout_ms" must be at most ${MAX_TIMEOUT_MS}ms`);
+        }
         const result = await execute(command, ctx.root, timeoutMs, ctx.signal, ctx.onOutput);
         const output = redactCredentials(result.output);
         const summary = result.timedOut
@@ -53,6 +58,7 @@ function execute(command, cwd, timeoutMs, signal, onOutput) {
         let aborted;
         let settled = false;
         let forceTimer;
+        let drainTimer;
         const timer = setTimeout(() => {
             timedOut = true;
             stopTree(child.pid, false);
@@ -68,8 +74,20 @@ function execute(command, cwd, timeoutMs, signal, onOutput) {
             clearTimeout(timer);
             if (forceTimer !== undefined)
                 clearTimeout(forceTimer);
+            if (drainTimer !== undefined)
+                clearTimeout(drainTimer);
             signal?.removeEventListener("abort", onAbort);
         };
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (aborted !== undefined)
+                reject(aborted);
+            else
+                resolve({ output: output.value().trimEnd(), code, timedOut });
+        };
         child.stdout.setEncoding("utf8");
         child.stderr.setEncoding("utf8");
         child.stdout.on("data", output.append);
@@ -81,16 +99,17 @@ function execute(command, cwd, timeoutMs, signal, onOutput) {
             cleanup();
             reject(error);
         });
-        child.on("close", (code) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            if (aborted !== undefined)
-                reject(aborted);
-            else
-                resolve({ output: output.value().trimEnd(), code, timedOut });
+        child.on("exit", (code) => {
+            // `close` normally follows once both pipes drain. A detached descendant
+            // can inherit those descriptors after the command itself has exited,
+            // though, so bound that final drain instead of hanging the tool on it.
+            drainTimer = setTimeout(() => {
+                child.stdout.destroy();
+                child.stderr.destroy();
+                finish(code);
+            }, PIPE_DRAIN_MS);
         });
+        child.on("close", finish);
     });
 }
 function capture(onOutput) {

package/dist/tui/app.js

@@ -34,6 +34,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     let closed;
     let frameTimer;
     let spinTimer;
+    let escapeTimer;
     let stopResize = () => { };
     let stopInput = () => { };
     // Timers outlive the teardown they were scheduled before. Painting after the
@@ -118,6 +119,8 @@ export async function runApp(session, transcriptRoot, environment = {}) {
             clearInterval(spinTimer);
         if (frameTimer !== undefined)
             clearTimeout(frameTimer);
+        if (escapeTimer !== undefined)
+            clearTimeout(escapeTimer);
         feedback.close();
         terminal.leave();
         closed?.();
@@ -204,12 +207,23 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         draw();
     });
     stopInput = terminal.onInput((chunk) => {
-        for (const key of keys.push(chunk))
+        if (escapeTimer !== undefined)
+            clearTimeout(escapeTimer);
+        for (const key of keys.push(chunk)) {
+            if (!live)
+                break;
             input.handle(key);
-        setTimeout(() => {
+        }
+        if (!live)
+            return;
+        escapeTimer = setTimeout(() => {
+            escapeTimer = undefined;
+            if (!live)
+                return;
             for (const key of keys.flush())
                 input.handle(key);
-            render();
+            if (live)
+                render();
         }, ESCAPE_MS);
         render();
     });

package/dist/tui/keys.js

@@ -12,6 +12,8 @@ const PASTE_END = "[201~";
 // one packs the coordinates into single bytes and simply stops being able to
 // say where the pointer is past column 223.
 const MOUSE = /^\[<(\d+);(\d+);(\d+)([Mm])/;
+const CSI_SEQUENCE = /^\[[0-?]*[ -/]*[@-~]/;
+const SS3_SEQUENCE = /^O[ -~]/;
 const BUTTONS = ["left", "middle", "right", "none"];
 // Both the normal and the application-cursor forms, because a terminal sends
 // either depending on the mode it thinks it is in.
@@ -59,6 +61,16 @@ export function decoder() {
             if (pasting) {
                 const end = held.indexOf(ESC + PASTE_END);
                 if (end === -1) {
+                    const interrupt = firstInterrupt(held);
+                    if (interrupt !== -1) {
+                        // A missing bracketed-paste terminator must not trap the decoder
+                        // forever. Ctrl+C/Ctrl+D are emergency exits: discard the partial
+                        // paste, then let the normal control-key path handle the byte.
+                        held = held.slice(interrupt);
+                        pasted = "";
+                        pasting = false;
+                        continue;
+                    }
                     // Hold back a possible partial terminator rather than pasting it.
                     const safe = held.length - PASTE_END.length - 1;
                     if (safe > 0) {
@@ -96,6 +108,13 @@ export function decoder() {
                     keys.push({ name: SEQUENCES[match], text: "", ctrl: false });
                     continue;
                 }
+                const unbound = completeTerminalSequence(rest);
+                if (unbound !== undefined) {
+                    // Terminals have many optional keys and mode reports. An unbound but
+                    // complete CSI/SS3 sequence is terminal protocol, never editor text.
+                    held = rest.slice(unbound.length);
+                    continue;
+                }
                 if (!final && couldGrow(rest))
                     break;
                 held = held.slice(1);
@@ -139,6 +158,15 @@ export function decoder() {
         },
     };
 }
+function firstInterrupt(text) {
+    const ctrlC = text.indexOf(String.fromCharCode(3));
+    const ctrlD = text.indexOf(String.fromCharCode(4));
+    if (ctrlC === -1)
+        return ctrlD;
+    if (ctrlD === -1)
+        return ctrlC;
+    return Math.min(ctrlC, ctrlD);
+}
 function matchSequence(rest) {
     for (const seq of Object.keys(SEQUENCES)) {
         if (rest.startsWith(seq))
@@ -146,10 +174,15 @@ function matchSequence(rest) {
     }
     return undefined;
 }
+function completeTerminalSequence(rest) {
+    return CSI_SEQUENCE.exec(rest)?.[0] ?? SS3_SEQUENCE.exec(rest)?.[0];
+}
 /** Whether `rest` is still a viable prefix of something we know. */
 function couldGrow(rest) {
     if (PASTE_START.startsWith(rest))
         return true;
+    if (/^\[[0-?]*[ -/]*$/.test(rest))
+        return true;
     // A mouse report has no fixed length, so it grows until its final letter.
     if (/^\[<?\d*;?\d*;?\d*$/.test(rest))
         return true;

package/dist/tui/screen.js

@@ -37,6 +37,7 @@ const CURSOR_RESET = `${CSI}0 q`;
 const SYNC_BEGIN = `${CSI}?2026h`;
 const SYNC_END = `${CSI}?2026l`;
 let active = false;
+let handlersRegistered = false;
 export function interactive() {
     return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
@@ -53,9 +54,7 @@ export function enter(reducedMotion = false) {
     if (active)
         return;
     active = true;
-    process.on("exit", leave);
-    process.on("SIGTERM", onFatalSignal);
-    process.on("SIGHUP", onFatalSignal);
+    registerProcessHandlers();
     write(ALT_ON + WRAP_OFF + CURSOR_HIDE + (reducedMotion ? CURSOR_STEADY : CURSOR_BLOCK) + PASTE_ON + MOUSE_ON);
     process.stdin.setRawMode(true);
     process.stdin.setEncoding("utf8");
@@ -74,9 +73,24 @@ export function setReducedMotion(reducedMotion) {
     if (active)
         write(reducedMotion ? CURSOR_STEADY : CURSOR_BLOCK);
 }
-function onFatalSignal() {
+function registerProcessHandlers() {
+    if (handlersRegistered)
+        return;
+    handlersRegistered = true;
+    process.on("exit", leave);
+    process.on("uncaughtExceptionMonitor", leave);
+    process.on("SIGTERM", onSigterm);
+    process.on("SIGHUP", onSighup);
+}
+function onSigterm() {
+    onFatalSignal(15);
+}
+function onSighup() {
+    onFatalSignal(1);
+}
+function onFatalSignal(number) {
     leave();
-    process.exit(0);
+    process.exit(128 + number);
 }
 export function onResize(handler) {
     process.stdout.on("resize", handler);

package/dist/ui/width.js

@@ -27,6 +27,43 @@ const WIDE = [
     [0x1fa70, 0x1faff],
     [0x20000, 0x3fffd],
 ];
+/** Default emoji-presentation ranges below the main supplementary blocks. */
+const EMOJI_WIDE = [
+    [0x231a, 0x231b],
+    [0x23e9, 0x23ec],
+    [0x23f0, 0x23f0],
+    [0x23f3, 0x23f3],
+    [0x25fd, 0x25fe],
+    [0x2614, 0x2615],
+    [0x2648, 0x2653],
+    [0x267f, 0x267f],
+    [0x2693, 0x2693],
+    [0x26a1, 0x26a1],
+    [0x26aa, 0x26ab],
+    [0x26bd, 0x26be],
+    [0x26c4, 0x26c5],
+    [0x26ce, 0x26ce],
+    [0x26d4, 0x26d4],
+    [0x26ea, 0x26ea],
+    [0x26f2, 0x26f3],
+    [0x26f5, 0x26f5],
+    [0x26fa, 0x26fa],
+    [0x26fd, 0x26fd],
+    [0x2705, 0x2705],
+    [0x270a, 0x270b],
+    [0x2728, 0x2728],
+    [0x274c, 0x274c],
+    [0x274e, 0x274e],
+    [0x2753, 0x2755],
+    [0x2757, 0x2757],
+    [0x2795, 0x2797],
+    [0x27b0, 0x27b0],
+    [0x27bf, 0x27bf],
+    [0x2b1b, 0x2b1c],
+    [0x2b50, 0x2b50],
+    [0x2b55, 0x2b55],
+    [0x1f1e6, 0x1f1ff],
+];
 /** Ranges that occupy no cell of their own: they attach to what precedes. */
 const ZERO = [
     [0x0300, 0x036f],
@@ -54,6 +91,7 @@ function inRanges(code, ranges) {
 }
 // The emoji presentation selector, built rather than typed: an invisible byte
 // 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
@@ -80,9 +118,11 @@ export function charWidth(cluster) {
         return 0;
     if (inRanges(code, ZERO))
         return 0;
+    if (cluster.includes(VS15))
+        return inRanges(code, WIDE) ? 2 : 1;
     if (cluster.includes(VS16))
         return 2;
-    return inRanges(code, WIDE) ? 2 : 1;
+    return inRanges(code, WIDE) || inRanges(code, EMOJI_WIDE) ? 2 : 1;
 }
 export function textWidth(text) {
     let total = 0;

package/package.json

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