agent.libx.js 0.93.29 → 0.93.31

package/cli/cli.ts

@@ -24,7 +24,7 @@ import { existsSync, readFileSync, appendFileSync, mkdirSync, writeFileSync, rea
 import { homedir, tmpdir } from 'node:os';
 import { grabClipboardImage } from './clipboard';
 import { join, resolve, basename, extname, dirname } from 'node:path';
-import { AIClient, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported } from 'ai.libx.js';
+import { AIClient, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported, disposeCursorSessions } from 'ai.libx.js';
 import {
   PermissionPolicy, loadCommands, expandCommand, loadSkills, forComponent, composeHooks, reflectOnRun,
   AgentOptions, exitSessionTool,
@@ -33,7 +33,7 @@ import {
 } from '../src/index';
 import { mountMcpServer, mountMcpServers, type MountedMcp, type McpServerConfig } from '../src/mcp.client';
 import { McpOAuth } from './mcpOAuth';
-import { buildAgent, summarizeCall, type CliOptions } from './core';
+import { buildAgent, summarizeCall, cursorProviderOptions, type CliOptions } from './core';
 import { DuplexAgent } from '../src/duplex';
 import { VoiceIO } from './voice';
 import { loadConfig, type AgentConfig } from './config';
@@ -95,7 +95,7 @@ interface Args {
   duplex: boolean; voiceModel?: string; thinkModel?: string | false; voice: boolean;
   cont: boolean; resume?: string; sessionId?: string; fork?: boolean; outputFormat: 'text' | 'json' | 'stream-json';
   allowedTools?: string[]; disallowedTools?: string[]; appendSystemPrompt?: string; addDirs?: string[];
-  print?: boolean; debug?: boolean;
+  print?: boolean; debug?: boolean; scratch?: boolean;
 }
 /** Parse a numeric flag, failing fast on a missing/NaN/negative value so a typo can't silently disable a kill-switch. */
 function numFlag(raw: string | undefined, flag: string): number {
@@ -141,6 +141,7 @@ export function parseArgs(argv: string[]): Args {
     else if (x === '--ask') a.ask = true;
     else if (x === '--yes' || x === '-y') a.yes = true;
     else if (x === '--vfs' || x === '--sandbox') a.vfs = true;
+    else if (x === '--scratch') a.scratch = true;
     else if (x === '--boddb') a.boddb = val(++i, x);
     else if (x === '--seed') a.seed = true;
     else if (x === '--shell') a.shell = true;
@@ -194,6 +195,7 @@ Flags:
   --no-stream          disable token streaming
                        (default: disk mode — full real filesystem access, like Claude Code)
   --vfs, --sandbox     sandbox mode: work over an in-memory copy of cwd — real disk is NEVER modified
+  --scratch            spill big web outputs to scratch files (kept out of context; peek via Grep/Ask)
   --boddb <dir>        database-backed workspace: files live in a persistent bod-db store at <dir>,
                        surviving across runs — real disk is NEVER modified (DB-native; add --seed below)
   --seed               with --boddb: hydrate the store from cwd on the first run (empty DB) only
@@ -211,7 +213,7 @@ Flags:
                        impulsive reactions, human pacing (implies --duplex; aliases: --convo, --voice)
                        with SONIOX_API_KEY + CARTESIA_API_KEY(+VOICE_ID) set: real voice I/O — mic in,
                        spoken replies out (echo-cancelled; speak over it to interrupt)
-  --voice-model <id>   with --duplex: the fast voice model (default groq/openai/gpt-oss-20b)
+  --voice-model <id>   with --duplex: the fast voice model (default groq/openai/gpt-oss-120b)
   --think-model <id>   with --duplex: the premium deep-reasoning model (default anthropic/claude-opus-4-6)
   --no-think           with --duplex: disable the Think tier (Act handles everything)
   --add-dir <path>     mount another directory into the workspace (repeatable; disk mode only)
@@ -243,7 +245,7 @@ Project instructions: ./AGENTS.md or ./CLAUDE.md are auto-loaded (scaffold with
 Auto-loaded from ./.agent/: commands/, skills/, memory/, agents/.
 
 REPL shortcuts: !<cmd> runs a shell command inline · #<note> saves a memory · @path inlines a file
-REPL slash commands: /help /version /tools /permissions /status /cost /context /cwd /model /reasoning /config /rename /compact /rewind /undo /clear /sessions /resume /commands /skills /mcp /init /export /paste /goal /exit (duplex: /act /think /voice-model /think-model)
+REPL slash commands: /help /version /tools /permissions /status /cost /context /cwd /model /reasoning /config /rename /compact /rewind /undo /clear /sessions /resume /commands /skills /mcp /init /export /paste /goal /exit (duplex: /act /think /voice /voice-model /think-model)
 REPL completion: type / (commands+skills) or @ (files) for a LIVE menu — ↑/↓ select, ⏎/Tab accept, Esc dismiss.
 REPL multi-line: Option/Alt+Enter inserts a newline, or end a line with \\ to continue. Esc cancels a running turn / clears the input line; double-Esc jumps back to edit a previous message.
 REPL shortcuts: Shift+Tab cycles permission posture (ask → accept-edits → plan) · Alt+T toggles reasoning · Alt+P switches model · Ctrl+O toggles verbose tool output · → or Tab accepts the dim history ghost-suggestion · Alt+S/Ctrl+S stash/unstash.
@@ -707,6 +709,7 @@ function optsFor(args: Args, ai: ChatLike, cfg: Partial<AgentConfig> = {}, extra
     boddb: args.boddb,
     seed: args.seed,
     realShell: args.shell,  // undefined → core.ts defaults (on for disk, off for sandbox/boddb)
+    scratch: args.scratch,
     appendSystemPrompt: args.appendSystemPrompt,
     addDirs: args.addDirs,
     stream: args.stream,
@@ -1044,6 +1047,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
   const duplex = args.duplex;
   let dx: DuplexAgent | undefined;
   let voiceIO: VoiceIO | undefined; // real voice I/O (--voice + keys): mic→STT in, text_delta→TTS out
+  let toggleVoice: (() => Promise<void>) | undefined; // bound below (duplex + TTY): /voice flips mic on/off live
   let editorRef: LineEditor | undefined; // bound once the line editor exists — async chrome repaints the prompt via it
   // During a turn the user's type-ahead lives on a "stash ›" line (no active editor to own it). Async
   // chrome (streamed deltas, task events) lands on top of it — repaint the stash below, so it survives.
@@ -1099,7 +1103,10 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
   if (duplex) {
     // Workers must not stream into the voice channel — strip the host/stream seam (display hooks stay:
     // worker tool activity prints as dim stderr chrome). `signal` is per-task (duplex.ts owns it).
-    const { host: _host, stream: _stream, signal: _signal, ...wo } = agent.options;
+    // Drop providerOptions too: they're computed for the MAIN agent's model (e.g. cursor's cwd/cursorSession)
+    // and must never leak onto a worker whose model differs — DuplexAgent recomputes them per worker model
+    // via providerOptionsFor below. (A cursor cursorSession leaking onto an anthropic worker is a hard 400.)
+    const { host: _host, stream: _stream, signal: _signal, providerOptions: _po, ...wo } = agent.options;
     workerOptions = wo as AgentOptions;
     if (workerOptions.permissions)
       workerOptions.permissions = new PermissionPolicy({ ...workerOptions.permissions.options, host: undefined, ask: duplexAsk });
@@ -1194,6 +1201,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
       ...((args.voiceModel ?? cfg.reflexModel) ? { reflexModel: resolveModelOrNewest((args.voiceModel ?? cfg.reflexModel)!) } : {}),
       actModel: agent.options.model,
       actOptions: workerOptions,
+      providerOptionsFor: (m) => cursorProviderOptions(m, cwd, cfg.mcpServers),
       ...((args.thinkModel ?? cfg.thinkModel) !== undefined ? { thinkModel: (args.thinkModel ?? cfg.thinkModel) === false ? false : resolveModelOrNewest(String(args.thinkModel ?? cfg.thinkModel)) } : {}),
       host,
       ...(args.voice ? { voiceStyle: 'conversational' as const, progressUpdates: true, askRelay: true } : {}), // voice: progress asides + worker questions relayed through the conversation
@@ -1278,11 +1286,22 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
     const img = grabClipboardImage(dir, String(Date.now()));
     return img ? { display: 'Image', ref: '@' + img.path, path: img.path } : null;
   };
-  // Ctrl-C: cancel the in-flight turn if one's running; otherwise clean up MCP children and exit.
+  // Hard teardown — used by the SIGINT path and the keypress force-quit escalation. Never let the
+  // user get trapped: even if a turn's abort() fails to unwind (wedged stream/tool), this exits.
+  const forceQuit = (code = 130) => {
+    try { voiceIO?.stop(); } catch { /* mic/player may already be down */ }
+    try { disposeCursorSessions(); } catch { /* reap warm cursor helpers, best-effort */ }
+    void closeMcp(mounted);
+    process.exit(code);
+  };
+  // Ctrl-C: cancel the in-flight turn if one's running; a second Ctrl-C while already cancelling
+  // (i.e. the abort didn't unwind) force-quits. No active turn → clean up MCP children and exit.
   process.on('SIGINT', () => {
-    if (activeTurn) { activeTurn.abort(); voiceIO?.interrupt(); return; }
-    voiceIO?.stop(); // kill mic/player children — they outlive the process otherwise
-    void closeMcp(mounted); process.exit(130);
+    if (activeTurn) {
+      if (aborting) { err(red('\n  ⏻ force-quit\n')); forceQuit(); return; } // already cancelling → hard escape
+      activeTurn.abort(); voiceIO?.interrupt(); return;
+    }
+    forceQuit();
   });
   installCancelGuards(mounted);
   const store = new SessionStore(cwd);
@@ -1600,6 +1619,12 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
         if (a[0] === 'full' || a[0] === 'minimal') { workerChrome = a[0]; err(green(`  ✓ worker chrome → ${a[0]}\n`)); return; }
         err(dim(`  worker chrome: ${workerChrome} (use /workers full|minimal)\n`));
       },
+    }, voice: {
+      desc: 'toggle live voice I/O on/off mid-session (needs SONIOX/CARTESIA keys + a TTY)',
+      run: async () => {
+        if (!toggleVoice) { err(dim('  (voice needs --duplex on a TTY)\n')); return; }
+        await toggleVoice();
+      },
     }, 'voice-model': {
       desc: 'switch the reflex (voice) model — /voice-model <id>, or alone for a picker',
       run: async (a: string[]) => {
@@ -1749,7 +1774,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
     commands: { desc: 'pick a custom slash command to run (./.agent/commands)', run: () => pickAndRun('command') },
     skills: { desc: 'pick a skill to run (./.agent/skills)', run: () => pickAndRun('skill') },
     mcp: {
-      desc: 'manage MCP servers — /mcp [add <name> <cmd|url>] [login <name>] [remove <name>] [resources [name]]',
+      desc: 'manage MCP servers — /mcp [add <name> <cmd|url>] [login <name>] [remove <name>] [tools [name]] [resources [name]]',
       run: async (a) => {
         const sub = a[0]?.toLowerCase();
         if (sub === 'login') {
@@ -1793,6 +1818,16 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
           err(dim(`  removed "${name}"\n`));
           return;
         }
+        if (sub === 'tools') {
+          const filter = a[1];
+          const targets = filter ? mounted.filter((m) => m.name === filter) : mounted;
+          if (!targets.length) { err(dim(`  (no ${filter ? `MCP server "${filter}"` : 'MCP servers'} found)\n`)); return; }
+          for (const m of targets) {
+            err(`  ${cyan(m.name)} ${dim(`(${m.tools.length} tools)`)}\n`);
+            for (const t of m.tools) err(dim(`     - ${t.name.replace(`mcp__${m.name}__`, '')}${t.description ? ' — ' + t.description.split('\n')[0] : ''}\n`));
+          }
+          return;
+        }
         if (sub === 'resources') {
           const filter = a[1];
           const targets = filter ? mounted.filter((m) => m.name === filter) : mounted;
@@ -1812,14 +1847,15 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
           if (!mounted.length) { err(dim('  (no MCP servers mounted)\n')); return; }
           for (const m of mounted) {
             const ver = m.serverInfo?.name ? dim(` · ${m.serverInfo.name}${m.serverInfo.version ? ' v' + m.serverInfo.version : ''}`) : '';
-            err(`  ${cyan(m.name)}${ver} ${dim(`(${m.tools.length} tools)`)}\n`);
-            for (const t of m.tools) err(dim(`     - ${t.name.replace(`mcp__${m.name}__`, '')}${t.description ? ' — ' + t.description.split('\n')[0] : ''}\n`));
+            err(`  ${green('✓')} ${cyan(m.name)}${ver} ${dim(`(${m.tools.length} tools)`)}\n`);
           }
+          err(dim('  /mcp tools [name] to list tools · /mcp resources [name] for resources\n'));
         };
         const items: SelectItem[] = [
           { label: 'list', value: 'list', desc: `show mounted servers (${mounted.length})` },
           { label: 'add', value: 'add', desc: 'mount a new MCP server' },
           ...(mounted.length ? [
+            { label: 'tools', value: 'tools', desc: 'list a server\'s tools' },
             { label: 'remove', value: 'remove', desc: 'unmount an MCP server' },
             { label: 'resources', value: 'resources', desc: 'list server resources' },
           ] : []),
@@ -1841,12 +1877,12 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
           const rv = await selectMenu(process.stderr, { title: 'remove server', items: mounted.map((m) => ({ label: m.name, value: m.name })) });
           if (!rv) return;
           a = ['remove', rv];
-        } else if (picked === 'resources') {
-          if (mounted.length === 1) { a = ['resources', mounted[0].name]; }
+        } else if (picked === 'tools' || picked === 'resources') {
+          if (mounted.length === 1) { a = [picked, mounted[0].name]; }
           else {
-            const rv = await selectMenu(process.stderr, { title: 'server resources', items: [{ label: '(all)', value: '' }, ...mounted.map((m) => ({ label: m.name, value: m.name }))] });
+            const rv = await selectMenu(process.stderr, { title: `server ${picked}`, items: [{ label: '(all)', value: '' }, ...mounted.map((m) => ({ label: m.name, value: m.name }))] });
             if (rv === null) return;
-            a = rv ? ['resources', rv] : ['resources'];
+            a = rv ? [picked, rv] : [picked];
           }
         }
         // fall through to re-run with the assembled args
@@ -1953,8 +1989,16 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
       const cancel = k === 'escape' || (key?.ctrl && k === 'c');
       if (cancel) {
         if (stashBuf) { stashBuf = ''; err('\r\x1b[K'); return; } // first Esc clears the stash line
-        if (!aborting) { aborting = true; activeTurn.abort(); voiceIO?.interrupt(); err(yellow('\n  ⎋ cancelling…\n')); }
-        else if (k === 'escape' && !pendingRewind) { pendingRewind = true; err(dim('  ⎋⎋ jumping back to edit…\n')); }
+        if (!aborting) {
+          aborting = true; activeTurn.abort(); voiceIO?.interrupt();
+          err(yellow('\n  ⎋ cancelling…') + dim(' (Ctrl-C again to force-quit)\n'));
+          // Watchdog: if the turn hasn't unwound shortly, the abort is wedged — surface the escape hatch.
+          setTimeout(() => {
+            if (activeTurn) err(red('  ⚠ still cancelling — press Ctrl-C to force-quit\n'));
+          }, 4000).unref?.();
+        } else if (key?.ctrl && k === 'c') {
+          err(red('\n  ⏻ force-quit\n')); forceQuit(); // already cancelling + another Ctrl-C → never trapped
+        } else if (k === 'escape' && !pendingRewind) { pendingRewind = true; err(dim('  ⎋⎋ jumping back to edit…\n')); }
         return;
       }
       // Stash input: type ahead while the turn runs
@@ -2028,11 +2072,17 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
   // spoken via the host tap above. Missing keys → conversational text mode, one-line note.
   let voicePartial = ''; // live partial transcript, rendered in the prompt footer
   let partialRedraw: ReturnType<typeof setTimeout> | null = null;
-  if (args.voice && duplex && process.stdin.isTTY) {
+  // Spin VoiceIO up live (launch with --voice, or /voice mid-session). `greet` opens with a spoken
+  // greeting turn (launch only); a manual toggle just turns the mic on quietly. Returns true if voice
+  // is now live. Duplex + TTY only — bound to `toggleVoice` below so /voice can flip it off again.
+  const startVoice = async (greet: boolean): Promise<boolean> => {
+    if (voiceIO) return true;
+    if (!duplex || !process.stdin.isTTY) { err(dim('  (voice needs --duplex on a TTY)\n')); return false; }
     if (!VoiceIO.available()) {
       err(dim('  (voice I/O off — set SONIOX_API_KEY, CARTESIA_API_KEY, CARTESIA_VOICE_ID to talk)\n'));
-    } else {
-      voiceIO = new VoiceIO({
+      return false;
+    }
+    voiceIO = new VoiceIO({
         // No ack phrase by default: a fixed "Mm-hm," every turn reads robotic, Haiku's TTFT doesn't
         // need masking (~0.7-1.2s full turns), and the conversational register already opens with a
         // natural reaction. The mechanism (+ echo-leak guard) stays for slower voice models.
@@ -2060,14 +2110,11 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
           err(`\r\x1b[K  ${bold(cyan('🎤 ›'))} ${text}\n`);
           void dispatchLine(text + note).then(async (r) => { if (r === 'quit') { await voiceIO?.awaitIdle(); editorRef?.abort(); } }).finally(() => editorRef?.redrawNow());
         },
-      });
-      try {
-        await voiceIO.start();
-        process.on('exit', () => voiceIO?.stop()); // last-resort child cleanup (uncaughtException path exits hard)
-        // SIGHUP/SIGTERM (terminal closed, kill) bypass 'exit' handlers by default — without these the
-        // mic/player children outlive the CLI and hold the microphone (verified leak in PTY testing).
-        for (const sig of ['SIGHUP', 'SIGTERM'] as const) process.on(sig, () => { voiceIO?.stop(); process.exit(0); });
-        err(dim(`  🎤 voice on (${voiceIO.usingAec ? 'echo-cancelled' : 'heuristic echo — headphones recommended'}) — just talk; speak over it to interrupt\n`));
+    });
+    try {
+      await voiceIO.start();
+      err(dim(`  🎤 voice on (${voiceIO.usingAec ? 'echo-cancelled' : 'heuristic echo — headphones recommended'}) — just talk; speak over it to interrupt\n`));
+      if (greet) {
         // Greeting: the agent makes the first turn — spoken, personalized from what it can see.
         // Straight to turn() (not dispatchLine): the synthetic prompt must not enter ↑-history.
         const where = cwd.split('/').pop();
@@ -2078,12 +2125,30 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
           `Context: working directory "${where}"${resumed ? '; this resumes an earlier conversation — glance at it and pick up naturally' : ''}. ` +
           `Personalize from whatever you learned (memory, prior conversation). Then ask what they'd like to do.`,
         ).finally(() => editorRef?.redrawNow());
-      } catch (e: any) {
-        err(yellow(`  ⚠ voice I/O failed to start: ${e?.message ?? e} — continuing text-only\n`));
-        voiceIO = undefined;
       }
+      return true;
+    } catch (e: any) {
+      err(yellow(`  ⚠ voice I/O failed to start: ${e?.message ?? e} — continuing text-only\n`));
+      voiceIO = undefined;
+      return false;
     }
+  };
+  // Child cleanup, registered ONCE (not per start — toggling on/off must not stack listeners). They
+  // close over the live `voiceIO`, so they cover whichever instance is up. SIGHUP/SIGTERM (terminal
+  // closed, kill) bypass 'exit' handlers by default — without these the mic/player children outlive
+  // the CLI and hold the microphone (verified leak in PTY testing).
+  if (duplex && process.stdin.isTTY) {
+    process.on('exit', () => voiceIO?.stop());
+    for (const sig of ['SIGHUP', 'SIGTERM'] as const) process.on(sig, () => { voiceIO?.stop(); process.exit(0); });
   }
+  // /voice toggle: flip the mic on or off without leaving the session (kills STT/TTS children on off).
+  if (duplex && process.stdin.isTTY) toggleVoice = async () => {
+    if (voiceIO) { voiceIO.stop(); voiceIO = undefined; voicePartial = ''; err(dim('  🔇 voice off\n')); editorRef?.redrawNow(); return; }
+    await startVoice(false);
+    editorRef?.redrawNow();
+  };
+  // Launch with --voice: start now, with the spoken greeting.
+  if (args.voice && duplex && process.stdin.isTTY) await startVoice(true);
 
   while (true) {
     // Double-Esc fired during the just-finished turn → open the jump-back picker now (turn has unwound).
@@ -2193,6 +2258,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
         // (voice children / sockets / MCP handles can keep the process alive otherwise).
         voiceIO?.stop();
         releaseStdin();
+        disposeCursorSessions();
         await closeMcp(mounted);
         process.exit(130);
       }
@@ -2201,6 +2267,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
     }
   }
   releaseStdin();
+  disposeCursorSessions(); // reap any warm cursor helper (its stdout pipe would otherwise keep the loop alive → hang on exit)
   await closeMcp(mounted);
 }
 

package/dist/{Agent-kWrJvtZM.d.ts → Agent-uWtu_WFY.d.ts}

@@ -228,6 +228,17 @@ declare class AgentOptions {
     /** Token-aware backstop (~4 chars/token estimate). After note-taking, drop oldest messages from the
      *  sent context until the estimate is under this ceiling (pairing-safe). 0 = off. */
     maxContextTokens: number;
+    /** Pagination ceiling for a SINGLE tool result (bytes). A result over this is cropped to page 1 with
+     *  a marker telling the model it was cropped (refine the query, or page further). Guards against one
+     *  Grep/Read/MCP call blowing the whole context window. 0 = off. Default 60k (~15k tokens). */
+    maxToolResultBytes: number;
+    /** Hook to handle an oversized tool result instead of the default lossy crop: receives the FULL output
+     *  and returns the (cropped) string to put in context — e.g. spill to scratch and return a recoverable,
+     *  paginated stub. Called only when a result exceeds `maxToolResultBytes`. */
+    capToolResult?: (full: string, info: {
+        tool: string;
+        args: any;
+    }) => string | Promise<string>;
     /** VFS dir(s) of skills (`<dir>/<id>/SKILL.md`). If set: inject a catalog + add the `Skill` tool. Multiple dirs are merged (first wins on name collisions). */
     skillsDir?: string | string[];
     /** VFS dir(s) of slash-command templates (`<dir>/<name>.md`). If set: inject a catalog + add the `SlashCommand` tool. Multiple dirs are merged (first wins). */

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { h as RunResult, R as ReasoningEffort } from './Agent-kWrJvtZM.js';
+import { h as RunResult, R as ReasoningEffort } from './Agent-uWtu_WFY.js';
 import { IFilesystem } from '@livx.cc/wcli/core';
 import { M as Message, c as ContentPart } from './tools-GPWp7oXq.js';
 
@@ -89,6 +89,7 @@ interface Args {
     addDirs?: string[];
     print?: boolean;
     debug?: boolean;
+    scratch?: boolean;
 }
 declare function parseArgs(argv: string[]): Args;
 /** Render a resumed conversation (like CC) so the user sees the context they're continuing: user