@tianmucreations/jeeves 0.2.1 → 0.3.0

package/dist/components/Transcript.js

@@ -1,15 +1,25 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useMemo } from 'react';
-import { Box, Text } from 'ink';
-import { useSession } from '../state/session.js';
-import { buildDisplayLines, visibleWindow } from './transcript-layout.js';
-// The transcript is clipped to a fixed height so the frame never grows past the
-// terminal window - this is what keeps the header and footer permanently in place.
-// The terminal's native scrollback is unavailable in alternate-screen mode, so
-// the region scrolls itself: arrow and page keys move the view, and 0 offset
-// keeps it pinned to the newest line while answers stream in.
-export function Transcript({ height, width }) {
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { Box, Text, useBoxMetrics, useStdout } from 'ink';
+import { session, useSession } from '../state/session.js';
+import { buildDisplayLines } from './transcript-layout.js';
+// Claude Code's ScrollBox pattern (ch13-14-terminal-ui.md): the outer box clips at
+// the viewport with overflow="hidden" and flexGrow={1}, so the transcript fills
+// every row left over by the fixed header, input, and footer slots - no dead space.
+// The content is anchored to the bottom (justifyContent flex-end), so the inner box
+// scrolls with a negative BOTTOM margin, which pushes it down past the bottom edge
+// and brings older lines in at the top. (A negative top margin, as in Claude Code's
+// top-anchored ScrollBox, does nothing to a bottom-anchored box - measured with
+// renderToString: the same last lines showed at every offset.) scrollTop is
+// clamped between 0 and contentHeight - viewportHeight, both measured live. While scrollTop is 0 the newest line sits at the bottom edge
+// (auto-follow): new content arrives and the view stays pinned to it.
+export function Transcript({ width }) {
     const s = useSession();
+    const { stdout } = useStdout();
+    const outer = useRef(null);
+    const inner = useRef(null);
+    const viewport = useBoxMetrics(outer);
+    const content = useBoxMetrics(inner);
     const entries = useMemo(() => {
         if (s.showLastReasoning && s.lastReasoning) {
             return [...s.transcript, { id: -1, kind: 'reasoning', text: s.lastReasoning }];
@@ -17,7 +27,12 @@ export function Transcript({ height, width }) {
         return s.transcript;
     }, [s.transcript, s.showLastReasoning, s.lastReasoning]);
     const lines = useMemo(() => buildDisplayLines(entries, width), [entries, width]);
-    const { visible, linesAbove, linesBelow } = useMemo(() => visibleWindow(lines, height, s.transcriptScrollUp), [lines, height, s.transcriptScrollUp]);
-    const showPosition = linesAbove > 0 || linesBelow > 0;
-    return (_jsxs(Box, { flexDirection: "column", justifyContent: "flex-end", height: height, children: [showPosition && (_jsxs(Text, { dimColor: true, children: ["\u2191 ", linesAbove, " line", linesAbove === 1 ? '' : 's', " above \u00B7 newest \u2193", linesBelow > 0 ? ` (+${linesBelow} below)` : ''] })), visible.map((line, index) => (_jsx(Text, { color: line.color, dimColor: line.dim, children: line.text }, index)))] }));
+    // Virtual scroll: never above the first line, never below the newest.
+    const maxScroll = Math.max(0, content.height - viewport.height);
+    const scrollTop = Math.min(s.transcriptScrollUp, maxScroll);
+    // The session clamps key and wheel scrolling to this same limit.
+    useEffect(() => {
+        session.setTranscriptScrollMax(maxScroll);
+    }, [maxScroll]);
+    return (_jsx(Box, { flexDirection: "column", overflow: "hidden", flexGrow: 1, justifyContent: "flex-end", ref: outer, children: _jsx(Box, { flexDirection: "column", flexShrink: 0, marginBottom: -scrollTop, ref: inner, children: lines.map((line, index) => (_jsx(Text, { color: line.color, dimColor: line.dim, children: line.text }, index))) }) }));
 }

package/dist/components/input-layout.js

@@ -0,0 +1,34 @@
+import stringWidth from 'string-width';
+// What the one-row input shows, and where the cursor goes. Two rules keep Ink off
+// its cursor-only update path, which in an exactly-fullscreen frame draws the
+// cursor two rows above the y passed (onto the separator - measured in a pty):
+//
+// 1. Text wider than the row shows only its tail, so the cursor never runs past
+//    the row and every keystroke changes what is drawn. (Left to wrap, the extra
+//    characters landed on a clipped second line: the frame stayed identical
+//    while the cursor moved, and the cursor climbed up through the transcript.)
+// 2. Trailing spaces are returned separately so the caller can style them (dim):
+//    a plain trailing space is indistinguishable from the row's padding, so
+//    "hello " and "hello" would otherwise be byte-identical frames.
+//
+// maxWidth leaves one column spare so the cursor itself stays inside the row.
+export function inputView(value, rowWidth) {
+    const maxWidth = Math.max(1, rowWidth - 1);
+    const chars = Array.from(value);
+    let width = 0;
+    let start = chars.length;
+    while (start > 0) {
+        const next = stringWidth(chars[start - 1]);
+        if (width + next > maxWidth)
+            break;
+        width += next;
+        start -= 1;
+    }
+    const visible = chars.slice(start).join('');
+    const text = visible.replace(/ +$/, '');
+    return { text, trailingSpaces: visible.slice(text.length), width };
+}
+// Backspace removes one whole character, never half of a surrogate pair.
+export function dropLastChar(value) {
+    return Array.from(value).slice(0, -1).join('');
+}

package/dist/components/transcript-layout.js

@@ -39,34 +39,30 @@ function wrapWithPrefix(s, width, prefix, indent) {
     }
     return raw.map((line, index) => (index === 0 ? prefix + line : indent + line));
 }
+// The tools' everyday names on screen; the internal names are for the model only.
+const TOOL_NAMES = { readFile: 'Read', listDir: 'List', writeFile: 'Write', runBash: 'Run', webSearch: 'Search', readWebPage: 'Read', askExpert: 'Expert', noteResearch: 'Research' };
+export function toolName(tool) {
+    return TOOL_NAMES[tool] ?? tool;
+}
 function toolLineText(d) {
     if (d.state === 'awaiting') {
-        return { text: `? ${d.tool} ${d.summary} — allow? (y/n)`, color: 'yellow' };
+        return { text: `? ${toolName(d.tool)} ${d.summary} — allow? (y/n)`, color: 'yellow' };
     }
     if (d.state === 'running') {
-        return { text: `… ${d.tool} ${d.summary}`, dim: true };
+        return { text: `… ${toolName(d.tool)} ${d.summary}`, dim: true };
     }
     if (d.state === 'declined') {
-        return { text: `✗ ${d.tool} declined`, color: 'red' };
+        return { text: `✗ ${toolName(d.tool)} ${clipLine(d.summary, 50)} - you said no`, color: 'red' };
+    }
+    // Held until research is done: not a failure and not a refusal, so neither red nor alarming.
+    if (d.state === 'held') {
+        return { text: `· ${toolName(d.tool)} ${clipLine(d.summary, 50)} - ${d.label}`, dim: true };
     }
     if (d.state === 'failed') {
-        return { text: `✗ ${d.tool} failed: ${clipLine(d.label, 60)}`, color: 'red' };
+        return { text: `✗ ${toolName(d.tool)} failed: ${clipLine(d.label, 60)}`, color: 'red' };
     }
     return { text: `✓ ${d.label}` };
 }
-// Picks the visible window of display lines for the transcript region. The
-// terminal's own scrollback is off in alternate-screen mode, so this is the
-// app's whole scrolling story: scrollUp counts lines above the bottom edge,
-// and 0 pins the view to the newest line (follow mode).
-export function visibleWindow(lines, height, scrollUp) {
-    const total = lines.length;
-    const maxScroll = Math.max(0, total - height);
-    const offset = Math.min(Math.max(0, scrollUp), maxScroll);
-    const end = total - offset;
-    const start = Math.max(0, end - height);
-    const visible = lines.slice(start, end);
-    return { visible, linesAbove: start, linesBelow: total - end };
-}
 // Turns transcript entries into physical display lines that fit the given width.
 export function buildDisplayLines(entries, width) {
     const lines = [];

package/dist/index.js

@@ -1,12 +1,14 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from 'ink';
 import { Command } from 'commander';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { App } from './app.js';
 import { session } from './state/session.js';
 import { AlternateScreen, leaveAltScreen } from './ink/AlternateScreen.js';
+import { killAllRunningCommands } from './tools/runBash.js';
+import { getAddress } from './platform/config.js';
 // Local development bridge: settings such as OPENROUTER_API_KEY are loaded from a gitignored
 // .env file at the project root. Replaced by the secure OS credential store in Phase 7.
 const envPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '.env');
@@ -18,19 +20,34 @@ if (existsSync(envPath)) {
         // A malformed .env is non-fatal; the on-screen notice explains what is missing.
     }
 }
-// Graceful degradation: without an interactive terminal there is nothing to draw,
-// so explain in plain English instead of crashing on raw mode.
-if (!process.stdin.isTTY) {
-    console.error('This app needs an interactive terminal window to run.');
-    process.exit(1);
+// The version comes from package.json, so it can never drift from the release.
+function packageVersion() {
+    try {
+        const file = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+        return JSON.parse(readFileSync(file, 'utf8')).version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
 }
 const program = new Command();
 program
     .name('jeeves')
-    .version('0.2.1')
+    .version(packageVersion())
     .description('A plain-English terminal assistant.')
     .argument('[prompt]', 'optional prompt to start with')
     .action((prompt) => {
+    // Graceful degradation: without an interactive terminal there is nothing to draw,
+    // so explain in plain English instead of crashing on raw mode. (Checked here, not
+    // earlier, so --version and --help still answer anywhere.)
+    if (!process.stdin.isTTY) {
+        console.error('This needs to be opened in a Terminal window.');
+        process.exit(1);
+    }
+    // The address question comes before the project picker on first launch only;
+    // a saved address skips straight to the picker.
+    if (getAddress())
+        session.skipAddressStage();
     // The prompt argument is accepted but not auto-sent yet; a later phase wires it into the loop.
     // 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
@@ -44,6 +61,7 @@ program
             quitting = true;
             instance.unmount();
             void instance.waitUntilExit().then(() => {
+                killAllRunningCommands();
                 leaveAltScreen();
                 process.exit(0);
             });

package/dist/ink/AlternateScreen.js

@@ -28,6 +28,9 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useInsertionEffect } from 'react';
 import { Box, useStdout } from 'ink';
 import { createRequire } from 'node:module';
+import { DEFAULT_CURSOR } from './cursor.js';
+import { ENABLE_MOUSE_TRACKING, DISABLE_MOUSE_TRACKING } from './mouse.js';
+import { killAllRunningCommands } from '../tools/runBash.js';
 // signal-exit covers the termination signals beyond exit and SIGINT
 // (SIGTERM, SIGHUP) with correct exit codes. Already in the tree as Ink's own
 // dependency; declared ours.
@@ -50,48 +53,59 @@ function write(data) {
     }
 }
 // Claude Code's Ink fork exposes this on the render instance; stock Ink has no
-// such method, so the notification lives here: the flag that says the
-// alternate screen owns the terminal, consulted by every exit path below.
+// such method, so the notification lives here: the flag that says the alternate
+// screen owns the terminal, consulted by every exit path below. Mouse tracking
+// is now genuinely on (wheel scrolling), so the flag reports it truthfully.
 export function setAltScreenActive(active, mouseTracking) {
     altScreenActive = active;
-    // Mouse tracking is deliberately left off: it would break click-drag text
-    // selection in Terminal.app, and the app already owns scrolling by key.
     void mouseTracking;
 }
 // Hands the terminal back. Safe to call from anywhere, any number of times.
 // The scrollback erase follows the switch back because macOS Terminal.app
 // archives the app's own frames into the scrollback at hand-back (measured),
-// and they must not linger; the cursor comes back on for the shell.
+// mouse tracking is switched off so the terminal's own selection works again,
+// and the cursor shape returns to the shell default with the cursor back on.
 export function leaveAltScreen() {
     if (!altScreenActive)
         return;
     altScreenActive = false;
-    write(LEAVE_ALT_SCREEN + ERASE_SCROLLBACK + SHOW_CURSOR);
+    write(LEAVE_ALT_SCREEN + ERASE_SCROLLBACK + DISABLE_MOUSE_TRACKING + DEFAULT_CURSOR + SHOW_CURSOR);
 }
-// The terminal must always be restored. process handlers per the mechanism,
-// plus signal-exit so kill signals re-raise with correct exit codes.
+// The terminal must always be restored, and any command the agent is running
+// must die with the app - the user is leaving, nothing may keep running or block
+// the exit. process handlers per the mechanism, plus signal-exit so kill signals
+// re-raise with correct exit codes.
 function registerCleanup() {
     if (cleanupRegistered)
         return;
     cleanupRegistered = true;
-    process.on('exit', () => leaveAltScreen());
+    process.on('exit', () => {
+        killAllRunningCommands();
+        leaveAltScreen();
+    });
     process.on('SIGINT', () => {
+        killAllRunningCommands();
         leaveAltScreen();
         process.exit(130);
     });
-    onSignalExit(() => leaveAltScreen(), { alwaysLast: false });
+    onSignalExit(() => {
+        killAllRunningCommands();
+        leaveAltScreen();
+    }, { alwaysLast: false });
 }
 export function AlternateScreen({ children }) {
     const { stdout } = useStdout();
     // Entered once, before the first frame, in Claude Code's order: take over
     // the window first, then clear the fresh alternate screen, erase the
-    // scrollback the switch archived, and home the cursor. Because the main
+    // scrollback the switch archived, home the cursor, and enable SGR mouse
+    // tracking so wheel events reach the app (the alternate screen has no native
+    // scrollback - wheel gestures scroll the transcript instead). Because the main
     // screen is never wiped, the shell's own screen survives for a perfect
     // restore on exit. The cursor is hidden for the same reason Ink's own mode
     // hides it. Empty dependency array: this runs exactly once, on mount.
     useInsertionEffect(() => {
-        write(ENTER_ALT_SCREEN + CLEAR_SCREEN + ERASE_SCROLLBACK + HOME_CURSOR + HIDE_CURSOR);
-        setAltScreenActive(true, false);
+        write(ENTER_ALT_SCREEN + CLEAR_SCREEN + ERASE_SCROLLBACK + HOME_CURSOR + HIDE_CURSOR + ENABLE_MOUSE_TRACKING);
+        setAltScreenActive(true, true);
         registerCleanup();
     }, []);
     // On unmount the terminal is handed back too (the app unmounts before the
@@ -100,7 +114,10 @@ export function AlternateScreen({ children }) {
         return () => leaveAltScreen();
     }, []);
     const rows = Math.max(stdout.rows ?? 24, 8);
-    // The alternate screen has no native scrollback, so the app owns its own
-    // scrolling: everything is constrained to the terminal's row count.
-    return (_jsx(Box, { height: rows, flexDirection: "column", overflow: "hidden", children: children }));
+    // The ceiling: without a height constraint on this box, flexGrow below has no
+    // limit - the viewport would size to the content, scrolling would pin at 0, and
+    // Ink's screen buffer would size to the full content. This is what makes the
+    // slot layout work. The alternate screen has no native scrollback, so the app
+    // owns its scrolling within these rows.
+    return (_jsx(Box, { height: rows, flexDirection: "column", children: children }));
 }

package/dist/ink/cursor.js

@@ -0,0 +1,18 @@
+// DECSCUSR cursor-shape sequences. The app switches the terminal's real cursor to a
+// steady block while it runs (the way Claude Code does) and restores the shell's
+// default shape when it quits. Not reverse-video fakery: the terminal's own cursor.
+export const BLOCK_CURSOR = '\x1b[2 q';
+export const DEFAULT_CURSOR = '\x1b[0 q';
+// The main window's fixed rows (see src/app.tsx): top border 1, header 1,
+// transcript flexGrow (rows-6), separator 1, input 1, bottom border 1, info bar
+// 1 (outside the box). The input text sits on 0-based frame row rows-3. Ink's
+// cursor placement in an exactly-fullscreen frame (outputHeight >= terminal rows)
+// lands the visible cursor one row ABOVE the y passed to setCursorPosition -
+// buildCursorSuffix moves up visibleLineCount - y from the last written line
+// (row visibleLineCount-1), which resolves to y-1 (verified against a real pty
+// capture). So the y passed here is the input row plus one: rows-2, which draws
+// the block cursor on the input text's own row, clear of the separator above and
+// the box's bottom border below.
+export function inputFrameRow(rows) {
+    return rows - 2;
+}

package/dist/ink/mouse.js

@@ -0,0 +1,48 @@
+import { session } from '../state/session.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.
+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
+// from ones it cannot resolve, so both forms are accepted here.
+const MOUSE_RE = /^\x1b?\[<(\d+);(\d+);(\d+)([Mm])$/;
+export function isMouseSequence(input) {
+    return MOUSE_RE.test(input);
+}
+// SGR mouse protocol: press ends in M, release ends in m; 64 is wheel up and 65
+// is wheel down, arriving as single events with no press/release distinction.
+// Everything else (clicks, drags) is parsed for recognition but not acted on.
+export function parseMouseSequence(input) {
+    const match = MOUSE_RE.exec(input);
+    if (!match)
+        return null;
+    const rawButton = Number(match[1]);
+    const col = Number(match[2]);
+    const row = Number(match[3]);
+    const final = match[4];
+    if (final === 'm') {
+        if (rawButton > 3)
+            return null;
+        return { kind: 'release', button: rawButton, col, row };
+    }
+    if (rawButton === 64 || rawButton === 65) {
+        return { kind: 'wheel', button: rawButton - 64, col, row };
+    }
+    if (rawButton <= 6) {
+        return { kind: 'press', button: rawButton, 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.
+export function handleMouseInput(input) {
+    const event = parseMouseSequence(input);
+    if (event === null || event.kind !== 'wheel')
+        return;
+    session.scrollTranscript(event.button === 0 ? 3 : -3);
+}

package/dist/keys/store.js

@@ -1,4 +1,5 @@
-const SERVICE = 'jeeves';
+// 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;
 async function load() {
     // Escape hatch for automated tests so they never touch the real credential store.

package/dist/models/registry.js

@@ -1,3 +1,4 @@
+import { AUTO_MODEL_ID, WORKER_MODELS, firstAvailable } from '../agent/auto-ids.js';
 import { getModelCache, setModelCache } from '../platform/config.js';
 const MODELS_URL = 'https://openrouter.ai/api/v1/models';
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
@@ -54,7 +55,7 @@ export async function loadModels() {
         if (cache) {
             return { models: normalizeModels(cache.raw), error: 'Could not refresh the model list - showing the saved copy.' };
         }
-        return { models: [], error: `Could not load the model list: ${error instanceof Error ? error.message : String(error)}` };
+        return { models: [], error: "Could not load the model list - check the internet connection, then open /model again." };
     }
 }
 export function compactContext(tokens) {
@@ -74,9 +75,24 @@ export const CURATED_MODELS = [
     { ids: ['google/gemini-3.1-pro-preview', 'google/gemini-3-pro-preview', 'google/gemini-2.5-pro'], blurb: 'huge memory' },
     { ids: ['qwen/qwen3-coder-plus', 'qwen/qwen3-coder', 'qwen/qwen3-coder-flash'], blurb: 'good for code' },
 ];
+// A free OpenRouter model: no charge for input or output. (Z.ai's plan models also
+// show 0 but are "included" in a paid plan, not free.)
+export function isFreeModel(model) {
+    return model.promptPrice === 0 && model.completionPrice === 0 && model.priceLabel !== 'included' && model.provider !== 'ollama';
+}
+// Auto heads the shortlist whenever its worker model is in the catalogue.
+export function autoPick(models) {
+    // Auto stays available as long as any of its worker models is still in the catalogue.
+    const workerId = firstAvailable(WORKER_MODELS, models);
+    const worker = models.find((model) => model.id === workerId);
+    if (!worker)
+        return null;
+    return { model: { ...worker, id: AUTO_MODEL_ID, name: 'Auto', priceLabel: 'cheap, expert when needed' }, blurb: 'recommended: cheap model, expert on call' };
+}
 export function resolveCurated(models) {
     const byId = new Map(models.map((model) => [model.id, model]));
-    const picks = [];
+    const auto = autoPick(models);
+    const picks = auto ? [auto] : [];
     for (const entry of CURATED_MODELS) {
         for (const id of entry.ids) {
             const model = byId.get(id);

package/dist/platform/config.js

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import Conf from 'conf';
 // Persistent settings. Phase 7 expands this into the full config surface
 // (default model, favourites, recents, verbose flag). API keys are NEVER stored here (spec 5.3).
@@ -5,14 +6,36 @@ import Conf from 'conf';
 const config = new Conf({
     projectName: process.env.NODE_ENV === 'test' ? 'jeeves-tests' : 'jeeves',
 });
-const VALID_METRICS = ['session', 'context', 'cache', 'today', 'credit', 'speed'];
-// Metrics a power user has chosen to hide from the footer - hiding is opt-in, never required.
-export function getHiddenMetrics() {
-    const stored = config.get('hiddenMetrics') ?? [];
-    return stored.filter((metric) => VALID_METRICS.includes(metric));
+// The folder Jeeves keeps its settings in (chosen by the conf library for each
+// operating system); backups live in a "checkpoints" folder beside the settings.
+export function settingsFolder() {
+    return path.dirname(config.path);
 }
-export function setHiddenMetrics(metrics) {
-    config.set('hiddenMetrics', metrics.filter((metric) => VALID_METRICS.includes(metric)));
+// The daily spending limit in dollars (default $3).
+export function getDailyLimit() {
+    const stored = config.get('dailyLimit');
+    return typeof stored === 'number' && stored > 0 ? stored : 3;
+}
+// Whether a limit has ever been chosen - the first paid model choice asks for one.
+export function hasSavedDailyLimit() {
+    return typeof config.get('dailyLimit') === 'number';
+}
+export function setDailyLimit(limit) {
+    config.set('dailyLimit', limit);
+}
+// Extra allowance agreed for one day when the limit was reached.
+export function getDailyExtra() {
+    return config.get('dailyExtra');
+}
+export function setDailyExtra(extra) {
+    config.set('dailyExtra', extra);
+}
+// The last OpenRouter usage reading, kept between launches so "today" survives a restart.
+export function getSpendReading() {
+    return config.get('spendReading');
+}
+export function setSpendReading(reading) {
+    config.set('spendReading', reading);
 }
 export function getFavorites() {
     return config.get('favorites') ?? [];
@@ -58,3 +81,36 @@ export function getVerbosePreference() {
 export function setVerbosePreference(value) {
     config.set('verbose', value);
 }
+// How Jeeves addresses the person (spec: asked once on first launch, changeable via /address).
+export function getAddress() {
+    return config.get('address') ?? null;
+}
+export function setAddress(address) {
+    config.set('address', address);
+}
+// The trimmed models.dev catalogue for direct connections (prices and abilities).
+export function getDirectCatalogue() {
+    return config.get('directCatalogue') ?? null;
+}
+export function setDirectCatalogue(catalogue, fetchedAt) {
+    config.set('directCatalogue', { catalogue, fetchedAt });
+}
+// The address of the "any compatible service" the person added (its key is in the keychain).
+export function getCustomService() {
+    return config.get('customService') ?? null;
+}
+export function setCustomService(service) {
+    if (service)
+        config.set('customService', service);
+    else
+        config.delete('customService');
+}
+// Today's spending worked out from price lists (direct connections), kept between
+// launches so the daily limit still holds after a restart. OpenRouter's own
+// figures are read from OpenRouter instead.
+export function getEstimatedSpend() {
+    return config.get('estimatedSpend');
+}
+export function setEstimatedSpend(spend) {
+    config.set('estimatedSpend', spend);
+}