@oxecli/oxe 1.0.69 → 1.0.70

package/dist/cli.js

@@ -88,7 +88,7 @@ export class CLI {
         const rows = COMMAND_HELP.map(([cmd, desc]) => {
             const styled = cmd.replace(/(<[^>]+>)/g, "\x1b[36m$1\x1b[0m");
             return {
-                cells: [`\x1b[1;36m${styled}\x1b[0m`, `\x1b[2m${desc}\x1b[0m`],
+                cells: [`\x1b[1;36m${styled}\x1b[0m`, `\x1b[90m${desc}\x1b[0m`],
             };
         });
         const panel = renderTableString(rows, {
@@ -181,7 +181,7 @@ export class CLI {
         }
         if (renders.length > maxItems) {
             const skipped = renders.length - maxItems;
-            process.stdout.write(`\x1b[2m… ${skipped} earlier message(s) omitted …\x1b[0m\n\n`);
+            process.stdout.write(`\x1b[90m… ${skipped} earlier message(s) omitted …\x1b[0m\n\n`);
             renders.splice(0, renders.length - maxItems);
         }
         const last = renders.length - 1;
@@ -212,7 +212,7 @@ export class CLI {
         let entries = story.filter((e) => String(e["text"] ?? "").trim());
         if (entries.length > maxItems) {
             const skipped = entries.length - maxItems;
-            process.stdout.write(`\x1b[2m… ${skipped} earlier message(s) omitted …\x1b[0m\n\n`);
+            process.stdout.write(`\x1b[90m… ${skipped} earlier message(s) omitted …\x1b[0m\n\n`);
             entries = entries.slice(-maxItems);
         }
         const last = entries.length - 1;
@@ -247,7 +247,7 @@ export class CLI {
         const label = truncateLabel(rec["label"]);
         const items = rec["input_items"] ?? [];
         const toks = estimateTokens(items).toLocaleString();
-        return `${sid.padStart(4)}\x1b[2m  ${updated}\x1b[0m  ${label}\x1b[2m  ${items.length} items · ${toks} tok\x1b[0m`;
+        return `${sid.padStart(4)}\x1b[90m  ${updated}\x1b[0m  ${label}\x1b[90m  ${items.length} items · ${toks} tok\x1b[0m`;
     }
     showConversationsPlain(recs) {
         process.stdout.write("\n");
@@ -273,9 +273,9 @@ export class CLI {
             const toks = estimateTokens(items).toLocaleString();
             const selectedRow = idx === selected;
             const content = `${selectedRow ? "\x1b[1;37m" : "\x1b[1m"}${sid.padStart(4)}\x1b[0m` +
-                `${selectedRow ? "\x1b[2;36m" : "\x1b[2m"}  ${updated}\x1b[0m` +
+                `${selectedRow ? "\x1b[2;36m" : "\x1b[90m"}  ${updated}\x1b[0m` +
                 `${selectedRow ? "  \x1b[1;37m" : "  "}${label}\x1b[0m` +
-                `${selectedRow ? "\x1b[2;36m" : "\x1b[2m"}  ${items.length} items · ${toks} tok\x1b[0m`;
+                `${selectedRow ? "\x1b[2;36m" : "\x1b[90m"}  ${items.length} items · ${toks} tok\x1b[0m`;
             rows.push({
                 cells: [selectedRow ? "\x1b[1;36m❯\x1b[0m" : "", content],
             });
@@ -283,11 +283,11 @@ export class CLI {
         const below = total - hi;
         let footer = "";
         if (lo > 0 && below > 0)
-            footer = `\x1b[2m▲ ${lo} earlier · ▼ ${below} more\x1b[0m`;
+            footer = `\x1b[90m▲ ${lo} earlier · ▼ ${below} more\x1b[0m`;
         else if (lo > 0)
-            footer = `\x1b[2m▲ ${lo} earlier\x1b[0m`;
+            footer = `\x1b[90m▲ ${lo} earlier\x1b[0m`;
         else if (below > 0)
-            footer = `\x1b[2m▼ ${below} more\x1b[0m`;
+            footer = `\x1b[90m▼ ${below} more\x1b[0m`;
         if (footer)
             rows.push({ cells: ["", footer] });
         const title = `Conversations  \x1b[1;36m${lo + 1}-${hi}/${total}\x1b[0m  (↑/↓ · Quit: q · Enter to select)`;
@@ -372,8 +372,8 @@ export class CLI {
         clearScreen();
         this.renderHeader(engine.modelName);
         process.stdout.write("\n");
-        process.stdout.write(`\x1b[2mResumed:\x1b[0m \x1b[1m${truncateLabel(rec["label"])}\x1b[0m\n`);
-        process.stdout.write(`\x1b[2m(${this.inputItems.length} items · ${estimateTokens(this.inputItems).toLocaleString()} tokens)\x1b[0m\n\n`);
+        process.stdout.write(`\x1b[90mResumed:\x1b[0m \x1b[1m${truncateLabel(rec["label"])}\x1b[0m\n`);
+        process.stdout.write(`\x1b[90m(${this.inputItems.length} items · ${estimateTokens(this.inputItems).toLocaleString()} tokens)\x1b[0m\n\n`);
         renderPanel("Conversation history restored", "Restored");
         process.stdout.write("\n");
         if (this.story.length)
@@ -430,7 +430,7 @@ export class CLI {
                     const effort = parts[1]?.toLowerCase() ?? "";
                     if (["none", "low", "high"].includes(effort)) {
                         engine.reasoningEffort = effort;
-                        process.stdout.write(`\n\x1b[32m✓\x1b[0m \x1b[2mReasoning effort set to \x1b[1;36m${effort}\x1b[0m\x1b[2m.\x1b[0m\n`);
+                        process.stdout.write(`\n\x1b[32m✓\x1b[0m \x1b[90mReasoning effort set to \x1b[1;36m${effort}\x1b[0m\x1b[90m.\x1b[0m\n`);
                     }
                     else {
                         process.stdout.write("\n");
@@ -477,7 +477,7 @@ export class CLI {
                     }
                     this.interruptPending = true;
                     process.stdout.write("\n");
-                    process.stdout.write("\x1b[2mInterrupted agent. Press Ctrl+C again to exit, or type a new prompt.\x1b[0m\n");
+                    process.stdout.write("\x1b[90mInterrupted agent. Press Ctrl+C again to exit, or type a new prompt.\x1b[0m\n");
                     continue;
                 }
                 throw err;

package/dist/engine.js

@@ -451,9 +451,9 @@ export class InferenceEngine {
             }
             parts.push(`Worked for ${tickDuration((Date.now() - queryStart) / 1000)}`);
             if (stats["tokens"] > 0) {
-                parts.push(`Used \x1b[22;37m${stats["tokens"].toLocaleString()}\x1b[2m tokens`);
+                parts.push(`Used \x1b[22;37m${stats["tokens"].toLocaleString()}\x1b[90m tokens`);
             }
-            return `\x1b[2m(${parts.join(" · ")})\x1b[0m`;
+            return `\x1b[90m(${parts.join(" · ")})\x1b[0m`;
         };
         const summary = () => mutedMarkdown(footerText());
         const attachFooter = (items) => {

package/dist/tools.js

@@ -42,7 +42,7 @@ export function flushPendingDiffOutput() {
 }
 function displayDiff(pathName, oldContent, newContent) {
     if (oldContent.length + newContent.length > max_diff_source_chars) {
-        pendingDiffOutput.push(`\x1b[2m${pathName}: ${oldContent.length.toLocaleString()} chars -> ${newContent.length.toLocaleString()} chars ` +
+        pendingDiffOutput.push(`\x1b[90m${pathName}: ${oldContent.length.toLocaleString()} chars -> ${newContent.length.toLocaleString()} chars ` +
             `(diff hidden: exceeds ${max_diff_source_chars.toLocaleString()} char limit)\x1b[0m`);
         return;
     }
@@ -118,7 +118,7 @@ function displayDiff(pathName, oldContent, newContent) {
         let line;
         if (v.kind === "~") {
             const body = truncateStyled(v.body, innerW - 2);
-            line = `\x1b[2m  ${body}\x1b[0m`;
+            line = `\x1b[90m  ${body}\x1b[0m`;
         }
         else if (v.kind === "+") {
             const body = truncateStyled(v.body, innerW - 2);
@@ -130,7 +130,7 @@ function displayDiff(pathName, oldContent, newContent) {
         }
         else {
             const body = truncateStyled(v.body, innerW - 2);
-            line = `\x1b[2m  ${body}\x1b[0m`;
+            line = `\x1b[90m  ${body}\x1b[0m`;
         }
         const fill = Math.max(0, innerW - plainLen(line));
         pendingDiffOutput.push(`\x1b[90m│\x1b[0m ${line}${" ".repeat(fill)} \x1b[90m│\x1b[0m`);

package/dist/ui.js

@@ -9,7 +9,6 @@ export function enableRawStdin() {
         readline.emitKeypressEvents(process.stdin);
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(true);
-            process.stdout.write("\x1b[>1u");
         }
         process.stdin.resume();
         hideCursor();
@@ -101,24 +100,15 @@ export function truncateStyled(text, maxVisible) {
 // ---------------------------------------------------------------------------
 const TAG_MAP = {
     bold: "\x1b[1m",
-    dim: "\x1b[2m",
+    dim: "\x1b[90m",
     italic: "\x1b[3m",
     underline: "\x1b[4m",
     red: "\x1b[31m",
     green: "\x1b[32m",
     yellow: "\x1b[33m",
-    blue: "\x1b[34m",
-    magenta: "\x1b[35m",
     cyan: "\x1b[36m",
     white: "\x1b[37m",
     bright_black: "\x1b[90m",
-    bright_red: "\x1b[91m",
-    bright_green: "\x1b[92m",
-    bright_yellow: "\x1b[93m",
-    bright_blue: "\x1b[94m",
-    bright_magenta: "\x1b[95m",
-    bright_cyan: "\x1b[96m",
-    bright_white: "\x1b[97m",
 };
 const RESET = "\x1b[0m";
 const MARKUP_RE = /\[(\/?)([a-z0-9_ ]+)\]/gi;
@@ -167,15 +157,13 @@ function highlightCodeLine(line, _lang = "") {
     if (!line)
         return "";
     if (/^\s*(\/\/|#|\/\*)/.test(line)) {
-        return `\x1b[2;37m${line}\x1b[0m`;
+        return `\x1b[90m${line}\x1b[0m`;
     }
-    return line.replace(/("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`)|(\b\d+\.?\d*\b)|(\b[a-zA-Z_$][\w$]*\b)|(\/\/[^\n]*|#[^\n]*)/g, (m, str, num, ident, comment) => {
+    return line.replace(/("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`)|(\b[a-zA-Z_$][\w$]*\b)|(\/\/[^\n]*|#[^\n]*)/g, (m, str, ident, comment) => {
         if (str)
             return `\x1b[32m${str}\x1b[0m`;
-        if (num)
-            return `\x1b[33m${num}\x1b[0m`;
         if (comment)
-            return `\x1b[2;37m${comment}\x1b[0m`;
+            return `\x1b[90m${comment}\x1b[0m`;
         if (ident && KEYWORDS.has(ident))
             return `\x1b[1;36m${ident}\x1b[0m`;
         return m;
@@ -186,7 +174,7 @@ function formatInlineMarkdown(text) {
     // Links MUST be converted first: the other rules inject ANSI escape codes,
     // and the link pattern `\[[^\]]+\]\([^)]+\)` would otherwise match the `[`
     // inside an already-inserted escape (e.g. `\x1b[1m`) and corrupt the output.
-    line = line.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "\x1b[4;36m$1\x1b[0m \x1b[2m($2)\x1b[0m");
+    line = line.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "\x1b[4;36m$1\x1b[0m \x1b[90m($2)\x1b[0m");
     line = line.replace(/\*\*\*([^*]+)\*\*\*/g, "\x1b[1;3m$1\x1b[0m");
     line = line.replace(/\*\*([^*]+)\*\*/g, "\x1b[1m$1\x1b[0m");
     line = line.replace(/(^|[^\w*])\*([^*\n]+)\*(?=$|[^\w*])/g, "$1\x1b[3m$2\x1b[0m");
@@ -313,7 +301,7 @@ export function markdownToAnsi(text) {
         }
         const h2 = line.match(/^##\s+(.+)$/);
         if (h2) {
-            out.push(`\x1b[1;34m${formatInlineMarkdown(h2[1])}\x1b[0m`);
+            out.push(`\x1b[1;36m${formatInlineMarkdown(h2[1])}\x1b[0m`);
             continue;
         }
         const h3 = line.match(/^###\s+(.+)$/);
@@ -371,7 +359,7 @@ export function aiMarkdown(text) {
 export function mutedMarkdown(text) {
     return markdownToAnsi(text)
         .split("\n")
-        .map((l) => `\x1b[2m${l}\x1b[0m`)
+        .map((l) => `\x1b[90m${l}\x1b[0m`)
         .join("\n");
 }
 // ---------------------------------------------------------------------------
@@ -466,7 +454,7 @@ export function formatDuration(seconds) {
     return `${mins}m ${remSecs}s`;
 }
 export function tickDuration(seconds) {
-    return `\x1b[22;37m${formatDuration(seconds)}\x1b[2m`;
+    return `\x1b[22;37m${formatDuration(seconds)}\x1b[90m`;
 }
 export function printAiChunk(chunk) {
     if (!chunk)
@@ -566,7 +554,7 @@ export class Spinner {
     draw() {
         const text = this.render ? this.render() : "";
         const icon = SPINNER_FRAMES[this.frame % SPINNER_FRAMES.length];
-        const rendered = `\x1b[36m${icon}\x1b[0m \x1b[2m${text}\x1b[0m`;
+        const rendered = `\x1b[36m${icon}\x1b[0m \x1b[90m${text}\x1b[0m`;
         // Nothing changed on this tick -> do not rewrite the line (avoids flicker).
         if (rendered === this.lastRendered)
             return;
@@ -807,7 +795,7 @@ export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor
     runs.push({ text: " ", style: "" });
     if (!buffer) {
         runs.push({ text: PROMPT_CARET, style: "\x1b[1;36m" });
-        runs.push({ text: PROMPT_PLACEHOLDER, style: "\x1b[2;37m" });
+        runs.push({ text: PROMPT_PLACEHOLDER, style: "\x1b[90m" });
     }
     else {
         const segs = splitBlocks(buffer, pasteSpans);
@@ -903,209 +891,23 @@ export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor
     return { frame, cursorRow, cursorCol, totalRows };
 }
 /**
- * Generic CSI Shift+Enter detection. The modifier encoding used by CSI-u,
- * legacy and kitty/modifyOtherKeys is a bitmask + 1, where Shift is bit0
- * (so modifier 2 = shift, 4 = shift+alt, 6 = shift+ctrl, ...). Enter has
- * key code 13. Handles:
- *   CSI-u / legacy:      ESC [ 13 ; M u   and   ESC [ 13 ; M ~
- *   modifyOtherKeys:     ESC [ 27 ; M ; 13 ~
- *   application:         ESC O M
+ * Returns true when a keypress encodes Enter in any form: a plain CR
+ * (readline name "return"), the application-keypad form (ESC O M), or a
+ * modifier-prefixed CSI sequence (CSI-u ESC [ 13 ; N u, kitty ESC [ 27 ; N ;
+ * 13 ~). The prompt is single-line, so every Enter submits — there is no
+ * Shift+Enter newline mode, and a bare LF (Ctrl+J, name "enter"/"linefeed")
+ * is not a real Enter.
  */
-/**
- * Parses a complete (reassembled) escape-sequence encoding of Enter and
- * classifies it as a newline (Shift+Enter) or a submit (plain Enter).
- *
- * Return values:
- *   "newline" — Shift+Enter (insert a new row)
- *   "submit"  — plain Enter (submit the prompt)
- *   null      — not an Enter sequence
- *
- * Handles every encoding a terminal can produce:
- *   CSI-u:                    ESC [ 13 ; M u        (M = xterm bitmask + 1)
- *   legacy / kitty:           ESC [ 13 ; M ~   /   ESC [ 13 ; M _
- *   modifyOtherKeys:          ESC [ 27 ; M ; 13 ~
- *   application (SS3):        ESC O M
- *   win32-input-mode:         ESC [ G ; R ; C ; VK ; MOD u
- *                             (VK = 13 for Enter, MOD = raw bitmask where
- *                              bit2 = Shift)
- */
-function parseEnterSequence(seq) {
-    if (!seq)
-        return null;
-    // win32-input-mode: ESC [ guard ; row ; col ; vk ; mod u
-    let m = seq.match(/^\x1b\[(\d+);(\d+);(\d+);(\d+);(\d+)u$/);
-    if (m) {
-        const vk = parseInt(m[4], 10);
-        if (vk !== 13)
-            return null;
-        const mod = parseInt(m[5], 10);
-        return mod & 4 ? "newline" : "submit";
-    }
-    // modifyOtherKeys / kitty: ESC [ 27 ; M ; 13 ~ (or _)
-    m = seq.match(/^\x1b\[27;(\d+);13[~_]$/);
-    if (m) {
-        const mod = parseInt(m[1], 10);
-        if (mod > 0)
-            return (mod - 1) & 1 ? "newline" : "submit";
-        return null;
-    }
-    // CSI-u / legacy: ESC [ 13 ; M u (or ~ or _)
-    m = seq.match(/^\x1b\[13;(\d+)[~u_]$/);
-    if (m) {
-        const mod = parseInt(m[1], 10);
-        if (mod > 0)
-            return (mod - 1) & 1 ? "newline" : "submit";
-        return null;
-    }
-    // Application keypad Enter (SS3)
-    if (seq === "\x1bOM")
-        return "newline";
-    return null;
-}
-export function isShiftEnterKey(str, key) {
-    if (!key)
-        return false;
-    const seq = key.sequence || str || "";
-    if (parseEnterSequence(seq) === "newline")
-        return true;
-    // Shift modifier reported by readline on a return/enter/linefeed key.
-    if (key.shift &&
-        (key.name === "return" ||
-            key.name === "enter" ||
-            key.name === "linefeed" ||
-            seq === "\r" ||
-            seq === "\n")) {
-        return true;
-    }
-    return false;
-}
-export const isNewlineKey = isShiftEnterKey;
-export function isSubmitEnterKey(str, key) {
+function isEnterKey(str, key) {
     if (!key)
         return false;
-    if (isShiftEnterKey(str, key))
-        return false;
     const seq = key.sequence || str || "";
-    if (parseEnterSequence(seq) === "submit")
-        return true;
-    if ((key.name === "return" ||
-        seq === "\r" ||
-        seq === "\x1b[13u" ||
-        seq === "\x1b[13;1u") &&
-        !key.shift) {
+    if (key.name === "return" || seq === "\r")
         return true;
-    }
-    return false;
-}
-/**
- * Maps a Windows virtual-key code + shift state to a printable character, or
- * null if the code isn't a printable character. US-layout approximation (the
- * common case); enough for a text prompt.
- */
-function vkToChar(vk, shift) {
-    if (vk >= 48 && vk <= 57) {
-        const symbols = [")", "!", "@", "#", "$", "%", "^", "&", "*", "("];
-        return shift ? symbols[vk - 48] : String(vk - 48);
-    }
-    if (vk >= 65 && vk <= 90) {
-        return shift ? String.fromCharCode(vk) : String.fromCharCode(vk).toLowerCase();
-    }
-    if (vk === 186)
-        return shift ? ":" : ";";
-    if (vk === 187)
-        return shift ? "+" : "=";
-    if (vk === 188)
-        return shift ? "<" : ",";
-    if (vk === 189)
-        return shift ? "_" : "-";
-    if (vk === 190)
-        return shift ? ">" : ".";
-    if (vk === 191)
-        return shift ? "?" : "/";
-    if (vk === 192)
-        return shift ? "~" : "`";
-    if (vk === 219)
-        return shift ? "{" : "[";
-    if (vk === 220)
-        return shift ? "|" : "\\";
-    if (vk === 221)
-        return shift ? "}" : "]";
-    if (vk === 222)
-        return shift ? '"' : "'";
-    return null;
-}
-/**
- * Decodes a complete win32-input-mode sequence (ESC [ G ; R ; C ; VK ; MOD u)
- * into a key action. Returns a descriptor for the prompt to execute, or null
- * if the sequence isn't a win32-input-mode sequence.
- */
-function decodeWin32Key(seq) {
-    const m = seq.match(/^\x1b\[(\d+);(\d+);(\d+);(\d+);(\d+)u$/);
-    if (!m)
-        return null;
-    const vk = parseInt(m[4], 10);
-    const mod = parseInt(m[5], 10);
-    // win32-input-mode MOD bitmask: bit2 = Shift, bit1 = Ctrl, bit0 = Alt
-    const shift = (mod & 4) === 4;
-    const ctrl = (mod & 2) === 2;
-    const alt = (mod & 1) === 1;
-    const cmd = (c) => ({ type: "cmd", cmd: c });
-    const text = (t) => ({ type: "text", text: t });
-    // Control combos
-    if (ctrl && vk === 67)
-        return cmd("interrupt"); // Ctrl+C
-    if (ctrl && vk === 68)
-        return cmd("eof"); // Ctrl+D
-    if (ctrl && vk === 90)
-        return cmd("eof"); // Ctrl+Z
-    if (ctrl && vk === 65)
-        return cmd("home"); // Ctrl+A
-    if (ctrl && vk === 69)
-        return cmd("end"); // Ctrl+E
-    if (ctrl && vk === 85)
-        return cmd("clear-line"); // Ctrl+U
-    if (ctrl && vk === 75)
-        return cmd("kill-line"); // Ctrl+K
-    if (ctrl && vk === 87)
-        return cmd("delete-word"); // Ctrl+W
-    switch (vk) {
-        case 13: // Enter
-            return shift ? cmd("newline") : cmd("submit");
-        case 8: // Backspace
-            return cmd(ctrl ? "delete-word" : "backspace");
-        case 46: // Delete
-            return cmd("delete");
-        case 37: // Left
-            return ctrl ? cmd("back-word") : cmd("left");
-        case 39: // Right
-            return ctrl ? cmd("forward-word") : cmd("right");
-        case 38: // Up
-            return cmd("up");
-        case 40: // Down
-            return cmd("down");
-        case 36: // Home
-            return cmd("home");
-        case 35: // End
-            return cmd("end");
-        case 33: // PageUp
-            return cmd("up");
-        case 34: // PageDown
-            return cmd("down");
-        case 9: // Tab
-            return cmd("tab");
-        case 32: // Space
-            return text(" ");
-        case 27: // Escape
-            return cmd("escape");
-        default: {
-            if (alt)
-                return null; // Alt combos unsupported -> ignore
-            const ch = vkToChar(vk, shift);
-            if (ch)
-                return text(ch);
-            return cmd("ignore");
-        }
-    }
+    return (/^\x1b\[13(;[\d;]*)?[u~_]$/.test(seq) || // CSI-u / legacy, any modifier
+        /^\x1b\[27;\d+;13[~_]$/.test(seq) || // modifyOtherKeys / kitty
+        seq === "\x1bOM" // application keypad
+    );
 }
 export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
     return new Promise((resolve, reject) => {
@@ -1133,23 +935,11 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
         let bracketedPasteBuffer = "";
         let pasteBurst = false;
         let pasteBurstTimer = null;
-        // Accumulator for modifier-prefixed CSI sequences (e.g. Shift+Enter sent as
-        // `\x1b[27;2;13~`), which Node's readline splits into several keypress
-        // events instead of one, so they must be reassembled here.
-        let modSeq = "";
-        let modSeqTimeout = null;
         readline.emitKeypressEvents(process.stdin);
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(true);
+            // Bracketed paste so multi-line pastes arrive inside \x1b[200~…\x1b[201~.
             process.stdout.write("\x1b[?2004h");
-            // Enable CSI-u disambiguation so Shift+Enter arrives as a distinct code
-            // (`\x1b[13;2u`) instead of a plain Enter. Plain keys still arrive as
-            // single keypress events. Deliberately NOT enabling win32-input-mode
-            // (`\x1b[?9001h`): it rewrites EVERY keystroke into a long CSI sequence
-            // that readline splits across many events, and an interrupted split
-            // leaves modSeq stuck so the next keystroke is silently dropped —
-            // that regression made typing in the prompt impossible.
-            process.stdout.write("\x1b[>1u");
         }
         process.stdin.resume();
         hideCursor();
@@ -1176,8 +966,6 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
             process.stdin.setRawMode(false);
             if (pasteBurstTimer)
                 clearTimeout(pasteBurstTimer);
-            if (modSeqTimeout)
-                clearTimeout(modSeqTimeout);
             clearBox();
             process.stdin.removeListener("keypress", onKeypress);
             process.stdin.pause();
@@ -1495,140 +1283,7 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
                 pasteBurstTimer = null;
             }, 500);
         };
-        const handleRawSequence = (full) => {
-            // Enter sequences (CSI-u, kitty, legacy, SS3, win32).
-            const enter = parseEnterSequence(full);
-            if (enter === "newline") {
-                insert("\n");
-                repaint();
-                return;
-            }
-            if (enter === "submit") {
-                if (buffer.trim())
-                    settle([buffer, pasteSpans], false);
-                return;
-            }
-            // Other win32-input-mode keys (arrows, backspace, etc.).
-            const dec = decodeWin32Key(full);
-            if (!dec)
-                return;
-            if (dec.type === "text") {
-                insert(dec.text);
-                repaint();
-                return;
-            }
-            switch (dec.cmd) {
-                case "interrupt":
-                    settle(new Error("interrupt"), true);
-                    return;
-                case "eof":
-                    settle(new Error("eof"), true);
-                    return;
-                case "backspace":
-                    backspace();
-                    repaint();
-                    return;
-                case "delete-word":
-                    deleteWordBefore();
-                    repaint();
-                    return;
-                case "delete":
-                    deleteChar();
-                    repaint();
-                    return;
-                case "left":
-                    moveLeft();
-                    repaint();
-                    return;
-                case "right":
-                    moveRight();
-                    repaint();
-                    return;
-                case "back-word": {
-                    const sp = buffer.slice(0, cursor).lastIndexOf(" ");
-                    cursor = sp === -1 ? 0 : sp + 1;
-                    repaint();
-                    return;
-                }
-                case "forward-word": {
-                    const sp = buffer.indexOf(" ", cursor);
-                    cursor = sp === -1 ? buffer.length : sp + 1;
-                    repaint();
-                    return;
-                }
-                case "up":
-                    moveUp();
-                    repaint();
-                    return;
-                case "down":
-                    moveDown();
-                    repaint();
-                    return;
-                case "home":
-                    cursor = 0;
-                    repaint();
-                    return;
-                case "end":
-                    cursor = buffer.length;
-                    repaint();
-                    return;
-                case "tab":
-                    insert("  ");
-                    repaint();
-                    return;
-                case "clear-line":
-                    buffer = "";
-                    cursor = 0;
-                    pasteSpans = [];
-                    repaint();
-                    return;
-                case "kill-line":
-                    buffer = buffer.slice(0, cursor);
-                    repaint();
-                    return;
-                default:
-                    return;
-            }
-        };
         const onKeypress = (str, key) => {
-            // Reassemble modifier-prefixed CSI sequences that Node's readline may
-            // split across keypress events (e.g. `\x1b[13;2u` arriving as `\x1b[13;2`
-            // + "u"). Only start/continue accumulation on bytes that can belong to a
-            // CSI sequence: digits / `;` while incomplete, or a terminator byte
-            // [A-Z~_u] that completes it. Any other keystroke (a typed letter, for
-            // instance) ABANDONS the partial instead of being swallowed, so a stuck
-            // partial can never eat input.
-            const seq = key?.sequence || str || "";
-            if (seq.startsWith("\x1b[") && /^\x1b\[[\d;]*$/.test(seq)) {
-                modSeq = seq;
-                if (modSeqTimeout)
-                    clearTimeout(modSeqTimeout);
-                modSeqTimeout = setTimeout(() => {
-                    modSeq = "";
-                    modSeqTimeout = null;
-                }, 200);
-                return;
-            }
-            if (modSeq) {
-                const s = str ?? seq ?? "";
-                const completes = /^\x1b\[[\d;]*[A-Z~_u]$/.test(modSeq + s);
-                if (/^[0-9;]$/.test(s) || completes) {
-                    modSeq += s;
-                    if (completes) {
-                        const full = modSeq;
-                        modSeq = "";
-                        if (modSeqTimeout)
-                            clearTimeout(modSeqTimeout);
-                        modSeqTimeout = null;
-                        handleRawSequence(full);
-                    }
-                    return;
-                }
-                modSeq = "";
-                if (modSeqTimeout)
-                    clearTimeout(modSeqTimeout);
-                modSeqTimeout = null;
-            }
             if (consumeBracketedPaste(str, key))
                 return;
             if (pasteBurst && str && str.length === 1 && !key?.ctrl && !key?.meta) {
@@ -1672,12 +1327,12 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
                 repaint();
                 return;
             }
-            if (isNewlineKey(str, key) || (pasteBurst && isSubmitEnterKey(str, key))) {
+            if (pasteBurst && isEnterKey(str, key)) {
                 insert("\n");
                 repaint();
                 return;
             }
-            if (isSubmitEnterKey(str, key)) {
+            if (isEnterKey(str, key)) {
                 if (buffer.trim()) {
                     settle([buffer, pasteSpans], false);
                 }
@@ -1734,10 +1389,9 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
                 return;
             }
             // Ctrl+J sends a bare LF (0x0a). Node reports it as name "enter" or
-            // "linefeed" with no shift modifier. Only Shift+Enter should create a
-            // new row, so ignore a lone LF (it is not a real Enter — a real Enter
-            // arrives as CR / name "return").
-            if (key && !key.shift && (key.name === "enter" || key.name === "linefeed")) {
+            // "linefeed". It is not a real Enter (a real Enter arrives as CR / name
+            // "return"), so ignore it rather than submitting or inserting a newline.
+            if (key && (key.name === "enter" || key.name === "linefeed")) {
                 return;
             }
             if (str) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxecli/oxe",
-  "version": "1.0.69",
+  "version": "1.0.70",
   "publishConfig": {
     "access": "public"
   },