@tianmucreations/jeeves 0.3.0 → 0.3.2

package/dist/components/transcript-layout.js

@@ -1,3 +1,47 @@
+import stringWidth from 'string-width';
+import { renderMarkdown } from './markdown.js';
+// Wraps formatted text at word boundaries, carrying each style range onto the
+// lines it lands on. Every line break in the text starts a new line.
+export function wrapStyled(text, spans, width) {
+    const out = [];
+    let offset = 0;
+    for (const paragraph of text.split('\n')) {
+        // A list line's wrapped lines start under its words, not under the "- ".
+        const hang = /^(\s*(?:[-•]|\d+\.)\s)/.exec(paragraph)?.[1].length ?? 0;
+        const pieces = [];
+        let start = 0;
+        do {
+            const max = Math.max(1, width - (start > 0 ? hang : 0));
+            if (paragraph.length - start <= max) {
+                pieces.push([start, paragraph.length]);
+                break;
+            }
+            let cut = paragraph.lastIndexOf(' ', start + max);
+            if (cut <= start)
+                cut = start + max;
+            pieces.push([start, cut]);
+            start = paragraph[cut] === ' ' ? cut + 1 : cut;
+        } while (start < paragraph.length);
+        pieces.forEach(([from, to], index) => {
+            const line = paragraph.slice(from, to).replace(/\s+$/, '');
+            const absFrom = offset + from;
+            const absTo = absFrom + line.length;
+            const pad = index > 0 ? hang : 0;
+            const lineSpans = spans
+                .filter((span) => span.to > absFrom && span.from < absTo)
+                .map((span) => ({ ...span, from: Math.max(span.from, absFrom) - absFrom + pad, to: Math.min(span.to, absTo) - absFrom + pad }));
+            // A single space: an empty line would be drawn with no height at all.
+            out.push({ text: ' '.repeat(pad) + line || ' ', spans: lineSpans });
+        });
+        offset += paragraph.length + 1;
+    }
+    return out;
+}
+// Claude Code marks the person's messages the same way: a blank line above and a
+// grey band behind (its dark theme's userMessageBackground, rgb(55, 55, 55)), with
+// white text so the band reads on light and dark terminals alike.
+export const OWN_MESSAGE_BACKGROUND = '#373737';
+export const OWN_MESSAGE_TEXT = '#ffffff';
 // Greedy word-wrap for plain text. Long unbreakable words are hard-broken at the width.
 export function wrapParagraph(s, max) {
     if (max <= 0)
@@ -44,7 +88,7 @@ const TOOL_NAMES = { readFile: 'Read', listDir: 'List', writeFile: 'Write', runB
 export function toolName(tool) {
     return TOOL_NAMES[tool] ?? tool;
 }
-function toolLineText(d) {
+export function toolLineText(d) {
     if (d.state === 'awaiting') {
         return { text: `? ${toolName(d.tool)} ${d.summary} — allow? (y/n)`, color: 'yellow' };
     }
@@ -73,11 +117,27 @@ export function buildDisplayLines(entries, width) {
     };
     for (const entry of entries) {
         switch (entry.kind) {
-            case 'user':
-                pushWrapped(entry.text, '> ', '  ');
+            case 'user': {
+                // A single space: an empty line would be drawn with no height at all.
+                if (lines.length > 0)
+                    lines.push({ text: ' ' });
+                for (const line of wrapWithPrefix(entry.text, width, '> ', '  ')) {
+                    lines.push({ text: line + ' '.repeat(Math.max(0, width - stringWidth(line))), own: true });
+                }
                 break;
+            }
             case 'assistant':
-                pushWrapped(entry.text, '', '');
+                // Always a gap above Jeeves's answer, so it never runs straight on from the
+                // actions above it (the owner's request, 18 Sept) or from your message.
+                if (lines.length > 0 && lines[lines.length - 1].text.trim() !== '')
+                    lines.push({ text: ' ' });
+                {
+                    // Markdown drawn as formatting, never as stray ** and ## marks.
+                    const styled = renderMarkdown(entry.text);
+                    for (const line of wrapStyled(styled.text, styled.spans, width)) {
+                        lines.push({ text: line.text, spans: line.spans.length ? line.spans : undefined });
+                    }
+                }
                 break;
             case 'reasoning':
                 pushWrapped(entry.text, '· ', '  ', undefined, true);

package/dist/index.js

@@ -52,7 +52,8 @@ program
     // The whole app - project picker, key screens, model picker, main window - runs inside a
     // single AlternateScreen, so the terminal is taken over exactly once for the whole
     // process and handed back only when Jeeves quits (Claude Code's mechanism).
-    const instance = render(_jsx(AlternateScreen, { children: _jsx(App, {}) }));
+    // Ctrl+C is Jeeves's own (src/ink/quit.ts): twice to quit, never at once.
+    const instance = render(_jsx(AlternateScreen, { children: _jsx(App, {}) }), { exitOnCtrlC: false });
     let quitting = false;
     // /exit asks for a clean shutdown: let Ink finish its frame teardown, hand the
     // terminal back, then leave.

package/dist/ink/mouse.js

@@ -1,10 +1,12 @@
 import { session } from '../state/session.js';
+import { pointAt, copySelection } from './selection.js';
 // SGR mouse tracking (modes 1000 + 1002 + 1006), enabled for the whole session by
 // the AlternateScreen takeover and disabled on every exit path. Claude Code's
 // approach: in the alternate screen the terminal has no scrollback, so wheel
 // events are captured and translated into transcript scrolling. The trade-off is
-// native click-drag selection; Shift (or Option in Terminal.app) bypasses mouse
-// capture for copying - the help screen says so.
+// the terminal's own click-drag selection, so selection is done here instead
+// (selection.ts): drag to select, copied on release. Fn in Terminal.app still
+// bypasses capture for the terminal's own selection.
 export const ENABLE_MOUSE_TRACKING = '\x1b[?1000h\x1b[?1002h\x1b[?1006h';
 export const DISABLE_MOUSE_TRACKING = '\x1b[?1006l\x1b[?1002l\x1b[?1000l';
 // Ink's input parser hands over complete CSI sequences but strips the leading ESC
@@ -35,14 +37,45 @@ export function parseMouseSequence(input) {
     if (rawButton <= 6) {
         return { kind: 'press', button: rawButton, col, row };
     }
+    // Mode 1002 reports movement with a button held as the button code plus 32.
+    if (rawButton >= 32 && rawButton <= 34) {
+        return { kind: 'drag', button: rawButton - 32, col, row };
+    }
     return null;
 }
 // Wheel up scrolls the transcript up 3 rows, wheel down 3 rows back; the session
-// clamps at the newest (0) and the Transcript clamps at the oldest. Non-wheel
-// events are consumed silently - clicks must never leak into text inputs.
+// clamps at the newest (0) and the Transcript clamps at the oldest. A left-button
+// press in the conversation starts a selection, dragging extends it, and releasing
+// copies it. Nothing here ever reaches the text being typed.
 export function handleMouseInput(input) {
     const event = parseMouseSequence(input);
-    if (event === null || event.kind !== 'wheel')
+    if (event === null)
+        return;
+    if (event.kind === 'wheel') {
+        session.scrollTranscript(event.button === 0 ? 3 : -3);
+        return;
+    }
+    if (event.button !== 0)
         return;
-    session.scrollTranscript(event.button === 0 ? 3 : -3);
+    if (event.kind === 'press') {
+        const point = pointAt(event.col, event.row);
+        session.setSelection(point ? { anchor: point, focus: point } : null);
+        // Outside the conversation: a click in the typing box places the cursor.
+        if (!point)
+            session.inputClick?.(event.col, event.row);
+        return;
+    }
+    const current = session.selection;
+    if (!current)
+        return;
+    const point = pointAt(event.col, event.row, true);
+    if (point)
+        session.setSelection({ anchor: current.anchor, focus: point });
+    if (event.kind === 'release') {
+        const moved = point && (point.line !== current.anchor.line || point.ch !== current.anchor.ch);
+        if (moved)
+            void copySelection();
+        else
+            session.setSelection(null);
+    }
 }

package/dist/ink/quit.js

@@ -0,0 +1,21 @@
+import { session } from '../state/session.js';
+// Quitting takes Ctrl+C twice within two seconds (Claude Code's rule), so a stray
+// Ctrl+C - the copy key on Windows and Linux - never closes Jeeves and loses the
+// conversation. The first press says so in the info bar.
+const WINDOW_MS = 2000;
+let firstPress = 0;
+let noteTimer = null;
+export function pressCtrlCToQuit(now = Date.now()) {
+    if (now - firstPress <= WINDOW_MS) {
+        session.requestExit();
+        return;
+    }
+    firstPress = now;
+    session.setBusyNote('press Ctrl+C again to quit');
+    if (noteTimer)
+        clearTimeout(noteTimer);
+    noteTimer = setTimeout(() => {
+        if (session.busyNote === 'press Ctrl+C again to quit')
+            session.setBusyNote(null);
+    }, WINDOW_MS);
+}

package/dist/ink/selection.js

@@ -0,0 +1,128 @@
+import { spawn } from 'node:child_process';
+import { session } from '../state/session.js';
+// A screen position (1-based column and row, as the mouse reports them) as a line
+// and character of the drawn conversation. Outside the conversation area: null,
+// unless clamp is set, when it is pinned to the nearest edge (for dragging past it).
+export function pointAt(col, row, clamp = false) {
+    const view = session.transcriptView;
+    if (!view)
+        return null;
+    let r = row - view.top;
+    if (r < 0 || r >= view.height) {
+        if (!clamp)
+            return null;
+        r = Math.max(0, Math.min(view.height - 1, r));
+    }
+    // The newest line sits on the bottom row; scrolling up moves older lines in.
+    const line = view.lines.length - view.scrollTop - view.height + r;
+    if (line < 0 || line >= view.lines.length) {
+        if (!clamp)
+            return null;
+        return { line: Math.max(0, Math.min(view.lines.length - 1, line)), ch: line < 0 ? 0 : Number.MAX_SAFE_INTEGER };
+    }
+    return { line, ch: Math.max(0, col - view.left) };
+}
+// Start and end in reading order.
+export function ordered(a, b) {
+    return a.line < b.line || (a.line === b.line && a.ch <= b.ch) ? [a, b] : [b, a];
+}
+// The selected characters of one drawn line, as [from, to), or null.
+export function selectedRange(lineIndex, length) {
+    const sel = session.selection;
+    if (!sel)
+        return null;
+    const [start, end] = ordered(sel.anchor, sel.focus);
+    if (lineIndex < start.line || lineIndex > end.line)
+        return null;
+    const from = lineIndex === start.line ? Math.min(start.ch, length) : 0;
+    const to = lineIndex === end.line ? Math.min(end.ch + 1, length) : length;
+    return to > from ? [from, to] : null;
+}
+// The selected text: each line's selected part without the padding the display adds.
+export function selectedText(lines) {
+    const sel = session.selection;
+    if (!sel)
+        return '';
+    const [start, end] = ordered(sel.anchor, sel.focus);
+    const out = [];
+    for (let i = start.line; i <= end.line && i < lines.length; i++) {
+        const range = selectedRange(i, lines[i].length);
+        out.push(range ? lines[i].slice(range[0], range[1]).replace(/\s+$/, '') : '');
+    }
+    return out.join('\n').replace(/^\n+|\n+$/g, '');
+}
+// As Claude Code (ink/termio/osc.ts setClipboard): the terminal's clipboard escape
+// (OSC 52) always, and - on this computer, not over SSH - its own clipboard
+// program too, because OSC 52 depends on terminal settings (several Linux terminals
+// ignore it): pbcopy on a Mac, clip on Windows, and on Linux the first of wl-copy
+// (Wayland), xclip or xsel (X11) that exists, remembered after the first copy.
+let linuxCopy;
+function runCopy(program, args, text) {
+    return new Promise((resolve) => {
+        try {
+            const child = spawn(program, args, { stdio: ['pipe', 'ignore', 'ignore'] });
+            const timer = setTimeout(() => child.kill(), 2000);
+            child.on('error', () => {
+                clearTimeout(timer);
+                resolve(false);
+            });
+            child.on('close', (code) => {
+                clearTimeout(timer);
+                resolve(code === 0);
+            });
+            child.stdin.on('error', () => { });
+            child.stdin.end(text);
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}
+export async function copyNative(text) {
+    if (process.platform === 'darwin')
+        return runCopy('pbcopy', [], text);
+    if (process.platform === 'win32')
+        return runCopy('clip', [], text);
+    if (linuxCopy === null)
+        return false;
+    if (linuxCopy)
+        return runCopy(linuxCopy[0], linuxCopy[1], text);
+    const candidates = [['wl-copy', []], ['xclip', ['-selection', 'clipboard']], ['xsel', ['--clipboard', '--input']]];
+    for (const candidate of candidates) {
+        if (await runCopy(candidate[0], candidate[1], text)) {
+            linuxCopy = candidate;
+            return true;
+        }
+    }
+    linuxCopy = null;
+    return false;
+}
+export async function copyToClipboard(text) {
+    let sent = false;
+    try {
+        process.stdout.write(`\x1b]52;c;${Buffer.from(text, 'utf8').toString('base64')}\x07`);
+        sent = true;
+    }
+    catch {
+        // A closed stream: the clipboard program below may still work.
+    }
+    if (process.env.SSH_CONNECTION)
+        return sent;
+    return (await copyNative(text)) || sent;
+}
+let noteTimer = null;
+// Copies the selection and says so in the info bar for two seconds.
+export async function copySelection() {
+    const view = session.transcriptView;
+    const text = view ? selectedText(view.lines) : '';
+    if (!text)
+        return;
+    const copied = await copyToClipboard(text);
+    session.setBusyNote(copied ? 'copied' : "couldn't copy");
+    if (noteTimer)
+        clearTimeout(noteTimer);
+    noteTimer = setTimeout(() => {
+        if (session.busyNote === 'copied' || session.busyNote === "couldn't copy")
+            session.setBusyNote(null);
+    }, 2000);
+}

package/dist/keys/store.js

@@ -1,13 +1,83 @@
+// API keys live in the operating system's own credential store (the macOS Keychain),
+// never in plain files. The library loads lazily so a missing native module degrades
+// gracefully instead of crashing the app.
+//
+// On a Mac, Jeeves uses Apple's own `security` program, as Claude Code does
+// (src/utils/secureStorage/macOsKeychainStorage.ts): no add-on to break. keytar is
+// archived (unmaintained since Dec 2022) and inside the desktop app it crashed on
+// quit whenever a keychain read was still running - 10 of 10 times (19 Sept). The
+// Keychain items are the same ones keytar made (service "jeeves", account = the
+// service id), so nobody re-enters a key: checked 19 Sept - an item keytar created
+// was updated, read, listed and deleted by `security` with no permission box.
+// Windows and Linux stay on keytar until the same check is done there.
+import { execFile } from 'node:child_process';
 // JEEVES_KEYCHAIN_SERVICE lets a test run use its own keychain entries, never the real ones.
 const SERVICE = process.env.JEEVES_KEYCHAIN_SERVICE || 'jeeves';
 let cached = null;
+function runSecurity(args, input) {
+    return new Promise((resolve) => {
+        const child = execFile('/usr/bin/security', args, { timeout: 10_000, maxBuffer: 16 * 1024 * 1024 }, (error, stdout) => {
+            const code = error ? (typeof error.code === 'number' ? error.code : 1) : 0;
+            resolve({ code, stdout: String(stdout) });
+        });
+        if (input !== undefined)
+            child.stdin?.end(input);
+    });
+}
+// Quotes a value for one line of `security -i`: the ids are plain words, but never trust that.
+const quoted = (value) => `"${value.replace(/["\\]/g, '')}"`;
+const macKeychain = {
+    async setPassword(service, account, password) {
+        // The key goes in as hex on standard input, so it never appears in the list of
+        // running programs (Claude Code's reason: process monitors see only "security -i").
+        const hex = Buffer.from(password, 'utf8').toString('hex');
+        const { code } = await runSecurity(['-i'], `add-generic-password -U -s ${quoted(service)} -a ${quoted(account)} -X "${hex}"\n`);
+        if (code !== 0)
+            throw new Error('The Mac keychain did not save the key.');
+    },
+    async getPassword(service, account) {
+        // Exit 44 is "no such item" - a real "no key". Any other failure (a timeout, a
+        // busy keychain) is asked once more rather than taken as "no key" (Claude Code
+        // treats a timed-out read as "may have a key" for the same reason).
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const { code, stdout } = await runSecurity(['find-generic-password', '-s', service, '-a', account, '-w']);
+            if (code === 0)
+                return stdout.replace(/\n$/, '') || null;
+            if (code === 44)
+                return null;
+        }
+        return null;
+    },
+    async deletePassword(service, account) {
+        const { code } = await runSecurity(['delete-generic-password', '-s', service, '-a', account]);
+        return code === 0;
+    },
+    // Names only: dump-keychain without -d lists what is saved, never the keys themselves.
+    async findCredentials(service) {
+        const { stdout } = await runSecurity(['dump-keychain']);
+        const accounts = [];
+        for (const block of stdout.split('keychain: ')) {
+            if (!block.includes(`"svce"<blob>="${service}"`))
+                continue;
+            const account = /"acct"<blob>="([^"]*)"/.exec(block)?.[1];
+            if (account)
+                accounts.push({ account, password: '' });
+        }
+        return accounts;
+    },
+};
 async function load() {
     // Escape hatch for automated tests so they never touch the real credential store.
     if (process.env.JEEVES_SKIP_KEYCHAIN === '1')
         return null;
     if (cached === null) {
-        const mod = await import('keytar');
-        cached = (mod.default ?? mod);
+        if (process.platform === 'darwin') {
+            cached = macKeychain;
+        }
+        else {
+            const mod = await import('keytar');
+            cached = (mod.default ?? mod);
+        }
     }
     return cached;
 }

package/dist/platform/address.js

@@ -0,0 +1,16 @@
+// How Jeeves addresses the person. Asked before anything else, in the terminal and
+// the window alike, so Jeeves never has to guess "Sir" (owner's request, 19 Sept).
+export const ADDRESS_MAX = 30;
+// Morning / afternoon / evening by this computer's own clock.
+export function partOfDay(now = new Date()) {
+    const hour = now.getHours();
+    return hour < 12 ? 'morning' : hour < 18 ? 'afternoon' : 'evening';
+}
+export function timeOfDayGreeting(now = new Date()) {
+    return `Good ${partOfDay(now)}`;
+}
+// The address as saved: trimmed and short; null when nothing usable was given.
+export function cleanAddress(raw) {
+    const value = raw.replace(/\s+/g, ' ').trim().slice(0, ADDRESS_MAX);
+    return value ? value : null;
+}

package/dist/platform/chat-folder.js

@@ -0,0 +1,24 @@
+import { mkdirSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+// "Just chat": no project needed. Jeeves still works in a folder of its own, so
+// anything it is asked to save lands somewhere the person can find, /undo still
+// works, and nothing ever runs loose in the whole home folder (agreed 19 Sept).
+export const CHAT_FOLDER_NAME = 'Jeeves Chats';
+export function chatFolder() {
+    return path.join(os.homedir(), 'Documents', CHAT_FOLDER_NAME);
+}
+// Creates the folder when needed; the location, or null if it could not be made.
+export function ensureChatFolder() {
+    const folder = chatFolder();
+    try {
+        mkdirSync(folder, { recursive: true });
+        return folder;
+    }
+    catch {
+        return null;
+    }
+}
+export function chatNotice(address) {
+    return `Just chatting, ${address} - anything I save for you goes in Documents/${CHAT_FOLDER_NAME}. Type /folder any time to work in a folder instead.`;
+}

package/dist/platform/config.js

@@ -88,6 +88,9 @@ export function getAddress() {
 export function setAddress(address) {
     config.set('address', address);
 }
+export function clearAddress() {
+    config.delete('address');
+}
 // The trimmed models.dev catalogue for direct connections (prices and abilities).
 export function getDirectCatalogue() {
     return config.get('directCatalogue') ?? null;
@@ -114,3 +117,11 @@ export function getEstimatedSpend() {
 export function setEstimatedSpend(spend) {
     config.set('estimatedSpend', spend);
 }
+// Project folders where the person chose "always allow": changes inside them need no
+// yes/no (they are still backed up, so /undo works). /ask removes a folder again.
+export function getTrustedProjects() {
+    return config.get('trustedProjects') ?? [];
+}
+export function setTrustedProjects(folders) {
+    config.set('trustedProjects', folders);
+}

package/dist/platform/wording.js

@@ -0,0 +1,10 @@
+// Words that depend on the computer Jeeves is running on (owner, 19 Sept: "What
+// if it is on a non-Mac?"). Keys are kept by keytar in Windows Credential Manager
+// and in the system password store on Linux; the copy keys are the terminal's own
+// (Windows Terminal's defaults include Ctrl+Shift+C - learn.microsoft.com, Windows
+// Terminal actions; Linux terminals use the same).
+const platform = process.platform;
+export const KEY_STORE = platform === 'darwin' ? 'your Mac keychain' : platform === 'win32' ? 'Windows Credential Manager' : "your computer's password store";
+export const KEY_STORE_SUBJECT = platform === 'darwin' ? 'The Mac keychain' : platform === 'win32' ? 'Windows Credential Manager' : "Your computer's password store";
+export const COPY_KEYS = platform === 'darwin' ? 'Cmd+C' : 'Ctrl+Shift+C';
+export const WORD_JUMP_KEYS = platform === 'darwin' ? 'Option+← →' : 'Ctrl+← →';

package/dist/providers/direct.js

@@ -6,6 +6,7 @@ import { createXai } from '@ai-sdk/xai';
 import { createMistral } from '@ai-sdk/mistral';
 import { createGroq } from '@ai-sdk/groq';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { silenceGuard } from './silence.js';
 import { prepareStepFor } from './step-control.js';
 import { directService, serviceNameFor, CUSTOM_SERVICE_ID } from './direct-services.js';
 import { estimateCost, priceOf } from './catalogue.js';
@@ -68,10 +69,13 @@ function streamWith(id, name, modelFor, costOf, caching) {
             const stepCostOf = (step) => costOf(step.model?.modelId ?? modelId, step.usage ?? {});
             const prepare = prepareStepFor(beforeStep, modelFor, stepCostOf);
             const system = caching && instructions ? { role: 'system', content: instructions, providerOptions: ANTHROPIC_CACHE } : instructions;
+            const guard = silenceGuard(abortSignal);
             const result = streamText({
                 instructions: system,
                 // The same limits on silence as the other services (see openrouter.ts).
-                timeout: { firstChunkMs: 120_000, chunkMs: 90_000, stepMs: 600_000 },
+                // Silence while the model answers is watched by silenceGuard (it pauses while a
+                // command runs or waits for the person); the first piece still has 2 minutes.
+                timeout: { firstChunkMs: 120_000 },
                 model: modelFor(modelId),
                 messages: caching ? markForCaching(messages) : messages,
                 tools,
@@ -85,13 +89,14 @@ function streamWith(id, name, modelFor, costOf, caching) {
                         return { ...control, messages: markForCaching(control.messages ?? step.messages) };
                     }
                     : undefined,
-                abortSignal,
+                abortSignal: guard.signal,
                 // The library prints every failure to the screen by default, over Jeeves's
                 // window; the failure still arrives below and is explained in plain English.
                 onError: () => { },
             });
             let streamedError = null;
             for await (const part of result.stream) {
+                guard.onPart(part);
                 if (part.type === 'text-delta') {
                     onToken(part.text);
                 }
@@ -105,6 +110,7 @@ function streamWith(id, name, modelFor, costOf, caching) {
                     streamedError = part.error;
                 }
             }
+            guard.stop();
             // The real stream error (a rejected key, a missing model) must win over the
             // SDK's generic no-output error, which would otherwise mask the cause.
             if (streamedError !== null) {

package/dist/providers/index.js

@@ -13,6 +13,7 @@ import { getKey, setKey, deleteKey, listProviders } from '../keys/store.js';
 import { existsSync, readFileSync, rmSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { KEY_STORE, KEY_STORE_SUBJECT } from '../platform/wording.js';
 let active = null;
 let resolvedKey = null;
 let zaiKey = null;
@@ -23,6 +24,10 @@ const serviceKeys = new Map();
 export function getOpenRouterKey() {
     return resolvedKey;
 }
+// The GLM Coding Plan key, for research on the plan (Z.ai's web search and reading).
+export function getZaiKey() {
+    return zaiKey;
+}
 // The calm provider list shared by the model picker and the key screens.
 export const PROVIDER_ROWS = [
     { id: 'openrouter', label: 'OpenRouter', description: 'one key unlocks 400+ models - recommended' },
@@ -107,7 +112,20 @@ export function hasCredentials() {
 // Startup key resolution: the Keychain wins; a .env file is a development fallback
 // that gets migrated into the Keychain on first launch. The first access may pop a
 // macOS permission dialog - that is expected and allowed once.
-export async function initKeys() {
+// Reading the keychain takes a moment; anything that decides "is there a key?" waits
+// for it first (Claude Code's keychainPrefetch pattern). Choosing a folder within
+// about 0.8 s of opening used to decide before the read finished and asked for a key
+// the person already had (measured 19 Sept).
+let keysLoading = null;
+export function initKeys() {
+    keysLoading ??= readKeys();
+    return keysLoading;
+}
+// Resolves once the saved keys have been read (starting the read if needed).
+export function keysRead() {
+    return initKeys();
+}
+async function readKeys() {
     // Read together, so startup is not held up by one keychain read after another.
     const ids = [...DIRECT_SERVICES.map((service) => service.id), CUSTOM_SERVICE_ID];
     const serviceStored = await Promise.all(ids.map((id) => getKey(id)));
@@ -131,10 +149,10 @@ export async function initKeys() {
         const moved = await setKey('openrouter', envKey);
         if (moved) {
             removeEnvFile();
-            session.addNotice('Your key was moved from a local file into your Mac keychain, and the file was removed.');
+            session.addNotice(`Your key was moved from a local file into ${KEY_STORE}, and the file was removed.`);
         }
         else {
-            session.addNotice('The Mac keychain was not reachable, so the key is being read from a local file for now. Type /keys to store it securely.');
+            session.addNotice(`${KEY_STORE_SUBJECT} was not reachable, so the key is being read from a local file for now. Type /keys to store it securely.`);
         }
         resolvedKey = envKey;
         keySource = moved ? 'keychain' : 'env';

package/dist/providers/ollama.js

@@ -1,5 +1,6 @@
 import { streamText, stepCountIs } from 'ai';
 import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { silenceGuard } from './silence.js';
 import { prepareStepFor } from './step-control.js';
 const OLLAMA_BASE_URL = 'http://localhost:11434/v1';
 const MAX_TOOL_STEPS = 25;
@@ -14,6 +15,7 @@ export function createOllamaProvider() {
         id: 'ollama',
         name: 'Ollama',
         async stream({ modelId, messages, tools, instructions, onToken, onReasoning, onToolCall, beforeStep, abortSignal }) {
+            const guard = silenceGuard(abortSignal);
             const result = streamText({
                 instructions,
                 // A stalled request must never wedge the app in the working state forever -
@@ -23,19 +25,22 @@ export function createOllamaProvider() {
                 // started, and 10 minutes for any single step, which also covers a request that
                 // never starts answering. (A plain number here limits the entire multi-step
                 // job; a 3-minute one killed healthy jobs mid-way in testing.)
-                timeout: { firstChunkMs: 120_000, chunkMs: 90_000, stepMs: 600_000 },
+                // Silence while the model answers is watched by silenceGuard (it pauses while a
+                // command runs or waits for the person); the first piece still has 2 minutes.
+                timeout: { firstChunkMs: 120_000 },
                 model: client.chat(modelId),
                 messages,
                 tools,
                 stopWhen: stepCountIs(MAX_TOOL_STEPS),
                 prepareStep: prepareStepFor(beforeStep, (id) => client.chat(id)),
-                abortSignal,
+                abortSignal: guard.signal,
                 // The library prints every failure to the screen by default, over Jeeves's
                 // window; the failure still arrives below and is explained in plain English.
                 onError: () => { },
             });
             let streamedError = null;
             for await (const part of result.stream) {
+                guard.onPart(part);
                 if (part.type === 'text-delta') {
                     onToken(part.text);
                 }
@@ -49,6 +54,7 @@ export function createOllamaProvider() {
                     streamedError = part.error;
                 }
             }
+            guard.stop();
             // The real stream error (a rejected key, a missing model) must win over the
             // SDK's generic no-output error, which would otherwise mask the cause.
             if (streamedError !== null) {