ikarmic-forge 0.0.0-stage → 4.4.0

package/dist/repl.js

@@ -0,0 +1,1174 @@
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { Box, Text, useInput } 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 path from 'node:path';
+import { buildRepoMap, changedFiles, createExploreEditRouter, lintFile, commitFiles, diffForFiles, generateCommitMessage, isGitRepo, undoLastForgeCommit, } from '@ikarmic/forge-core';
+import { Approval } from './components/Approval.js';
+import { ChatFiles, stripChatFiles } from './chat-files.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 { 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, }) {
+    const [messages, setMessages] = useState([]);
+    const [input, setInput] = useState('');
+    const [running, setRunning] = useState(false);
+    const [pendingApproval, setPendingApproval] = useState(null);
+    const [status, setStatus] = useState('idle');
+    const [inputTokens, setInputTokens] = useState(0);
+    const [outputTokens, setOutputTokens] = useState(0);
+    const [iter, setIter] = useState(0);
+    const [maxIter, setMaxIter] = useState(baseConfig.maxIterations ?? 50);
+    const [currentSessionId, setCurrentSessionId] = useState(sessionId);
+    const [currentLabel, setCurrentLabel] = useState(initialLabel);
+    const [costUsd, setCostUsd] = useState(undefined);
+    const [redactedCount, setRedactedCount] = useState(0);
+    const [cacheHits, setCacheHits] = useState(0);
+    const [cacheMisses, setCacheMisses] = useState(0);
+    /** When set, the user is reviewing a proposed plan. */
+    const [pendingPlan, setPendingPlan] = useState(null);
+    /** Task that the plan was generated FOR: re-runs with this when approved. */
+    const [pendingPlanTask, setPendingPlanTask] = useState(null);
+    /** When set, the user is reviewing a proposed spec (raw, unsplit text). */
+    const [pendingSpec, setPendingSpec] = useState(null);
+    /** Task that the spec was generated FOR: used as the spec's `task` field on approve. */
+    const [pendingSpecTask, setPendingSpecTask] = useState(null);
+    // History sent to the agent: seeded from the resumed session if any,
+    // otherwise starts empty (the agent creates the system prompt on turn 1).
+    const historyRef = useRef(initialHistory ?? []);
+    const agentConfigRef = useRef(baseConfig);
+    /** The model in use; `/model` changes it for the rest of the session. */
+    const [model, setModel] = useState(initialModel);
+    /** Files attached with /add and /read-only; sent with every turn. */
+    const chatFilesRef = useRef(new ChatFiles(baseConfig.cwd ?? process.cwd()));
+    /** Output of /run commands, handed to the model with the next turn. */
+    const pendingNotesRef = useRef([]);
+    /** `/weak-model`: cheap model for read-only exploration steps and commit messages. */
+    const [weakModel, setWeakModel] = useState(undefined);
+    // 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.
+    const abortControllerRef = useRef(null);
+    // Aggregate token + cost counters across turns so we can write them into
+    // the session on save.
+    const tokensRef = useRef({ input: 0, output: 0 });
+    const costRef = useRef(0);
+    const redactionsRef = useRef(0);
+    const handleSubmit = useCallback(async (raw) => {
+        const task = raw.trim();
+        if (!task || running)
+            return;
+        setInput('');
+        // Slash commands
+        if (task === '/exit' || task === '/quit') {
+            onExit();
+            return;
+        }
+        if (task === '/clear') {
+            setMessages([]);
+            historyRef.current = [];
+            return;
+        }
+        if (task.startsWith('/save')) {
+            const label = task.replace(/^\/save\s*/, '').trim();
+            if (label)
+                setCurrentLabel(label);
+            const savedPath = await persistSession({
+                id: currentSessionId,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                ...(label || currentLabel ? { label: label || currentLabel } : {}),
+                cwd: process.cwd(),
+                model,
+                messages: historyRef.current,
+                totalInputTokens: tokensRef.current.input,
+                totalOutputTokens: tokensRef.current.output,
+                totalCostUsd: costRef.current,
+                costKnown: costUsd !== undefined,
+            });
+            setMessages((m) => [
+                ...m,
+                {
+                    kind: 'status',
+                    id: cryptoId(),
+                    text: savedPath
+                        ? `saved session ${currentSessionId}${label ? ` [${label}]` : ''} → ${savedPath}`
+                        : 'save failed: no completed turns yet',
+                },
+            ]);
+            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>/.',
+                },
+            ]);
+            return;
+        }
+        if (task === '/id') {
+            setMessages((m) => [
+                ...m,
+                {
+                    kind: 'status',
+                    id: cryptoId(),
+                    text: `session id: ${currentSessionId}: pick up later with: forge --resume ${currentSessionId}`,
+                },
+            ]);
+            return;
+        }
+        // /rewind: list the agent's per-turn checkpoints so the user can
+        // restore a file's pre-tool state. Pair with the `forge checkpoint …`
+        // CLI for non-interactive restore (which requires --yes). Within
+        // the REPL we just list; the next iteration of this command will
+        // accept an `<id>` argument and call `store.restore()` directly.
+        if (task === '/rewind' || task.startsWith('/rewind ')) {
+            const arg = task.replace(/^\/rewind\s*/, '').trim();
+            const store = sessionCheckpointStore(sessionDir, currentSessionId, agentConfigRef.current.cwd ?? process.cwd());
+            const items = await store.list();
+            if (items.length === 0) {
+                setMessages((m) => [
+                    ...m,
+                    { kind: 'status', id: cryptoId(), text: 'no checkpoints yet (they appear after the first file-mutating tool call)' },
+                ]);
+                return;
+            }
+            if (!arg) {
+                const lines = items.slice(-10).map((cp) => `  ${cp.id}  turn ${cp.turnIndex}  ${cp.description}  (${cp.fileCount} files)`);
+                setMessages((m) => [
+                    ...m,
+                    {
+                        kind: 'status',
+                        id: cryptoId(),
+                        text: `checkpoints (most recent 10 of ${items.length}):\n` +
+                            lines.join('\n') +
+                            `\nusage: /rewind <id>: restore files to that checkpoint\n` +
+                            `       forge checkpoint restore <id> --yes: same, from another shell`,
+                    },
+                ]);
+                return;
+            }
+            // Restore requires explicit confirmation: refuse without it.
+            if (arg !== '!') {
+                setMessages((m) => [
+                    ...m,
+                    {
+                        kind: 'status',
+                        id: cryptoId(),
+                        text: `restore requires confirmation. Re-run as: /rewind ${arg} !   (note the trailing '!')`,
+                    },
+                ]);
+                return;
+            }
+            const targetId = task.replace(/^\/rewind\s+/, '').replace(/\s+!\s*$/, '').trim();
+            const result = await store.restore(targetId);
+            if (!result) {
+                setMessages((m) => [
+                    ...m,
+                    { kind: 'status', id: cryptoId(), text: `checkpoint "${targetId}" not found` },
+                ]);
+                return;
+            }
+            const parts = [];
+            if (result.restored.length > 0)
+                parts.push(`${result.restored.length} restored`);
+            if (result.modified.length > 0)
+                parts.push(`${result.modified.length} modified`);
+            if (result.removed.length > 0)
+                parts.push(`${result.removed.length} removed`);
+            setMessages((m) => [
+                ...m,
+                { kind: 'status', id: cryptoId(), text: `restored ${targetId}: ${parts.join(', ') || 'no changes'}` },
+            ]);
+            return;
+        }
+        // Plan-mode approval flow.
+        if (pendingPlan !== null) {
+            const action = task.toLowerCase();
+            if (action === 'a' || action === 'approve') {
+                const approvedPlan = pendingPlan;
+                const approvedTask = pendingPlanTask ?? task;
+                setPendingPlan(null);
+                setPendingPlanTask(null);
+                await runWithPlan(approvedTask, approvedPlan);
+                return;
+            }
+            if (action === 'c' || action === 'cancel') {
+                setPendingPlan(null);
+                setPendingPlanTask(null);
+                setMessages((m) => [
+                    ...m,
+                    { kind: 'status', id: cryptoId(), text: 'plan cancelled.' },
+                ]);
+                return;
+            }
+            if (action === 'e' || action === 'edit') {
+                // User wants to edit the plan: the NEXT input they type becomes
+                // the edited plan. We signal this with a sentinel value.
+                setMessages((m) => [
+                    ...m,
+                    { kind: 'status', id: cryptoId(), text: 'enter the edited plan (empty line to cancel):' },
+                ]);
+                setPendingPlan('\u0001edit\u0001');
+                return;
+            }
+            // Sentinel: we're capturing the next input as the edited plan.
+            if (pendingPlan === '\u0001edit\u0001') {
+                if (!task.trim()) {
+                    setPendingPlan(null);
+                    setPendingPlanTask(null);
+                    setMessages((m) => [...m, { kind: 'status', id: cryptoId(), text: 'edit cancelled.' }]);
+                    return;
+                }
+                setPendingPlan(task);
+                setMessages((m) => [
+                    ...m,
+                    { kind: 'status', id: cryptoId(), text: 'edited plan saved. approve (a) or cancel (c)?' },
+                ]);
+                return;
+            }
+            // Unknown action while a real plan is pending.
+            setMessages((m) => [
+                ...m,
+                { kind: 'status', id: cryptoId(), text: 'enter: a (approve), e (edit), c (cancel)' },
+            ]);
+            return;
+        }
+        // Spec-mode approval flow. Mirrors the plan-mode block above, except
+        // "approve" writes the three documents to disk via SpecStore instead
+        // of re-running the task: spec approval is terminal, per design
+        // decision #5 (no auto-chain into execution). Positioned before the
+        // /plan and /spec slash-command checks below: same precedence as
+        // pendingPlan above it: so a stray /plan or /spec while a spec
+        // review is pending falls through to "enter: a/e/c" instead of
+        // silently starting a new run.
+        if (pendingSpec !== null) {
+            const action = task.toLowerCase();
+            if (action === 'a' || action === 'approve') {
+                try {
+                    const sections = splitSpecSections(pendingSpec);
+                    const specTask = pendingSpecTask ?? task;
+                    const id = slugifyTaskForSpecId(specTask);
+                    const store = new SpecStore(process.cwd());
+                    const summary = await store.approve(id, specTask, sections);
+                    setPendingSpec(null);
+                    setPendingSpecTask(null);
+                    setMessages((m) => [
+                        ...m,
+                        {
+                            kind: 'status',
+                            id: cryptoId(),
+                            text: `✓ spec approved → ${summary.dir}\n  requirements.md, design.md, tasks.md written.`,
+                        },
+                    ]);
+                }
+                catch (err) {
+                    // Splitting failed (e.g. an edit removed a section header): 
+                    // keep pendingSpec set so the user can fix it with 'e' rather
+                    // than losing their edit.
+                    setMessages((m) => [
+                        ...m,
+                        {
+                            kind: 'status',
+                            id: cryptoId(),
+                            text: `error: ${err.message}\nFix with e (edit) or discard with c (cancel).`,
+                            isError: true,
+                        },
+                    ]);
+                }
+                return;
+            }
+            if (action === 'c' || action === 'cancel') {
+                setPendingSpec(null);
+                setPendingSpecTask(null);
+                setMessages((m) => [
+                    ...m,
+                    { kind: 'status', id: cryptoId(), text: 'spec cancelled: nothing written to disk.' },
+                ]);
+                return;
+            }
+            if (action === 'e' || action === 'edit') {
+                setMessages((m) => [
+                    ...m,
+                    { kind: 'status', id: cryptoId(), text: 'enter the edited spec text (empty line to cancel):' },
+                ]);
+                setPendingSpec('\u0001edit\u0001');
+                return;
+            }
+            if (pendingSpec === '\u0001edit\u0001') {
+                if (!task.trim()) {
+                    setPendingSpec(null);
+                    setPendingSpecTask(null);
+                    setMessages((m) => [...m, { kind: 'status', id: cryptoId(), text: 'edit cancelled.' }]);
+                    return;
+                }
+                setPendingSpec(task);
+                setMessages((m) => [
+                    ...m,
+                    { kind: 'status', id: cryptoId(), text: 'edited spec saved. approve (a) or cancel (c)?' },
+                ]);
+                return;
+            }
+            setMessages((m) => [
+                ...m,
+                { kind: 'status', id: cryptoId(), text: 'enter: a (approve), e (edit), c (cancel)' },
+            ]);
+            return;
+        }
+        if (task.startsWith('/plan')) {
+            const planTask = task.replace(/^\/plan\s*/, '').trim();
+            if (!planTask) {
+                setMessages((m) => [
+                    ...m,
+                    { kind: 'status', id: cryptoId(), text: 'usage: /plan <task to plan>' },
+                ]);
+                return;
+            }
+            await runInPlanMode(planTask);
+            return;
+        }
+        if (task.startsWith('/spec')) {
+            const specTask = task.replace(/^\/spec\s*/, '').trim();
+            if (!specTask) {
+                setMessages((m) => [
+                    ...m,
+                    { kind: 'status', id: cryptoId(), text: 'usage: /spec <task to design>' },
+                ]);
+                return;
+            }
+            await runInSpecMode(specTask);
+            return;
+        }
+        if (task === '/compact') {
+            await compactNow();
+            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)) {
+            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;
+            try {
+                if (name === 'model' || name === 'weak-model') {
+                    const weak = name === 'weak-model';
+                    if (!args) {
+                        say(weak ? `weak model: ${weakModel ? describeModel(weakModel) : '(none; --cheap-model or /weak-model <model>)'}` : `model: ${describeModel(model)}`);
+                        return;
+                    }
+                    const res = switchModel(args, model, aliases);
+                    if (!res.ok) {
+                        say(res.error, true);
+                        return;
+                    }
+                    const next = weak ? model : res.model;
+                    const cheap = weak ? res.model : weakModel;
+                    if (weak)
+                        setWeakModel(res.model);
+                    else
+                        setModel(res.model);
+                    agentConfigRef.current = {
+                        ...agentConfigRef.current,
+                        model: next,
+                        ...(cheap ? { modelRouter: createExploreEditRouter({ strong: next, cheap }) } : {}),
+                    };
+                    say(weak ? `weak model → ${describeModel(res.model)} (read-only exploration steps and commit messages)` : `model → ${describeModel(res.model)}`);
+                    return;
+                }
+                if (name === 'models') {
+                    say(formatModels(aliases, args));
+                    return;
+                }
+                if (name === 'ls') {
+                    const { editable, readOnly } = chatFilesRef.current.list();
+                    say(editable.length + readOnly.length === 0
+                        ? 'no files attached (/add <file>, /read-only <file>)'
+                        : [...editable.map((f) => `  ${f}`), ...readOnly.map((f) => `  ${f} (read-only)`)].join('\n'));
+                    return;
+                }
+                if (name === 'add' || name === 'read-only') {
+                    const res = await chatFilesRef.current.add(args, name === 'add' ? 'editable' : 'read-only');
+                    const lines = [
+                        ...(res.added.length > 0 ? [`attached ${res.added.join(', ')}${name === 'read-only' ? ' (read-only)' : ''}`] : []),
+                        ...res.errors,
+                    ];
+                    say(lines.join('\n'), res.added.length === 0);
+                    return;
+                }
+                if (name === 'drop') {
+                    const res = chatFilesRef.current.drop(args);
+                    const lines = [
+                        ...(res.dropped.length > 0 ? [`detached ${res.dropped.join(', ')}`] : args ? [] : ['nothing attached']),
+                        ...res.notFound.map((f) => `${f}: not attached`),
+                    ];
+                    say(lines.join('\n'), res.dropped.length === 0 && args !== '');
+                    return;
+                }
+                if (name === 'reset') {
+                    chatFilesRef.current.drop('');
+                    pendingNotesRef.current = [];
+                    historyRef.current = [];
+                    setMessages([]);
+                    say('detached all files and cleared the conversation');
+                    return;
+                }
+                if (name === 'tokens') {
+                    say(formatTokens({
+                        inputTokens,
+                        outputTokens,
+                        costUsd,
+                        model,
+                        contextTokens: estimateContextTokens(historyRef.current),
+                        attachedFiles: chatFilesRef.current.size,
+                    }));
+                    return;
+                }
+                if (name === 'settings') {
+                    const c = agentConfigRef.current;
+                    say([
+                        `model: ${describeModel(model)}${weakModel ? `   weak model: ${describeModel(weakModel)}` : ''}`,
+                        `mode: ${c.auto ? 'autonomous' : 'interactive'}   max iterations: ${c.maxIterations ?? 50}   cwd: ${cwd}`,
+                        `repo map: ${c.repoMap?.tokens ? `${c.repoMap.tokens} tokens` : 'off'}   auto-lint: ${c.autoLint ? 'on' : 'off'}   auto-commit: ${gitWorkflow ? 'on' : 'off'}`,
+                        `verify: ${c.verify?.commands.length ? c.verify.commands.join(' && ') : 'off'}`,
+                        `attached files: ${chatFilesRef.current.size}   session: ${currentSessionId}`,
+                    ].join('\n'));
+                    return;
+                }
+                if (name === 'ok') {
+                    setMessages((m) => [...m, { kind: 'user', id: cryptoId(), text: OK_TASK }]);
+                    await runAgent(OK_TASK, { planMode: false });
+                    return;
+                }
+                if (name === 'lint') {
+                    const aut = agentConfigRef.current.autoLint ?? { syntax: true };
+                    const named = args ? args.split(/\s+/).filter(Boolean) : [];
+                    const targets = named.length > 0 ? named : [...new Set([...chatFilesRef.current.focusFiles(), ...(await isGitRepo(cwd) ? await changedFiles(cwd) : [])])];
+                    if (targets.length === 0) {
+                        say('nothing to lint: attach files with /add, or have uncommitted changes');
+                        return;
+                    }
+                    setRunning(true);
+                    setStatus('running');
+                    const problems = [];
+                    try {
+                        for (const file of targets) {
+                            const rep = await lintFile(file, aut, { cwd });
+                            problems.push(...rep.problems);
+                        }
+                    }
+                    finally {
+                        setRunning(false);
+                        setStatus('idle');
+                    }
+                    if (problems.length === 0) {
+                        say(`lint clean (${targets.length} file${targets.length === 1 ? '' : 's'})`);
+                        return;
+                    }
+                    const report = problems.join('\n');
+                    say(`✘ lint: ${problems.length} problem${problems.length === 1 ? '' : 's'}\n${report}`, true);
+                    const fix = `Linting found problems. Fix them:\n\n${report}`;
+                    setMessages((m) => [...m, { kind: 'user', id: cryptoId(), text: fix }]);
+                    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);
+                    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)');
+                    return;
+                }
+                if (result.exitCode === 0)
+                    return;
+                const fix = fixTask('test', command, result);
+                setMessages((m) => [...m, { kind: 'user', id: cryptoId(), text: fix }]);
+                await runAgent(fix, { planMode: false });
+            }
+            catch (err) {
+                setRunning(false);
+                setStatus('idle');
+                say(`/${name}: ${err.message}`, true);
+            }
+            return;
+        }
+        if (task === '/map' || task === '/map-refresh') {
+            const say = (text, isError) => setMessages((m) => [...m, { kind: 'status', id: cryptoId(), text, ...(isError ? { isError } : {}) }]);
+            const cwd = agentConfigRef.current.cwd ?? process.cwd();
+            try {
+                // /map-refresh drops the cached symbol index so every file is parsed again.
+                if (task === '/map-refresh')
+                    await rm(path.join(cwd, '.forge', 'index', 'symbols.json'), { force: true });
+                const map = await buildRepoMap(cwd, { tokens: agentConfigRef.current.repoMap?.tokens });
+                say(map.text ? `${map.text}\n\n(${map.files.length} file${map.files.length === 1 ? '' : 's'}, ~${map.tokens} tokens)` : 'no source files to map');
+            }
+            catch (err) {
+                say(`${task}: ${err.message}`, true);
+            }
+            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();
+            try {
+                if (!(await isGitRepo(cwd))) {
+                    say(`${task}: ${cwd} is not a git repository`, true);
+                    return;
+                }
+                if (task === '/undo') {
+                    const result = await undoLastForgeCommit(cwd);
+                    say(result.ok
+                        ? `undid ${result.commit.slice(0, 7)} ${result.message.split('\n')[0]} (${result.files.length} file${result.files.length === 1 ? '' : 's'} restored)`
+                        : result.reason, !result.ok);
+                    return;
+                }
+                const files = await changedFiles(cwd);
+                if (files.length === 0) {
+                    say('no uncommitted changes');
+                    return;
+                }
+                const diff = await diffForFiles(cwd, files);
+                if (task === '/diff') {
+                    say(diff.trim() || `${files.length} changed file(s), no textual diff:\n${files.join('\n')}`);
+                    return;
+                }
+                const message = await generateCommitMessage(diff, files, weakModel ?? commitModel ?? model);
+                const commit = await commitFiles(cwd, files, message, gitCommitOptions(gitOptions));
+                say(commit ? formatCommitLine(commit) : 'nothing to commit');
+            }
+            catch (err) {
+                say(`${task}: ${err.message}`, true);
+            }
+            return;
+        }
+        const userMessageId = cryptoId();
+        setMessages((m) => [...m, { kind: 'user', id: userMessageId, text: task }]);
+        await runAgent(task, { planMode: false });
+    }, [
+        running,
+        onExit,
+        inputTokens,
+        outputTokens,
+        currentSessionId,
+        currentLabel,
+        model,
+        sessionDir,
+        costUsd,
+        pendingPlan,
+        pendingSpec,
+    ]);
+    /**
+     * 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.
+     *
+     * Declared as a regular function (not `useCallback`) so it can be
+     * referenced by `handleSubmit` below: function declarations are hoisted
+     * while `const` callbacks are not.
+     */
+    async function runAgent(task, options) {
+        setRunning(true);
+        setStatus('running');
+        const controller = new AbortController();
+        abortControllerRef.current = controller;
+        const approvals = new Map();
+        const overrides = {
+            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] } } : {}),
+        };
+        const localConfig = {
+            ...agentConfigRef.current,
+            ...overrides,
+            checkpoints: agentConfigRef.current.checkpoints ?? sessionCheckpointsConfig(sessionDir, currentSessionId, agentConfigRef.current.cwd ?? process.cwd()),
+            abortSignal: controller.signal,
+            approve: (req) => new Promise((resolve) => {
+                approvals.set(req.id, resolve);
+                setPendingApproval({ request: req, resolve });
+            }),
+        };
+        // Attached files are re-read every turn; /run output is handed over once.
+        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');
+        if (localConfig.repoMap && chatFilesRef.current.size > 0) {
+            localConfig.repoMap = { ...localConfig.repoMap, focusFiles: chatFilesRef.current.focusFiles() };
+        }
+        const agent = new Agent(localConfig);
+        const gitRun = gitWorkflow && !options.planMode && !options.specMode ? gitWorkflow : null;
+        if (gitRun) {
+            const saved = await gitRun.before().catch(() => null);
+            if (saved)
+                setMessages((m) => [...m, { kind: 'status', id: cryptoId(), text: `${formatCommitLine(saved)} (your earlier changes)` }]);
+        }
+        const messageIdsByToolCallId = new Map();
+        let agentRunResult;
+        try {
+            agentRunResult = await agent.run({
+                task,
+                ...(turnContext ? { context: turnContext } : {}),
+                history: historyRef.current,
+                abortSignal: controller.signal,
+                onEvent: (event) => {
+                    switch (event.type) {
+                        case 'iteration':
+                            setIter(event.iteration);
+                            setMaxIter(event.maxIterations);
+                            break;
+                        case 'text_delta': {
+                            setMessages((prev) => {
+                                const idx = prev.findIndex((m) => m.kind === 'assistant' && m.streaming);
+                                if (idx === -1) {
+                                    return [
+                                        ...prev,
+                                        {
+                                            kind: 'assistant',
+                                            id: cryptoId(),
+                                            text: event.text,
+                                            streaming: true,
+                                        },
+                                    ];
+                                }
+                                const copy = prev.slice();
+                                const cur = copy[idx];
+                                copy[idx] = { ...cur, text: (cur.text ?? '') + event.text };
+                                return copy;
+                            });
+                            break;
+                        }
+                        case 'text_done': {
+                            setMessages((prev) => {
+                                const idx = prev.findIndex((m) => m.kind === 'assistant' && m.streaming);
+                                if (idx === -1) {
+                                    return [
+                                        ...prev,
+                                        {
+                                            kind: 'assistant',
+                                            id: cryptoId(),
+                                            text: event.text,
+                                        },
+                                    ];
+                                }
+                                const copy = prev.slice();
+                                copy[idx] = { ...copy[idx], text: event.text, streaming: false };
+                                return copy;
+                            });
+                            break;
+                        }
+                        case 'reasoning_delta': {
+                            setMessages((prev) => {
+                                const idx = prev.findIndex((m) => m.kind === 'reasoning' && m.streaming);
+                                if (idx === -1) {
+                                    return [...prev, { kind: 'reasoning', id: cryptoId(), text: event.text, streaming: true }];
+                                }
+                                const copy = prev.slice();
+                                const cur = copy[idx];
+                                copy[idx] = { ...cur, text: (cur.text ?? '') + event.text };
+                                return copy;
+                            });
+                            break;
+                        }
+                        case 'reasoning_done': {
+                            setMessages((prev) => {
+                                const idx = prev.findIndex((m) => m.kind === 'reasoning' && m.streaming);
+                                if (idx === -1)
+                                    return prev;
+                                const copy = prev.slice();
+                                copy[idx] = { ...copy[idx], text: event.text, streaming: false };
+                                return copy;
+                            });
+                            break;
+                        }
+                        case 'plan': {
+                            // Plan-mode result: render the plan and set pendingPlan so
+                            // the user can approve / edit / cancel.
+                            setMessages((prev) => [
+                                ...prev,
+                                {
+                                    kind: 'status',
+                                    id: cryptoId(),
+                                    text: `📋 plan:\n\n${event.plan}`,
+                                },
+                            ]);
+                            setPendingPlan(event.plan);
+                            setPendingPlanTask(task);
+                            break;
+                        }
+                        case 'spec': {
+                            // Spec-mode result: render the raw three-section text and
+                            // set pendingSpec so the user can approve / edit / cancel.
+                            setMessages((prev) => [
+                                ...prev,
+                                {
+                                    kind: 'status',
+                                    id: cryptoId(),
+                                    text: `📐 spec drafted:\n\n${event.spec}`,
+                                },
+                            ]);
+                            setPendingSpec(event.spec);
+                            setPendingSpecTask(task);
+                            break;
+                        }
+                        case 'tool_call': {
+                            const id = cryptoId();
+                            messageIdsByToolCallId.set(event.id, id);
+                            setMessages((prev) => [
+                                ...prev,
+                                {
+                                    kind: 'tool_call',
+                                    id,
+                                    toolName: event.name,
+                                    toolArgs: event.args,
+                                },
+                            ]);
+                            break;
+                        }
+                        case 'tool_result': {
+                            if (event.redacted !== undefined && event.redacted > 0) {
+                                redactionsRef.current += event.redacted;
+                                setRedactedCount(redactionsRef.current);
+                                setMessages((prev) => [
+                                    ...prev,
+                                    {
+                                        kind: 'status',
+                                        id: cryptoId(),
+                                        text: `🔒 ${event.redacted} secret${event.redacted === 1 ? '' : 's'} redacted from ${event.name} result`,
+                                    },
+                                ]);
+                            }
+                            setMessages((prev) => {
+                                const id = messageIdsByToolCallId.get(event.id);
+                                if (!id)
+                                    return prev;
+                                return [
+                                    ...prev,
+                                    {
+                                        kind: 'tool_result',
+                                        id: cryptoId(),
+                                        toolName: event.name,
+                                        toolResult: event.result,
+                                        isError: event.isError,
+                                    },
+                                ];
+                            });
+                            break;
+                        }
+                        case 'approval_requested':
+                            break;
+                        case 'usage':
+                            tokensRef.current.input = event.inputTokens;
+                            tokensRef.current.output = event.outputTokens;
+                            setInputTokens(event.inputTokens);
+                            setOutputTokens(event.outputTokens);
+                            break;
+                        case 'cost':
+                            costRef.current = event.runningCostUsd;
+                            setCostUsd(event.runningCostUsd);
+                            break;
+                        case 'cache_stats':
+                            setCacheHits(event.hits);
+                            setCacheMisses(event.misses);
+                            break;
+                        case 'compaction':
+                            setMessages((prev) => [
+                                ...prev,
+                                {
+                                    kind: 'status',
+                                    id: cryptoId(),
+                                    text: `🗜 compacted ${event.droppedCount} older turn${event.droppedCount === 1 ? '' : 's'} (saved ~${event.savedTokens} tokens)`,
+                                },
+                            ]);
+                            break;
+                        case 'steering':
+                            setMessages((prev) => [...prev, { kind: 'status', id: cryptoId(), text: formatSteeringLine(event) }]);
+                            break;
+                        case 'verify':
+                            setMessages((prev) => [
+                                ...prev,
+                                {
+                                    kind: 'status',
+                                    id: cryptoId(),
+                                    text: event.passed
+                                        ? `✔ verification passed (pass ${event.attempt})`
+                                        : `✘ verification failed (pass ${event.attempt}): ${event.failedCommands.join(', ')}`,
+                                },
+                            ]);
+                            break;
+                        case 'lint':
+                            if (!event.passed) {
+                                setMessages((prev) => [
+                                    ...prev,
+                                    { kind: 'status', id: cryptoId(), text: `✘ lint: ${event.problems} problem${event.problems === 1 ? '' : 's'} in ${event.path}` },
+                                ]);
+                            }
+                            break;
+                        case 'model_route':
+                            setMessages((prev) => [
+                                ...prev,
+                                { kind: 'status', id: cryptoId(), text: `⇄ step ${event.iteration} → ${event.provider}/${event.model}` },
+                            ]);
+                            break;
+                        case 'error':
+                            setMessages((prev) => [
+                                ...prev,
+                                { kind: 'status', id: cryptoId(), text: `error: ${event.error}`, isError: true },
+                            ]);
+                            break;
+                        case 'done':
+                            setStatus(event.reason === 'error' ? 'error' : 'done');
+                            setMessages((prev) => [
+                                ...prev,
+                                {
+                                    kind: 'status',
+                                    id: cryptoId(),
+                                    text: `done (${event.reason})`,
+                                    inputTokens,
+                                    outputTokens,
+                                },
+                            ]);
+                            break;
+                    }
+                },
+            });
+        }
+        catch (err) {
+            setMessages((prev) => [
+                ...prev,
+                { kind: 'status', id: cryptoId(), text: `error: ${err.message}`, isError: true },
+            ]);
+            setStatus('error');
+        }
+        finally {
+            setRunning(false);
+            setPendingApproval(null);
+            approvals.clear();
+            if (abortControllerRef.current === controller)
+                abortControllerRef.current = null;
+        }
+        notify?.(agentRunResult ? `Forge finished (${agentRunResult.reason}) - waiting for you` : 'Forge stopped - waiting for you');
+        if (gitRun && agentRunResult?.reason === 'completed') {
+            const commit = await gitRun.after(task).catch(() => null);
+            if (commit)
+                setMessages((m) => [...m, { kind: 'status', id: cryptoId(), text: formatCommitLine(commit) }]);
+        }
+        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;
+            if (historyRef.current.length > 0 && !options.planMode && !options.specMode) {
+                const savedPath = await persistSession({
+                    id: currentSessionId,
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                    ...(currentLabel ? { label: currentLabel } : {}),
+                    cwd: process.cwd(),
+                    model,
+                    messages: historyRef.current,
+                    totalInputTokens: tokensRef.current.input,
+                    totalOutputTokens: tokensRef.current.output,
+                    totalCostUsd: costRef.current,
+                    costKnown: costUsd !== undefined,
+                });
+                if (!savedPath) {
+                    setMessages((m) => [
+                        ...m,
+                        {
+                            kind: 'status',
+                            id: cryptoId(),
+                            text: `warning: auto-save failed (couldn't write ${currentSessionId}.json)`,
+                            isError: true,
+                        },
+                    ]);
+                }
+            }
+        }
+    }
+    /** Run the agent in plan mode for a task. */
+    function runInPlanMode(planTask) {
+        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) {
+        setMessages((m) => [
+            ...m,
+            { kind: 'status', id: cryptoId(), text: '✓ plan approved: executing…' },
+            { kind: 'user', id: cryptoId(), text: realTask },
+        ]);
+        return runAgent(realTask, { planMode: false, planContext: plan });
+    }
+    /**
+     * Run the agent in spec mode for a task. Unlike `runWithPlan`, there is
+     * no re-run-on-approve counterpart: spec approval writes files directly
+     * via `SpecStore.approve` in the pendingSpec branch above, with no
+     * second agent run: spec approval is terminal (design decision #5).
+     */
+    function runInSpecMode(specTask) {
+        setMessages((m) => [...m, { kind: 'user', id: cryptoId(), text: `/spec ${specTask}` }]);
+        return runAgent(specTask, { planMode: false, specMode: true });
+    }
+    /**
+     * Force a compaction pass now. Useful in long sessions where the user
+     * wants to free context space before the next turn. Uses the agent's
+     * configured summarizer (default: the same model the agent runs on).
+     */
+    async function compactNow() {
+        if (historyRef.current.length <= 2) {
+            setMessages((m) => [
+                ...m,
+                { kind: 'status', id: cryptoId(), text: 'nothing to compact (history too short)' },
+            ]);
+            return;
+        }
+        setRunning(true);
+        setStatus('running');
+        try {
+            const summarizer = agentConfigRef.current.modelFactory
+                ? await import('@ikarmic/forge-core').then((m) => m.buildLlmSummarizer(agentConfigRef.current.compactionModel ?? agentConfigRef.current.model, agentConfigRef.current.modelFactory))
+                : await import('@ikarmic/forge-core').then((m) => m.buildLlmSummarizer(agentConfigRef.current.compactionModel ?? agentConfigRef.current.model));
+            const result = await (await import('@ikarmic/forge-core')).compactMessages(historyRef.current, summarizer, {
+                keepRecent: agentConfigRef.current.compactionKeepRecent,
+            });
+            if (result.droppedCount > 0) {
+                historyRef.current = result.messages;
+                setMessages((m) => [
+                    ...m,
+                    {
+                        kind: 'status',
+                        id: cryptoId(),
+                        text: `🗜 compacted ${result.droppedCount} older turn${result.droppedCount === 1 ? '' : 's'} (saved ~${result.savedTokens} tokens)`,
+                    },
+                ]);
+            }
+            else {
+                setMessages((m) => [
+                    ...m,
+                    { kind: 'status', id: cryptoId(), text: 'nothing to compact (everything is recent)' },
+                ]);
+            }
+        }
+        catch (err) {
+            setMessages((m) => [
+                ...m,
+                { kind: 'status', id: cryptoId(), text: `compact failed: ${err.message}`, isError: true },
+            ]);
+        }
+        finally {
+            setStatus('idle');
+            setRunning(false);
+        }
+    }
+    const handleApproval = useCallback((approved) => {
+        if (pendingApproval) {
+            pendingApproval.resolve(approved);
+            setPendingApproval(null);
+        }
+    }, [pendingApproval]);
+    // Esc cancels the in-flight turn. Only active while a turn is running
+    // (Approval.tsx handles Escape itself during an approval prompt, and
+    // TextInput owns input while idle).
+    useInput((_input, key) => {
+        if (key.escape)
+            abortControllerRef.current?.abort();
+    }, { isActive: running });
+    useEffect(() => {
+        // Welcome banner
+        setMessages([
+            {
+                kind: 'status',
+                id: cryptoId(),
+                text: `Interactive REPL - type a task and press Enter. Type /help for the slash commands`,
+            },
+        ]);
+    }, []);
+    return (React.createElement(Box, { flexDirection: "column", paddingX: 1 },
+        React.createElement(Header, { model: model, iteration: iter, maxIterations: maxIter, status: status, auto: baseConfig.auto ?? false }),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1, flexGrow: 1 },
+            messages.map((m) => (React.createElement(MessageView, { key: m.id, message: m, display: display }))),
+            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(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(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "gray" },
+                "\u2191",
+                inputTokens,
+                " \u2193",
+                outputTokens,
+                " tokens",
+                costUsd !== undefined && (React.createElement(React.Fragment, null,
+                    ' · ',
+                    React.createElement(Text, { color: "green" }, costUsd < 0.01 ? '$' + costUsd.toFixed(4) : '$' + costUsd.toFixed(3)))),
+                redactedCount > 0 && (React.createElement(React.Fragment, null,
+                    ' · ',
+                    React.createElement(Text, { color: "red" },
+                        "\uD83D\uDD12 ",
+                        redactedCount))),
+                ' · ',
+                running ? 'busy' : 'ready'))));
+}
+function MessageView({ message, display, }) {
+    switch (message.kind) {
+        case 'user':
+            return (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+                React.createElement(Text, { color: "gray" }, "\u250C\u2500 you"),
+                React.createElement(Box, { marginLeft: 2 },
+                    React.createElement(Text, null, message.text))));
+        case 'assistant':
+            return (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+                React.createElement(Text, { color: "gray" }, "\u251C\u2500 forge"),
+                React.createElement(Box, { marginLeft: 2 },
+                    React.createElement(Text, null,
+                        message.text,
+                        message.streaming ? '▌' : ''))));
+        case 'reasoning':
+            if (display?.showReasoning === false)
+                return null;
+            return (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+                React.createElement(Text, { color: "gray" }, "\u251C\u2500 reasoning"),
+                React.createElement(Box, { marginLeft: 2 },
+                    React.createElement(Text, { color: "gray" },
+                        message.text,
+                        message.streaming ? '▌' : ''))));
+        case 'tool_call':
+            return (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { color: "blue", bold: true },
+                    "\u25CC ",
+                    message.toolName),
+                React.createElement(Text, { color: "gray" },
+                    " ",
+                    summarizeArgs(message.toolArgs))));
+        case 'tool_result': {
+            const diffText = getUnifiedDiffText(message.toolName, message.toolArgs, message.toolResult);
+            return (React.createElement(Box, { marginLeft: 2, flexDirection: "column" },
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: message.isError ? 'red' : 'green', bold: true },
+                        message.isError ? '✗' : '✓',
+                        " ",
+                        message.toolName)),
+                diffText && (React.createElement(Box, { flexDirection: "column", marginLeft: 2 }, diffText.replace(/\n$/, '').split('\n').map((line, i) => (React.createElement(Text, { key: i, color: line.startsWith('+') ? 'green' : line.startsWith('-') ? 'red' : 'gray' }, line))))),
+                !diffText && message.toolResult !== undefined && (React.createElement(Box, { marginLeft: 2 },
+                    React.createElement(Text, { color: message.isError ? 'red' : 'gray' }, summarizeToolResult(message.toolResult, message.isError, display?.detail ?? 'compact'))))));
+        }
+        case 'status':
+            return (React.createElement(Box, { marginLeft: 2, marginTop: 1 },
+                React.createElement(Text, { color: message.isError ? 'red' : 'gray' },
+                    message.text,
+                    message.inputTokens !== undefined && ` · ↑${message.inputTokens} ↓${message.outputTokens}`)));
+    }
+}
+function summarizeArgs(args) {
+    if (args === undefined || args === null)
+        return '()';
+    const obj = args;
+    if (typeof obj !== 'object')
+        return `(${String(args)})`;
+    const keys = Object.keys(obj);
+    if (keys.length === 0)
+        return '()';
+    return `(${keys
+        .slice(0, 3)
+        .map((k) => `${k}=${shortVal(obj[k])}`)
+        .join(' ')}${keys.length > 3 ? ` +${keys.length - 3}` : ''})`;
+}
+function summarizeResult(result) {
+    let text;
+    if (typeof result === 'string') {
+        text = result;
+    }
+    else {
+        try {
+            text = JSON.stringify(result);
+        }
+        catch {
+            text = String(result);
+        }
+    }
+    if (text.length > 240)
+        text = text.slice(0, 240) + '…';
+    return text;
+}
+function shortVal(v) {
+    const s = typeof v === 'string' ? JSON.stringify(v) : JSON.stringify(v);
+    return s.length > 40 ? s.slice(0, 37) + '…' : s;
+}
+async function persistSession(s) {
+    try {
+        return await saveSession(s, defaultSessionDir());
+    }
+    catch {
+        return null;
+    }
+}
+let _id = 0;
+function cryptoId() {
+    _id++;
+    return `${Date.now().toString(36)}-${_id}`;
+}
+/**
+ * Build a CoreMessage history from the agent run. Removed in favor of
+ * snapshotting the final `messages` array directly from `Agent.run()`. Kept
+ * here as a placeholder for future session-export functionality.
+ */
+function _unusedBuildHistory(_initial, _agent, _task) {
+    return [];
+}
+void _unusedBuildHistory;
+//# sourceMappingURL=repl.js.map