atris 3.24.0 → 3.25.0

package/bin/atris.js

@@ -361,12 +361,6 @@ function showHelp() {
   console.log('  plan       - Create build spec with visualization');
   console.log('  do         - Execute tasks');
   console.log('  review     - Validate work (tests, safety checks, docs)');
-  console.log('  slop       - Detect frontend AI-slop tells (deterministic, exit 1 = found)');
-  console.log('  deck       - Generate a premium Google Slides deck from a content spec');
-  console.log('  site       - Build a beautiful static site from a folder of markdown');
-  console.log('  theme      - Brand themes: "theme create" builds your own by feel (deck/html/site)');
-  console.log('  card       - One line of text into an on-brand image (uses your theme)');
-  console.log('  reel       - One line of text into a short on-brand video (animated card)');
   console.log('  run        - Auto-chain plan→do→review (autonomous loop, auto-pushes)');
   console.log('  run logs   - Browse glass run logs (phase reasoning persisted to disk)');
   console.log('  run search - Search phase reasoning across all run logs');
@@ -380,7 +374,7 @@ function showHelp() {
   console.log('  radar      - Show live agents joined with tasks, missions, and worktrees');
   console.log('  ctop       - Show a process-first live agent CPU/memory view');
   console.log('  status     - See local work and completions (`atris status <business>` for remote)');
-  console.log('  recap      - What your AI team did, in plain English (--share, or --html for a memory page)');
+  console.log('  recap      - What your AI team did, in plain English (--share for paste-ready)');
   console.log('  xp         - Show Career XP and contribution graph');
   console.log('  analytics  - Show recent productivity from journals');
   console.log('  search     - Search journal history (atris search <keyword>)');
@@ -832,7 +826,7 @@ if (command === '2' && ['fast', 'pro'].includes(String(firstCommandArg || '').to
 const knownCommands = ['init', 'log', 'now', 'radar', 'ctop', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'verify', 'search', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'plugin', 'experiments', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube',
-                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'probe', 'worktree', 'aeo', 'slop', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'xp', 'play', 'gm', 'x', 'recap',
+                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'probe', 'worktree', 'aeo', 'improve', 'xp', 'play', 'gm', 'x', 'recap',
                        'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
                        'fork', 'browse', 'publish', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'compile', 'spaceship'];
 
@@ -1346,36 +1340,6 @@ if (command === 'init') {
   Promise.resolve(require('../commands/codex-goal').codexGoalCommand(process.argv.slice(3)))
     .then(() => process.exit(process.exitCode || 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
-} else if (command === 'slop') {
-  // Slop: deterministic frontend-slop detector (no LLM). Exit 1 = slop found, for CI + the autopilot gate.
-  Promise.resolve(require('../commands/slop').slopCommand(process.argv.slice(3)))
-    .then((code) => process.exit(typeof code === 'number' ? code : 0))
-    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
-} else if (command === 'deck') {
-  // Deck: premium Google Slides from a plain content spec, via the Atris deck engine (anti-slop design system).
-  Promise.resolve(require('../commands/deck').run(process.argv.slice(3)))
-    .then((code) => process.exit(typeof code === 'number' ? code : 0))
-    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
-} else if (command === 'site') {
-  // Site: beautiful static site from a folder of markdown, in the anti-slop design system.
-  Promise.resolve(require('../commands/site').run(process.argv.slice(3)))
-    .then((code) => process.exit(typeof code === 'number' ? code : 0))
-    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
-} else if (command === 'theme') {
-  // Theme: brand themes (.atris/theme.json) for the whole design system (deck/html/site).
-  Promise.resolve(require('../commands/theme').run(process.argv.slice(3)))
-    .then((code) => process.exit(typeof code === 'number' ? code : 0))
-    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
-} else if (command === 'card') {
-  // Card: one line of text into an on-brand image (uses your theme + the design system).
-  Promise.resolve(require('../commands/card').run(process.argv.slice(3)))
-    .then((code) => process.exit(typeof code === 'number' ? code : 0))
-    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
-} else if (command === 'reel') {
-  // Reel: one line of text into a short on-brand video (an animated card; frames via Chrome + ffmpeg).
-  Promise.resolve(require('../commands/reel').run(process.argv.slice(3)))
-    .then((code) => process.exit(typeof code === 'number' ? code : 0))
-    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'aeo') {
   // AEO: AI Engine Optimization — credit-metered citation drafting against the customer workspace.
   Promise.resolve(require('../commands/aeo').run(process.argv.slice(3)))

package/commands/aeo.js

@@ -5,17 +5,17 @@
  *   atris aeo init                          # create entity-graph skeleton
  *   atris aeo draft "<topic>" [opts]        # generate citation-optimized article
  *
- * Local-read against ~/arena/atrisos-backend/atris/features/aeo/proof/:
+ * Local-read against a developer-provided AEO workspace:
  *   atris aeo log [--engine X] [--limit N]  # citation attempt log
  *   atris aeo status                        # engine + proof + buyer summary
  *   atris aeo packet <slug>                 # buyer packet for a surface
  *   atris aeo proofs [--filter X]           # list proof receipt categories
  *
- * Shell out to atrisos-backend/scripts/aeo_*.py:
+ * Shell out to the configured workspace scripts/aeo_*.py:
  *   atris aeo discover <source> [...]       # discovery audit
  *   atris aeo audit <source> [...]          # agent-usability audit
  *
- * Backend root resolution: $ATRIS_BACKEND_ROOT or ~/arena/atrisos-backend.
+ * Local workspace resolution: $ATRIS_AEO_ROOT or legacy $ATRIS_BACKEND_ROOT.
  */
 
 const fs = require('fs');
@@ -28,8 +28,8 @@ const { loadBusinesses, saveBusinesses } = require('./business');
 
 function resolveBackendRoot() {
   const candidates = [
+    process.env.ATRIS_AEO_ROOT,
     process.env.ATRIS_BACKEND_ROOT,
-    path.join(os.homedir(), 'arena', 'atrisos-backend'),
   ].filter(Boolean);
   for (const root of candidates) {
     if (fs.existsSync(path.join(root, 'atris', 'features', 'aeo'))) return root;
@@ -40,7 +40,7 @@ function resolveBackendRoot() {
 function requireBackendRoot() {
   const root = resolveBackendRoot();
   if (!root) {
-    console.error('Cannot find atrisos-backend. Set $ATRIS_BACKEND_ROOT or clone to ~/arena/atrisos-backend.');
+    console.error('Cannot find local AEO workspace. Set ATRIS_AEO_ROOT to a workspace containing atris/features/aeo.');
     process.exit(1);
   }
   return root;

package/commands/computer.js

@@ -664,7 +664,6 @@ function findAtrisCodeTerminal() {
     envPath,
     path.join(__dirname, '..', 'cli', 'atris_code.py'),
     path.join(process.cwd(), 'cli', 'atris_code.py'),
-    path.join(os.homedir(), 'arena', 'atrisos-backend', 'cli', 'atris_code.py'),
   ].filter(Boolean);
 
   let dir = process.cwd();

package/commands/mission.js

@@ -1627,8 +1627,9 @@ async function runMission(args) {
     process.exit(0);
   }
 
+  const preLockRunner = String(mission.runner || '').trim().toLowerCase();
   const preLockCallerSession = runnerUsesCallerSession(mission.runner);
-  if (!skipClaude && !preLockCallerSession) {
+  if (!skipClaude && !preLockCallerSession && preLockRunner !== 'atris2') {
     const probe = probeClaudeBinary();
     if (!probe.ok) {
       console.error(`[mission run] claude probe failed: ${probe.error}`);

package/commands/recap.js

@@ -220,22 +220,6 @@ function recapAtris(args = []) {
     printRecapHelp();
     return;
   }
-  if (args.includes('--html')) {
-    // another way to view memory updates: a beautiful HTML page of what the workspace learned
-    const { buildMemorySpec } = require('../lib/memory-view');
-    const { renderHtml, renderBlock, THEMES: HTML_THEMES } = require('../lib/html-render');
-    const { mergedThemes } = require('../lib/theme');
-    const themes = mergedThemes(HTML_THEMES);
-    const flagVal = (n) => { const i = args.indexOf(n); return i !== -1 ? args[i + 1] : null; };
-    const spec = buildMemorySpec(process.cwd(), { theme: flagVal('--theme'), brand: flagVal('--brand') });
-    if (!themes[spec.theme]) spec.theme = 'atris';
-    if (args.includes('--block')) { console.log(JSON.stringify(renderBlock(spec, { title: 'Workspace memory', themes }), null, 2)); return; }
-    const html = renderHtml(spec, { title: 'Workspace memory', themes });
-    const out = flagVal('--out');
-    if (out) { fs.writeFileSync(out, html); console.log(`\n  ✓ memory view written: ${out}\n`); }
-    else process.stdout.write(html + '\n');
-    return;
-  }
   const daysIdx = args.indexOf('--days');
   const days = daysIdx !== -1 ? Number(args[daysIdx + 1]) : DEFAULT_DAYS;
   const data = buildRecapData(process.cwd(), { days });

package/commands/sync.js

@@ -463,6 +463,7 @@ function syncAtris() {
 
   const filesToSync = [
     { source: 'atris.md', target: 'atris.md' },
+    { source: 'atris/atrisDev.md', target: 'atrisDev.md' },
     { source: 'PERSONA.md', target: 'PERSONA.md' },
     { source: 'GETTING_STARTED.md', target: 'GETTING_STARTED.md' },
     { source: 'atris/CLAUDE.md', target: 'CLAUDE.md' },
@@ -807,6 +808,7 @@ function _findAtrisProjects(rootDir, maxDepth = 8) {
 // Canonical files shipped from the package root. Must match syncAtris's filesToSync.
 const SYNC_ALL_FILES = [
   { source: 'atris.md', target: 'atris.md' },
+  { source: 'atris/atrisDev.md', target: 'atrisDev.md' },
   { source: 'PERSONA.md', target: 'PERSONA.md' },
   { source: 'GETTING_STARTED.md', target: 'GETTING_STARTED.md' },
   { source: 'atris/CLAUDE.md', target: 'CLAUDE.md' },

package/commands/workflow.js

@@ -1626,8 +1626,7 @@ async function executeAgentSDKFast(userInput) {
   } catch (error) {
     console.error(`✗ Error: ${error.message}`);
     console.log('');
-    console.log('💡 Make sure the AtrisOS backend is running on port 8000');
-    console.log('   Start it with: cd /Users/keshavrao/arena/atrisos-backend/backend && python -m uvicorn main:app --reload --port 8000');
+    console.log('💡 Hosted turns use https://api.atris.ai. For local development, set ATRIS_API_BASE to your own backend URL.');
     process.exit(1);
   }
 }

package/commands/youtube.js

@@ -0,0 +1,183 @@
+const { apiRequestJson } = require('../utils/api');
+const { ensureValidCredentials } = require('../utils/auth');
+
+const DEFAULT_QUERY = 'Extract main topics, key insights, and actionable takeaways.';
+const DEFAULT_TIMEOUT_MS = 300000;
+
+function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
+  output('');
+  output(`Usage: ${commandName} process <youtube-url> [options]`);
+  output(`       ${commandName} <youtube-url> [options]`);
+  output('');
+  output('Process a YouTube video through Atris using Gemini native video analysis.');
+  output('');
+  output('Options:');
+  output('  --query, -q <text>  Focus question for the analysis');
+  output('  --agent <id>        Agent id to store knowledge against');
+  output('  --store             Save as agent knowledge (requires --agent)');
+  output('  --timeout <sec>     Request timeout in seconds (default: 300)');
+  output('  --json              Print the raw JSON response');
+  output('  -h, --help          This help');
+  output('');
+  output('Examples:');
+  output(`  ${commandName} https://www.youtube.com/watch?v=VIDEO_ID`);
+  output(`  ${commandName} process https://youtu.be/VIDEO_ID --query "Key takeaways"`);
+  output('');
+}
+
+function readValue(args, index, name) {
+  if (index >= args.length - 1 || String(args[index + 1]).startsWith('--')) {
+    throw new Error(`${name} requires a value`);
+  }
+  return args[index + 1];
+}
+
+function parseTimeoutMs(raw) {
+  const seconds = Number(raw);
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    throw new Error('--timeout must be a positive number of seconds');
+  }
+  return Math.round(seconds * 1000);
+}
+
+function parseYoutubeArgs(argv = []) {
+  const args = [...argv];
+  const options = {
+    help: false,
+    json: false,
+    youtubeUrl: null,
+    query: DEFAULT_QUERY,
+    agentId: null,
+    storeAsKnowledge: false,
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+  };
+
+  if (args.length === 0 || ['help', '--help', '-h'].includes(args[0])) {
+    options.help = true;
+    return options;
+  }
+
+  if (['process', 'analyze', 'watch'].includes(args[0])) {
+    args.shift();
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h' || arg === 'help') {
+      options.help = true;
+    } else if (arg === '--json') {
+      options.json = true;
+    } else if (arg === '--store' || arg === '--store-as-knowledge') {
+      options.storeAsKnowledge = true;
+    } else if (arg === '--query' || arg === '-q') {
+      options.query = readValue(args, i, arg);
+      i++;
+    } else if (arg.startsWith('--query=')) {
+      options.query = arg.slice('--query='.length);
+    } else if (arg === '--agent' || arg === '--agent-id') {
+      options.agentId = readValue(args, i, arg);
+      i++;
+    } else if (arg.startsWith('--agent=')) {
+      options.agentId = arg.slice('--agent='.length);
+    } else if (arg === '--timeout') {
+      options.timeoutMs = parseTimeoutMs(readValue(args, i, arg));
+      i++;
+    } else if (arg.startsWith('--timeout=')) {
+      options.timeoutMs = parseTimeoutMs(arg.slice('--timeout='.length));
+    } else if (arg.startsWith('-')) {
+      throw new Error(`Unknown option: ${arg}`);
+    } else if (!options.youtubeUrl) {
+      options.youtubeUrl = arg;
+    } else {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+  }
+
+  if (options.help) return options;
+  if (!options.youtubeUrl) throw new Error('Missing YouTube URL. Run "atris youtube --help".');
+  if (options.storeAsKnowledge && !options.agentId) {
+    throw new Error('--store requires --agent <id>');
+  }
+  return options;
+}
+
+function buildYoutubePayload(options) {
+  const payload = {
+    youtube_url: options.youtubeUrl,
+    query: options.query || DEFAULT_QUERY,
+  };
+  if (options.agentId) payload.agent_id = options.agentId;
+  if (options.storeAsKnowledge) payload.store_as_knowledge = true;
+  return payload;
+}
+
+async function processYoutube(options, deps = {}) {
+  const apiFn = deps.apiRequestJson || apiRequestJson;
+  const ensureFn = deps.ensureValidCredentials || ensureValidCredentials;
+  const ensured = await ensureFn(apiFn);
+  const creds = ensured && ensured.credentials;
+  if (!creds?.token) {
+    const detail = ensured?.detail || ensured?.error;
+    throw new Error(detail ? `Authentication failed: ${detail}. Run "atris login".` : 'Not logged in. Run "atris login".');
+  }
+
+  const result = await apiFn('/agent/process_youtube', {
+    method: 'POST',
+    token: creds.token,
+    timeoutMs: options.timeoutMs,
+    body: buildYoutubePayload(options),
+  });
+
+  if (!result.ok) {
+    const hint = result.status === 401
+      ? ' Run "atris login --force".'
+      : result.status === 402
+        ? ' Check Atris credits.'
+        : '';
+    throw new Error(`YouTube processing failed (${result.status}): ${result.error || result.text || 'unknown error'}.${hint}`);
+  }
+
+  return result.data;
+}
+
+function formatYoutubeResult(data) {
+  const lines = [];
+  const metadata = data?.metadata || {};
+  lines.push(data?.message || 'YouTube video processed successfully');
+  if (metadata.title) lines.push(`Title: ${metadata.title}`);
+  if (metadata.channel) lines.push(`Channel: ${metadata.channel}`);
+  if (data?.credits_used !== undefined || data?.credits_remaining !== undefined) {
+    const used = data.credits_used !== undefined ? data.credits_used : '?';
+    const remaining = data.credits_remaining !== undefined ? data.credits_remaining : '?';
+    lines.push(`Credits: ${used} used, ${remaining} remaining`);
+  }
+  const analysis = data?.video_analysis || data?.analysis || data?.result;
+  if (analysis) {
+    lines.push('');
+    lines.push(String(analysis).trim());
+  }
+  return lines.join('\n');
+}
+
+async function youtubeCommand(argv = process.argv.slice(3), deps = {}) {
+  const output = deps.output || ((line = '') => console.log(line));
+  const options = parseYoutubeArgs(argv);
+  if (options.help) {
+    showYoutubeHelp(output, deps.commandName || 'atris youtube');
+    return 0;
+  }
+  const data = await processYoutube(options, deps);
+  output(options.json ? JSON.stringify(data, null, 2) : formatYoutubeResult(data));
+  return 0;
+}
+
+module.exports = {
+  DEFAULT_QUERY,
+  DEFAULT_TIMEOUT_MS,
+  showYoutubeHelp,
+  parseYoutubeArgs,
+  buildYoutubePayload,
+  processYoutube,
+  formatYoutubeResult,
+  youtubeCommand,
+};

package/lib/ax-chat-input.js

@@ -0,0 +1,164 @@
+const MULTILINE_CSI = [
+  '\x1b[13;2~',
+  '\x1b[27;2;13~',
+  '\x1b[23~',
+  '\x1b[13;2u',
+];
+
+const MULTILINE_CSI_RE = /\x1b\[(?:13;2~|27;2;13~|23~|13;2u)/;
+const MULTILINE_CSI_VISIBLE_RE = /\[(?:13;2~|27;2;13~|23~|13;2u)/g;
+
+// Node's readline cannot emit a 'line' whose buffer contains a literal "\n"
+// (it reorders the text around the newline on submit). So newlines live in the
+// buffer as this sentinel while typing is rendered, then are restored to "\n"
+// when the answer is read back via stripMultilineCsiText.
+const MULTILINE_PLACEHOLDER = '\x1f';
+const MULTILINE_PLACEHOLDER_RE = /\x1f/g;
+
+function isMultilineCsiPrefix(buffer) {
+  const value = String(buffer || '');
+  if (!value) return false;
+  return MULTILINE_CSI.some((seq) => seq.startsWith(value));
+}
+
+function isMultilineCsiComplete(buffer) {
+  return MULTILINE_CSI.includes(String(buffer || ''));
+}
+
+function isMultilineCsiKey(key) {
+  const sequence = String(key?.sequence || '');
+  return MULTILINE_CSI_RE.test(sequence);
+}
+
+function isMultilineInsertKey(str, key) {
+  if (!key) return str === '\n';
+  if (key.shift && (key.name === 'return' || key.name === 'enter')) return true;
+  if (key.meta && (key.name === 'return' || key.name === 'enter')) return true;
+  if (str === '\n' && key.name !== 'return') return true;
+  return false;
+}
+
+function isSubmitKey(str, key) {
+  if (key && (key.name === 'return' || key.name === 'enter') && !key.shift && !key.meta) return true;
+  if (!key && str === '\r') return true;
+  return false;
+}
+
+function stripMultilineCsiText(text) {
+  return String(text || '')
+    .replace(MULTILINE_PLACEHOLDER_RE, '\n')
+    .replace(/\x1b\[20[01]~/g, '')
+    .replace(/\x1b\[(?:13;2~|27;2;13~|23~|13;2u)/g, '\n')
+    .replace(MULTILINE_CSI_VISIBLE_RE, '\n')
+    .replace(/\^?\[\[27;2;13~/g, '\n');
+}
+
+// The raw bytes a keypress represents. readline's keypress decoder mangles
+// some CSI sequences (e.g. it splits \x1b[27;2;13~ into a malformed escape
+// whose `sequence` is \x1b[27;2; followed by literal "1", "3", "~"), so when
+// `str` is empty we fall back to the decoded `sequence`.
+function keyBytes(str, key) {
+  if (typeof str === 'string' && str.length > 0) return str;
+  if (key && typeof key.sequence === 'string' && key.sequence.length > 0) return key.sequence;
+  return typeof str === 'string' ? str : '';
+}
+
+function defaultInsertBreak(rl) {
+  if (!rl) return;
+  // _insertString splices a literal newline at the cursor; rl.write('\n')
+  // would instead SUBMIT the line, so it must not be used here.
+  if (typeof rl._insertString === 'function') {
+    rl._insertString('\n');
+    return;
+  }
+  if (typeof rl.line === 'string') {
+    const cursor = Number.isFinite(rl.cursor) ? rl.cursor : rl.line.length;
+    rl.line = rl.line.slice(0, cursor) + '\n' + rl.line.slice(cursor);
+    rl.cursor = cursor + 1;
+    if (typeof rl._refreshLine === 'function') rl._refreshLine();
+    return;
+  }
+  if (typeof rl.write === 'function') rl.write('\n');
+}
+
+function attachMultilineChatInput(rl, { insertBreak = defaultInsertBreak, onSubmit } = {}) {
+  if (!rl || typeof rl._ttyWrite !== 'function') return () => {};
+  const ttyWrite = rl._ttyWrite.bind(rl);
+  let escBuffer = null;
+
+  rl._ttyWrite = (str, key) => {
+    const bytes = keyBytes(str, key);
+
+    // Mid-sequence: keypress decoder shredded a multiline CSI across calls and
+    // we're reassembling it (e.g. \x1b[27;2; then "1", "3", "~").
+    if (escBuffer !== null) {
+      escBuffer += bytes;
+      if (isMultilineCsiComplete(escBuffer)) {
+        escBuffer = null;
+        insertBreak(rl);
+        return;
+      }
+      if (isMultilineCsiPrefix(escBuffer) && escBuffer.length <= 24) {
+        return;
+      }
+      // Diverged from every target sequence: replay the swallowed bytes
+      // literally (current keypress is already included in the buffer).
+      const replay = escBuffer;
+      escBuffer = null;
+      for (const ch of replay) ttyWrite(ch);
+      return;
+    }
+
+    // Whole multiline CSI delivered in a single keypress (terminals or Node
+    // versions that don't shred it).
+    if (isMultilineCsiKey(key) || MULTILINE_CSI_RE.test(bytes)) {
+      insertBreak(rl);
+      return;
+    }
+
+    // Start of a shredded multiline CSI: begin buffering from the raw escape.
+    if (bytes && bytes.charCodeAt(0) === 0x1b && isMultilineCsiPrefix(bytes)) {
+      escBuffer = bytes;
+      if (isMultilineCsiComplete(escBuffer)) {
+        escBuffer = null;
+        insertBreak(rl);
+      }
+      return;
+    }
+
+    // Plain Shift+Enter / Meta+Enter / synthetic \n.
+    if (isMultilineInsertKey(str, key)) {
+      insertBreak(rl);
+      return;
+    }
+
+    // Submit (Enter): the line buffer keeps its literal "\n" so readline's own
+    // multiline cursor math advances past every wrapped row (otherwise the box
+    // bottom border overwrites a row). readline mangles the emitted 'line'
+    // string when it holds a newline, so we hand the true buffer to onSubmit
+    // and the caller reads that instead of the line event.
+    if (isSubmitKey(str, key) && typeof rl.line === 'string' && rl.line.includes('\n')) {
+      if (typeof onSubmit === 'function') onSubmit(rl.line);
+    }
+
+    ttyWrite(str, key);
+  };
+
+  return () => {
+    rl._ttyWrite = ttyWrite;
+    escBuffer = null;
+  };
+}
+
+module.exports = {
+  MULTILINE_CSI,
+  MULTILINE_PLACEHOLDER,
+  attachMultilineChatInput,
+  isMultilineCsiComplete,
+  isMultilineCsiKey,
+  isMultilineInsertKey,
+  isMultilineCsiPrefix,
+  isSubmitKey,
+  stripMultilineCsiText,
+  keyBytes,
+};