shmakk 1.1.0

package/src/index.js

@@ -0,0 +1,166 @@
+const { parseArgs, HELP } = require('./cli');
+const { normalizeProfile, resolveProfile } = require('./profiles');
+const { applyEndpoint } = require('./endpoints');
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+
+  // Apply named endpoint preset from .shmakk/endpoints.json before
+  // any other module reads SHMAKK_* environment variables.
+  if (opts.endpoint) {
+    const cwd = opts.workspace || process.cwd();
+    if (!applyEndpoint(opts.endpoint, cwd)) {
+      process.stderr.write(`[shmakk] endpoint "${opts.endpoint}" not found in ${path.join(cwd, '.shmakk', 'endpoints.json')}\n`);
+    }
+  }
+
+  if (opts.colors !== null) {
+    const v = String(opts.colors).toLowerCase();
+    if (v !== 'true' && v !== 'false') {
+      process.stderr.write('[shmakk] invalid --colors. Use: true|false\n');
+      process.exit(2);
+    }
+    opts.colors = v === 'true';
+  }
+
+  if (opts.help) {
+    process.stdout.write(HELP);
+    process.exit(0);
+  }
+
+  if (opts.completion) {
+    const { generate } = require('./completions');
+    try {
+      process.stdout.write(generate(opts.completion));
+      process.exit(0);
+    } catch (e) {
+      process.stderr.write(`[shmakk] ${e.message}\n`);
+      process.exit(1);
+    }
+  }
+
+  if (opts.printConfig) {
+    const profile = resolveProfile(opts.profile || process.env.SHMAKK_PROFILE);
+    const cfg = {
+      review: opts.review,
+      yesFiles: opts.yesFiles,
+      noAi: opts.noAi,
+      noCorrection: opts.noCorrection,
+      workspace: opts.workspace || process.cwd(),
+      shell: process.env.SHELL,
+      term: process.env.TERM,
+      baseUrl: process.env.SHMAKK_BASE_URL || null,
+      model: process.env.SHMAKK_MODEL || null,
+      endpoint: opts.endpoint || null,
+      profile: profile.name,
+      colors: opts.colors,
+      stt: opts.stt,
+      tts: opts.tts,
+      sts: opts.sts,
+    };
+    process.stdout.write(JSON.stringify(cfg, null, 2) + '\n');
+    process.exit(0);
+  }
+
+  if (opts.updateGlossary) {
+    const { updateGlossary } = require('./glossary');
+    await updateGlossary({ debug: opts.debug });
+    process.exit(0);
+  }
+
+  if (opts.buildHistory !== null) {
+    const hist = require('./history-parser');
+    const files = opts.buildHistory && opts.buildHistory.length
+      ? opts.buildHistory
+      : hist.autoDetectHistoryFiles();
+    if (!files.length) {
+      process.stderr.write('[shmakk] no history files found. Specify paths: shmakk --build-history ~/.bash_history ...\n');
+      process.exit(1);
+    }
+    process.stdout.write(`[shmakk] parsing ${files.length} history file(s)...\n`);
+    for (const f of files) process.stdout.write(`  ${f}\n`);
+    const freqMap = hist.buildFreqMap(files);
+    const count = Object.keys(freqMap).length;
+    const total = Object.values(freqMap).reduce((a, b) => a + b, 0);
+    const saved = hist.saveFreqMap(freqMap);
+    process.stdout.write(`[shmakk] built frequency map: ${count} unique commands, ${total} total uses\n`);
+    process.stdout.write(`[shmakk] saved to: ${saved}\n`);
+    process.exit(0);
+  }
+
+  if (opts.status || opts.stats || opts.compact || opts.loadSkill || opts.installSkill || opts.listSkills || opts.skillStatus || opts.unloadSkill || opts.resumeStatus || opts.exitNow || opts.restart || opts.reset || opts.profileSet) {
+    const ctl = require('./control');
+    if (opts.status) process.exit(ctl.status());
+    if (opts.stats) process.exit(ctl.stats());
+    if (opts.compact) process.exit(ctl.compactContext());
+    if (opts.loadSkill) process.exit(ctl.loadSkill(opts.loadSkill));
+    if (opts.installSkill) process.exit(await ctl.installSkill(opts.installSkill));
+    if (opts.listSkills) process.exit(ctl.listSkills());
+    if (opts.skillStatus) process.exit(ctl.skillStatus());
+    if (opts.unloadSkill) process.exit(ctl.unloadSkill(opts.unloadSkill));
+    if (opts.resumeStatus) process.exit(ctl.resumeStatus());
+    if (opts.exitNow) process.exit(ctl.exitParent());
+    if (opts.restart) process.exit(ctl.restartParent());
+    if (opts.reset) process.exit(ctl.resetConversation());
+    if (opts.profileSet) process.exit(ctl.setProfileAndRestart(opts.profileSet));
+  }
+
+  if (opts.profile && !normalizeProfile(opts.profile)) {
+    process.stderr.write('[shmakk] invalid --profile. Use: tiny|balanced|deep|builder|large-app\n');
+    process.exit(2);
+  }
+
+  if (opts.unknown.length) {
+    process.stderr.write(`[shmakk] unknown args: ${opts.unknown.join(' ')}\n`);
+    process.stderr.write(HELP);
+    process.exit(2);
+  }
+
+  // Lazy-init STT/TTS models if flags are set (model downloads happen on first use)
+  if (opts.stt || opts.tts || opts.sts) {
+    const initTasks = [];
+    if (opts.stt || opts.sts) {
+      const { _ensureModel } = require('./services/stt');
+      initTasks.push(
+        _ensureModel().then(() => process.stdout.write('[shmakk] STT ready (Whisper ONNX)\n')),
+      );
+    }
+    if (opts.tts || opts.sts) {
+      const tts = require('./services/tts');
+      const voice = opts.ttsVoice || process.env.SHMAKK_TTS_VOICE || 'af_heart';
+      initTasks.push(
+        tts.listVoices().then(() => process.stdout.write(`[shmakk] TTS ready (Kokoro ONNX, voice=${voice})\n`)),
+      );
+    }
+    // Don't block startup — models download in background
+    Promise.allSettled(initTasks).then((results) => {
+      for (const r of results) {
+        if (r.status === 'rejected') {
+          process.stderr.write(`[shmakk] voice init: ${r.reason?.message || r.reason}\n`);
+        }
+      }
+    });
+  }
+
+  // Pre-seed SHMAKK_VOICE_* env vars from CLI flags before voice module loads.
+  // voice.js reads these at require-time; orchestrator → session → getVoiceService().
+  if (opts.voiceLanguage) process.env.SHMAKK_VOICE_LANGUAGE = opts.voiceLanguage;
+  if (opts.voiceMaxDuration) process.env.SHMAKK_VOICE_MAX_SEC = String(opts.voiceMaxDuration);
+  if (opts.voiceSilenceSec) process.env.SHMAKK_VOICE_SILENCE_SEC = opts.voiceSilenceSec;
+  if (opts.voiceSilenceThreshold) process.env.SHMAKK_VOICE_SILENCE_THRESHOLD = opts.voiceSilenceThreshold;
+  if (opts.voiceSilenceStartSec) process.env.SHMAKK_VOICE_SILENCE_START_SEC = opts.voiceSilenceStartSec;
+  if (opts.voicePadStartSec) process.env.SHMAKK_VOICE_PAD_START_SEC = opts.voicePadStartSec;
+  if (opts.ttsVoice) process.env.SHMAKK_TTS_VOICE = opts.ttsVoice;
+
+  const { start } = require('./orchestrator');
+  const exitCode = await start(opts);
+  process.exit(exitCode);
+}
+
+main().catch((err) => {
+  process.stderr.write(`[shmakk] fatal: ${err && err.stack || err}\n`);
+  process.exit(1);
+});

package/src/llm.js

@@ -0,0 +1,45 @@
+let OpenAI;
+try { OpenAI = require('openai'); } catch { OpenAI = null; }
+
+function parseHeaders(s) {
+  const out = {};
+  if (!s) return out;
+  for (const part of s.split(',')) {
+    const eq = part.indexOf('=');
+    if (eq === -1) continue;
+    const k = part.slice(0, eq).trim();
+    const v = part.slice(eq + 1).trim();
+    if (k) out[k] = v;
+  }
+  return out;
+}
+
+function envForProvider() {
+  return {
+    baseURL: process.env.SHMAKK_BASE_URL,
+    apiKey: process.env.SHMAKK_API_KEY,
+    headers: process.env.SHMAKK_HEADERS,
+    model: process.env.SHMAKK_MODEL,
+  };
+}
+
+function isConfigured() {
+  const cfg = envForProvider();
+  return !!cfg.baseURL && !!OpenAI;
+}
+
+function makeClient() {
+  if (!OpenAI) throw new Error('openai sdk not installed');
+  const cfg = envForProvider();
+  return new OpenAI({
+    baseURL: cfg.baseURL,
+    apiKey: cfg.apiKey || 'not-needed',
+    defaultHeaders: parseHeaders(cfg.headers),
+  });
+}
+
+function modelFor() {
+  return process.env.SHMAKK_MODEL || 'gpt-4o-mini';
+}
+
+module.exports = { makeClient, modelFor, isConfigured };

package/src/markers.js

@@ -0,0 +1,113 @@
+// OSC marker emitted by injected shell hooks:
+//   ESC ] 6973 ; <type> ; <payload> BEL
+// Types:
+//   B  command starting    payload = base64(command line)
+//   C  command finished    payload = exit code (decimal)
+//   D  cwd update          payload = base64(absolute path)
+
+const OSC = '\x1b]6973;';
+const BEL = '\x07';
+const PARTIAL_KEEP = 64; // bytes of unfinished sequence we hold across chunks
+
+function b64decode(s) {
+  try { return Buffer.from(s, 'base64').toString('utf8'); } catch { return ''; }
+}
+
+function createMarkerStream(emit) {
+  // emit(event, payload) — events: 'command', 'exit', 'cwd'
+  // returns a function: feed(buf) -> cleanedBuf (Buffer)
+  let pending = '';
+
+  return function feed(chunk) {
+    pending += chunk.toString('utf8');
+    let out = '';
+    let i = 0;
+    while (i < pending.length) {
+      const start = pending.indexOf(OSC, i);
+      if (start === -1) {
+        out += pending.slice(i);
+        i = pending.length;
+        break;
+      }
+      out += pending.slice(i, start);
+      const end = pending.indexOf(BEL, start + OSC.length);
+      if (end === -1) {
+        // incomplete marker — keep it in pending for next chunk
+        pending = pending.slice(start);
+        return Buffer.from(out, 'utf8');
+      }
+      const body = pending.slice(start + OSC.length, end);
+      const semi = body.indexOf(';');
+      const type = semi === -1 ? body : body.slice(0, semi);
+      const data = semi === -1 ? '' : body.slice(semi + 1);
+      switch (type) {
+        case 'B': emit('command', b64decode(data)); break;
+        case 'C': emit('exit', parseInt(data, 10)); break;
+        case 'D': emit('cwd', b64decode(data)); break;
+      }
+      i = end + 1;
+    }
+    // Possibly trailing incomplete ESC near the end without OSC prefix yet
+    const lastEsc = pending.lastIndexOf('\x1b', pending.length - 1);
+    if (lastEsc !== -1 && lastEsc >= i && (pending.length - lastEsc) < PARTIAL_KEEP &&
+        !pending.slice(lastEsc).includes(BEL)) {
+      out = out.slice(0, out.length - (pending.length - lastEsc));
+      pending = pending.slice(lastEsc);
+      return Buffer.from(out, 'utf8');
+    }
+    pending = '';
+    return Buffer.from(out, 'utf8');
+  };
+}
+
+// Strip terminal-response sequences (DA, DSR, OSC color queries) from stdin
+// before forwarding to the child PTY. These come back from the terminal in
+// reply to queries the shell or its plugins make at startup; if they arrive
+// after the shell is already at the prompt, they appear as typed input.
+//
+// Examples we strip:
+//   ESC ] N ; ... BEL                     (OSC with BEL term)
+//   ESC ] N ; ... ESC \                   (OSC with ST term)
+//   ESC [ <digits>;<digits> R             (cursor position report / DSR)
+//   ESC [ ? <digits>(;<digits>)* c        (primary device attributes)
+//   ESC [ > <digits>(;<digits>)* c        (secondary device attributes)
+//
+// User-typed bare ESC (Escape key) is preserved.
+
+function createStdinFilter() {
+  let pending = Buffer.alloc(0);
+  const HOLD_MAX = 128;
+  return function feed(chunk) {
+    pending = pending.length ? Buffer.concat([pending, chunk]) : Buffer.from(chunk);
+    const out = [];
+    let i = 0;
+    while (i < pending.length) {
+      const b = pending[i];
+      if (b !== 0x1b) { out.push(b); i++; continue; }
+      // Look at what follows ESC.
+      const tail = pending.slice(i);
+      const tailStr = tail.toString('binary');
+      // OSC: ESC ] ... (BEL | ESC \)
+      let m = /^\x1b\][^\x07\x1b]*(\x07|\x1b\\)/.exec(tailStr);
+      if (m) { i += m[0].length; continue; }
+      // CSI response: ESC [ optional ?> digits ; digits R/c
+      m = /^\x1b\[[\?>]?[\d;]*[Rc]/.exec(tailStr);
+      if (m) { i += m[0].length; continue; }
+      // Possibly incomplete — hold short tail for next chunk
+      if (tail.length < HOLD_MAX && (
+        /^\x1b\][^\x07\x1b]*$/.test(tailStr) ||
+        /^\x1b\[[\?>]?[\d;]*$/.test(tailStr) ||
+        tailStr === '\x1b' || tailStr === '\x1b['
+      )) {
+        pending = tail;
+        return Buffer.from(out);
+      }
+      // Bare ESC or unknown sequence — pass through
+      out.push(b); i++;
+    }
+    pending = Buffer.alloc(0);
+    return Buffer.from(out);
+  };
+}
+
+module.exports = { createMarkerStream, createStdinFilter, OSC, BEL };

package/src/orchestrator.js

@@ -0,0 +1,61 @@
+// shmakk orchestrator entry point.
+// Manages signal-driven lifecycle (restart, exit, profile changes) and
+// delegates each session to ./session.js.
+
+const { runOneSession } = require('./session');
+const { normalizeProfile } = require('./profiles');
+const { profileSignalPath } = require('./control');
+
+function isAbortError(e) {
+  return e && (e.name === 'AbortError' || /aborted/i.test(String(e.message || '')));
+}
+
+function stripAnsi(s) {
+  return String(s || '').replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+async function start(opts) {
+  let runtimeProfile = normalizeProfile(opts.profile || process.env.SHMAKK_PROFILE) || 'balanced';
+  let lastExit = 0;
+  let restartRequested = false;
+  let exitRequested = false;
+  let activeSession = null;
+
+  // Handlers persist across restarts; only installed once.
+  const onSigTerm = () => { exitRequested = true; if (activeSession) activeSession.kill(); };
+  const onSigUsr1 = () => { restartRequested = true; if (activeSession) activeSession.kill(); };
+  // SIGUSR2 = clear conversation history. Hot-replaced per session below.
+  let onSigUsr2 = () => {};
+  process.on('SIGTERM', onSigTerm);
+  process.on('SIGUSR1', onSigUsr1);
+  process.on('SIGUSR2', () => onSigUsr2());
+
+  while (true) {
+    const signalFile = profileSignalPath(process.pid);
+    try {
+      const fs = require('fs');
+      if (fs.existsSync(signalFile)) {
+        const requested = String(fs.readFileSync(signalFile, 'utf8') || '').trim().toLowerCase();
+        const normalized = normalizeProfile(requested);
+        if (normalized) runtimeProfile = normalized;
+        fs.rmSync(signalFile, { force: true });
+      }
+    } catch {}
+    lastExit = await runOneSession({ ...opts, profile: runtimeProfile }, (s, resetFn) => { activeSession = s; onSigUsr2 = resetFn; });
+    activeSession = null;
+    onSigUsr2 = () => {};
+    if (exitRequested) break;
+    if (restartRequested) {
+      restartRequested = false;
+      process.stdout.write('\r\n\x1b[36m[shmakk] restarting...\x1b[0m\r\n');
+      continue;
+    }
+    break;
+  }
+  process.removeListener('SIGTERM', onSigTerm);
+  process.removeListener('SIGUSR1', onSigUsr1);
+
+  return lastExit;
+}
+
+module.exports = { start };

package/src/profiles.js

@@ -0,0 +1,19 @@
+const PRESETS = {
+  tiny: { contextMode: 'tiny', maxToolIters: 10 },
+  balanced: { contextMode: 'balanced', maxToolIters: 16 },
+  deep: { contextMode: 'deep', maxToolIters: 24 },
+  builder: { contextMode: 'deep', maxToolIters: 32 },
+  'large-app': { contextMode: 'deep', maxToolIters: 32 },
+};
+
+function normalizeProfile(name) {
+  const n = String(name || '').toLowerCase();
+  return PRESETS[n] ? n : null;
+}
+
+function resolveProfile(name) {
+  const key = normalizeProfile(name) || 'balanced';
+  return { name: key, ...PRESETS[key] };
+}
+
+module.exports = { PRESETS, normalizeProfile, resolveProfile };

package/src/prompt-cache.js

@@ -0,0 +1,83 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const DEFAULT_TTL_MS = Math.max(60_000, Number(process.env.SHMAKK_PROMPT_CACHE_TTL_MS) || 6 * 60 * 60 * 1000);
+const DEFAULT_MAX_ENTRIES = Math.max(20, Number(process.env.SHMAKK_PROMPT_CACHE_MAX_ENTRIES) || 200);
+
+function cachePath(root) {
+  return path.join(root, '.shmakk', 'state', 'prompt-cache.json');
+}
+
+function hashObj(obj) {
+  return crypto.createHash('sha256').update(JSON.stringify(obj), 'utf8').digest('hex');
+}
+
+function normalizeMessages(messages) {
+  return (messages || []).map((m) => ({
+    role: m.role,
+    content: m.content,
+    tool_calls: m.tool_calls || undefined,
+    tool_call_id: m.tool_call_id || undefined,
+  }));
+}
+
+function makeKey({ model, messages, toolChoice = 'auto' }) {
+  return hashObj({ model, toolChoice, messages: normalizeMessages(messages) });
+}
+
+function load(root) {
+  try {
+    const p = cachePath(root);
+    if (!fs.existsSync(p)) return { entries: {} };
+    const j = JSON.parse(fs.readFileSync(p, 'utf8'));
+    return { entries: j.entries || {} };
+  } catch {
+    return { entries: {} };
+  }
+}
+
+function save(root, cache) {
+  try {
+    const p = cachePath(root);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify({ entries: cache.entries || {} }, null, 2));
+  } catch {}
+}
+
+function get(root, key, ttlMs = DEFAULT_TTL_MS) {
+  const c = load(root);
+  const e = c.entries[key];
+  if (!e) return null;
+  const age = Date.now() - Number(e.createdAt || 0);
+  if (!Number.isFinite(age) || age > ttlMs) {
+    delete c.entries[key];
+    save(root, c);
+    return null;
+  }
+  e.lastHitAt = Date.now();
+  e.hits = Number(e.hits || 0) + 1;
+  c.entries[key] = e;
+  save(root, c);
+  return e;
+}
+
+function put(root, key, value, maxEntries = DEFAULT_MAX_ENTRIES) {
+  const c = load(root);
+  c.entries[key] = {
+    content: String(value.content || ''),
+    createdAt: Date.now(),
+    lastHitAt: Date.now(),
+    hits: 0,
+  };
+
+  const keys = Object.keys(c.entries);
+  if (keys.length > maxEntries) {
+    keys.sort((a, b) => Number(c.entries[a].lastHitAt || 0) - Number(c.entries[b].lastHitAt || 0));
+    const removeN = keys.length - maxEntries;
+    for (let i = 0; i < removeN; i++) delete c.entries[keys[i]];
+  }
+  save(root, c);
+}
+
+module.exports = { makeKey, get, put };

package/src/pty.js

@@ -0,0 +1,107 @@
+const pty = require('node-pty');
+const { EventEmitter } = require('events');
+const { detectShell } = require('./shell');
+const { configureForShell } = require('./hooks');
+const { createMarkerStream, createStdinFilter } = require('./markers');
+
+function getSize() {
+  return {
+    cols: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24,
+  };
+}
+
+const VOICE_HOTKEY = 0x0f; // Ctrl+O — triggers voice recording
+
+function startSession({ debug = false, voiceEnabled = false } = {}) {
+  const shell = detectShell();
+  const cfg = configureForShell(shell.name);
+  const { cols, rows } = getSize();
+
+  if (debug) {
+    process.stderr.write(`[shmakk] shell=${shell.path} args=${cfg.args.join(' ')}\n`);
+  }
+
+  const child = pty.spawn(shell.path, cfg.args, {
+    name: process.env.TERM || 'xterm-256color',
+    cols, rows,
+    cwd: process.cwd(),
+    // SHMAKK_PID lets `shmakk --status/--exit/--restart` find us from
+    // inside the inner shell.
+    env: { ...process.env, SHMAKK: '1', SHMAKK_PID: String(process.pid), ...cfg.env },
+  });
+
+  const ev = new EventEmitter();
+  // Stack of stdin handlers: top of stack receives data. Null at bottom
+  // means "relay to child PTY".
+  const stdinStack = [];
+  const topHandler = () => stdinStack.length ? stdinStack[stdinStack.length - 1] : null;
+
+  const feed = createMarkerStream((type, data) => ev.emit(type, data));
+  const filterStdin = createStdinFilter();
+
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const wasRaw = stdin.isTTY ? stdin.isRaw : false;
+  if (stdin.isTTY) stdin.setRawMode(true);
+  stdin.resume();
+
+  const onStdin = (data) => {
+    const h = topHandler();
+    if (h) return h(data);
+
+    // Voice hotkey detection — only when voice is enabled
+    if (voiceEnabled) {
+      const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      if (buf.length === 1 && buf[0] === VOICE_HOTKEY) {
+        ev.emit('voice');
+        return;
+      }
+    }
+
+    const cleaned = filterStdin(Buffer.isBuffer(data) ? data : Buffer.from(data));
+    if (cleaned.length) child.write(cleaned);
+  };
+  const onPty = (data) => {
+    const cleaned = feed(Buffer.isBuffer(data) ? data : Buffer.from(data));
+    if (cleaned.length) ev.emit('output', cleaned);
+  };
+  const onResize = () => {
+    const s = getSize();
+    try { child.resize(s.cols, s.rows); } catch {}
+  };
+
+  stdin.on('data', onStdin);
+  child.onData(onPty);
+  process.stdout.on('resize', onResize);
+
+  const exitPromise = new Promise((resolve) => {
+    child.onExit(({ exitCode, signal }) => {
+      stdin.removeListener('data', onStdin);
+      process.stdout.removeListener('resize', onResize);
+      if (stdin.isTTY) { try { stdin.setRawMode(wasRaw); } catch {} }
+      stdin.pause();
+      cfg.cleanup();
+      resolve({ exitCode: exitCode ?? 0, signal });
+    });
+  });
+
+  return {
+    ev,
+    stdoutWrite: (s) => stdout.write(s),
+    childWrite: (s) => child.write(s),
+    // Push a handler; returns a release fn that pops it. Stacked so nested
+    // captures (e.g. ask() inside an AI tap) don't wipe the outer handler.
+    captureStdin(handler) {
+      stdinStack.push(handler);
+      return () => {
+        const i = stdinStack.lastIndexOf(handler);
+        if (i !== -1) stdinStack.splice(i, 1);
+      };
+    },
+    waitExit: () => exitPromise,
+    kill: () => { try { child.kill(); } catch {} },
+  };
+}
+
+module.exports = { startSession };

package/src/review.js

@@ -0,0 +1,75 @@
+// Y/n prompt with cooperative cancellation. The returned `ask` accepts an
+// optional `{ onCancel }` callback that fires when the user hits Ctrl-C.
+
+function makePrompter(pty, write) {
+  return function ask(question, defaultYes, { onCancel, onWhy } = {}) {
+    return new Promise((resolve) => {
+      const tag = defaultYes ? '[Y/n/?]' : '[y/N/?]';
+      write(`${question} ${tag} `);
+      let buf = '';
+      function finishYesNo(ans) {
+        write('\n');
+        release();
+        return resolve(ans);
+      }
+      const release = pty.captureStdin((data) => {
+        for (const ch of data.toString('utf8')) {
+          const code = ch.charCodeAt(0);
+          if (!buf && (ch === 'y' || ch === 'Y')) return finishYesNo(true);
+          if (!buf && (ch === 'n' || ch === 'N')) return finishYesNo(false);
+          if (!buf && ch === '?') {
+            write('\n');
+            if (onWhy) onWhy();
+            write(`${question} ${tag} `);
+            continue;
+          }
+          if (ch === '\r' || ch === '\n') {
+            write('\n');
+            const ans = buf.trim().toLowerCase();
+            if (!ans) {
+              release();
+              return resolve(defaultYes);
+            }
+            if (ans === '?') {
+              if (onWhy) onWhy();
+              buf = '';
+              write(`${question} ${tag} `);
+              return;
+            }
+            release();
+            return resolve(ans === 'y' || ans === 'yes');
+          }
+          if (code === 0x7f || code === 0x08) {
+            if (buf.length) { buf = buf.slice(0, -1); write('\b \b'); }
+          } else if (code === 0x03) { // Ctrl-C
+            write('^C\n');
+            release();
+            if (onCancel) onCancel();
+            return resolve(false);
+          } else if (code >= 0x20) {
+            buf += ch;
+            write(ch);
+          }
+        }
+      });
+    });
+  };
+}
+
+function decisionBanner({ input, decision, mode }) {
+  const lines = [];
+  lines.push('');
+  lines.push('\x1b[36m── shmakk ──\x1b[0m');
+  lines.push(`  input:    ${input}`);
+  lines.push(`  category: ${decision.category}`);
+  if (decision.proposed) lines.push(`  proposed: ${decision.proposed}`);
+  lines.push(`  safety:   ${decision.safety}`);
+  if (decision.reason) lines.push(`  reason:   ${decision.reason}`);
+  if (mode === 'review') {
+    const wouldAuto = decision.safety === 'safe' && decision.category === 'command_correction';
+    lines.push(`  auto-mode: ${wouldAuto ? 'would auto-run' : 'would ask confirmation'}`);
+  }
+  return lines.join('\r\n') + '\r\n';
+}
+
+module.exports = { makePrompter, decisionBanner };