ikarmic-forge 4.4.0 → 4.5.0

package/dist/repl.js

@@ -1,19 +1,49 @@
 import React, { useCallback, useEffect, useRef, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
+import { Box, Text, useInput, useStdin } from 'ink';
 import TextInput from 'ink-text-input';
-import { Agent, formatSteeringLine, defaultSessionDir, saveSession, SPEC_READONLY_TOOLS, SpecStore, splitSpecSections, slugifyTaskForSpecId, } from '@ikarmic/forge-core';
-import { rm } from 'node:fs/promises';
+import { Agent, formatSteeringLine, defaultSessionDir, expandCustomCommand, formatCustomCommands, listSessions, loadCustomCommands, saveSession, searchSessions, SPEC_READONLY_TOOLS, SpecStore, splitSpecSections, slugifyTaskForSpecId, } from '@ikarmic/forge-core';
+import { readFile, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { buildRepoMap, changedFiles, createExploreEditRouter, lintFile, commitFiles, diffForFiles, generateCommitMessage, isGitRepo, undoLastForgeCommit, } from '@ikarmic/forge-core';
+import { buildRepoMap, changedFiles, createExploreEditRouter, fetchUrlTool, lintFile, redact, commitFiles, diffForFiles, generateCommitMessage, isGitRepo, undoLastForgeCommit, } from '@ikarmic/forge-core';
 import { Approval } from './components/Approval.js';
-import { ChatFiles, stripChatFiles } from './chat-files.js';
+import { ChatFiles, stripAttachedFiles } from './chat-files.js';
+import { copyToClipboard, readClipboard } from './clipboard.js';
+import { buildProgram } from './options.js';
+import { composeInEditor, conversationMarkdown, helpQuestionTask, lastAssistantText, reportUrl, } from './repl-extras.js';
 import { formatCommitLine, gitCommitOptions } from './git-workflow.js';
-import { OK_TASK, describeModel, estimateContextTokens, fixTask, formatModels, formatTokens, parseSlashCommand, runContextNote, runShell, switchModel, } from './repl-commands.js';
+import { OK_TASK, describeModel, formatScript, parseReasoningEffort, parseThinkTokens, scriptLines, estimateContextTokens, fixTask, formatModels, formatTokens, parseSlashCommand, runContextNote, runShell, switchModel, } from './repl-commands.js';
 import { Header } from './components/Header.js';
 import { Spinner } from './components/Spinner.js';
 import { sessionCheckpointStore, sessionCheckpointsConfig } from './session-checkpoints.js';
 import { getUnifiedDiffText, summarizeResult as summarizeToolResult } from './tool-display.js';
-export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initialHistory, initialLabel, sessionDir, display = {}, gitWorkflow = null, gitOptions = { noAttribute: false, gitCommitVerify: false }, commitModel, notify, aliases, }) {
+/** The text of `/help`. */
+function replHelpText(sessionId) {
+    return [
+        'Slash commands: /help [question] /clear /reset /save [label] /plan <task> /spec <task> /compact /rewind /ok /model /weak-model /models /add /read-only /drop /ls /run /test /lint /tokens /settings /commit /undo /diff /map /map-refresh /copy /copy-context /paste /web /editor /report /reasoning-effort /think-tokens /editor-model /architect /load /save-script /retry /edit-last /sessions /exit /quit.',
+        '/retry [new text] runs your last message again (or an edited one) in place of the last turn; /edit-last opens it in your editor first. Files the dropped turn changed stay changed: /undo or /rewind reverts them.',
+        '/sessions [words] lists recent sessions, or searches all of them; resume one with forge --resume <id>. Messages typed while a turn runs wait in a queue and run in order.',
+        'Custom commands: a Markdown file in .forge/commands/<name>.md (project) or ~/.forge/commands/<name>.md becomes /<name> [args]; $ARGUMENTS and $1..$9 in it are filled in.',
+        '/commit commits all pending changes with a drafted message; /undo reverts the last Forge commit; /diff shows uncommitted changes.',
+        '/model [id|alias|provider:model] switches (or shows) the model; /weak-model sets the cheap model; /models [query] lists aliases and known models.',
+        '/add <files> and /read-only <files> attach files to every turn (images and PDFs go to the model as they are); /drop [files] detaches; /ls lists them. /run <cmd> (or !<cmd>) runs a command and shows the model its output on the next turn; /test [cmd] and /lint [files] send failures to the model to fix; with no argument they run your --test-cmd / --lint-cmd commands.',
+        '/ok says "go ahead"; /reset detaches files and clears the conversation; /tokens shows context use; /settings shows the effective settings.',
+        '/map shows the repo map (--map-tokens sets the size sent to the model); /map-refresh re-parses every file first.',
+        '/copy copies the last reply to the clipboard; /copy-context copies the whole conversation as Markdown; /paste adds the clipboard text to your next message; /web <url> adds a web page to it.',
+        '/editor [text] (or /edit) writes your message in $VISUAL / $EDITOR and sends it; /report prints a prefilled GitHub issue link with diagnostics only; /help <question> answers a question about Forge.',
+        '/reasoning-effort <level|default> sets how hard the model thinks; /think-tokens <n|8k|0> picks the nearest level for a thinking budget (Forge sets a level, not an exact count).',
+        '/editor-model <model> and /architect <task>: the main model plans without tools (like /plan), you approve, then the editor model applies it. Attach files (/add) and use /map to give the planner context.',
+        '/load <file> runs the commands and messages in a file, one per line (# for comments); /save-script <file> writes the model and attached files as such a script.',
+        'Otherwise type a task and press Enter.',
+        `Session: ${sessionId} (auto-saved after each turn).`,
+        'Plan review: when a plan is proposed, type a (approve), e (edit), or c (cancel).',
+        'Spec review: same a/e/c keys: approve writes requirements.md/design.md/tasks.md to .forge/specs/<id>/.',
+    ].join('\n');
+}
+async function defaultFetchPage(url, cwd) {
+    const r = await fetchUrlTool.execute({ url }, { cwd, auto: false });
+    return { url: r.url, ...(r.title ? { title: r.title } : {}), status: r.status, excerpt: r.excerpt, truncated: r.truncated };
+}
+export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initialHistory, initialLabel, sessionDir, display = {}, gitWorkflow = null, gitOptions = { noAttribute: false, gitCommitVerify: false }, commitModel, notify, aliases, version = 'unknown', services, lintCmds = [], testCmds = [], }) {
     const [messages, setMessages] = useState([]);
     const [input, setInput] = useState('');
     const [running, setRunning] = useState(false);
@@ -49,6 +79,34 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
     const pendingNotesRef = useRef([]);
     /** `/weak-model`: cheap model for read-only exploration steps and commit messages. */
     const [weakModel, setWeakModel] = useState(undefined);
+    /** `/editor-model`: the model that applies a plan made with `/architect`. */
+    const [editorModel, setEditorModel] = useState(undefined);
+    /** Set while an `/architect` plan awaits approval: the model to apply it with. */
+    const architectEditorRef = useRef(null);
+    /** True while a `/load` script runs, so a script cannot load another. */
+    const loadingRef = useRef(false);
+    /** The latest `handleSubmit`, for `/load` to replay lines through. */
+    const submitRef = useRef(null);
+    /** The last chat message and the history before it, for `/retry` and `/edit-last`. */
+    const lastTurnRef = useRef(null);
+    /** Messages typed while a submission is being handled; they run in order afterwards. */
+    const queueRef = useRef([]);
+    const inFlightRef = useRef(false);
+    const { setRawMode, isRawModeSupported } = useStdin();
+    /** Hand the terminal to the editor: leave raw mode while it runs, then take it back. */
+    const editInTerminal = async (initial) => {
+        if (services?.edit)
+            return services.edit(initial);
+        if (isRawModeSupported)
+            setRawMode(false);
+        try {
+            return await composeInEditor(initial);
+        }
+        finally {
+            if (isRawModeSupported)
+                setRawMode(true);
+        }
+    };
     // Per-turn AbortController so Escape can cancel a running agent turn (see
     // the useInput handler below). Stored in a ref so it survives re-renders
     // across the async run and stays reachable from the key handler.
@@ -60,7 +118,9 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
     const redactionsRef = useRef(0);
     const handleSubmit = useCallback(async (raw) => {
         const task = raw.trim();
-        if (!task || running)
+        // No `running` check: submitFromUser queues what arrives mid-turn, and this callback's
+        // `running` can be a render behind when a queued message or a /load line comes in.
+        if (!task)
             return;
         setInput('');
         // Slash commands
@@ -73,7 +133,7 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
             historyRef.current = [];
             return;
         }
-        if (task.startsWith('/save')) {
+        if (task === '/save' || task.startsWith('/save ')) {
             const label = task.replace(/^\/save\s*/, '').trim();
             if (label)
                 setCurrentLabel(label);
@@ -103,23 +163,9 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
             return;
         }
         if (task === '/help') {
-            setMessages((m) => [
-                ...m,
-                {
-                    kind: 'status',
-                    id: cryptoId(),
-                    text: 'Slash commands: /help /clear /reset /save [label] /plan <task> /spec <task> /compact /rewind /ok /model /weak-model /models /add /read-only /drop /ls /run /test /lint /tokens /settings /commit /undo /diff /map /map-refresh /exit /quit.\n' +
-                        '/commit commits all pending changes with a drafted message; /undo reverts the last Forge commit; /diff shows uncommitted changes.\n' +
-                        '/model [id|alias|provider:model] switches (or shows) the model; /weak-model sets the cheap model; /models [query] lists aliases and known models.\n' +
-                        '/add <files> and /read-only <files> attach files to every turn; /drop [files] detaches; /ls lists them. /run <cmd> (or !<cmd>) runs a command and shows the model its output on the next turn; /test [cmd] and /lint [files] send failures to the model to fix.\n' +
-                        '/ok says "go ahead"; /reset detaches files and clears the conversation; /tokens shows context use; /settings shows the effective settings.\n' +
-                        '/map shows the repo map (--map-tokens sets the size sent to the model); /map-refresh re-parses every file first.\n' +
-                        `Otherwise type a task and press Enter.\n` +
-                        `Session: ${currentSessionId} (auto-saved after each turn).\n` +
-                        'Plan review: when a plan is proposed, type a (approve), e (edit), or c (cancel).\n' +
-                        'Spec review: same a/e/c keys: approve writes requirements.md/design.md/tasks.md to .forge/specs/<id>/.',
-                },
-            ]);
+            const custom = await loadCustomCommands(agentConfigRef.current.cwd ?? process.cwd()).catch(() => new Map());
+            const extra = custom.size > 0 ? `\nYour commands:\n${formatCustomCommands(custom)}` : '';
+            setMessages((m) => [...m, { kind: 'status', id: cryptoId(), text: replHelpText(currentSessionId) + extra }]);
             return;
         }
         if (task === '/id') {
@@ -204,12 +250,15 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
             if (action === 'a' || action === 'approve') {
                 const approvedPlan = pendingPlan;
                 const approvedTask = pendingPlanTask ?? task;
+                const applyWith = architectEditorRef.current;
+                architectEditorRef.current = null;
                 setPendingPlan(null);
                 setPendingPlanTask(null);
-                await runWithPlan(approvedTask, approvedPlan);
+                await runWithPlan(approvedTask, approvedPlan, applyWith ?? undefined);
                 return;
             }
             if (action === 'c' || action === 'cancel') {
+                architectEditorRef.current = null;
                 setPendingPlan(null);
                 setPendingPlanTask(null);
                 setMessages((m) => [
@@ -331,7 +380,7 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
             ]);
             return;
         }
-        if (task.startsWith('/plan')) {
+        if (task === '/plan' || task.startsWith('/plan ')) {
             const planTask = task.replace(/^\/plan\s*/, '').trim();
             if (!planTask) {
                 setMessages((m) => [
@@ -343,7 +392,7 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
             await runInPlanMode(planTask);
             return;
         }
-        if (task.startsWith('/spec')) {
+        if (task === '/spec' || task.startsWith('/spec ')) {
             const specTask = task.replace(/^\/spec\s*/, '').trim();
             if (!specTask) {
                 setMessages((m) => [
@@ -360,10 +409,39 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
             return;
         }
         const slash = parseSlashCommand(task);
-        if (slash && ['model', 'weak-model', 'models', 'run', 'test', 'lint', 'ok', 'add', 'read-only', 'drop', 'ls', 'reset', 'tokens', 'settings'].includes(slash.name)) {
+        if (slash && ['model', 'weak-model', 'models', 'run', 'test', 'lint', 'ok', 'add', 'read-only', 'drop', 'ls', 'reset', 'tokens', 'settings', 'help', 'copy', 'copy-context', 'paste', 'web', 'editor', 'edit', 'report', 'reasoning-effort', 'think-tokens', 'editor-model', 'architect', 'load', 'save-script'].includes(slash.name)) {
             const say = (text, isError) => setMessages((m) => [...m, { kind: 'status', id: cryptoId(), text, ...(isError ? { isError } : {}) }]);
             const cwd = agentConfigRef.current.cwd ?? process.cwd();
             const { name, args } = slash;
+            /** Run one command, showing the command and its output tail. */
+            const runShown = async (command) => {
+                say(`$ ${command}`);
+                setRunning(true);
+                setStatus('running');
+                let result;
+                try {
+                    result = await runShell(command, cwd);
+                }
+                finally {
+                    setRunning(false);
+                    setStatus('idle');
+                }
+                const tail = result.output.trim().split('\n').slice(-40).join('\n');
+                say(`${tail || '(no output)'}\n[${result.timedOut ? 'timed out' : `exit ${result.exitCode ?? 'none'}`}]`, result.exitCode !== 0);
+                return result;
+            };
+            /** Run checks in order; the first failure goes to the model to fix, as in Aider. */
+            const runChecks = async (kind, commands) => {
+                for (const command of commands) {
+                    const result = await runShown(command);
+                    if (result.exitCode === 0)
+                        continue;
+                    const fix = fixTask(kind, command, result);
+                    setMessages((m) => [...m, { kind: 'user', id: cryptoId(), text: fix }]);
+                    await runAgent(fix, { planMode: false });
+                    return;
+                }
+            };
             try {
                 if (name === 'model' || name === 'weak-model') {
                     const weak = name === 'weak-model';
@@ -394,6 +472,174 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
                     say(formatModels(aliases, args));
                     return;
                 }
+                if (name === 'reasoning-effort' || name === 'think-tokens') {
+                    if (!args) {
+                        say(`reasoning effort: ${model.reasoningEffort ?? 'default (the provider decides)'}\n` +
+                            (name === 'reasoning-effort' ? 'usage: /reasoning-effort <none|minimal|low|medium|high|xhigh|default>' : 'usage: /think-tokens <tokens, e.g. 8k | 0 | default>'));
+                        return;
+                    }
+                    const change = name === 'reasoning-effort' ? parseReasoningEffort(args) : parseThinkTokens(args);
+                    if (!change.ok) {
+                        say(change.error, true);
+                        return;
+                    }
+                    const { reasoningEffort: _dropped, ...rest } = model;
+                    const next = change.effort ? { ...rest, reasoningEffort: change.effort } : rest;
+                    setModel(next);
+                    agentConfigRef.current = {
+                        ...agentConfigRef.current,
+                        model: next,
+                        ...(weakModel ? { modelRouter: createExploreEditRouter({ strong: next, cheap: weakModel }) } : {}),
+                    };
+                    const note = 'note' in change && typeof change.note === 'string' ? change.note : undefined;
+                    say(note ?? `reasoning effort → ${change.effort ?? 'default (the provider decides)'}`);
+                    return;
+                }
+                if (name === 'editor-model') {
+                    if (!args) {
+                        say(`editor model: ${editorModel ? describeModel(editorModel) : '(none) set one with /editor-model <model>, then use /architect <task>'}`);
+                        return;
+                    }
+                    if (args.toLowerCase() === 'off') {
+                        setEditorModel(undefined);
+                        say('editor model cleared');
+                        return;
+                    }
+                    const res = switchModel(args, model, aliases);
+                    if (!res.ok) {
+                        say(res.error, true);
+                        return;
+                    }
+                    setEditorModel(res.model);
+                    say(`editor model → ${describeModel(res.model)} (applies plans made with /architect)`);
+                    return;
+                }
+                if (name === 'architect') {
+                    if (!editorModel) {
+                        say('set the model that applies the plan first: /editor-model <model>', true);
+                        return;
+                    }
+                    if (!args) {
+                        say('usage: /architect <task>  (the main model plans, you approve, then the editor model applies it)', true);
+                        return;
+                    }
+                    architectEditorRef.current = editorModel;
+                    setMessages((m) => [...m, { kind: 'user', id: cryptoId(), text: `/architect ${args}` }]);
+                    await runAgent(args, { planMode: true });
+                    return;
+                }
+                if (name === 'load') {
+                    if (!args) {
+                        say('usage: /load <file>  (one command or message per line; blank lines and # comments are skipped)', true);
+                        return;
+                    }
+                    if (loadingRef.current) {
+                        say('a script cannot /load another script', true);
+                        return;
+                    }
+                    const file = path.resolve(cwd, args);
+                    let text;
+                    try {
+                        text = await readFile(file, 'utf8');
+                    }
+                    catch {
+                        say(`cannot read ${args}`, true);
+                        return;
+                    }
+                    const lines = scriptLines(text);
+                    if (lines.length === 0) {
+                        say(`${args} has no commands`, true);
+                        return;
+                    }
+                    if (lines.length > 500) {
+                        say(`${args} has ${lines.length} lines; scripts are limited to 500`, true);
+                        return;
+                    }
+                    loadingRef.current = true;
+                    try {
+                        for (const line of lines) {
+                            say(`> ${line}`);
+                            await submitRef.current?.(line);
+                        }
+                    }
+                    finally {
+                        loadingRef.current = false;
+                    }
+                    return;
+                }
+                if (name === 'save-script') {
+                    if (!args) {
+                        say('usage: /save-script <file>  (writes the model and attached files as commands for /load)', true);
+                        return;
+                    }
+                    const target = path.resolve(cwd, args);
+                    const rel = path.relative(cwd, target);
+                    if (rel.startsWith('..') || path.isAbsolute(rel) || rel === '') {
+                        say('the script must be inside the working directory', true);
+                        return;
+                    }
+                    const script = formatScript({ model, weakModel, editorModel, files: chatFilesRef.current.list() });
+                    await writeFile(target, script, 'utf8');
+                    say(`wrote ${scriptLines(script).length} commands to ${rel.split(path.sep).join('/')}`);
+                    return;
+                }
+                if (name === 'help') {
+                    // /help <question>: answered from the command reference; read-only tools only.
+                    const reference = `${replHelpText(currentSessionId)}\n\nCommand-line options:\n${buildProgram().helpInformation()}`;
+                    const question = helpQuestionTask(args, reference);
+                    setMessages((m) => [...m, { kind: 'user', id: cryptoId(), text: `/help ${args}` }]);
+                    await runAgent(question, { planMode: false, readOnlyTools: true });
+                    return;
+                }
+                if (name === 'copy' || name === 'copy-context') {
+                    const text = name === 'copy' ? lastAssistantText(historyRef.current) : conversationMarkdown(historyRef.current);
+                    if (!text) {
+                        say(name === 'copy' ? 'nothing to copy yet: no reply from the model' : 'nothing to copy yet: the conversation is empty', true);
+                        return;
+                    }
+                    const res = await (services?.copy ?? copyToClipboard)(text);
+                    say(res.ok ? `copied ${text.length.toLocaleString('en-US')} characters to the clipboard (${res.tool})` : `copy failed: ${res.error}`, !res.ok);
+                    return;
+                }
+                if (name === 'paste') {
+                    const res = await (services?.read ?? readClipboard)();
+                    if (!res.ok) {
+                        say(`paste failed: ${res.error}`, true);
+                        return;
+                    }
+                    if (!res.text.trim()) {
+                        say('the clipboard is empty', true);
+                        return;
+                    }
+                    pendingNotesRef.current.push(`Pasted from the clipboard:\n\`\`\`\n${redact(res.text.trimEnd()).text}\n\`\`\``);
+                    say(`pasted ${res.text.length.toLocaleString('en-US')} characters (sent with your next message)`);
+                    return;
+                }
+                if (name === 'web') {
+                    if (!args) {
+                        say('usage: /web <url>', true);
+                        return;
+                    }
+                    say(`fetching ${args} ...`);
+                    const page = await (services?.fetchPage ?? defaultFetchPage)(args, cwd);
+                    pendingNotesRef.current.push(`Web page ${page.url}${page.title ? ` ("${page.title}")` : ''}${page.truncated ? ' (truncated)' : ''}:\n\`\`\`\n${page.excerpt}\n\`\`\``);
+                    say(`fetched ${page.url} (HTTP ${page.status}, ${page.excerpt.length.toLocaleString('en-US')} characters${page.truncated ? ', truncated' : ''}); sent with your next message`);
+                    return;
+                }
+                if (name === 'editor' || name === 'edit') {
+                    const res = await editInTerminal(args);
+                    if (!res.ok) {
+                        say(`/${name}: ${res.error}`, true);
+                        return;
+                    }
+                    await chatTurn(res.text, res.text);
+                    return;
+                }
+                if (name === 'report') {
+                    const url = reportUrl({ version, platform: `${process.platform} ${process.arch}`, node: process.version, model, sessionId: currentSessionId });
+                    say(`Open this link to file an issue. It is prefilled with diagnostics only (version, platform, model): no keys, paths or prompts.\n${url}`);
+                    return;
+                }
                 if (name === 'ls') {
                     const { editable, readOnly } = chatFilesRef.current.list();
                     say(editable.length + readOnly.length === 0
@@ -454,6 +700,10 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
                     await runAgent(OK_TASK, { planMode: false });
                     return;
                 }
+                if (name === 'lint' && !args && lintCmds.length > 0) {
+                    await runChecks('lint', lintCmds);
+                    return;
+                }
                 if (name === 'lint') {
                     const aut = agentConfigRef.current.autoLint ?? { syntax: true };
                     const named = args ? args.split(/\s+/).filter(Boolean) : [];
@@ -486,35 +736,26 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
                     await runAgent(fix, { planMode: false });
                     return;
                 }
-                // /run and /test
-                const command = name === 'test' && !args ? agentConfigRef.current.verify?.commands[0] ?? '' : args;
-                if (!command) {
-                    say(name === 'test' ? 'usage: /test <command> (or start with --verify <command>)' : 'usage: /run <command>  (or !<command>)', true);
+                // /run runs one command; /test with no argument runs every --test-cmd.
+                if (name === 'test' && !args) {
+                    if (testCmds.length === 0) {
+                        say('usage: /test <command>  (or start forge with --test-cmd <command>)', true);
+                        return;
+                    }
+                    await runChecks('test', testCmds);
                     return;
                 }
-                say(`$ ${command}`);
-                setRunning(true);
-                setStatus('running');
-                let result;
-                try {
-                    result = await runShell(command, cwd);
-                }
-                finally {
-                    setRunning(false);
-                    setStatus('idle');
-                }
-                const tail = result.output.trim().split('\n').slice(-40).join('\n');
-                say(`${tail || '(no output)'}\n[${result.timedOut ? 'timed out' : `exit ${result.exitCode ?? 'none'}`}]`, result.exitCode !== 0);
-                if (name === 'run') {
-                    pendingNotesRef.current.push(runContextNote(command, result));
-                    say('(output will be sent to the model with your next message)');
+                if (!args) {
+                    say(name === 'test' ? 'usage: /test <command>  (or start forge with --test-cmd <command>)' : 'usage: /run <command>  (or !<command>)', true);
                     return;
                 }
-                if (result.exitCode === 0)
+                if (name === 'test') {
+                    await runChecks('test', [args]);
                     return;
-                const fix = fixTask('test', command, result);
-                setMessages((m) => [...m, { kind: 'user', id: cryptoId(), text: fix }]);
-                await runAgent(fix, { planMode: false });
+                }
+                const result = await runShown(args);
+                pendingNotesRef.current.push(runContextNote(args, result));
+                say('(output will be sent to the model with your next message)');
             }
             catch (err) {
                 setRunning(false);
@@ -538,17 +779,6 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
             }
             return;
         }
-        if (task === '/tokens') {
-            setMessages((m) => [
-                ...m,
-                {
-                    kind: 'status',
-                    id: cryptoId(),
-                    text: `tokens this session: ${inputTokens} in, ${outputTokens} out${costUsd !== undefined ? `, $${costUsd.toFixed(4)}` : ''}`,
-                },
-            ]);
-            return;
-        }
         if (task === '/commit' || task === '/undo' || task === '/diff') {
             const say = (text, isError) => setMessages((m) => [...m, { kind: 'status', id: cryptoId(), text, ...(isError ? { isError } : {}) }]);
             const cwd = agentConfigRef.current.cwd ?? process.cwd();
@@ -583,9 +813,57 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
             }
             return;
         }
-        const userMessageId = cryptoId();
-        setMessages((m) => [...m, { kind: 'user', id: userMessageId, text: task }]);
-        await runAgent(task, { planMode: false });
+        const say = (text, isError) => setMessages((m) => [...m, { kind: 'status', id: cryptoId(), text, ...(isError ? { isError } : {}) }]);
+        if (task === '/retry' || task.startsWith('/retry ') || task === '/edit-last') {
+            const last = lastTurnRef.current;
+            if (!last) {
+                say('nothing to retry yet: send a message first', true);
+                return;
+            }
+            let next = task.replace(/^\/retry\s*/, '').trim() || last.task;
+            if (task === '/edit-last') {
+                const res = await editInTerminal(last.task);
+                if (!res.ok) {
+                    say(`/edit-last: ${res.error}`, true);
+                    return;
+                }
+                next = res.text;
+            }
+            // Drop the last turn from the conversation and run the message again in its place.
+            historyRef.current = last.historyBefore;
+            say(`retrying${next !== last.task ? ' with your edit' : ''}: the last turn is dropped from the conversation (files it changed stay changed; /undo or /rewind reverts them)`);
+            await chatTurn(next, next);
+            return;
+        }
+        if (task === '/sessions' || task.startsWith('/sessions ')) {
+            const query = task.replace(/^\/sessions\s*/, '').trim();
+            try {
+                if (!query) {
+                    const recent = (await listSessions(sessionDir)).slice(0, 10);
+                    say(recent.length === 0
+                        ? 'no saved sessions yet'
+                        : `recent sessions (resume with forge --resume <id>):\n${recent.map((e) => `  ${e.id}${e.label ? ` [${e.label}]` : ''}  ${e.updatedAt.slice(0, 16).replace('T', ' ')}  ${e.preview ?? ''}`).join('\n')}`);
+                    return;
+                }
+                const found = await searchSessions(sessionDir, query, { limit: 10 });
+                say(found.length === 0
+                    ? `no session mentions "${query}"`
+                    : `sessions mentioning "${query}" (resume with forge --resume <id>):\n${found.map((f) => `  ${f.entry.id}${f.entry.label ? ` [${f.entry.label}]` : ''}  ${f.entry.updatedAt.slice(0, 10)}  ${f.snippet}`).join('\n')}`);
+            }
+            catch (err) {
+                say(`/sessions: ${err.message}`, true);
+            }
+            return;
+        }
+        const customSlash = parseSlashCommand(task);
+        if (customSlash && !task.startsWith('!')) {
+            const custom = (await loadCustomCommands(agentConfigRef.current.cwd ?? process.cwd()).catch(() => new Map())).get(customSlash.name);
+            if (custom) {
+                await chatTurn(task, expandCustomCommand(custom, customSlash.args));
+                return;
+            }
+        }
+        await chatTurn(task, task);
     }, [
         running,
         onExit,
@@ -597,13 +875,63 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
         sessionDir,
         costUsd,
         pendingPlan,
+        pendingPlanTask,
         pendingSpec,
+        pendingSpecTask,
+        // Everything the handler reads from props or state: a value missing here is stale after it changes.
+        weakModel,
+        editorModel,
+        aliases,
+        services,
+        version,
+        lintCmds,
+        testCmds,
+        gitWorkflow,
+        gitOptions,
+        commitModel,
     ]);
+    submitRef.current = handleSubmit;
+    /** One chat message: shown as `shown`, sent as `task`, and remembered for /retry. */
+    async function chatTurn(shown, task) {
+        lastTurnRef.current = { task, historyBefore: historyRef.current };
+        setMessages((m) => [...m, { kind: 'user', id: cryptoId(), text: shown }]);
+        await runAgent(task, { planMode: false });
+    }
+    /**
+     * What Enter does: handle the message now, or queue it while an earlier one is still being
+     * handled (a turn, a /test run, a script). Queued messages then run one by one, in order.
+     */
+    const submitFromUser = (raw) => {
+        const task = raw.trim();
+        if (!task)
+            return;
+        if (inFlightRef.current) {
+            queueRef.current.push(task);
+            setInput('');
+            setMessages((m) => [
+                ...m,
+                { kind: 'status', id: cryptoId(), text: `queued (${queueRef.current.length} waiting): ${task.length > 60 ? `${task.slice(0, 57)}...` : task}` },
+            ]);
+            return;
+        }
+        inFlightRef.current = true;
+        void (async () => {
+            try {
+                await submitRef.current?.(task);
+            }
+            finally {
+                inFlightRef.current = false;
+                const next = queueRef.current.shift();
+                if (next !== undefined)
+                    submitFromUser(next);
+            }
+        })();
+    };
     /**
      * Run the agent for a single turn. `options.planMode: true` makes the
      * agent emit a plan instead of executing; the returned finalText holds
-     * the plan. `options.planContext` prepends an `<approved-plan>` block
-     * to the system prompt so the agent knows what to do.
+     * the plan. `options.planContext` puts an `<approved-plan>` block at the
+     * start of this turn's message so the agent knows what to do.
      *
      * Declared as a regular function (not `useCallback`) so it can be
      * referenced by `handleSubmit` below: function declarations are hoisted
@@ -616,19 +944,15 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
         abortControllerRef.current = controller;
         const approvals = new Map();
         const overrides = {
+            // An /architect plan is applied by the editor model; its cost router must not route back to the planner.
+            ...(options.modelOverride ? { model: options.modelOverride, modelRouter: undefined } : {}),
             planMode: options.planMode,
             specMode: options.specMode === true,
-            ...(options.planContext
-                ? {
-                    systemPrompt: (agentConfigRef.current.systemPrompt ?? '') +
-                        `\n\n<approved-plan>\n${options.planContext}\n</approved-plan>\nFollow the plan above. You may deviate if you find an issue, but explain why in your final summary.`,
-                }
-                : {}),
             // Spec mode always gets exactly the six read-only tools: a hard
             // override of whatever toolSandbox the user configured via
             // --allow-tools/--deny-tools, matching options.ts's toAgentConfig
             // wiring for one-shot `--spec`.
-            ...(options.specMode === true ? { toolSandbox: { allowTools: [...SPEC_READONLY_TOOLS] } } : {}),
+            ...(options.specMode === true || options.readOnlyTools === true ? { toolSandbox: { allowTools: [...SPEC_READONLY_TOOLS] } } : {}),
         };
         const localConfig = {
             ...agentConfigRef.current,
@@ -644,7 +968,12 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
         const attached = await chatFilesRef.current.render();
         for (const note of attached.notes)
             setMessages((m) => [...m, { kind: 'status', id: cryptoId(), text: note }]);
-        const turnContext = [...pendingNotesRef.current.splice(0), attached.block].filter((part) => part.length > 0).join('\n\n');
+        // The approved plan rides in this turn's message: a system-prompt override is ignored once the
+        // conversation has history (and it always has, right after the plan run), which also dropped edited plans.
+        const planBlock = options.planContext
+            ? `<approved-plan>\n${options.planContext}\n</approved-plan>\nFollow the plan above. You may deviate if you find an issue, but explain why in your final summary.`
+            : '';
+        const turnContext = [planBlock, ...pendingNotesRef.current.splice(0), attached.block].filter((part) => part.length > 0).join('\n\n');
         if (localConfig.repoMap && chatFilesRef.current.size > 0) {
             localConfig.repoMap = { ...localConfig.repoMap, focusFiles: chatFilesRef.current.focusFiles() };
         }
@@ -661,6 +990,7 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
             agentRunResult = await agent.run({
                 task,
                 ...(turnContext ? { context: turnContext } : {}),
+                ...(attached.attachments.length > 0 ? { attachments: attached.attachments } : {}),
                 history: historyRef.current,
                 abortSignal: controller.signal,
                 onEvent: (event) => {
@@ -907,9 +1237,8 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
         }
         if (agentRunResult) {
             // The attached files were for this turn; keep them out of the stored history.
-            historyRef.current = attached.block
-                ? agentRunResult.messages.map((m) => (m.role === 'user' && typeof m.content === 'string' ? { ...m, content: stripChatFiles(m.content) } : m))
-                : agentRunResult.messages;
+            historyRef.current =
+                attached.block || attached.attachments.length > 0 ? agentRunResult.messages.map(stripAttachedFiles) : agentRunResult.messages;
             if (historyRef.current.length > 0 && !options.planMode && !options.specMode) {
                 const savedPath = await persistSession({
                     id: currentSessionId,
@@ -940,17 +1269,18 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
     }
     /** Run the agent in plan mode for a task. */
     function runInPlanMode(planTask) {
+        architectEditorRef.current = null; // a plain /plan is applied by the main model
         setMessages((m) => [...m, { kind: 'user', id: cryptoId(), text: `/plan ${planTask}` }]);
         return runAgent(planTask, { planMode: true });
     }
     /** Run a normal (non-plan) agent turn with a previously-approved plan injected. */
-    function runWithPlan(realTask, plan) {
+    function runWithPlan(realTask, plan, applyWith) {
         setMessages((m) => [
             ...m,
-            { kind: 'status', id: cryptoId(), text: '✓ plan approved: executing…' },
+            { kind: 'status', id: cryptoId(), text: applyWith ? `✓ plan approved: ${describeModel(applyWith)} is applying it…` : '✓ plan approved: executing…' },
             { kind: 'user', id: cryptoId(), text: realTask },
         ]);
-        return runAgent(realTask, { planMode: false, planContext: plan });
+        return runAgent(realTask, { planMode: false, planContext: plan, ...(applyWith ? { modelOverride: applyWith } : {}) });
     }
     /**
      * Run the agent in spec mode for a task. Unlike `runWithPlan`, there is
@@ -1043,9 +1373,12 @@ export function Repl({ baseConfig, model: initialModel, onExit, sessionId, initi
             pendingApproval && (React.createElement(Approval, { request: pendingApproval.request, onResolve: handleApproval }))),
         React.createElement(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, marginTop: 1, flexDirection: "row" },
             React.createElement(Text, { color: "cyan", bold: true }, "forge \u276F"),
-            React.createElement(Box, { marginLeft: 1, flexGrow: 1 }, running ? (React.createElement(Box, null,
+            React.createElement(Box, { marginLeft: 1, flexGrow: 1 }, pendingApproval ? (React.createElement(Box, null,
+                React.createElement(Spinner, null),
+                React.createElement(Text, { color: "gray" }, " waiting for your answer above"))) : running ? (React.createElement(Box, null,
                 React.createElement(Spinner, null),
-                React.createElement(Text, { color: "gray" }, " running\u2026 (esc to cancel)"))) : (React.createElement(TextInput, { value: input, onChange: setInput, onSubmit: handleSubmit, placeholder: "ask forge anything\u2026" })))),
+                React.createElement(Text, { color: "gray" }, " running\u2026 (esc to cancel) "),
+                React.createElement(TextInput, { value: input, onChange: setInput, onSubmit: submitFromUser, placeholder: "type to queue a message" }))) : (React.createElement(TextInput, { value: input, onChange: setInput, onSubmit: submitFromUser, placeholder: "ask forge anything\u2026" })))),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { color: "gray" },
                 "\u2191",