@tianmucreations/jeeves 0.3.0 → 0.3.1

package/LICENSE

@@ -1,21 +1,41 @@
-MIT License
+Jeeves Licence
+Copyright (c) 2026 Tianmu Creations. All rights reserved.
 
-Copyright (c) 2026 tianmucreations
+This licence applies to Jeeves version 0.3.1 and every later version. Versions
+0.3.0 and earlier were released under the MIT licence, which still applies to
+those versions.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+1. YOU MAY
+   - Install Jeeves and use it free of charge, for personal use and for work,
+     on as many of your own computers as you like.
+   - Read the source code on GitHub.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+2. YOU MAY NOT, without written permission from Tianmu Creations
+   - copy Jeeves, or any part of its source code, except as needed to install
+     and run it;
+   - change, adapt, translate, or build other software from Jeeves or its
+     source code;
+   - merge Jeeves, or any part of it, into other software;
+   - publish, share, distribute, host, or make Jeeves available to others,
+     changed or unchanged, except by pointing them to the official copies on
+     npm (npmjs.com/package/@tianmucreations/jeeves) and GitHub;
+   - sublicense, rent, lease, lend, or sell Jeeves or access to it; or
+   - remove or change this licence or any copyright notice.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+3. OTHER PEOPLE'S WORK
+   Jeeves uses add-ons made by others, which are installed alongside it and keep
+   their own licences. Its built-in list of AI models and prices comes from
+   models.dev (MIT licence).
+
+4. NO WARRANTY
+   Jeeves is provided "as is", without any warranty of any kind. Jeeves asks
+   before changing your computer and keeps backups for /undo, but you are
+   responsible for what you approve and for the costs of the AI services you
+   connect it to. To the fullest extent the law allows, Tianmu Creations is not
+   liable for any loss or damage arising from using Jeeves.
+
+5. ENDING
+   This licence ends automatically if you break it. When it ends you must stop
+   using Jeeves and delete your copies.
+
+Questions or permission requests: https://tianmucreations.com

package/README.md

@@ -32,7 +32,9 @@ Needs [Node.js](https://nodejs.org) 22.12 or newer, and a key from an AI service
 
 **He doesn't guess.** Facts about the outside world are looked up on the web, read from the most official page, and given with their source. Before building something new, he checks what already exists and shows you a short research note: use an existing tool, adapt one (licence permitting), or build new — and why. If the same problem happens twice, he researches the cause instead of patching blindly.
 
-**Safe to say yes to.** Anything that changes your computer asks first. Before any change in your project folder he quietly takes a backup, so `/undo` puts the folder back — changed and deleted files return, new ones disappear. Changes outside the folder come with a warning, because they can't be undone.
+**Safe to say yes to.** Anything that changes your computer asks first — or answer **a** once to always allow changes inside that project folder (`/ask` turns asking back on). Before any change in your project folder he quietly takes a backup, so `/undo` puts the folder back — changed and deleted files return, new ones disappear. Changes outside the folder always ask, with a warning, because they can't be undone.
+
+**Type while he works.** Your message box grows as you type, and anything you send while Jeeves is busy waits its turn and goes as soon as he finishes. Your own messages sit on a soft grey band, so they're easy to find when you scroll back.
 
 **Honest about costs.** A daily spending limit (you choose it; $3 to start) stops and asks before going over, and a long job checks in every 50 cents. Nothing is spent without you seeing it — and it can cost nothing at all: OpenRouter's free models, or models running on your own computer with Ollama.
 
@@ -70,6 +72,7 @@ Auto is offered only where a pairing has been measured doing everyday and diffic
 | `/model` | Choose a service and a model (or Auto), and set your daily limit |
 | `/keys` | Add, replace or remove keys |
 | `/undo` | Put the project folder back to before your last request |
+| `/ask` | Ask before every change in this project folder again (after choosing "always allow") |
 | `/clear` | Start a fresh conversation |
 | `/address` | Change how Jeeves addresses you |
 | `/verbose` | Show the technical details as well |
@@ -90,4 +93,4 @@ Arrow keys and the trackpad scroll the conversation; `Page Up` / `Page Down` jum
 
 ## Licence
 
-MIT — made by [Tianmu Creations](https://tianmucreations.com). More about Jeeves at [tianmucreations.com/jeeves](https://tianmucreations.com/jeeves/).
+Free to use, for personal use and for work. All rights reserved — see [LICENSE](LICENSE): you may not copy, change, share or sell Jeeves. Versions up to 0.3.0 were released under the MIT licence. Made by [Tianmu Creations](https://tianmucreations.com). More about Jeeves at [tianmucreations.com/jeeves](https://tianmucreations.com/jeeves/).

package/dist/agent/loop.js

@@ -17,6 +17,7 @@ import { startJob, endJob, reportStepCost, withinLimits } from './spending.js';
 import { getAddress } from '../platform/config.js';
 import { startTurnCheckpoints, undoLastChange } from '../checkpoints/index.js';
 import { noteSkipRequest } from './research-gate.js';
+import { untrustProject } from './trust.js';
 // Added to the rulebook when the chosen model cannot use tools, so a task request
 // gets a plain answer instead of a pretend attempt.
 export const CHAT_ONLY_NOTE = `
@@ -42,6 +43,11 @@ export async function runTurn(input) {
         else if (input === '/address') {
             openAddressPrompt();
         }
+        else if (input === '/ask') {
+            session.addNotice(untrustProject()
+                ? "I'll ask before every change in this project folder again."
+                : 'I already ask before every change in this project folder.');
+        }
         else if (input === '/undo') {
             if (session.status === 'working') {
                 session.addNotice('Undo works between tasks - wait for this one to finish, then type /undo.');

package/dist/agent/permissions.js

@@ -1,4 +1,6 @@
 import { session } from '../state/session.js';
+import { trustProject } from './trust.js';
+import { getAddress } from '../platform/config.js';
 // Pure-output commands that never require permission (the rule: harmless
 // output must never prompt). A command is auto-approved only when every stage of
 // it - across pipes, && and || - is one of the commands below, and the only
@@ -172,18 +174,32 @@ const queue = [];
 export function hasPendingApproval() {
     return queue.length > 0;
 }
-export function requestApproval() {
+export function requestApproval(options = {}) {
     return new Promise((resolve) => {
-        queue.push({ resolve });
+        queue.push({ resolve, trustable: options.trustable === true });
         if (queue.length === 1) {
             session.setActiveApproval();
         }
     });
 }
-export function answerApproval(approved) {
+// Whether the question now on screen may be answered with "always allow".
+export function currentApprovalTrustable() {
+    return queue[0]?.trustable === true;
+}
+// always: "always allow in this project" - approves this change, every other change
+// inside the project already waiting, and all future ones in this folder.
+export function answerApproval(approved, always = false) {
     const current = queue.shift();
     if (!current)
         return;
+    if (always && approved && current.trustable) {
+        trustProject();
+        session.addNotice(`From now on I won't ask before changing things in this project folder, ${getAddress() ?? 'Sir'} - every change is still backed up, so /undo puts it back. I'll still ask about anything outside it. Type /ask to have me ask every time again.`);
+        for (let i = queue.length - 1; i >= 0; i--) {
+            if (queue[i].trustable)
+                queue.splice(i, 1)[0].resolve(true);
+        }
+    }
     current.resolve(approved);
     if (queue.length > 0) {
         session.setActiveApproval();

package/dist/agent/trust.js

@@ -0,0 +1,29 @@
+import { realpathSync } from 'node:fs';
+import { getTrustedProjects, setTrustedProjects } from '../platform/config.js';
+// "Always allow in this project" (after Claude Code's "Yes, allow all edits in this
+// folder during this session" - here remembered per project folder, as asked for).
+// It covers changes inside the project folder only: anything outside it, or a
+// command that may reach outside it, still asks. Every change is still backed up
+// first, so /undo can put it back.
+function canonical(folder) {
+    try {
+        return realpathSync(folder);
+    }
+    catch {
+        return folder;
+    }
+}
+export function isProjectTrusted(folder = process.cwd()) {
+    return getTrustedProjects().includes(canonical(folder));
+}
+export function trustProject(folder = process.cwd()) {
+    const key = canonical(folder);
+    if (!getTrustedProjects().includes(key))
+        setTrustedProjects([...getTrustedProjects(), key]);
+}
+export function untrustProject(folder = process.cwd()) {
+    const key = canonical(folder);
+    const before = getTrustedProjects();
+    setTrustedProjects(before.filter((entry) => entry !== key));
+    return before.includes(key);
+}

package/dist/app.js

@@ -3,7 +3,7 @@ import { useEffect } from 'react';
 import { Box, Text, useStdout } from 'ink';
 import { Header } from './components/Header.js';
 import { Transcript } from './components/Transcript.js';
-import { Input } from './components/Input.js';
+import { Input, inputRowsFor } from './components/Input.js';
 import { Footer } from './components/Footer.js';
 import { session, useSession } from './state/session.js';
 import { initKeys, hasCredentials, refreshCredit, serviceKey } from './providers/index.js';
@@ -29,7 +29,12 @@ export function App() {
     const rows = Math.max(stdout.rows ?? 24, 8);
     const columns = Math.max(stdout.columns ?? 80, 40);
     const inner = columns - 2;
-    const midHeight = Math.max(1, rows - 6);
+    // The input box grows with the message (up to MAX_INPUT_ROWS); the transcript gives
+    // up the rows. A hint or question in the input row is always one row.
+    const inputRows = s.approvalPending || s.transcriptScrollUp > 0 ? 1 : inputRowsFor(s.inputText, inner - 2);
+    const midHeight = Math.max(1, rows - 5 - inputRows);
+    const inputSideLeft = Array.from({ length: inputRows }, () => '│ ').join('\n');
+    const inputSideRight = Array.from({ length: inputRows }, () => ' │').join('\n');
     const side = '│\n'.repeat(midHeight - 1) + '│';
     const separator = '─'.repeat(inner);
     useEffect(() => {
@@ -79,5 +84,5 @@ export function App() {
     if (s.launchStage === 'project') {
         return _jsx(ProjectPicker, { rows: rows, columns: columns });
     }
-    return (_jsxs(Box, { flexDirection: "column", height: rows, width: columns, children: [_jsxs(Text, { dimColor: true, children: ["\u256D", separator, "\u256E"] }), _jsxs(Box, { height: 1, children: [_jsx(Text, { dimColor: true, children: "\u2502" }), _jsx(Box, { width: inner, paddingLeft: 1, paddingRight: 1, flexDirection: "column", children: _jsx(Header, {}) }), _jsx(Text, { dimColor: true, children: "\u2502" })] }), _jsxs(Box, { height: midHeight, children: [_jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { dimColor: true, children: side }) }), _jsx(Box, { width: inner, paddingLeft: 1, paddingRight: 1, children: _jsx(Transcript, { width: inner - 2 }) }), _jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { dimColor: true, children: side }) })] }), _jsxs(Text, { dimColor: true, children: ["\u251C", separator, "\u2524"] }), _jsxs(Box, { height: 1, children: [_jsx(Text, { dimColor: true, children: "\u2502 " }), _jsx(Box, { width: inner - 2, children: _jsx(Input, { scrollPage: midHeight, width: inner - 2 }) }), _jsx(Text, { dimColor: true, children: " \u2502" })] }), _jsxs(Text, { dimColor: true, children: ["\u2570", separator, "\u256F"] }), _jsx(Box, { height: 1, flexDirection: "column", children: _jsx(Footer, {}) })] }));
+    return (_jsxs(Box, { flexDirection: "column", height: rows, width: columns, children: [_jsxs(Text, { dimColor: true, children: ["\u256D", separator, "\u256E"] }), _jsxs(Box, { height: 1, children: [_jsx(Text, { dimColor: true, children: "\u2502" }), _jsx(Box, { width: inner, paddingLeft: 1, paddingRight: 1, flexDirection: "column", children: _jsx(Header, {}) }), _jsx(Text, { dimColor: true, children: "\u2502" })] }), _jsxs(Box, { height: midHeight, children: [_jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { dimColor: true, children: side }) }), _jsx(Box, { width: inner, paddingLeft: 1, paddingRight: 1, children: _jsx(Transcript, { width: inner - 2 }) }), _jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { dimColor: true, children: side }) })] }), _jsxs(Text, { dimColor: true, children: ["\u251C", separator, "\u2524"] }), _jsxs(Box, { height: inputRows, children: [_jsx(Text, { dimColor: true, children: inputSideLeft }), _jsx(Box, { width: inner - 2, children: _jsx(Input, { scrollPage: midHeight, width: inner - 2 }) }), _jsx(Text, { dimColor: true, children: inputSideRight })] }), _jsxs(Text, { dimColor: true, children: ["\u2570", separator, "\u256F"] }), _jsx(Box, { height: 1, flexDirection: "column", children: _jsx(Footer, {}) })] }));
 }

package/dist/commands/help.js

@@ -5,6 +5,7 @@ export const COMMANDS = [
     { command: '/address', description: 'change how Jeeves addresses you' },
     { command: '/verbose', description: "show the model's thinking and technical details" },
     { command: '/undo', description: 'put the project folder back to how it was before the last change' },
+    { command: '/ask', description: 'ask before every change in this project folder again (after "always allow")' },
     { command: '/clear', description: 'start a fresh conversation and clear the screen' },
     { command: '/exit', description: 'quit' },
 ];

package/dist/components/Input.js

@@ -1,23 +1,38 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useRef, useState } from 'react';
-import { Text, useCursor, useInput, useStdout } from 'ink';
+import { useEffect, useRef } from 'react';
+import { Box, Text, useCursor, useInput, usePaste, useStdout } from 'ink';
 import { runTurn } from '../agent/loop.js';
-import { answerApproval } from '../agent/permissions.js';
-import { useSession } from '../state/session.js';
+import { answerApproval, currentApprovalTrustable } from '../agent/permissions.js';
+import { session, useSession } from '../state/session.js';
 import { BLOCK_CURSOR, inputFrameRow } from '../ink/cursor.js';
 import { isMouseSequence, handleMouseInput } from '../ink/mouse.js';
-import { inputView, dropLastChar } from './input-layout.js';
+import { inputLayout, dropLastChar, splitTypedBurst, cleanPaste } from './input-layout.js';
+// The rows the input box needs for the text being typed (the window makes room).
+export const MAX_INPUT_ROWS = 6;
+export function inputRowsFor(text, width) {
+    return text ? inputLayout(text, width, MAX_INPUT_ROWS).rows.length : 1;
+}
+// Sends a message, then any sent while Jeeves was busy, one after another.
+async function sendAndDrain(text) {
+    await runTurn(text);
+    for (let next = session.takeQueued(); next !== undefined; next = session.takeQueued()) {
+        await runTurn(next);
+    }
+}
 export function Input({ scrollPage = 10, width = 76 }) {
-    const [value, setValue] = useState('');
     // The text lives in a ref as well as state: the keystroke handler reads and
     // writes the ref, so two keys arriving before React re-renders never build on
     // a stale value.
-    const valueRef = useRef('');
+    const valueRef = useRef(session.inputText);
     const s = useSession();
     const { stdout } = useStdout();
     const { setCursorPosition } = useCursor();
-    const view = inputView(valueRef.current, width);
+    const layout = inputLayout(valueRef.current, width, MAX_INPUT_ROWS);
     const showingText = !s.approvalPending && s.transcriptScrollUp === 0;
+    const setValue = (text) => {
+        valueRef.current = text;
+        session.setInputText(text);
+    };
     // The block cursor sits at the text insertion point: two columns in (the
     // border's │ and its padding space) plus the visible text's width, measured
     // with stringWidth so wide characters count. y is the input row, third from
@@ -27,7 +42,9 @@ export function Input({ scrollPage = 10, width = 76 }) {
     // this commit's frame is written - a useLayoutEffect call runs after that and
     // only lands a frame late (measured: the cursor stayed hidden when the window
     // opened). Hidden while the row shows a hint instead of the text.
-    setCursorPosition(showingText ? { x: 2 + view.width, y: inputFrameRow(stdout.rows ?? 24) } : undefined);
+    // The last row of the box stays on the same terminal row however tall the box
+    // grows (it grows upwards), so the cursor's row is unchanged.
+    setCursorPosition(showingText ? { x: 2 + layout.cursorX, y: inputFrameRow(stdout.rows ?? 24) } : undefined);
     // The terminal's real cursor becomes a steady block for the whole session; it is
     // restored to the shell's default shape by the AlternateScreen exit paths.
     useEffect(() => {
@@ -52,6 +69,8 @@ export function Input({ scrollPage = 10, width = 76 }) {
             const answer = input.toLowerCase();
             if (answer === 'y')
                 answerApproval(true);
+            else if (answer === 'a' && currentApprovalTrustable())
+                answerApproval(true, true);
             else if (answer === 'n')
                 answerApproval(false);
             return;
@@ -87,32 +106,45 @@ export function Input({ scrollPage = 10, width = 76 }) {
             s.followTranscript();
             return;
         }
-        // Anything typed while reading history returns to the newest first.
-        if (key.return) {
-            const text = valueRef.current.trim();
+        // A burst of typing that ends with Enter is typing plus Enter (see splitTypedBurst).
+        const burst = key.return ? { typed: '', enter: true, rest: '' } : splitTypedBurst(input);
+        if (burst.enter) {
+            const text = (valueRef.current + burst.typed).trim();
+            setValue(burst.rest);
+            if (!text)
+                return;
+            s.followTranscript();
             // /exit is honoured even mid-turn so a wedged request can never trap the user.
-            if (text === '/exit' || (text && s.status !== 'working')) {
-                s.followTranscript();
-                valueRef.current = '';
-                setValue('');
-                void runTurn(text);
+            if (text === '/exit' || s.status !== 'working') {
+                void sendAndDrain(text);
+            }
+            else {
+                // Busy: the message waits its turn and is sent as soon as this job finishes.
+                session.queueMessage(text);
+                session.addNotice(`Noted - I'll read this as soon as I've finished: "${text.length > 80 ? text.slice(0, 79) + '…' : text}"`);
             }
             return;
         }
         if (key.backspace || key.delete) {
             s.followTranscript();
-            valueRef.current = dropLastChar(valueRef.current);
-            setValue(valueRef.current);
+            setValue(dropLastChar(valueRef.current));
             return;
         }
         if (!input || key.ctrl || key.meta)
             return;
         s.followTranscript();
-        valueRef.current += input;
-        setValue(valueRef.current);
+        setValue(valueRef.current + input);
+    });
+    // Pasted text arrives whole (bracketed paste), keeps its line breaks, and never
+    // sends by itself - only Enter does.
+    usePaste((text) => {
+        if (s.pickerOpen || s.keysOpen || s.wizardActive || s.helpOpen || s.approvalPending)
+            return;
+        s.followTranscript();
+        setValue(valueRef.current + cleanPaste(text));
     });
     if (s.approvalPending) {
-        return _jsx(Text, { color: "yellow", children: "y = allow \u00B7 n = deny" });
+        return (_jsx(Text, { color: "yellow", children: currentApprovalTrustable() ? 'y = allow · a = always allow in this project · n = deny' : 'y = allow · n = deny' }));
     }
     // While the transcript is scrolled away from the newest, the prompt is replaced
     // by Claude Code's reading-history hint; End (or any typing) returns to the live
@@ -123,5 +155,8 @@ export function Input({ scrollPage = 10, width = 76 }) {
     // Trailing spaces are dimmed: invisible on screen, but it makes the frame's
     // bytes differ from the same text without them, keeping Ink on its full-frame
     // path (see input-layout.ts).
-    return (_jsx(Text, { children: value ? (_jsxs(Text, { children: [view.text, view.trailingSpaces ? _jsx(Text, { dimColor: true, children: view.trailingSpaces }) : null] })) : (_jsx(Text, { dimColor: true, children: "ask anything" })) }));
+    if (!valueRef.current) {
+        return _jsx(Text, { dimColor: true, children: s.status === 'working' ? 'type your next message - it will be sent when I finish' : 'ask anything' });
+    }
+    return (_jsx(Box, { flexDirection: "column", children: layout.rows.map((row, index) => (_jsxs(Text, { children: [row.text, row.trailingSpaces ? _jsx(Text, { dimColor: true, children: row.trailingSpaces }) : null] }, index))) }));
 }

package/dist/components/Transcript.js

@@ -2,7 +2,7 @@ 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';
+import { buildDisplayLines, OWN_MESSAGE_BACKGROUND, OWN_MESSAGE_TEXT } 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.
@@ -34,5 +34,5 @@ export function Transcript({ width }) {
     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))) }) }));
+    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.own ? OWN_MESSAGE_TEXT : line.color, backgroundColor: line.own ? OWN_MESSAGE_BACKGROUND : undefined, dimColor: line.dim, children: line.text }, index))) }) }));
 }

package/dist/components/input-layout.js

@@ -32,3 +32,61 @@ export function inputView(value, rowWidth) {
 export function dropLastChar(value) {
     return Array.from(value).slice(0, -1).join('');
 }
+// The input box grows as the message does (as in Claude Code): the text wraps at
+// word boundaries onto new rows, up to maxRows, then the oldest rows scroll away so
+// the end of the message - where the typing is - always shows. Pasted line breaks
+// start new rows. One column is kept spare so the cursor stays inside the box.
+// This keeps inputView's two rules: every keystroke still changes what is drawn (a
+// wrap adds a row, which resizes the box), and the last row's trailing spaces are
+// returned apart so they can be styled.
+export function inputLayout(value, rowWidth, maxRows = 6) {
+    const maxWidth = Math.max(1, rowWidth - 1);
+    const lines = [];
+    for (const paragraph of value.split('\n')) {
+        let line = '';
+        for (const ch of Array.from(paragraph)) {
+            if (stringWidth(line + ch) <= maxWidth) {
+                line += ch;
+                continue;
+            }
+            if (ch === ' ') {
+                // A space at the edge ends the row; the next word starts the next row.
+                lines.push(line);
+                line = '';
+                continue;
+            }
+            const lastSpace = line.lastIndexOf(' ');
+            if (lastSpace > 0) {
+                lines.push(line.slice(0, lastSpace));
+                line = line.slice(lastSpace + 1) + ch;
+            }
+            else {
+                lines.push(line);
+                line = ch;
+            }
+        }
+        lines.push(line);
+    }
+    const shown = lines.slice(-maxRows);
+    const rows = shown.map((line, index) => {
+        if (index < shown.length - 1)
+            return { text: line, trailingSpaces: '' };
+        const text = line.replace(/ +$/, '');
+        return { text, trailingSpaces: line.slice(text.length) };
+    });
+    return { rows, cursorX: stringWidth(shown[shown.length - 1] ?? '') };
+}
+// A burst of typed characters can arrive together with Enter (when Jeeves is busy
+// and the keyboard runs ahead). The text before the first line break is typed text,
+// and the break itself is Enter. Measured 18 Sept: the break was otherwise stored in
+// the message as a carriage return, which pushed the text over the window's border.
+export function splitTypedBurst(input) {
+    const match = /\r\n|\r|\n/.exec(input);
+    if (!match)
+        return { typed: input, enter: false, rest: '' };
+    return { typed: input.slice(0, match.index), enter: true, rest: input.slice(match.index + match[0].length).replace(/\r\n|\r/g, '\n') };
+}
+// Pasted text keeps its line breaks (as newlines) and never sends by itself.
+export function cleanPaste(text) {
+    return text.replace(/\r\n|\r/g, '\n').replace(/\t/g, '  ');
+}

package/dist/components/transcript-layout.js

@@ -1,3 +1,9 @@
+import stringWidth from 'string-width';
+// 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)
@@ -73,9 +79,15 @@ 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, '', '');
                 break;

package/dist/platform/config.js

@@ -114,3 +114,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/state/session.js

@@ -58,6 +58,10 @@ class SessionStore {
     // The furthest the transcript can scroll up (contentHeight - viewportHeight),
     // reported by the Transcript from its live measurements.
     transcriptScrollMax = Number.POSITIVE_INFINITY;
+    // What is being typed in the input box (the window sizes the box to fit it).
+    inputText = '';
+    // Messages sent while Jeeves was busy, in order; each is sent when he finishes.
+    queued = [];
     turnEvents = [];
     nextId = 1;
     version = 0;
@@ -73,6 +77,22 @@ class SessionStore {
         for (const listener of this.listeners)
             listener();
     }
+    setInputText(text) {
+        if (text === this.inputText)
+            return;
+        this.inputText = text;
+        this.emit();
+    }
+    queueMessage(text) {
+        this.queued = [...this.queued, text];
+        this.emit();
+    }
+    takeQueued() {
+        const [next, ...rest] = this.queued;
+        this.queued = rest;
+        this.emit();
+        return next;
+    }
     setStatus(status) {
         this.status = status;
         this.emit();

package/dist/tools/index.js

@@ -8,6 +8,7 @@ import { runBashSchema, runRunBash } from './runBash.js';
 import { webSearchSchema, runWebSearch, readWebPageSchema, runReadWebPage } from './web/research.js';
 import { ensureCheckpoint, isOutsideProject, commandMayReachOutside } from '../checkpoints/index.js';
 import { resolveFromCwd } from '../platform/paths.js';
+import { isProjectTrusted } from '../agent/trust.js';
 import { holdForWrite, holdForCommand, recordCommandResult, recordNote, noteResearchSchema, HELD_PREFIX, commandEditsFiles, } from '../agent/research-gate.js';
 import { holdUntilReproduced } from '../agent/review.js';
 // Assumption: every tool result is capped to keep huge outputs from flooding the conversation.
@@ -78,13 +79,15 @@ function defineTool(config) {
                 });
                 throw new Error(held);
             }
-            const needsPermission = typeof config.permission === 'function' ? config.permission(input) : config.permission;
             const warning = config.warning?.(input) ?? null;
+            // A change inside the project folder (no outside warning) may be "always allowed".
+            const trustable = warning === null;
+            const needsPermission = (typeof config.permission === 'function' ? config.permission(input) : config.permission) && !(trustable && isProjectTrusted());
             if (warning)
                 session.addNotice(warning);
             const lineId = session.addToolLine(config.name, summary, needsPermission ? 'awaiting' : 'running');
             if (needsPermission) {
-                const approved = await requestApproval();
+                const approved = await requestApproval({ trustable });
                 if (!approved) {
                     session.updateToolLine(lineId, { state: 'declined' });
                     throw new Error(`Permission denied by the user - ${config.name} ${summary} was not executed.`);
@@ -154,7 +157,8 @@ export const TOOLS = {
         schema: webSearchSchema,
         permission: false,
         summarize: (input) => clip(input.query, 60),
-        label: (input) => `Searched ${clip(input.query, 60)}`,
+        // On another service, searches still go through OpenRouter (about a cent each), so say so.
+        label: (input) => `Searched ${clip(input.query, 50)}${session.providerId === 'openrouter' ? '' : ' (via OpenRouter)'}`,
         run: runWebSearch,
     }),
     readWebPage: defineTool({
@@ -163,7 +167,7 @@ export const TOOLS = {
         schema: readWebPageSchema,
         permission: false,
         summarize: (input) => clip(input.url, 60),
-        label: (input) => `Read ${clip(input.url.replace(/^https?:\/\//, ''), 60)}`,
+        label: (input) => `Read ${clip(input.url.replace(/^https?:\/\//, ''), 50)}${session.providerId === 'openrouter' ? '' : ' (via OpenRouter)'}`,
         run: runReadWebPage,
     }),
     runBash: defineTool({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tianmucreations/jeeves",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Your personal assistant in the terminal: say what you need in plain English and Jeeves does the work carefully - asks first, can undo, watches your spending. Auto mode picks the right AI model for you.",
   "keywords": [
     "ai",
@@ -33,7 +33,7 @@
   "bugs": {
     "url": "https://github.com/tianmucreations/Jeeves/issues"
   },
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE",
   "files": [
     "bin/",
     "dist/",