@synqa/cli 1.1.0 → 1.2.0

package/dist/main.js

@@ -1,18 +1,115 @@
 import { createInterface } from "node:readline/promises";
 import { runAgent } from "./agent.js";
-import { checkKey } from "./api.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 { API_BASE, looksLikeKey, readConfig, resolveApiKey, resolveProviderKey, writeConfig, configPath } from "./config.js";
 import { EditJournal } from "./journal.js";
-import { unsafeStartDir } from "./paths.js";
+import { isHomeDir, isSensitivePath, unsafeStartDir } from "./paths.js";
+                                             
+                                  
+import { join } from "node:path";
+import { loadHooks, runHooks, toggleHook } from "./hooks.js";
+                                            
+import { MODE_LABEL, nextMode } from "./modes.js";
+import { providerDef, unlockGate } from "./providers.js";
+import { pickOne, readMasked, streamKeys } from "./select.js";
+                                                       
+import { bashEnv } from "./tools.js";
+import { checkForUpdate, runUpdate } from "./update.js";
+
+// 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.
+// envInUse: false when a saved key is used and SYNQA_API_KEY is ignored (no warning then).
+export function startWarnings(env                                    , cwd        , home         , envInUse = true)           {
+  const out           = [];
+  if (envInUse && 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, StatusBar } from "./statusbar.js";
-import { DEFAULT_TIER, findEffort, findTier, routingLabel } from "./tiers.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, readVersion, renderBanner, Spinner, styleOf, TurnRenderer } from "./ui.js";
+import { balanceFrom, formatFooter, makeUi, promptText, readVersion, renderBanner, renderStatusLines, Spinner, styleOf, textWidth, TurnRenderer } from "./ui.js";
+import { PromptFrame } from "./prompt.js";
                                        
 
 const VERSION = readVersion();
@@ -23,50 +120,31 @@ 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
+  synqa login               save your Synqa API key
 Options:
-  -y, --yes                 do not ask before write, edit and bash
+  -y, --yes                 do not ask before ordinary file writes and edits
+                            (shell commands always ask; not allowed in your home folder)
+  --env-key                 use SYNQA_API_KEY (and the other provider key variables)
+                            instead of a key saved by /login
   -m, --model <tier>        blink | sonata | aeon (default blink)
-  -e, --effort <level>      default | low | medium (default default)
-  --allow-home              allow starting in your home folder or the filesystem root
+  -e, --effort <level>      default | low | medium | high (default default)
   -h, --help   -v, --version
-In a session: /model, /effort, /status, /init, /compact, /undo, /clear, /help, /exit`;
-
-// 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);
-  });
+In a session, type / for the command menu (/model, /effort, /provider, /login, /logout, /status,
+/init, /compact, /undo, /hooks, /update, /clear, /help, /exit). Shift+Tab cycles the permission
+mode (ask before edits, auto-accept edits, plan only).`;
+
+// Said when SYNQA_API_KEY is set in the shell but a key saved by synqa login or /login exists:
+// the saved key wins (since 1.2.0), so there is nothing to unset.
+export const ENV_KEY_NOTE = "SYNQA_API_KEY is set in this shell and takes effect only because the --env-key flag was passed or no key is saved. A key saved by synqa login or /login wins otherwise.";
+
+// Masked single-line input on the process terminal: each character shows as a bullet.
+export async function readSecret(promptText        )                  {
+  const stdin = process.stdin;
+  if (!stdin.isTTY) throw new Error("login needs an interactive terminal (or set SYNQA_API_KEY)");
+  const v = await readMasked(promptText, { keys: streamKeys(stdin), out: process.stdout });
+  stdin.pause();
+  if (v === undefined) throw new Error("cancelled");
+  return v;
 }
 
 // The error text can come from the network, so it is sanitized before printing.
@@ -91,14 +169,15 @@ export async function login()                  {
   return 0;
 }
 
-                                                                                                                                 
+                                                                                                                                                  
 
 export function parseArgs(argv          )       {
-  const a       = { allowHome: false, yes: false, model: "", effort: "", help: false, version: false, rest: [] };
+  const a       = { allowHome: false, yes: false, envKey: 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;
+    else if (t === "--env-key") a.envKey = 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] ?? "";
@@ -108,19 +187,39 @@ export function parseArgs(argv          )       {
   return a;
 }
 
-export async function main(argv          )                  {
+// Where a session starts: the saved active provider if its credentials are still there, else Synqa Cloud.
+export function startProvider(synqaKey        , env                                    , envKey         )                                                                                                {
+  const cfg = readConfig(env);
+  const id = cfg.activeProvider;
+  const def = id ? providerDef(id) : undefined;
+  if (id && def && id !== "synqa") {
+    const entry = cfg.providers?.[id];
+    const key = resolveProviderKey(id, env, { envKey });
+    const base = id === "custom" ? entry?.baseUrl : def.baseUrl;
+    if (key && base) return { apiKey: key, providerId: def.id, baseUrl: base, modelId: entry?.model };
+  }
+  return { apiKey: synqaKey, providerId: "synqa", baseUrl: API_BASE };
+}
+
+// `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 && !args.allowHome) {
-    console.error(`Refusing to start in ${unsafe}: the agent could read your keys and settings there. cd into a project folder, or pass --allow-home if you really mean it.`);
+  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 apiKey = resolveApiKey();
-  if (!apiKey) {
+  const yesRefused = homeYesRefusal(process.cwd(), args.yes);
+  if (yesRefused) { console.error(yesRefused); return 1; }
+  const interactive = Boolean(input.isTTY) && args.rest.length === 0;
+  const synqaKey0 = resolveApiKey(process.env, { envKey: args.envKey }) ?? "";
+  // A terminal session with no usable Synqa key shows the welcome screen and signs in first.
+  const needSignIn = interactive && !looksLikeKey(synqaKey0);
+  if (!synqaKey0 && !interactive) {
     console.error(`No API key. Run "synqa login" or set SYNQA_API_KEY. (config: ${configPath()})`);
     return 1;
   }
@@ -129,10 +228,15 @@ export async function main(argv          )                  {
   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; }
+  if (!effort) { console.error(`Unknown effort "${args.effort}". Use default, low, medium or high.`); return 1; }
 
-  const interactive = Boolean(process.stdin.isTTY) && args.rest.length === 0;
-  const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: Boolean(process.stdin.isTTY) });
+  // 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.
@@ -143,44 +247,79 @@ export async function main(argv          )                  {
   // `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 (!process.stdin.isTTY) return false;
+    if (!input.isTTY) return false;
     spinner.stop();
-    if (detail) say(inCard(detail));
+    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());
   };
 
+  // The arrow-key controls: every key goes to the selector or the masked prompt, none to readline.
+  const keySource                        = keys ?? (input.isTTY ? streamKeys(input) : undefined);
+  const pick = keySource
+    ?    (items                        , title         ) => pickOne(items, { keys: keySource, out: term, style, unicode: ui.unicode, title })
+    : undefined;
+  const secret = keySource ? (p        ) => readMasked(p, { keys: keySource, out: term, unicode: ui.unicode }) : undefined;
+  const ask = interactive ? async (p        )                              => { try { return (await rl.question(p)).trim(); } catch { return undefined; } } : undefined;
+
   const cwd = process.cwd();
+  const sp = startProvider(synqaKey0, process.env, args.envKey);
   const st               = {
-    apiKey, cwd, tier, effort, history: [], journal: new EditJournal(),
+    apiKey: sp.apiKey, cwd, tier, effort, history: [], journal: new EditJournal(),
     total: { prompt: 0, completion: 0 }, last: { prompt: 0, completion: 0 }, routing: "?", notesChars: 0, notesShown: 0,
+    providerId: sp.providerId, baseUrl: sp.baseUrl, modelId: sp.modelId, mode: "ask",
   };
   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; } };
-
-  // The pinned bar needs a terminal on both ends; otherwise the status is an ordinary line.
-  const bar = new StatusBar(
-    process.stdout,
-    interactive && Boolean(process.stdout.isTTY) && process.env.TERM !== "dumb",
-    (s) => dim(style, s),
-  );
-  const refresh = () => {
-    if (bar.enabled) bar.update(formatStatus(statusParts(st), (process.stdout.columns ?? 80) - 1));
+  const ctx = {
+    cwd, confirm, yes: args.yes, color: style.color, journal: st.journal, show: (t        ) => say(inCard(t)),
+    get notesLoaded() { return st.notesChars > 0; },
+    get mode() { return st.mode; },
   };
-  const restore = () => { spinner.stop(); bar.uninstall(); };
-  process.on("exit", restore);
-  process.stdout.on("resize", () => { bar.resize(); refresh(); });
+  const external = () => (st.providerId ?? "synqa") !== "synqa";
+  const providerInfo = () => (external() ? { name: providerDef(st.providerId          )?.name ?? "Custom endpoint", model: st.modelId } : undefined);
 
-  // Known balance for the footer; refreshed in the background after each turn, never awaited.
+  // Hooks: shell commands at SessionStart, PreToolUse, PostToolUse and Stop. They never print errors.
+  const fire = async (event           , payload                                              = {}) => {
+    if (st.mode === "plan" && (event === "PostToolUse" || event === "Stop")) return []; // plan mode runs nothing after the fact
+    try { return await runHooks(loadHooks(cwd), event, { cwd, ...payload }, cwd, { env: bashEnv(process.env) }); } catch { return []; }
+  };
+  const toolHooks = {
+    pre: async (name        , a        ) => {
+      const blocked = (await fire("PreToolUse", { tool: name, input: a.slice(0, 4000) })).find((h) => h.blocked);
+      return blocked ? blocked.reason ?? "stopped by a PreToolUse hook" : undefined;
+    },
+    post: async (name        , a        , result        ) => { await fire("PostToolUse", { tool: name, input: a.slice(0, 4000), result: result.slice(0, 4000) }); },
+  };
+
+  // Known balance for the footer and status line; refreshed in the background after each turn.
   let balance          = { kind: "unavailable" };
-  const loadBalance = async ()                   => balanceFrom(await fetchAccount(apiKey, undefined, BALANCE_TIMEOUT_MS));
+  let latestVersion                    ;
+  // 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,
+    provider: providerInfo(), mode: MODE_LABEL[st.mode ?? "ask"], updateHint: latestVersion ? `update ${latestVersion}: /update` : undefined,
+  }, ui);
+  const refresh = () => { frame?.redraw(); };
+  // Shift+Tab cycles the permission mode; the footer shows it.
+  if (keys) keys.onShiftTab = () => { st.mode = nextMode(st.mode ?? "ask"); };
+  // Raw mode and bracketed paste are always switched off again, also after a crash.
+  const { restore, done } = wireSession({ spinner, keys, rl, oneShot: !interactive });
+  // 'resize' (not SIGWINCH) fires on Windows, macOS and Linux; a changed width redraws the frame.
+  process.stdout.on("resize", () => { if (frame) frame.onResize(); else refresh(); });
+  // The balance belongs to Synqa Cloud: it is never asked with a secondary provider's key.
+  const loadBalance = async ()                   => {
+    const key = resolveApiKey(process.env, { envKey: args.envKey });
+    return key ? balanceFrom(await fetchAccount(key, undefined, BALANCE_TIMEOUT_MS)) : { kind: "unavailable" };
+  };
   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,
+        apiKey: st.apiKey, tier: st.tier, effort: st.effort, history: st.history, ctx,
+        baseUrl: external() ? st.baseUrl : undefined, modelId: external() ? st.modelId : undefined, hooks: toolHooks,
         events: chrome
           ? {
             onRequest: () => renderer.requestStart(),
@@ -204,50 +343,95 @@ export async function main(argv          )                  {
         renderer.turnEnd();
         const footer = formatFooter({
           ttftMs: r.ttftMs, tokPerSec: r.tokPerSec, routing: st.routing,
-          creditLeft: balance.kind === "ok" ? balance.account.creditRemaining : undefined,
+          creditLeft: balance.kind === "ok" && !external() ? balance.account.creditRemaining : undefined,
         }, ui);
         if (footer) say(stone(style, footer));
-        refreshBalance();
+        if (!external()) refreshBalance();
       } else {
         process.stdout.write("\n");
       }
     } catch (err) {
-      spinner.stop();
-      console.error(`\nerror: ${sanitize(err instanceof Error ? err.message : String(err))}`);
+      spinner.stop(); // the thinking timer ends on an error or an abort too
+      const msg = sanitize(err instanceof Error ? err.message : String(err));
+      const envNote = err instanceof ApiError && err.status === 401 && !external() && process.env.SYNQA_API_KEY?.trim() ? `\n${ENV_KEY_NOTE}` : "";
+      console.error(`\n${chrome ? accent(style, "error") : "error"}: ${msg}${envNote}`);
     }
+    await fire("Stop", { tokens: st.total.prompt + st.total.completion });
     refresh();
   };
 
+  // Welcome screen and the Synqa-first gate: chat and every other provider stay locked until a
+  // valid Synqa Cloud key is saved. Returns false when the person cancels.
+  const bannerInfo = (locked         ) => ({ version: VERSION, tier: st.tier, effort: st.effort, cwd, notesChars: st.notesChars, balance, warnings: locked ? [] : startWarnings(process.env, cwd, undefined, apiKeyFromEnv()), provider: providerInfo(), locked });
+  const apiKeyFromEnv = () => {
+    const e = process.env.SYNQA_API_KEY?.trim();
+    return Boolean(e) && resolveApiKey(process.env, { envKey: args.envKey }) === e;
+  };
+  const signIn = async ()                   => {
+    if (!secret) return false;
+    say("");
+    for (const line of renderBanner(bannerInfo(true), ui)) say(line);
+    say("");
+    const key = await unlockGate({ secret, print: (m) => say(dim(style, m)) });
+    if (!key) return false;
+    const p = startProvider(key, process.env, args.envKey);
+    st.apiKey = p.apiKey; st.providerId = p.providerId; st.baseUrl = p.baseUrl; st.modelId = p.modelId;
+    st.history = freshHistory(st);
+    say(dim(style, "Signed in to Synqa Cloud."));
+    return true;
+  };
+
   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, undefined, apiKeyFromEnv())) console.error(`Warning: ${w}`);
+      await fire("SessionStart", { source: "one-shot" });
       await turn(prompt);
       say(dim(style, formatStatus(statusParts(st))));
       return 0;
     }
 
+    if (needSignIn) {
+      if (!(await signIn())) { say(dim(style, "Not signed in. Run synqa again to sign in to Synqa Cloud.")); return 1; }
+    }
     // The balance may take a moment; the banner waits at most BALANCE_TIMEOUT_MS for it.
-    balance = await loadBalance();
-    for (const line of renderBanner({ version: VERSION, tier: st.tier, cwd, notesChars: st.notesChars, balance }, ui)) say(line);
-    say(dim(style, "Type /help for commands."));
-    announceNotes(st, say);
-    bar.install();
-    refresh();
+    if (!external()) balance = await loadBalance();
+    say("");
+    if (!needSignIn) for (const line of renderBanner(bannerInfo(false), ui)) say(line);
+    say("");
+    if (!frame) say(dim(style, "Type /help for commands."));
+    announceNotes(st, (t) => say(dim(style, t)));
+    await fire("SessionStart", { source: "startup" });
+    // A quiet, short check for a newer release; any failure is silent and nothing waits for it.
+    if (chrome && !process.env.SYNQA_NO_UPDATE_CHECK) void checkForUpdate(VERSION).then((v) => { latestVersion = v; if (v) refresh(); }, () => {});
+    const io = {
+      print: say, confirm, style, ui, pick, secret, ask, envKey: args.envKey,
+      hooks: { list: () => loadHooks(cwd), toggle: (id        ) => toggleHook(cwd, id) },
+      update: { current: VERSION, get latest() { return latestVersion; }, run: () => runUpdate() },
+    };
     for (;;) {
-      // Without a pinned bar the status is printed above each prompt instead.
-      if (!bar.enabled) say(dim(style, formatStatus(statusParts(st))));
+      // Without the frame the status is printed above each prompt instead.
+      if (!frame) say(dim(style, formatStatus(statusParts(st))));
       let line        ;
-      try { line = (await rl.question(`${accent(style, ui.unicode ? "❯" : ">")} `)).trim(); } catch { break; }
+      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 });
+      const r = await runCommand(line, st, io);
       refresh();
       if (r.exit) break;
+      if (r.relogin) {
+        // A full logout locks the session: back to the sign-in prompt, nothing else works until then.
+        if (!(await signIn())) { say(dim(style, "Locked. Run synqa again to sign in.")); break; }
+        continue;
+      }
       if (!r.handled) await turn(line);
     }
     return 0;
   } finally {
+    done(); // a normal end: closing readline below is not an interrupt
     restore();
     rl.close();
   }

package/dist/modes.js

@@ -0,0 +1,20 @@
+// Permission modes of the session, cycled with Shift+Tab at the prompt and shown in the footer.
+//   ask    every file write and edit asks first (the default)
+//   auto   file writes and edits inside the workspace are applied without a question, like --yes
+//          (shell commands, secret files and files that can run code later still ask)
+//   plan   no file is written and no command is run: the agent can only read and describe a plan
+export const MODES = ["ask", "auto", "plan"]         ;
+                                                    
+
+export const MODE_LABEL                                 = {
+  ask: "ask before edits",
+  auto: "auto-accept edits",
+  plan: "plan only",
+};
+
+export function nextMode(m                )                 {
+  return MODES[(MODES.indexOf(m) + 1) % MODES.length]                  ;
+}
+
+// Tools that change something; plan mode refuses them.
+export const MUTATING_TOOLS                    = ["write_file", "edit_file", "bash"];