@synqa/cli 0.0.0-stage → 1.1.1

package/dist/init.js

@@ -0,0 +1,177 @@
+// /init: scan the project and write a starter AGENTS.md. No model call; the output is a plain
+// template filled from what is on disk, for the user to edit.
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, extname, join } from "node:path";
+import { snapshot } from "./journal.js";
+                                                
+import { confine, writeConfined } from "./paths.js";
+import { sanitize } from "./sanitize.js";
+
+                                                     
+
+                           
+               
+                                         
+                                              
+                      
+                      
+                     
+  
+
+const SKIP = new Set([".git", "node_modules", "dist", "build", "target", "__pycache__", ".venv", "venv", ".next", "coverage", ".cache"]);
+const MAX_FILES = 3000;
+const MAX_DEPTH = 4;
+
+const LANGS                         = {
+  ".ts": "TypeScript", ".tsx": "TypeScript", ".js": "JavaScript", ".jsx": "JavaScript", ".mjs": "JavaScript", ".cjs": "JavaScript",
+  ".py": "Python", ".go": "Go", ".rs": "Rust", ".java": "Java", ".kt": "Kotlin", ".rb": "Ruby", ".php": "PHP",
+  ".c": "C", ".h": "C", ".cpp": "C++", ".cs": "C#", ".swift": "Swift", ".sh": "Shell", ".html": "HTML", ".css": "CSS",
+};
+
+const DIR_NOTES                         = {
+  src: "source code", lib: "library code", app: "application code", cli: "command line code", bin: "executables",
+  test: "tests", tests: "tests", spec: "tests", docs: "documentation", doc: "documentation", scripts: "helper scripts",
+  public: "static files served as is", static: "static files served as is", assets: "images, fonts and other assets",
+  website: "website", web: "web front end", api: "API code", config: "configuration", examples: "examples",
+};
+
+const MANIFESTS = ["package.json", "pyproject.toml", "requirements.txt", "Cargo.toml", "go.mod", "Gemfile", "pom.xml", "build.gradle", "Makefile", "Dockerfile", "docker-compose.yml"];
+
+function readText(p        , max = 200_000)         {
+  try {
+    return readFileSync(p, "utf8").slice(0, max);
+  } catch {
+    return "";
+  }
+}
+
+function countLanguages(root        )           {
+  const counts = new Map                ();
+  let seen = 0;
+  const walk = (dir        , depth        ) => {
+    if (depth > MAX_DEPTH || seen >= MAX_FILES) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (SKIP.has(e.name) || e.name.startsWith(".")) continue;
+      if (e.isDirectory()) walk(join(dir, e.name), depth + 1);
+      else if (e.isFile()) {
+        seen++;
+        const lang = LANGS[extname(e.name).toLowerCase()];
+        if (lang) counts.set(lang, (counts.get(lang) ?? 0) + 1);
+      }
+    }
+  };
+  walk(root, 0);
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 4).map(([l]) => l);
+}
+
+function nodeCommands(root        , pkg                         )            {
+  const pm = existsSync(join(root, "pnpm-lock.yaml")) ? "pnpm" : existsSync(join(root, "yarn.lock")) ? "yarn" : existsSync(join(root, "bun.lockb")) ? "bun" : "npm";
+  const scripts = pkg.scripts && typeof pkg.scripts === "object" ? (pkg.scripts                           ) : {};
+  const out            = [];
+  const add = (label        , name        ) => {
+    if (typeof scripts[name] !== "string") return;
+    out.push({ label, cmd: name === "test" && pm === "npm" ? "npm test" : name === "start" && pm === "npm" ? "npm start" : `${pm} run ${name}` });
+  };
+  add("Run", "dev");
+  add("Run", "start");
+  add("Build", "build");
+  add("Test", "test");
+  add("Lint", "lint");
+  return out;
+}
+
+function makeTargets(text        )              {
+  const set = new Set        ();
+  for (const m of text.matchAll(/^([A-Za-z0-9_.-]+):(?!=)/gm)) set.add(m[1]          );
+  return set;
+}
+
+export function scanProject(root        )              {
+  const manifests = MANIFESTS.filter((m) => existsSync(join(root, m)));
+  let name = basename(root);
+  const commands            = [];
+  if (manifests.includes("package.json")) {
+    try {
+      const pkg = JSON.parse(readText(join(root, "package.json")))                           ;
+      if (typeof pkg.name === "string" && pkg.name) name = pkg.name;
+      commands.push(...nodeCommands(root, pkg));
+    } catch {
+      // A broken package.json is not this command's problem; the scan just skips it.
+    }
+  }
+  const hasTestsDir = ["test", "tests"].some((d) => existsSync(join(root, d)));
+  if (manifests.includes("pyproject.toml") || manifests.includes("requirements.txt")) {
+    if (hasTestsDir) commands.push({ label: "Test", cmd: "python -m pytest" });
+  }
+  if (manifests.includes("Cargo.toml")) commands.push({ label: "Build", cmd: "cargo build" }, { label: "Test", cmd: "cargo test" });
+  if (manifests.includes("go.mod")) commands.push({ label: "Build", cmd: "go build ./..." }, { label: "Test", cmd: "go test ./..." });
+  if (manifests.includes("Makefile")) {
+    const targets = makeTargets(readText(join(root, "Makefile")));
+    for (const [label, t] of [["Build", "build"], ["Test", "test"], ["Lint", "lint"]]         ) {
+      if (targets.has(t)) commands.push({ label, cmd: `make ${t}` });
+    }
+  }
+  let dirs                                        = [];
+  try {
+    dirs = readdirSync(root, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && !SKIP.has(e.name) && !e.name.startsWith("."))
+      .map((e) => ({ name: sanitize(e.name), note: DIR_NOTES[e.name.toLowerCase()] ?? "" }))
+      .sort((a, b) => a.name.localeCompare(b.name))
+      .slice(0, 15);
+  } catch {
+    dirs = [];
+  }
+  const hasReadme = readdirSync(root).some((f) => /^readme(\.|$)/i.test(f));
+  return { name: sanitize(name), languages: countLanguages(root), dirs, manifests, commands, hasReadme };
+}
+
+export function renderAgentsMd(s             )         {
+  const lines           = [`# ${s.name}`, "", "Starter notes for the Synqa coding agent. Edit this file: the agent reads it at the start of every session.", ""];
+  lines.push("## Overview", "", "Describe in one or two sentences what this project does and who uses it.");
+  if (s.languages.length) lines.push("", `Main languages: ${s.languages.join(", ")}.`);
+  if (s.hasReadme) lines.push("", "See the README for background.");
+  lines.push("", "## Layout", "");
+  if (s.dirs.length) for (const d of s.dirs) lines.push(`- \`${d.name}/\`${d.note ? `: ${d.note}` : ""}`);
+  else lines.push("- (no sub folders found)");
+  if (s.manifests.length) lines.push("", `Project files: ${s.manifests.map((m) => `\`${m}\``).join(", ")}.`);
+  lines.push("", "## Commands", "");
+  if (s.commands.length) for (const c of s.commands) lines.push(`- ${c.label}: \`${c.cmd}\``);
+  else lines.push("- (no build, test or run commands detected: add them here)");
+  lines.push("", "## Conventions", "", "- Add your code style, naming and review rules here.", "- Say what the agent must never touch (generated files, secrets, vendored code).", "");
+  return lines.join("\n");
+}
+
+// The project's AGENTS.md, for the system prompt. Empty when there is none or it cannot be read.
+export function loadNotes(cwd        , max = 8000)         {
+  try {
+    const p = confine(cwd, "AGENTS.md");
+    return existsSync(p) ? sanitize(readText(p, max)) : "";
+  } catch {
+    return "";
+  }
+}
+
+                      
+                                           
+                        
+  
+
+                                                                         
+
+export async function initProject(cwd        , io        )                      {
+  const target = confine(cwd, "AGENTS.md");
+  const existing = snapshot(target);
+  if (existing !== null && !(await io.confirm("AGENTS.md already exists. Overwrite it with a new starter file?"))) {
+    return { status: "kept", message: "AGENTS.md left as it is." };
+  }
+  const content = renderAgentsMd(scanProject(cwd));
+  writeConfined(cwd, target, content);
+  if (existing !== "too-large") io.journal?.record({ path: target, before: existing, after: Buffer.from(content) });
+  return { status: "written", message: `Wrote AGENTS.md (${content.split("\n").length - 1} lines). Edit it, then run /clear so the agent reads it.${io.journal ? " /undo reverts it." : ""}` };
+}

package/dist/journal.js

@@ -0,0 +1,61 @@
+// In-memory journal of the files the agent wrote, so /undo can put the last one back.
+import { existsSync, readFileSync, rmSync, statSync } from "node:fs";
+import { relative } from "node:path";
+import { confine, writeConfined } from "./paths.js";
+
+                            
+                                     
+                                                        
+                
+  
+
+export const MAX_JOURNAL = 100;
+export const MAX_SNAPSHOT_BYTES = 5_000_000;
+
+// The current bytes of a file, null when it does not exist, "too-large" when it is not safe to keep.
+export function snapshot(path        )                              {
+  if (!existsSync(path)) return null;
+  if (statSync(path).size > MAX_SNAPSHOT_BYTES) return "too-large";
+  return readFileSync(path);
+}
+
+                        
+                                                                                      
+                                                                                
+
+export class EditJournal {
+          entries                 = [];
+
+  get size()         {
+    return this.entries.length;
+  }
+
+  record(e              )       {
+    this.entries.push(e);
+    if (this.entries.length > MAX_JOURNAL) this.entries.shift();
+  }
+
+  peek()                           {
+    return this.entries[this.entries.length - 1];
+  }
+
+  // Reverts the newest entry. If the file changed since the agent wrote it (the user edited it, or a
+  // command did), the caller must confirm first: `force` is that answer.
+  undo(cwd        , force         )             {
+    const e = this.peek();
+    if (!e) return { ok: false, reason: "empty", message: "nothing to undo" };
+    try {
+      const abs = confine(cwd, e.path);
+      const current = existsSync(abs) ? readFileSync(abs) : null;
+      if (!force && (current === null || !current.equals(e.after))) {
+        return { ok: false, reason: "changed-since", message: "the file changed after the agent wrote it" };
+      }
+      if (e.before === null) rmSync(abs, { force: true });
+      else writeConfined(cwd, e.path, e.before);
+    } catch (err) {
+      return { ok: false, reason: "error", message: err instanceof Error ? err.message : String(err) };
+    }
+    this.entries.pop();
+    return { ok: true, path: relative(cwd, e.path) || e.path, removed: e.before === null, before: e.before, after: e.after };
+  }
+}

package/dist/main.js

@@ -0,0 +1,360 @@
+import { createInterface } from "node:readline/promises";
+import { runAgent } from "./agent.js";
+import { ApiError, checkKey } from "./api.js";
+import { announceNotes, freshHistory, runCommand, statusParts } from "./commands.js";
+                                                  
+import { looksLikeKey, readConfig, resolveApiKey, writeConfig, configPath } from "./config.js";
+import { EditJournal } from "./journal.js";
+import { isHomeDir, isSensitivePath, unsafeStartDir } from "./paths.js";
+                                             
+                                  
+import { join } from "node:path";
+
+// A workspace inside a protected area (~/.dotfiles, ~/.config/nvim, ~/Library/...): every file is
+// refused there, so say why once at start-up instead of leaving the user with refusals.
+export function protectedWorkspaceWarning(cwd        , home         )                     {
+  if (!isSensitivePath(join(cwd, "probe.txt"), undefined, home)) return undefined;
+  return "this folder is inside a protected area (a dot folder or Library in your home folder, or a credentials folder), where tools keep keys and tokens. The agent cannot read, write or search files here. Copy the project to a normal folder to work on it.";
+}
+
+// The start-up notes both the session banner and a one-shot run print.
+export function startWarnings(env                                    , cwd        , home         )           {
+  const out           = [];
+  if (env.SYNQA_API_KEY?.trim()) out.push("using the key from SYNQA_API_KEY (not the one saved by synqa login)");
+  const inProtected = protectedWorkspaceWarning(cwd, home);
+  if (inProtected) out.push(inProtected);
+  return out;
+}
+
+                                                                             
+
+// Keys from a terminal always go through a PromptFrame, framed or not, so pasted text can never
+// answer a y/N question; the frame (rules, status, / menu) is drawn only when `framed`. Questions
+// and the bracketed paste switch go to the terminal: stdout when it is one, else stderr, so
+// `synqa "task" | tee log` still asks on the screen and still tells pasted text from typing.
+export function openSessionInput(o   
+                                                                              
+                                             
+ )                                                                                {
+  const tty = Boolean(o.stdin.isTTY);
+  const term = o.stdout.isTTY || !o.stderr.isTTY ? o.stdout : o.stderr;
+  const keys = tty ? new PromptFrame(o.stdin, term, o.ui, o.below, o.promptWidth, { paste: Boolean(term.isTTY) }) : undefined;
+  const rl = createInterface({ input: keys ? keys.input : (o.stdin                         ), output: term, terminal: tty });
+  keys?.start(rl);
+  return { rl, keys, term };
+}
+
+                                                                          
+
+// Raw mode and bracketed paste are switched off on every way out: a normal exit, an uncaught
+// exception and an unhandled rejection (then the error is printed and the exit code is 1).
+export function installTerminalRestore(
+  restore            , proc           = process,
+  exit                         = (c) => process.exit(c), report                      = (s) => console.error(s),
+)       {
+  proc.on("exit", restore);
+  const crash = (err         ) => {
+    restore();
+    report(`\nerror: ${sanitize(err instanceof Error ? err.message : String(err))}`);
+    exit(1);
+  };
+  proc.on("uncaughtException", crash);
+  proc.on("unhandledRejection", crash);
+}
+
+// The session's terminal wiring, in one place so it is tested as main uses it: restore stops the
+// spinner and gives the keys back, on every way out. In a one-shot run on a terminal, a Ctrl+C the
+// key router saw (it closes readline) ends the process with 130, the shell's code for an
+// interrupt. Readline closing for any other reason (end of piped input, /dev/null) is not an
+// interrupt: without a terminal there is no key router and no handler at all.
+export function wireSession(o   
+                                                                                                                    
+                                                                               
+ )                                            {
+  const exit = o.exit ?? ((c        ) => process.exit(c));
+  const report = o.report ?? ((s        ) => console.error(s));
+  const restore = () => { o.spinner.stop(); o.keys?.stop(); };
+  installTerminalRestore(restore, o.proc ?? process, exit, report);
+  let finished = false;
+  const keys = o.keys;
+  if (o.oneShot && keys) {
+    o.rl.on("close", () => {
+      if (finished || !keys.interrupted) return;
+      restore();
+      report("\ninterrupted");
+      exit(130);
+    });
+  }
+  return { restore, done: () => { finished = true; } };
+}
+
+// --yes in the home folder would let the agent write shell startup files, launch agents and the
+// like without a question, so it is refused there (the tools also ignore it, as a second guard).
+export function homeYesRefusal(cwd        , yes         , home         )                     {
+  return yes && isHomeDir(cwd, home) ? "--yes is not allowed in your home folder. Run without --yes, or cd into a project folder." : undefined;
+}
+import { sanitize } from "./sanitize.js";
+import { formatStatus } from "./statusbar.js";
+import { CONTEXT_TOKENS, DEFAULT_TIER, findEffort, findTier, routingLabel } from "./tiers.js";
+import { accent, dim, stone } from "./theme.js";
+                                        
+import { fetchAccount } from "./account.js";
+import { balanceFrom, formatFooter, makeUi, promptText, readVersion, renderBanner, renderStatusLines, Spinner, styleOf, textWidth, TurnRenderer } from "./ui.js";
+import { PromptFrame } from "./prompt.js";
+                                       
+
+const VERSION = readVersion();
+
+// The balance fetch gets this long at startup and after a turn; the banner never waits longer.
+const BALANCE_TIMEOUT_MS = 2000;
+
+const HELP = `Usage:
+  synqa                     interactive session in the current folder
+  synqa "do something"      one-shot task
+  synqa login               save your API key
+Options:
+  -y, --yes                 do not ask before ordinary file writes and edits
+                            (shell commands always ask; not allowed in your home folder)
+  -m, --model <tier>        blink | sonata | aeon (default blink)
+  -e, --effort <level>      default | low | medium (default default)
+  -h, --help   -v, --version
+In a session, type / for the command menu (/model, /effort, /status, /init, /compact, /undo,
+/clear, /help, /exit).`;
+
+// Said when SYNQA_API_KEY is set: it wins over the key that synqa login saved.
+export const ENV_KEY_NOTE = "SYNQA_API_KEY is set in this shell, so it is used instead of the key saved by synqa login. Remove it (unset SYNQA_API_KEY, and delete the line from ~/.zshrc or ~/.bash_profile) to use the saved key.";
+
+// Masked single-line input: nothing typed is echoed.
+export function readSecret(promptText        )                  {
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    if (!stdin.isTTY) {
+      reject(new Error("login needs an interactive terminal (or set SYNQA_API_KEY)"));
+      return;
+    }
+    process.stdout.write(promptText);
+    let value = "";
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const onData = (chunk        ) => {
+      for (const ch of chunk) {
+        if (ch === "\r" || ch === "\n") {
+          stdin.setRawMode(false);
+          stdin.pause();
+          stdin.off("data", onData);
+          process.stdout.write("\n");
+          resolve(value.trim());
+          return;
+        }
+        if (ch === "\u0003") {
+          stdin.setRawMode(false);
+          process.stdout.write("\n");
+          reject(new Error("cancelled"));
+          return;
+        }
+        if (ch === "\u007f" || ch === "\b") value = value.slice(0, -1);
+        else if (ch >= " ") value += ch;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
+// The error text can come from the network, so it is sanitized before printing.
+export function loginFailureMessage(err         )         {
+  return sanitize(`Could not verify the key: ${err instanceof Error ? err.message : String(err)}`);
+}
+
+export async function login()                  {
+  const key = await readSecret("Paste your Synqa API key (input is hidden): ");
+  if (!looksLikeKey(key)) {
+    console.error("That does not look like a Synqa key (expected synqa_live_...).");
+    return 1;
+  }
+  try {
+    await checkKey(key);
+  } catch (err) {
+    console.error(loginFailureMessage(err));
+    return 1;
+  }
+  const file = writeConfig({ ...readConfig(), apiKey: key });
+  console.log(`Key verified and saved to ${file}`);
+  const fromEnv = process.env.SYNQA_API_KEY?.trim();
+  if (fromEnv && fromEnv !== key) console.error(`\nWarning: ${ENV_KEY_NOTE}`);
+  return 0;
+}
+
+                                                                                                                                 
+
+export function parseArgs(argv          )       {
+  const a       = { allowHome: false, yes: false, model: "", effort: "", help: false, version: false, rest: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const t = argv[i]          ;
+    if (t === "-y" || t === "--yes") a.yes = true;
+    else if (t === "--allow-home") a.allowHome = true; // accepted and ignored since 1.1.1
+    else if (t === "-h" || t === "--help") a.help = true;
+    else if (t === "-v" || t === "--version") a.version = true;
+    else if (t === "-m" || t === "--model") a.model = argv[++i] ?? "";
+    else if (t === "-e" || t === "--effort") a.effort = argv[++i] ?? "";
+    else a.rest.push(t);
+  }
+  return a;
+}
+
+// `input` is the key source; tests pass a stream that ends at once, like `< /dev/null`.
+export async function main(argv          , input            = process.stdin)                  {
+  const args = parseArgs(argv);
+  if (args.help) { console.log(HELP); return 0; }
+  if (args.version) { console.log(VERSION); return 0; }
+  if (args.rest[0] === "login") return login();
+
+  const unsafe = unsafeStartDir(process.cwd());
+  if (unsafe) {
+    console.error(`Synqa does not start in ${unsafe} (the whole disk would be its workspace). cd into a project folder first.`);
+    return 1;
+  }
+  const yesRefused = homeYesRefusal(process.cwd(), args.yes);
+  if (yesRefused) { console.error(yesRefused); return 1; }
+  const apiKey = resolveApiKey();
+  if (!apiKey) {
+    console.error(`No API key. Run "synqa login" or set SYNQA_API_KEY. (config: ${configPath()})`);
+    return 1;
+  }
+  const ui = makeUi(process.env, process.stdout);
+  const style        = styleOf(ui);
+  const tier = findTier(args.model || readConfig().tier || DEFAULT_TIER);
+  if (!tier) { console.error(`Unknown tier "${args.model}". Use blink, sonata or aeon.`); return 1; }
+  const effort = args.effort ? findEffort(args.effort) : "default";
+  if (!effort) { console.error(`Unknown effort "${args.effort}". Use default, low or medium.`); return 1; }
+
+  const interactive = Boolean(input.isTTY) && args.rest.length === 0;
+  // On a terminal the prompt frame reads the keys (for the / menu) and hands them to readline.
+  const framed = interactive && ui.tty && ui.unicode;
+  let statusLines                 = () => [];
+  const { rl, keys, term } = openSessionInput({
+    stdin: input, stdout: process.stdout, stderr: process.stderr, ui, framed, below: () => statusLines(), promptWidth: textWidth(ui.unicode ? "❯ " : "> "),
+  });
+  const frame = framed ? keys : undefined;
+  const say = (s        ) => console.log(s);
+  // Chrome (spinner, cards, footer) is for interactive terminals only. Pipes and one-shot runs get
+  // the plain text output they had before.
+  const chrome = interactive && ui.tty;
+  const spinner = new Spinner(process.stdout, { enabled: chrome, ui });
+  const renderer = new TurnRenderer(process.stdout, ui, spinner);
+  const inCard = (t        ) => (chrome ? renderer.body(t) : t);
+  // `detail` is the coloured diff the tools built; the question is sanitized, the diff is not
+  // (the tools already escaped every file character in it).
+  const confirm = async (q        , detail         )                   => {
+    if (!input.isTTY) return false;
+    spinner.stop();
+    if (detail) term.write(inCard(detail) + "\n"); // with the question, on the terminal
+    const ans = await rl.question(`${accent(style, "?")} ${sanitize(q)} [y/N] `);
+    return /^y(es)?$/i.test(ans.trim());
+  };
+
+  const cwd = process.cwd();
+  const st               = {
+    apiKey, cwd, tier, effort, history: [], journal: new EditJournal(),
+    total: { prompt: 0, completion: 0 }, last: { prompt: 0, completion: 0 }, routing: "?", notesChars: 0, notesShown: 0,
+  };
+  st.history = freshHistory(st);
+  const ctx = { cwd, confirm, yes: args.yes, color: style.color, journal: st.journal, show: (t        ) => say(inCard(t)), get notesLoaded() { return st.notesChars > 0; } };
+
+  // Known balance for the footer and status line; refreshed in the background after each turn.
+  let balance          = { kind: "unavailable" };
+  // The status line under the input: only known values (tier, workspace, context, tokens, credit).
+  statusLines = () => renderStatusLines({
+    tier: st.tier, effort: st.effort, cwd, tokens: st.total.prompt + st.total.completion,
+    contextTokens: st.last.prompt || undefined, contextMax: CONTEXT_TOKENS, routing: st.routing, balance,
+  }, ui);
+  const refresh = () => { frame?.redraw(); };
+  // Raw mode and bracketed paste are always switched off again, also after a crash.
+  const { restore, done } = wireSession({ spinner, keys, rl, oneShot: !interactive });
+  process.stdout.on("resize", () => refresh());
+  const loadBalance = async ()                   => balanceFrom(await fetchAccount(apiKey, undefined, BALANCE_TIMEOUT_MS));
+  const refreshBalance = () => { void loadBalance().then((b) => { balance = b; }, () => {}); };
+
+  const turn = async (text        )                => {
+    st.history.push({ role: "user", content: text });
+    try {
+      const r = await runAgent({
+        apiKey, tier: st.tier, effort: st.effort, history: st.history, ctx,
+        events: chrome
+          ? {
+            onRequest: () => renderer.requestStart(),
+            onText: (t) => renderer.text(t),
+            onTool: (name, a) => renderer.toolStart(name, a),
+            onToolResult: (name, _a, result) => renderer.toolResult(name, result),
+            onTurn: () => renderer.requestEnd(),
+          }
+          : {
+            onText: (t) => process.stdout.write(sanitize(t)),
+            onTool: (name, a) => process.stdout.write(`\n${dim(style, `> ${sanitize(name)} ${sanitize(a.length > 120 ? a.slice(0, 117) + "..." : a)}`)}\n`),
+            onTurn: () => {},
+          },
+      });
+      st.total = { prompt: st.total.prompt + r.total.prompt, completion: st.total.completion + r.total.completion };
+      st.last = r.lastUsage;
+      st.routing = routingLabel(r.routing);
+      st.ttftMs = r.ttftMs;
+      st.tokPerSec = r.tokPerSec;
+      if (chrome) {
+        renderer.turnEnd();
+        const footer = formatFooter({
+          ttftMs: r.ttftMs, tokPerSec: r.tokPerSec, routing: st.routing,
+          creditLeft: balance.kind === "ok" ? balance.account.creditRemaining : undefined,
+        }, ui);
+        if (footer) say(stone(style, footer));
+        refreshBalance();
+      } else {
+        process.stdout.write("\n");
+      }
+    } catch (err) {
+      spinner.stop();
+      const msg = sanitize(err instanceof Error ? err.message : String(err));
+      const envNote = err instanceof ApiError && err.status === 401 && process.env.SYNQA_API_KEY?.trim() ? `\n${ENV_KEY_NOTE}` : "";
+      console.error(`\n${chrome ? accent(style, "error") : "error"}: ${msg}${envNote}`);
+    }
+    refresh();
+  };
+
+  try {
+    if (!interactive) {
+      const prompt = args.rest.join(" ");
+      if (!prompt) { console.error("Nothing to do. Pass a task or run in a terminal."); return 1; }
+      announceNotes(st, say);
+      for (const w of startWarnings(process.env, cwd)) console.error(`Warning: ${w}`);
+      await turn(prompt);
+      say(dim(style, formatStatus(statusParts(st))));
+      return 0;
+    }
+
+    // The balance may take a moment; the banner waits at most BALANCE_TIMEOUT_MS for it.
+    balance = await loadBalance();
+    const warnings = startWarnings(process.env, cwd);
+    say("");
+    for (const line of renderBanner({ version: VERSION, tier: st.tier, effort: st.effort, cwd, notesChars: st.notesChars, balance, warnings }, ui)) say(line);
+    say("");
+    if (!frame) say(dim(style, "Type /help for commands."));
+    announceNotes(st, (t) => say(dim(style, t)));
+    for (;;) {
+      // Without the frame the status is printed above each prompt instead.
+      if (!frame) say(dim(style, formatStatus(statusParts(st))));
+      let line        ;
+      try {
+        line = (frame ? await frame.ask(promptText(ui)) : keys ? await keys.askPlain(`${accent(style, ui.unicode ? "❯" : ">")} `) : await rl.question(`${accent(style, ui.unicode ? "❯" : ">")} `)).trim();
+      } catch { break; }
+      if (!line) continue;
+      const r = await runCommand(line, st, { print: say, confirm, style, ui });
+      refresh();
+      if (r.exit) break;
+      if (!r.handled) await turn(line);
+    }
+    return 0;
+  } finally {
+    done(); // a normal end: closing readline below is not an interrupt
+    restore();
+    rl.close();
+  }
+}