@synqa/cli 1.1.1 → 1.2.1

package/dist/prompt.js

@@ -11,18 +11,24 @@ import { emitKeypressEvents } from "node:readline";
                                                         
 import { bold, dim, stone, terracottaBold } from "./theme.js";
 import { fit, oneLine, pad, PLACEHOLDER, rule, styleOf, textWidth } from "./ui.js";
+                                                    
                                   
 
                                                                                                                    
 
 export const SLASH_COMMANDS                          = [
-  { name: "/model", args: "blink|sonata|aeon", desc: "Switch tier", group: "Session" },
-  { name: "/effort", args: "default|low|medium", desc: "Set reasoning effort", group: "Session" },
+  { name: "/model", args: "blink|sonata|aeon", desc: "Choose the model (arrow keys)", group: "Session" },
+  { name: "/effort", args: "default|low|medium|high", desc: "Set reasoning effort (arrow keys)", group: "Session" },
+  { name: "/provider", desc: "Switch provider: Synqa Cloud, OpenCode, ...", group: "Session" },
+  { name: "/login", desc: "Sign in to a provider", group: "Session" },
+  { name: "/logout", desc: "Sign out of a provider or fully", group: "Session" },
   { name: "/status", desc: "Tier, routing, tokens, credit and weekly pool", group: "Session" },
   { name: "/compact", desc: "Summarize the conversation to save context", group: "Session" },
   { name: "/clear", desc: "Start a fresh conversation", group: "Session" },
   { name: "/init", desc: "Write a starter AGENTS.md for this project", group: "Project" },
   { name: "/undo", desc: "Revert the last file the agent wrote", group: "Project" },
+  { name: "/hooks", desc: "List hooks and switch them on or off", group: "General" },
+  { name: "/update", desc: "Install the latest @synqa/cli", group: "General" },
   { name: "/help", desc: "Show commands and keys", group: "General" },
   { name: "/exit", desc: "Leave Synqa", group: "General" },
 ];
@@ -110,7 +116,7 @@ export function renderMenu(items                         , selected        , ui
 const ESC = "\x1b";
 
 // Draws below the input line and routes keys. One per session, TTY only.
-export class PromptFrame {
+export class PromptFrame                      {
            input                                                                     ;
           rl                       ;
           shown = 0; // rows drawn below the input line
@@ -122,6 +128,13 @@ export class PromptFrame {
           started = false;
           pasting = false; // between the terminal's paste-start and paste-end marks
           ctrlC = false; // Ctrl+C was pressed (typed, not pasted)
+          capture                                           ; // a selector or secret prompt owns the keys
+          lastCols = 0;
+          promptStr = "";
+          turnAbort                          ; // set while a response streams: keys are locked
+          holds = 0; // open questions during a turn (y/N): keys go to readline again meanwhile
+  // Shift+Tab at the prompt (cycles the permission mode); the footer is redrawn after it.
+  onShiftTab                          ;
 
   // True once the person pressed Ctrl+C. An end of input is not an interrupt.
   get interrupted()          {
@@ -165,8 +178,29 @@ export class PromptFrame {
     rl.on("close", () => this.stop());
   }
 
+  // While a turn runs, typed characters are not echoed or kept: Esc or Ctrl+C calls onAbort and
+  // every other key is dropped. Pasted text was already dropped outside the prompt.
+  beginTurn(onAbort            )       {
+    this.turnAbort = onAbort;
+  }
+
+  endTurn()       {
+    this.turnAbort = undefined;
+  }
+
+  // Runs a question that needs the keyboard (the y/N approval) inside a locked turn.
+  async withKeys   (fn                  )             {
+    this.holds++;
+    try {
+      return await fn();
+    } finally {
+      this.holds--;
+    }
+  }
+
   // Gives the terminal back: raw mode and bracketed paste off. Safe to call any number of times.
   stop()       {
+    this.turnAbort = undefined;
     if (!this.started) return;
     this.started = false;
     this.stdin.off("keypress", this.onKey);
@@ -176,6 +210,35 @@ export class PromptFrame {
     this.input.end();
   }
 
+  // KeySource: gives every key to fn and none to readline until the returned function is called.
+  // Pasted text reaches fn only when asked for (a secret), with its line breaks dropped.
+  subscribe(fn       , opts                      = {})             {
+    const mine = { fn, paste: opts.paste === true };
+    this.capture = mine;
+    return () => { if (this.capture === mine) this.capture = undefined; };
+  }
+
+  // The window changed: when the columns differ, redraw the whole frame (see redrawFrame).
+  onResize()       {
+    const cols = this.cols();
+    const prev = this.lastCols || cols;
+    this.lastCols = cols;
+    if (this.active && !this.capture && cols !== prev) this.redrawFrame(prev);
+  }
+
+  // Rebuilds the framed prompt at the current width: the old top rule is erased (it may have
+  // reflowed onto several rows if the window got narrower), then the top rule, the prompt with the
+  // typed text, the bottom rule and the footer are drawn again, so no half-width border is left.
+  redrawFrame(prevCols        )       {
+    if (!this.active) return;
+    const cols = this.cols();
+    const ruleRows = Math.max(1, Math.ceil(Math.max(1, prevCols - 1) / Math.max(1, cols)));
+    this.out.write(`\r${ESC}[${ruleRows}A${ESC}[J` + rule(this.ui) + "\n" + this.promptStr + this.line());
+    this.shown = 0;
+    this.placeholder = false;
+    this.draw();
+  }
+
           line()         {
     return (this.rl                                            )?.line ?? "";
   }
@@ -189,6 +252,8 @@ export class PromptFrame {
   // The rule above the prompt; then the prompt itself is asked by the caller.
   async ask(promptText        )                  {
     const rl = this.rl             ;
+    this.promptStr = promptText;
+    this.lastCols = this.cols();
     this.out.write(rule(this.ui) + "\n");
     this.active = true;
     this.pasteOk = true;
@@ -276,7 +341,21 @@ export class PromptFrame {
           key(s                    , key                 )       {
     const seq = key?.sequence ?? s ?? "";
     if (key?.name === "paste-start") { this.pasting = true; return; }
-    if (key?.name === "paste-end") { this.pasting = false; this.after(); return; }
+    if (key?.name === "paste-end") { this.pasting = false; if (!this.capture) this.after(); return; }
+    if (this.capture) {
+      if (this.pasting) {
+        const k = key?.name;
+        if (this.capture.paste && k !== "return" && k !== "enter" && seq !== "\r" && seq !== "\n") this.capture.fn(s, key);
+        return;
+      }
+      this.capture.fn(s, key);
+      return;
+    }
+    if (this.turnAbort && this.holds === 0) {
+      // A turn is streaming: nothing typed reaches readline, so nothing is echoed.
+      if (!this.pasting && (seq === "\x03" || key?.name === "escape")) this.turnAbort();
+      return;
+    }
     if (!this.pasting && seq === "\x03") this.ctrlC = true;
     if (this.pasting) {
       // Pasted text is never a key press. While a y/N question (or a turn) holds the input it is
@@ -290,6 +369,7 @@ export class PromptFrame {
     if (!this.active) { this.forward(seq); return; }
     const items = this.menuItems();
     const name = key?.name;
+    if (name === "tab" && key?.shift) { this.onShiftTab?.(); this.draw(); return; }
     // A lone Esc closes the menu (node reports it with meta set on some versions).
     if (items.length && name === "escape") { this.dismissed = true; this.draw(); return; }
     if (items.length && !key?.ctrl && !key?.meta) {
@@ -301,7 +381,6 @@ export class PromptFrame {
       const pick = items[this.selected]                ;
       if (name === "tab") { this.replaceLine(pick.args ? pick.name + " " : pick.name); this.after(); return; }
       if (name === "return" || name === "enter") {
-        if (pick.args && this.line().toLowerCase() !== pick.name) { this.replaceLine(pick.name + " "); this.after(); return; }
         this.clear();
         this.replaceLine(pick.name);
         this.forward("\r");

package/dist/providers.js

@@ -0,0 +1,234 @@
+// Providers: Synqa Cloud is the primary one and unlocks first; the others are the user's own
+// accounts (OpenCode Go and Zen, a bring-your-own router key, any OpenAI-compatible endpoint).
+// Their credentials are stored in the private config file and sent only to that provider's URL.
+import { checkKey } from "./api.js";
+                                          
+import { fetchAccount } from "./account.js";
+import { API_BASE, looksLikeKey, readConfig, resolveApiKey, resolveProviderKey, saveProvider, writeConfig } from "./config.js";
+import { sanitize, sanitizeModelId } from "./sanitize.js";
+import { TIERS } from "./tiers.js";
+                                            
+
+                                                                                            
+
+                                                                                           
+
+export const PROVIDERS                         = [
+  { id: "synqa", name: "Synqa Cloud", label: "Synqa Cloud (Blink 5.5 · Sonata 6.0 · Aeon 6.5) [Primary]", baseUrl: API_BASE },
+  { id: "opencode-go", name: "OpenCode Go", label: "OpenCode Go (Subscription models via OpenCode)", baseUrl: "https://opencode.ai/zen/v1" },
+  { id: "opencode-zen", name: "OpenCode Zen", label: "OpenCode Zen (Pay-as-you-go via OpenCode)", baseUrl: "https://opencode.ai/zen/v1" },
+  { id: "openrouter", name: "OpenRouter", label: "OpenRouter (Bring your own sk-or-... key)", baseUrl: "https://openrouter.ai/api/v1" },
+  { id: "custom", name: "Custom endpoint", label: "Custom OpenAI-Compatible Endpoint", baseUrl: "" },
+];
+
+export const providerDef = (id        )                          => PROVIDERS.find((p) => p.id === id);
+
+// Shown only when the provider's own /v1/models list cannot be fetched.
+export const CURATED_MODELS                                    = {
+  "opencode-go": ["kimi-k2", "grok-code"],
+  "opencode-zen": ["grok-code", "kimi-k2"],
+  openrouter: ["openrouter/auto", "moonshotai/kimi-k2", "x-ai/grok-code-fast-1"],
+  custom: [],
+};
+
+// What /model offers. On Synqa Cloud it is the three tiers (the short id after the name); on the
+// others it is the fetched list, or the curated defaults when nothing could be fetched.
+export function modelItems(provider        , fetched                    )                     {
+  if (provider === "synqa") {
+    return TIERS.map((t) => ({ label: `${t.display} (${t.id.replace(/-\d+(\.\d+)*$/, "")})`, value: t.key }));
+  }
+  const ids = fetched && fetched.length ? fetched : CURATED_MODELS[provider] ?? [];
+  return ids.slice(0, 200).map((id) => ({ label: id, value: id }));
+}
+
+const trimSlash = (u        ) => u.replace(/\/+$/, "");
+
+// GET {base}/models. Returns the model ids; throws a short, sanitized message on failure.
+export async function fetchModelIds(baseUrl        , secret        , fetchFn            = fetch, timeoutMs = 8000)                    {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const res = await fetchFn(`${trimSlash(baseUrl)}/models`, { headers: { authorization: `Bearer ${secret}` }, signal: ac.signal });
+    if (res.status === 401 || res.status === 403) throw new Error("the key was rejected");
+    if (!res.ok) throw new Error(`the provider answered with status ${res.status}`);
+    const body = (await res.json())                      ;
+    const data = Array.isArray(body.data) ? body.data : [];
+    return data
+      .map((m) => (m && typeof m === "object" ? (m                    ).id : undefined))
+      .filter((id)               => typeof id === "string" && id.length > 0 && id.length <= 200)
+      .map((id) => sanitize(id));
+  } catch (err) {
+    if (ac.signal.aborted) throw new Error("the provider did not answer in time");
+    throw new Error(sanitize(err instanceof Error ? err.message : String(err)));
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// A base URL a person typed: http(s) only, no credentials in it, no query or fragment.
+export function normalizeBaseUrl(raw        )                     {
+  try {
+    const u = new URL(raw.trim());
+    if (u.protocol !== "https:" && u.protocol !== "http:") return undefined;
+    // The key travels in a header: plain http only to this machine.
+    if (u.protocol === "http:" && !["localhost", "127.0.0.1", "[::1]"].includes(u.hostname)) return undefined;
+    if (u.username || u.password || u.search || u.hash) return undefined;
+    return trimSlash(u.toString());
+  } catch {
+    return undefined;
+  }
+}
+
+// Verifies a Synqa key against GET /v1/account (the models list when the account route is not
+// available to keys yet). Returns undefined when the key is good, else a short reason.
+export async function verifySynqaKey(candidate        , fetchFn            )                              {
+  if (!looksLikeKey(candidate)) return "That does not look like a Synqa key (expected synqa_live_...).";
+  const r = await fetchAccount(candidate, fetchFn, 8000);
+  if (r.ok) return undefined;
+  if (r.notFound) {
+    try {
+      await checkKey(candidate, fetchFn);
+      return undefined;
+    } catch (err) {
+      return `Could not verify the key: ${sanitize(err instanceof Error ? err.message : String(err))}`;
+    }
+  }
+  return `Could not verify the key: ${sanitize(r.message)}`;
+}
+
+                                                     
+
+// The synqa-first gate: nothing else unlocks until a valid Synqa Cloud key is saved. `secret`
+// reads masked input (undefined = cancelled). Returns the key, or undefined when cancelled or
+// out of attempts (the TUI stays locked).
+export async function unlockGate(o   
+                                                          
+                             
+            
+                      
+                    
+ )                              {
+  const env = o.env ?? process.env;
+  for (let i = 0; i < (o.attempts ?? 3); i++) {
+    const entered = await o.secret("Synqa Cloud API key (synqa_live_...): ");
+    if (entered === undefined) return undefined;
+    const why = await verifySynqaKey(entered, o.fetchFn);
+    if (why) { o.print(why); continue; }
+    writeConfig({ ...readConfig(env), apiKey: entered }, env);
+    return entered;
+  }
+  o.print("Too many attempts. Run synqa again to sign in.");
+  return undefined;
+}
+
+                               
+                                                      
+                         
+                  
+                                                                                                
+  
+
+                          
+                             
+                                                                                     
+                                                          
+                                                       
+                      
+            
+                                                                      
+  
+
+// Makes `id` the active provider. For a secondary one it asks for the key when none is saved,
+// verifies it with GET /models, stores it and picks a first model. Returns false when cancelled.
+export async function activateProvider(st                 , id            , io            )                   {
+  const env = io.env ?? process.env;
+  const def = providerDef(id)               ;
+  if (id === "synqa") {
+    const saved = resolveApiKey(env, { envKey: io.envKey });
+    if (!saved) { io.print("Not signed in to Synqa Cloud."); return false; }
+    st.apiKey = saved; st.providerId = "synqa"; st.baseUrl = API_BASE; st.modelId = undefined;
+    writeConfig({ ...readConfig(env), activeProvider: "synqa" }, env);
+    io.print("Using Synqa Cloud.");
+    return true;
+  }
+  const entry = readConfig(env).providers?.[id];
+  let baseUrl = def.baseUrl;
+  let model = entry?.model;
+  if (id === "custom") {
+    const raw = entry?.baseUrl ?? (await io.ask("Base URL (for example https://host/v1): "));
+    if (raw === undefined) return false;
+    const norm = normalizeBaseUrl(raw);
+    if (!norm) { io.print("That is not a usable base URL (https, or http for localhost only)."); return false; }
+    baseUrl = norm;
+  }
+  let credential = resolveProviderKey(id, env, { envKey: io.envKey });
+  if (!credential) {
+    credential = await io.secret(`${def.name} API key: `);
+    if (!credential) { io.print("Cancelled."); return false; }
+  }
+  let ids           = [];
+  try {
+    ids = await fetchModelIds(baseUrl, credential, io.fetchFn);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    // A custom endpoint may not serve /models at all; a rejected key is always final.
+    if (id !== "custom" || /rejected/.test(msg)) { io.print(`Could not verify the key: ${msg}`); return false; }
+    io.print(`Could not list models (${msg}); continuing.`);
+  }
+  if (id === "custom" && !model) {
+    const m = await io.ask("Model ID: ");
+    if (!m) { io.print("Cancelled."); return false; }
+    model = sanitizeModelId(m);
+    if (!model) { io.print("That is not a usable model id."); return false; }
+  }
+  if (!model) model = modelItems(id, ids)[0]?.value;
+  saveProvider(id, { apiKey: credential, ...(id === "custom" ? { baseUrl } : {}), ...(model ? { model } : {}) }, env);
+  writeConfig({ ...readConfig(env), activeProvider: id }, env);
+  st.apiKey = credential; st.providerId = id; st.baseUrl = baseUrl; st.modelId = model;
+  io.print(`Using ${def.name}${model ? ` with ${model}` : ""}.`);
+  return true;
+}
+
+// /provider and /login: the arrow-key menu.
+export async function providerMenu(st                 , io            , arg = "")                   {
+  const wanted = arg.trim().toLowerCase();
+  let id                         = PROVIDERS.find((p) => p.id === wanted)?.id;
+  if (!id) {
+    const items = PROVIDERS.map((p) => ({ label: p.label, value: p.id, hint: p.id === st.providerId ? "(active)" : undefined }));
+    id = await io.pick(items, "Choose a provider");
+  }
+  if (!id) { io.print("Cancelled."); return false; }
+  return activateProvider(st, id, io);
+}
+
+                                                
+
+// /logout. Returns "locked" after a full logout (the caller returns to the sign-in prompt),
+// "secondary" after leaving a secondary provider, or undefined when nothing changed.
+export async function logout(st                 , io            )                                              {
+  const env = io.env ?? process.env;
+  const choice = await io.pick              ([
+    { label: "Log out of active secondary provider", value: "secondary" },
+    { label: "Full logout (clear Synqa key and lock TUI)", value: "full" },
+  ], "Log out");
+  if (!choice) { io.print("Cancelled."); return undefined; }
+  const cfg = readConfig(env);
+  if (choice === "secondary") {
+    if (st.providerId === "synqa") { io.print("No secondary provider is active."); return undefined; }
+    const providers = { ...cfg.providers };
+    delete providers[st.providerId];
+    const synqaKey = cfg.apiKey?.trim() || env.SYNQA_API_KEY?.trim() || "";
+    writeConfig({ ...cfg, providers, activeProvider: "synqa" }, env);
+    st.providerId = "synqa"; st.baseUrl = API_BASE; st.modelId = undefined; st.apiKey = synqaKey;
+    io.print("Logged out of the secondary provider. Using Synqa Cloud.");
+    return "secondary";
+  }
+  const next = { ...cfg, activeProvider: "synqa" };
+  delete next.apiKey;
+  writeConfig(next, env);
+  // The variable is cleared in this process only, so nobody has to unset it in their shell.
+  delete env.SYNQA_API_KEY;
+  st.apiKey = ""; st.providerId = "synqa"; st.baseUrl = API_BASE; st.modelId = undefined;
+  io.print("Logged out of Synqa Cloud. The session is locked until you sign in again.");
+  return "locked";
+}

package/dist/sanitize.js

@@ -51,3 +51,9 @@ export function fenceText(s        , max        )         {
     .slice(0, max)
     .replace(/</g, "\u2039");
 }
+
+// A model id a person typed or a provider listed: letters, digits and . _ : / @ + - only, 200 at most.
+export function sanitizeModelId(s        )                     {
+  const t = s.trim();
+  return /^[A-Za-z0-9._:\/@+-]{1,200}$/.test(t) ? t : undefined;
+}

package/dist/select.js

@@ -0,0 +1,131 @@
+// Inline terminal controls that take over the keyboard for a moment: an Up/Down selector (pickOne)
+// and a masked secret prompt (readMasked). Both read keys from a KeySource and write to a plain
+// { write } sink, so they are tested with a fake source and a string buffer. The only control
+// sequences written are the fixed ones in this file (cursor up, erase to end of screen).
+import { emitKeypressEvents } from "node:readline";
+import { dim, terracottaBold } from "./theme.js";
+                                        
+
+                                                                                                             
+                                                                               
+// Something that delivers key presses and can be listened to exclusively: subscribe returns the
+// function that gives the keyboard back.
+                                                                                         
+                                                    
+
+const ESC = "\x1b";
+
+// A KeySource over a raw stdin stream (used where no PromptFrame owns the keyboard, and in tests
+// that drive a PassThrough).
+export function streamKeys(stdin                                                                                    )            {
+  emitKeypressEvents(stdin);
+  return {
+    subscribe(fn) {
+      const was = (stdin                       ).isRaw;
+      stdin.setRawMode?.(true);
+      stdin.on("keypress", fn);
+      stdin.resume();
+      return () => {
+        stdin.off("keypress", fn);
+        if (!was) { stdin.setRawMode?.(false); stdin.pause(); }
+      };
+    },
+  };
+}
+
+                                                                     
+                           
+                  
+               
+                                                 
+                    
+                 
+                                              
+                                                       
+  
+
+const oneLine = (s        ) => s.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/\s+/g, " ").trim();
+
+// Draws the list and returns the number of rows written. Text comes from our own tables or from
+// a provider's model list, so it is cut to one plain line first.
+export function renderPick   (items                        , active        , o                                                )           {
+  const s = o.style ?? { color: false, depth: 8 };
+  const pointer = o.unicode === false ? ">" : "❯";
+  const max = Math.max(1, o.max ?? 10);
+  const start = Math.max(0, Math.min(active - max + 1, items.length - max));
+  return items.slice(start, start + max).map((it, i) => {
+    const on = start + i === active;
+    const label = oneLine(it.label);
+    const hint = it.hint ? " " + dim(s, oneLine(it.hint)) : "";
+    return on ? `${terracottaBold(s, `${pointer} ${label}`)}${hint}` : `  ${label}${hint}`;
+  });
+}
+
+// Up/Down (or k/j) move, Enter confirms, Esc or Ctrl+C cancels. Resolves to the chosen value, or
+// undefined when cancelled. The list is erased on the way out so the transcript stays clean.
+export function pickOne   (items                        , o             )                         {
+  if (items.length === 0) return Promise.resolve(undefined);
+  return new Promise((resolve) => {
+    let active = Math.min(Math.max(0, o.initial ?? 0), items.length - 1);
+    let rows = 0;
+    const s = o.style ?? { color: false, depth: 8 };
+    const header = o.title ? [dim(s, oneLine(o.title) + (o.unicode === false ? " (up/down, enter, esc)" : " (↑↓ move, enter select, esc cancel)"))] : [];
+    const draw = () => {
+      const lines = [...header, ...renderPick(items, active, o)];
+      let out = rows > 0 ? `\r${ESC}[${rows}A${ESC}[J` : "";
+      out += lines.join("\n") + "\n";
+      rows = lines.length;
+      o.out.write(out);
+    };
+    const finish = (v               ) => {
+      off();
+      o.out.write(`\r${ESC}[${rows}A${ESC}[J`);
+      resolve(v);
+    };
+    const off = o.keys.subscribe((str, key) => {
+      const name = key?.name;
+      const seq = key?.sequence ?? str ?? "";
+      if (name === "up" || (name === undefined && seq === "k")) active = (active - 1 + items.length) % items.length;
+      else if (name === "down" || (name === undefined && seq === "j") || name === "tab") active = (active + 1) % items.length;
+      else if (name === "return" || name === "enter") { finish((items[active]               ).value); return; }
+      else if (name === "escape" || (key?.ctrl && name === "c") || seq === "\x03") { finish(undefined); return; }
+      else return;
+      draw();
+    });
+    draw();
+  });
+}
+
+                                                                               
+
+// A secret read one key at a time; each character shows as a bullet and nothing typed is echoed.
+// Pasted text arrives as characters and is accepted; Enter ends it, Esc or Ctrl+C cancels
+// (undefined). Backspace removes one character and one bullet.
+export function readMasked(prompt        , o             )                              {
+  const bullet = o.unicode === false ? "*" : "•";
+  return new Promise((resolve) => {
+    let value = "";
+    const finish = (v                    ) => {
+      off();
+      o.out.write("\n");
+      resolve(v);
+    };
+    o.out.write(prompt);
+    const off = o.keys.subscribe((str, key) => {
+      const name = key?.name;
+      const seq = key?.sequence ?? str ?? "";
+      if (name === "return" || name === "enter" || seq === "\r" || seq === "\n") { finish(value.trim()); return; }
+      if (name === "escape" || (key?.ctrl && name === "c") || seq === "\x03") { finish(undefined); return; }
+      if (name === "backspace" || seq === "\x7f" || seq === "\b") {
+        if (value.length > 0) { value = Array.from(value).slice(0, -1).join(""); o.out.write("\b \b"); }
+        return;
+      }
+      if (key?.ctrl || key?.meta) return;
+      // Printable text only (a paste may carry several characters; control characters are dropped).
+      const text = Array.from(seq).filter((ch) => ch >= " " && ch !== "\x7f" && !/[\u0080-\u009f]/.test(ch)).join("");
+      if (!text) return;
+      value += text;
+      o.out.write(bullet.repeat(Array.from(text).length));
+    }, { paste: true });
+  });
+}

package/dist/tiers.js

@@ -9,7 +9,7 @@ export const TIERS                  = [
 export const DEFAULT_TIER = "blink";
 
 // Reasoning effort the user can pick. "default" sends no reasoning_effort at all.
-export const EFFORTS = ["default", "low", "medium"]         ;
+export const EFFORTS = ["default", "low", "medium", "high"]         ;
                                               
 
 export function findEffort(name        )                     {

package/dist/tools.js

@@ -5,6 +5,8 @@ import { dirname, isAbsolute, join, relative, sep } from "node:path";
 import { MAX_DIFF_LINES, renderDiff, unifiedDiff } from "./diff.js";
 import { snapshot } from "./journal.js";
                                                 
+import { MUTATING_TOOLS } from "./modes.js";
+                                                 
 import { commandTouchesSecrets, confine, fold, isHomeDir, isSecretStemSource, isSensitivePath, writeConfined } from "./paths.js";
 import { visibleEscapes } from "./sanitize.js";
                                         
@@ -73,6 +75,7 @@ export function bashEnv(env                                    )
                                                                             
                                                                       
                                                                                                             
+                                                                                                             
   
 
 const MAX_OUT = 20_000;
@@ -174,6 +177,8 @@ export function riskReasons(root        , abs        )           {
   if (/\/(\.config|\.local\/share)\/systemd\//.test(full)) reasons.push("a systemd unit (runs as a service)");
   if (full.includes("/.config/fish/")) reasons.push("a fish startup file (runs in every new shell)");
   if (full.includes("/.local/bin/")) reasons.push("a program on your PATH");
+  if (full.includes("/start menu/programs/startup/")) reasons.push("a Windows startup entry (runs at login)");
+  if (dirs.includes(".synqa") && base === "hooks.json") reasons.push("Synqa hooks (commands that run at session start and around tools)");
   if (rel.startsWith(".git/hooks/") || rel.includes("/.git/hooks/")) reasons.push("a git hook (runs on git actions)");
   else if (dirs.includes(".git")) reasons.push("inside .git");
   if (base === "package.json") reasons.push("package.json (scripts can run on install or test)");
@@ -396,7 +401,10 @@ function str(a                         , k        )         {
 // Never throws: failures come back as text so the model can react.
 export async function runTool(ctx0             , name        , args                         )                  {
   // --yes never applies when the workspace is the home folder: too much there can run code later.
-  const ctx = ctx0.yes && isHomeDir(ctx0.cwd, ctx0.home) ? { ...ctx0, yes: false } : ctx0;
+  // The auto-accept mode is --yes for file edits only, with the same limits.
+  if (ctx0.mode === "plan" && MUTATING_TOOLS.includes(name)) return "error: plan only mode is on, so nothing was changed or run. Describe the plan instead; the user leaves this mode with Shift+Tab.";
+  const yes = (ctx0.yes || ctx0.mode === "auto") && !isHomeDir(ctx0.cwd, ctx0.home);
+  const ctx = yes === ctx0.yes ? ctx0 : { ...ctx0, yes };
   try {
     switch (name) {
       case "read_file": return await toolRead(ctx, args);