deepclause-sdk 0.1.2 → 0.2.1

package/dist/cli/repl.js

@@ -14,14 +14,25 @@ import { createHarnessRepl } from '../repl/index.js';
 import { HistoryStore } from '../repl/history.js';
 import { resolveReplJudgeSelection } from '../repl/judge.js';
 import { ReplRenderer } from '../repl/render.js';
+import { TranscriptDocument } from '../repl/tui/document.js';
+import { ServicesPanel } from '../repl/tui/services-panel.js';
+import { formatProcessCode, formatProcessTable } from '../repl/harness-tools.js';
+import { ChoicePicker } from '../repl/tui/picker.js';
+import { openPiRuntime } from '../repl/backend.js';
+import { listLoginProviders, loginToProvider } from '../repl/auth.js';
+import { HarnessView } from '../repl/tui/harness-view.js';
+import { TuiRenderer } from '../repl/tui/renderer.js';
+import { WorkingLine } from '../repl/tui/working-line.js';
+import { createReplAutocomplete } from '../repl/tui/autocomplete.js';
+import { initTuiTheme, scrollbarStyles } from '../repl/tui/theme.js';
+import { SizedTerminal } from '../repl/tui/terminal.js';
 import { ReplStatusTracker } from '../repl/status.js';
-import { LineSink, TranscriptComponent } from '../repl/tui/transcript.js';
 import { StatusBarComponent } from '../repl/tui/status-bar.js';
-import { Container, ProcessTerminal, Spacer, TuiMainScreen, matchesKey } from '@earendil-works/pi-tui';
+import { Container, HStack, ScrollView, Spacer, TuiAltScreen, VStack, matchesKey, } from '@earendil-works/pi-tui';
 import { editorTheme, formatInputAnswer } from '../repl/tui/theme.js';
 import { PromptEditor } from '../repl/tui/editor.js';
 import { loadProjectContext } from '../repl/project-context.js';
-import { createPiBackend } from '../repl/backend.js';
+import { createPiBackend, THINKING_LEVELS } from '../repl/backend.js';
 import { createReplToolset } from '../repl/toolset.js';
 import { takeStartupPrologMessages } from '../prolog/loader.js';
 import { createPiImageBackend } from '../repl/imagegen.js';
@@ -71,6 +82,13 @@ export function parseVizArgs(arg) {
 export function formatTurnInput(turn) {
     return turn.mode === 'goal' ? `/goal ${turn.request}` : turn.request;
 }
+/**
+ * Slash commands are executed (or queued), never steered into a running model
+ * turn: `/send`, `/call`, `/ps`, `/stop` … address processes, not the model.
+ */
+export function isSlashCommand(line) {
+    return line.trim().startsWith('/');
+}
 /**
  * Classify one REPL input line.
  *
@@ -113,6 +131,15 @@ export function classifyReplInput(line) {
                 return { kind: 'export', path: arg || undefined };
             case 'model':
                 return { kind: 'model', model: arg || undefined };
+            case 'harness':
+            case 'side':
+                return { kind: 'harness', width: arg || undefined };
+            case 'reasoning':
+            case 'reasoning-level':
+                return { kind: 'reasoning', level: arg || undefined };
+            case 'show-reasoning':
+            case 'reasoning-summary':
+                return { kind: 'show-reasoning' };
             case 'freeze':
                 return { kind: 'freeze' };
             case 'unfreeze':
@@ -132,6 +159,36 @@ export function classifyReplInput(line) {
             case 'gen':
             case 'imagine':
                 return arg ? { kind: 'gen', prompt: arg } : { kind: 'unknown-command', name: 'gen (missing prompt)' };
+            case 'spawn':
+            case 'serve':
+                return arg ? { kind: 'spawn', goal: arg } : { kind: 'unknown-command', name: 'spawn (missing goal)' };
+            case 'ps':
+            case 'processes': {
+                const watch = /(?:^|\s)--watch(?:\s|$)/.test(arg);
+                const logs = /(?:^|\s)--logs(?:\s|$)/.test(arg);
+                // `--code` alone shows the current harness version; `--code <target>`
+                // prints the harness snapshot that process is running.
+                const codeMatch = /(?:^|\s)--code(?:=(\S+)|\s+(\S+))?/.exec(arg);
+                const code = codeMatch ? (codeMatch[1] ?? codeMatch[2] ?? '') : undefined;
+                return { kind: 'ps', watch, logs, code };
+            }
+            case 'send':
+            case 'cast': {
+                const [target, ...rest] = arg.split(/\s+/);
+                return target && rest.length > 0
+                    ? { kind: 'send', target, message: rest.join(' ') }
+                    : { kind: 'unknown-command', name: 'send (usage: /send <name> <message>)' };
+            }
+            case 'call': {
+                const [target, ...rest] = arg.split(/\s+/);
+                return target && rest.length > 0
+                    ? { kind: 'call', target, message: rest.join(' ') }
+                    : { kind: 'unknown-command', name: 'call (usage: /call <name> <message>)' };
+            }
+            case 'stop':
+                return arg ? { kind: 'stop', target: arg } : { kind: 'unknown-command', name: 'stop (usage: /stop <name>)' };
+            case 'login':
+                return { kind: 'login' };
             default:
                 return { kind: 'unknown-command', name };
         }
@@ -444,6 +501,7 @@ export async function createReplRuntime(options) {
         modelResolver,
         history: historyOptions,
         harness: harnessName,
+        execution: options.execution,
         autoLoadHarness: !(options.load?.length),
         compaction: { settings: replCompaction, auto: replCompaction.auto },
         contextWindow,
@@ -472,7 +530,7 @@ export async function createReplRuntime(options) {
                 + "or run 'deepclause set-backend pi'.";
         }
     }
-    return {
+    const runtime = {
         repl,
         renderer,
         workspace,
@@ -484,6 +542,10 @@ export async function createReplRuntime(options) {
         backend: backendKind,
         contextWindow,
         reasoning,
+        reasoningMode: options.showReasoning ?? config.repl.showReasoning,
+        modelResolver,
+        llmBackend,
+        setThinkingLevel: (level) => statusTracker.setThinkingLevel(level),
         thinkingLevel,
         sessionId: repl.session.getSessionId(),
         harnessName,
@@ -495,6 +557,23 @@ export async function createReplRuntime(options) {
         setOnInput: (handler) => repl.setOnInput(handler),
         missingCredential,
     };
+    // Session-scoped subagents render their lifecycle and output through the
+    // active renderer (the TUI swaps it in after this runtime is built).
+    repl.session.setProcessEventSink((event) => {
+        const label = `⚙ ${event.name}`;
+        const sink = runtime.renderer;
+        if (event.type === 'output' && event.content) {
+            sink.writeLine(`${label}  ${event.content.trimEnd()}`);
+        }
+        else if (event.type === 'answer') {
+            sink.writeLine(`${label} › ${String(event.answer ?? 'ok')}`);
+        }
+        else if (event.type === 'exited' && event.state !== 'done') {
+            const reason = event.reason && event.reason !== 'normal' ? ` (${String(event.reason)})` : '';
+            sink.writeLine(`${label} ${event.state}${reason}`);
+        }
+    });
+    return runtime;
 }
 /** Package version, read once from package.json for the banner/`--version`. */
 export const PACKAGE_VERSION = (() => {
@@ -546,13 +625,28 @@ async function printBanner(runtime, loaded) {
     if (harnessFresh) {
         lines.push('', `  ${bold('Two modes.')} Plain English authors the harness; ${accent('/goal')} runs DML directly.`, '', `    ${accent('<plain English>')}   default. Ask for anything: add a new skill, add a tool,`, `                      change existing logic, run or test code in the living`, `                      module, or just ask a question about the harness. An authoring`, `                      agent writes the DML, tests it with ${dim('execute')}, and commits it.`, `    ${accent('/goal <dml>')}        run DML/Prolog directly against the current harness.`, '', `  ${bold('Example')}`, `    add a research(Question, Answer) skill that answers with task/2`, `    run research on "why is the sky blue?"`, `    A = "…"`, '', `    ...or run DML directly (${accent('/goal')}):`, `    ${accent('/goal')} research("why is the sky blue?", A).`, `    A = "…"`, '', `  When you're ready, export the harness and re-use it whenever you need:`, `    /export research.dml              save a portable harness`, `    ${dim('$')} deepclause repl -l research.dml    load it back any time`, `    ${dim('$')} deepclause repl --session last   resume the last session`);
     }
-    lines.push('', `  ${accent('/goal')} ${dim('<dml>')}            run a DML goal, e.g. ${dim('/goal member(X, [1,2,3])')}`, `  ${accent('<plain English>')}        author the harness`, '', `  ${accent('/help')}  ${accent('/listing')}  ${accent('/viz')}  ${accent('/export')}  ${accent('/freeze')}  ${accent('/model')}  ${accent('/halt')}`);
+    lines.push('', `  ${accent('/goal')} ${dim('<dml>')}            run a DML goal, e.g. ${dim('/goal member(X, [1,2,3])')}`, `  ${accent('<plain English>')}        author the harness`, `  ${accent('/spawn')} ${dim('<goal>')}           start a session-scoped subagent`, `  ${accent('/ps')} ${dim('[--watch|--logs|--code <pid>]')}  list subagents / inspect a snapshot`, `  ${accent('/send')} ${accent('/call')} ${accent('/stop')}       message, call, or stop a subagent`, '', `  ${accent('/help')}  ${accent('/listing')}  ${accent('/viz')}  ${accent('/export')}  ${accent('/freeze')}  ${accent('/model')}  ${accent('/halt')}`);
     if (runtime.historyEnabled) {
         lines.push(`  ${dim('resume later:')} deepclause repl --session ${runtime.sessionId}`);
     }
     lines.push('');
     runtime.renderer.writeLine(lines.join('\n'));
 }
+/**
+ * Replay a resumed session's prior events so the transcript continues instead of
+ * starting blank. Bounded, and skipped when the session was not resumed or
+ * tracing was off.
+ */
+async function renderResumedSession(runtime) {
+    const events = await runtime.repl.resumedTranscript().catch(() => []);
+    if (events.length === 0)
+        return;
+    runtime.renderer.writeLine('');
+    runtime.renderer.writeLine(`── resumed session ${runtime.sessionId} ──`);
+    for (const event of events)
+        runtime.renderer.render(event);
+    runtime.renderer.writeLine('');
+}
 /** Dispatch one classified input. Returns false when the REPL should exit. */
 export async function dispatchReplInput(runtime, input, options = {}) {
     const { repl, renderer } = runtime;
@@ -561,6 +655,53 @@ export async function dispatchReplInput(runtime, input, options = {}) {
         case 'empty':
         case 'comment':
             return true;
+        case 'spawn': {
+            try {
+                const pid = await repl.session.spawnProcess(input.goal, input.name ? { name: input.name } : {});
+                print(`spawned ${formatProcessTable(repl.session.processes().filter((p) => p.pid.id === pid.id))}`);
+            }
+            catch (error) {
+                print(`ERROR: ${error.message}`);
+            }
+            return true;
+        }
+        case 'ps': {
+            if (input.code !== undefined) {
+                for (const line of formatProcessCode(repl.session, input.code).split('\n'))
+                    print(line);
+                return true;
+            }
+            for (const line of formatProcessTable(repl.session.processes(), repl.session.currentHarnessVersion()).split('\n'))
+                print(line);
+            return true;
+        }
+        case 'send': {
+            try {
+                repl.session.sendProcess(input.target, input.message);
+            }
+            catch (error) {
+                print(`ERROR: ${error.message}`);
+            }
+            return true;
+        }
+        case 'call': {
+            try {
+                const reply = await repl.session.callProcess(input.target, input.message, 60_000);
+                print(`${input.target} › ${reply}`);
+            }
+            catch (error) {
+                print(`ERROR: ${error.message}`);
+            }
+            return true;
+        }
+        case 'stop': {
+            await repl.session.stopProcess(input.target);
+            print(`stopped ${input.target}`);
+            return true;
+        }
+        case 'login':
+            print("sign in from the terminal: deepclause login (or /login in the TUI)");
+            return true;
         case 'unknown-command':
             print(`unknown command: /${input.name} — try /help.`);
             return true;
@@ -739,6 +880,11 @@ function helpText() {
         '                         question. An agent writes, tests, and commits the DML.',
         '',
         '  Commands',
+        '    /spawn <goal>        start a session-scoped subagent (alias /serve)',
+        '    /ps [--watch|--logs|--code <pid>]  list subagents; --watch pins a panel, --logs follows output, --code shows a process harness snapshot',
+        '    /send <name> <msg>   send a DML term to a subagent (alias /cast)',
+        '    /call <name> <msg>   request/reply with a service subagent',
+        '    /stop <name>         stop a subagent',
         '    /listing [filter]    inspect the harness (all | Name/Arity | tools | scripts)',
         '    /viz [entry] [--spec] diagram of a skill, drawn in the terminal',
         '                         (--graphics=auto|kitty|iterm2|ascii|off)',
@@ -750,6 +896,7 @@ function helpText() {
         '    /compact [notes]     compact the authoring memory',
         '    /export [file]       save the harness (use .zip to bundle linked files)',
         '    /model [provider/id] show / set the model',
+        '    /login               sign in to a provider (from the terminal or the TUI)',
         '    /freeze  /unfreeze   read-only lock',
         '    /params              show session parameters',
         '    /trace   /notrace    toggle verbose logging',
@@ -782,18 +929,15 @@ async function executeLoad(runtime, files) {
 }
 /** Non-interactive mode: read classified inputs line by line until EOF. */
 /**
- * Route Ctrl-C to the active turn. While a turn is running the first Ctrl-C
- * aborts it (the session then saves the harness to a temp file); a Ctrl-C while
- * idle exits.
+ * Ctrl-C exits, in every mode: this is the plain/readline path, where there is no
+ * raw key to distinguish Escape from an editing sequence, so the TUI's
+ * "Esc interrupts, Ctrl-C exits" cannot be mirrored exactly. A running turn is
+ * aborted first, so nothing keeps writing after the UI is gone.
  */
-function installSigint(runtime, holder, rl, onExit) {
+function installSigint(holder, rl, onExit) {
     const handler = () => {
-        if (holder.turn) {
-            holder.turn.abort(new Error('cancelled by user'));
-            runtime.renderer.writeErrorLine('(cancelling current turn… press Ctrl-C again to exit)');
-        }
-        else if (onExit) {
-            // Save the harness before exiting (Ctrl-C while idle).
+        holder.turn?.abort(new Error('cancelled by user'));
+        if (onExit) {
             void onExit().finally(() => process.exit(130));
         }
         else {
@@ -811,7 +955,7 @@ async function runNonInteractive(runtime, options, onExit) {
     let exitCode = 0;
     const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
     const holder = { turn: null };
-    const removeSigint = installSigint(runtime, holder, rl, onExit);
+    const removeSigint = installSigint(holder, rl, onExit);
     try {
         for await (const line of rl) {
             const input = classifyReplInput(line);
@@ -881,7 +1025,7 @@ async function runInteractive(runtime, options, onExit) {
         return answer === null ? undefined : answer;
     });
     const holder = { turn: null };
-    const removeSigint = installSigint(runtime, holder, rl, onExit);
+    const removeSigint = installSigint(holder, rl, onExit);
     try {
         while (true) {
             const line = await ask(promptPrefix);
@@ -976,11 +1120,36 @@ export async function runInteractiveGoal(repl, renderer, goal, options, ask, sig
  * input prompts never fight the main prompt for stdin.
  */
 export async function runTui(runtime, options, onExit, loaded = []) {
-    const terminal = new ProcessTerminal();
-    const tui = new TuiMainScreen(terminal);
-    const transcript = new TranscriptComponent();
-    const sink = new LineSink(transcript);
-    const runState = { running: false, steerable: false };
+    initTuiTheme();
+    // Sized, because pi-tui falls back to a hard 24 rows when the stream reports no
+    // size, which leaves the bottom of a taller terminal untouched.
+    const terminal = new SizedTerminal();
+    // Fullscreen: an application-owned viewport (ScrollView) with the editor and
+    // status bar pinned in a dock. In this mode pi-tui hands scrolling, mouse wheel,
+    // text selection and search to the viewport, and reassigns layout on resize —
+    // which is what makes the transcript scroll inside the app and the input box
+    // behave when the terminal changes size.
+    const tui = new TuiAltScreen(terminal, undefined, undefined, {
+        mouse: true,
+        wheelScrollLines: 'auto',
+        copyOnSelect: true,
+    });
+    const document = new TranscriptDocument();
+    const transcript = document;
+    // The TUI renders components rather than lines: tool calls become panes and
+    // streamed text becomes markdown. There is no external sink to wire.
+    const working = new WorkingLine(tui);
+    const renderer = new TuiRenderer({
+        document,
+        onWorking: (label) => {
+            working.set(label);
+            tui.requestRender();
+        },
+    });
+    runtime.renderer = renderer;
+    const runState = { running: false, steerable: false, bufferable: false };
+    /** Slash commands typed during a turn/command, run when it finishes. */
+    const pendingCommands = [];
     /** Lines typed during a goal query, consumed by the solution pager. */
     const bufferedInput = [];
     const statusBar = new StatusBarComponent({
@@ -991,14 +1160,25 @@ export async function runTui(runtime, options, onExit, loaded = []) {
         backend: runtime.backend,
         isFrozen: () => runtime.repl.isFrozen(),
         isRunning: () => runState.running,
+        processLabel: () => {
+            const active = runtime.repl.session
+                .processes()
+                .filter((process) => ['running', 'runnable', 'waiting', 'input'].includes(process.state));
+            if (active.length === 0)
+                return undefined;
+            const attention = active.some((process) => process.state === 'input');
+            return `⚙ ${active.length} svc${attention ? ' !' : ''}`;
+        },
     });
     transcript.onChange = () => tui.requestRender();
-    // Redirect the renderer into the transcript (including error lines).
-    runtime.renderer.setSink((text) => sink.write(text), (text) => sink.write(text));
-    runtime.renderer.setImageSink((lines) => transcript.appendImageLines(lines));
-    runtime.renderer.setWidth(terminal.columns);
+    renderer.setImageSink((lines) => document.appendImageLines(lines));
+    renderer.setWidth(terminal.columns);
+    // pi-tui re-renders on resize but does not invalidate the component tree, and a
+    // component that caches by width (a tool pane, markdown) would draw stale lines.
     const onResize = () => {
-        runtime.renderer.setWidth(terminal.columns);
+        terminal.refreshSize();
+        renderer.setWidth(terminal.columns);
+        tui.invalidate();
         tui.requestRender();
     };
     process.stdout.on('resize', onResize);
@@ -1027,7 +1207,9 @@ export async function runTui(runtime, options, onExit, loaded = []) {
                 }
                 else if (activePrompt === runtime.promptPrefix) {
                     // A user turn: separate it from the previous output and from the
-                    // response that follows; render it as a pi-style blue block.
+                    // response that follows; render it as a pi-style blue block. The previous
+                    // turn's text block is closed first, so the new response starts below this.
+                    runtime.renderer.endTextBlock?.();
                     if (transcript.getLines().length > 0)
                         transcript.append('');
                     transcript.append(text, 'user');
@@ -1037,15 +1219,58 @@ export async function runTui(runtime, options, onExit, loaded = []) {
         }
         else if (text.trim()) {
             // No pending ask means a turn is running.
-            if (runState.steerable) {
+            const trimmed = text.trim();
+            if (isSlashCommand(trimmed)) {
+                // Slash commands are never steering. UI toggles and read-only
+                // snapshots act now; everything else is queued for when the current
+                // turn/command finishes, so /send, /call, /stop … reach the processes
+                // instead of being injected into the model's conversation.
+                const immediate = classifyReplInput(trimmed);
+                transcript.append(trimmed, 'user');
+                if (immediate.kind === 'ps') {
+                    if (immediate.logs) {
+                        const on = !(servicesVisible && servicesLogs);
+                        servicesLogs = on;
+                        servicesVisible = true;
+                    }
+                    else if (immediate.watch) {
+                        servicesVisible = !servicesVisible;
+                    }
+                    else if (immediate.code !== undefined) {
+                        for (const line of formatProcessCode(runtime.repl.session, immediate.code).split('\n')) {
+                            renderer.writeLine(line);
+                        }
+                    }
+                    else {
+                        for (const line of formatProcessTable(runtime.repl.session.processes(), runtime.repl.session.currentHarnessVersion()).split('\n')) {
+                            renderer.writeLine(line);
+                        }
+                    }
+                    tui.requestRender();
+                }
+                else if (immediate.kind === 'harness') {
+                    void handleHarnessCommand(immediate.width);
+                }
+                else {
+                    pendingCommands.push(trimmed);
+                    transcript.append('  (queued — runs when the current turn finishes)');
+                }
+            }
+            else if (runState.steerable) {
+                runtime.renderer.endTextBlock?.();
                 transcript.append(text, 'steer');
                 runtime.repl.steer(text);
             }
-            else {
+            else if (runState.bufferable) {
                 // A goal query is running: queue the line for the solution pager.
                 bufferedInput.push(text);
                 transcript.append(text, 'steer');
             }
+            else {
+                // A command (e.g. /call) is running and owns the prompt; typing does
+                // not steer it. Say so rather than mislabeling the line as steering.
+                transcript.append('  (a command is running — wait, or press Ctrl-C)');
+            }
         }
         if (editor) {
             editor.setPrompt(null);
@@ -1059,6 +1284,7 @@ export async function runTui(runtime, options, onExit, loaded = []) {
     };
     const createEditor = () => {
         editor = new PromptEditor(tui, editorTheme());
+        editor.setAutocompleteProvider(createReplAutocomplete(runtime.workspace));
         editor.onSubmit = handleSubmit;
         editorContainer.clear();
         editorContainer.addChild(editor);
@@ -1097,55 +1323,434 @@ export async function runTui(runtime, options, onExit, loaded = []) {
         const answer = await ask(`${prompt}${suffix}`, true);
         return answer === null ? undefined : answer;
     });
-    const cancelTurn = () => {
-        if (holder.turn) {
-            holder.turn.abort(new Error('cancelled by user'));
-            transcript.append('(cancelling current turn… press Ctrl-C again to exit)');
-            tui.requestRender();
-            return;
-        }
+    /** Interrupt the running turn, if any. Returns whether there was one. */
+    const interruptTurn = () => {
+        if (!holder.turn)
+            return false;
+        holder.turn.abort(new Error('cancelled by user'));
+        // Close the streamed block and clear the dock spinner so an interrupted turn
+        // leaves no live line behind.
+        runtime.renderer.endTextBlock?.();
+        working.set(null);
+        transcript.append('(interrupted — Ctrl-C exits)');
+        tui.requestRender();
+        return true;
+    };
+    /** Leave the REPL, aborting anything still running so nothing outlives the UI. */
+    const exitRepl = () => {
+        holder.turn?.abort(new Error('cancelled by user'));
         void (onExit ? onExit() : Promise.resolve()).finally(() => {
             tui.stop();
             process.exit(130);
         });
     };
-    // Ctrl-C aborts the current turn; Ctrl-D (on an empty editor) exits. Use pi's
-    // key matcher so kitty/meta key encodings are recognized, not just raw bytes.
+    // Esc interrupts, Ctrl-C exits, Ctrl-D (on an empty editor) exits. Escape is
+    // left alone while a completion list or an overlay owns it, so it keeps its
+    // usual meaning there. Use pi's key matcher so kitty/meta encodings are
+    // recognized, not just raw bytes.
     tui.addInputListener((data) => {
         if (matchesKey(data, 'ctrl+c')) {
-            cancelTurn();
+            exitRepl();
             return { consume: true };
         }
         if (matchesKey(data, 'ctrl+d') && !holder.turn && (editor?.getText().length ?? 0) === 0) {
-            cancelTurn();
+            exitRepl();
             return { consume: true };
         }
+        if (matchesKey(data, 'escape')
+            && !tui.hasOverlay()
+            && !(editor?.isShowingAutocomplete() ?? false)) {
+            if (interruptTurn())
+                return { consume: true };
+            return undefined;
+        }
+        // ctrl+o expands or collapses the most recent tool call, the way pi reveals
+        // full tool output on demand.
+        if (matchesKey(data, 'ctrl+o')) {
+            if (renderer.toggleLastPane())
+                return { consume: true };
+            return undefined;
+        }
         return undefined;
     });
-    // Fallback for terminals/raw-mode setups that deliver SIGINT instead of \x03.
-    process.on('SIGINT', cancelTurn);
+    // Fallback for terminals/raw-mode setups that deliver SIGINT instead of \x03:
+    // the terminal's own Ctrl-C, which now exits.
+    process.on('SIGINT', exitRepl);
     createEditor();
     for (const line of runtime.inputHistory)
         editor?.addToHistory(line);
-    tui.addChild(transcript);
-    tui.addChild(new Spacer(1));
-    tui.addChild(editorContainer);
-    tui.addChild(statusBar);
+    /**
+     * Show a chooser over the transcript and resolve when it closes.
+     *
+     * The overlay owns input while it is up (pi-tui routes keys to the focused
+     * overlay), so the editor does not see the keys the list is using.
+     */
+    const choose = (build) => {
+        return new Promise((resolve) => {
+            let handle;
+            const done = (picked) => {
+                handle?.hide();
+                if (editor)
+                    tui.setFocus(editor);
+                tui.requestRender();
+                resolve(picked);
+            };
+            const picker = build(done);
+            handle = tui.showOverlay(picker, {
+                anchor: 'center',
+                width: '70%',
+                maxHeight: picker.contentHeight + 2,
+            });
+        });
+    };
+    const pickReasoningMode = async () => {
+        const modes = ['off', 'summary', 'full'];
+        const picked = await choose((done) => new ChoicePicker({
+            title: 'Reasoning',
+            hint: 'How much of the model\'s thinking to show in the transcript',
+            current: runtime.reasoningMode,
+            items: [
+                { value: 'off', label: 'off', description: 'hide reasoning entirely' },
+                { value: 'summary', label: 'summary', description: 'a bounded preview' },
+                { value: 'full', label: 'full', description: 'everything the model emits' },
+            ].filter((item) => modes.includes(item.value)),
+            onSelect: (item) => done(item.value),
+            onCancel: () => done(),
+        }));
+        if (!picked)
+            return;
+        const mode = picked;
+        runtime.reasoningMode = mode;
+        runtime.renderer.setReasoningMode?.(mode);
+        await persistSetting({ repl: { showReasoning: mode } }, 'reasoning display');
+        renderer.writeLine(`reasoning display: ${mode}`);
+    };
+    /**
+     * The model's reasoning level (its thinking effort), as opposed to how much of
+     * that reasoning is displayed — `/show-reasoning` is the other one.
+     */
+    /**
+     * Persist a setting, but never let that failure stop it applying.
+     *
+     * `updateConfig` requires an existing config file (`deepclause init`), and a
+     * picker that threw before applying the change left the selection doing nothing at
+     * all — which read as "I cannot adjust the reasoning".
+     */
+    const persistSetting = async (patch, label) => {
+        try {
+            await updateConfig(runtime.workspace, patch);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            renderer.writeLine(`${label} applied to this session, but not saved: ${message.split('\n')[0]}`);
+        }
+    };
+    const pickReasoningLevel = async (level) => {
+        const backend = runtime.llmBackend;
+        const supported = (backend?.supportedThinkingLevels?.() ?? THINKING_LEVELS.slice());
+        const apply = async (chosen) => {
+            backend?.setThinkingLevel?.(chosen);
+            runtime.thinkingLevel = chosen;
+            runtime.setThinkingLevel?.(chosen);
+            await persistSetting({ backend: { kind: 'pi', thinkingLevel: chosen } }, 'reasoning level');
+            renderer.writeLine(`reasoning level: ${chosen}`);
+        };
+        if (level) {
+            if (!supported.includes(level)) {
+                renderer.writeLine(`unknown reasoning level '${level}'; supported: ${supported.join(', ')}`);
+                return;
+            }
+            await apply(level);
+            return;
+        }
+        const chosen = await choose((done) => new ChoicePicker({
+            title: 'Reasoning level',
+            hint: 'How hard the model is asked to think (not how much is shown)',
+            current: runtime.thinkingLevel,
+            items: supported.map((value) => ({
+                value,
+                label: value,
+                description: value === 'off' ? 'no reasoning requested' : undefined,
+            })),
+            onSelect: (item) => done(item.value),
+            onCancel: () => done(),
+        }));
+        if (chosen)
+            await apply(chosen);
+    };
+    /**
+     * `/harness` toggles the side view; `/harness 40`, `wider` and `narrower` resize it.
+     * The width is a layout basis, so a resize rebuilds the root.
+     */
+    const handleHarnessCommand = async (width) => {
+        if (!width) {
+            harnessVisible = !harnessVisible;
+            applyLayout();
+            if (harnessVisible)
+                harnessView.refresh();
+            tui.invalidate();
+            tui.requestRender();
+            renderer.writeLine(`harness view ${harnessVisible ? 'on' : 'off'}${harnessVisible ? ` (${harnessWidth} columns)` : ''}`);
+            return;
+        }
+        const requested = width === 'wider' ? harnessWidth + 8
+            : width === 'narrower' ? harnessWidth - 8
+                : Number(width);
+        if (!Number.isFinite(requested) || requested < 20 || requested > 120) {
+            renderer.writeLine(`harness view width must be 20-120 columns (got '${width}')`);
+            return;
+        }
+        harnessWidth = Math.round(requested);
+        if (!harnessVisible)
+            harnessVisible = true;
+        applyLayout();
+        tui.invalidate();
+        tui.requestRender();
+        renderer.writeLine(`harness view ${harnessWidth} columns`);
+    };
+    const pickModel = async () => {
+        const catalog = runtime.modelResolver?.catalog() ?? [];
+        if (catalog.length === 0) {
+            renderer.writeLine(`model: ${runtime.model} (no catalog to choose from; set one in config)`);
+            return;
+        }
+        const current = runtime.model.includes(':') ? runtime.model : undefined;
+        const picked = await choose((done) => new ChoicePicker({
+            title: 'Model',
+            hint: 'The default for this workspace (applies to the next session)',
+            current,
+            items: catalog.map((entry) => ({
+                value: entry.model,
+                label: entry.model,
+                description: entry.inputCost !== undefined
+                    ? `$${entry.inputCost}/$${entry.outputCost ?? '?'} per 1M in/out`
+                    : (entry.contextWindow ? `${Math.round(entry.contextWindow / 1000)}k context` : undefined),
+            })),
+            onSelect: (item) => done(item.value),
+            onCancel: () => done(),
+        }));
+        if (!picked)
+            return;
+        await persistSetting({ backend: { kind: 'pi', model: picked } }, 'model');
+        renderer.writeLine(`default model set to ${picked} (takes effect on the next start)`);
+    };
+    /** `/login`: sign in to a provider from inside the TUI. */
+    const runLogin = async () => {
+        let handle;
+        try {
+            handle = await openPiRuntime({});
+        }
+        catch (error) {
+            renderer.writeLine(`login unavailable: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        const providers = listLoginProviders(handle);
+        if (providers.length === 0) {
+            renderer.writeLine('no login providers available');
+            return;
+        }
+        const picked = await choose((done) => new ChoicePicker({
+            title: 'Sign in to a provider',
+            hint: 'Esc to cancel',
+            items: providers.map((provider) => ({
+                value: provider.id,
+                label: `${provider.name} (${provider.id})`,
+                description: provider.configured ? '✓ configured' : provider.authType,
+            })),
+            onSelect: (item) => done(item.value),
+            onCancel: () => done(),
+        }));
+        if (!picked)
+            return;
+        const interaction = {
+            prompt: async (prompt) => {
+                if (prompt.options && prompt.options.length > 0) {
+                    const method = await choose((done) => new ChoicePicker({
+                        title: prompt.message,
+                        items: prompt.options.map((option) => ({
+                            value: option.id,
+                            label: option.label,
+                            description: option.description,
+                        })),
+                        onSelect: (item) => done(item.value),
+                        onCancel: () => done(),
+                    }));
+                    if (!method)
+                        throw new Error('cancelled');
+                    return method;
+                }
+                const answer = await ask(`${prompt.message}${prompt.placeholder ? ` (${prompt.placeholder})` : ''} `);
+                if (answer === null)
+                    throw new Error('cancelled');
+                return answer;
+            },
+            notify: (event) => {
+                if (event.type === 'auth_url' && event.url)
+                    renderer.writeLine(`open this URL to authorize: ${event.url}`);
+                else if (event.type === 'device_code')
+                    renderer.writeLine(`visit ${event.verificationUri} and enter code ${event.userCode}`);
+                else if (event.message)
+                    renderer.writeLine(event.message);
+            },
+        };
+        try {
+            await loginToProvider(handle, picked, { interaction });
+            await persistSetting({ backend: { kind: 'pi' } }, 'login');
+            renderer.writeLine(`signed in to ${picked} (run /model to pick one of its models)`);
+        }
+        catch (error) {
+            renderer.writeLine(`login failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    // The experiment: a live side view of the harness, beside the transcript. It reads
+    // the session module (so uncommitted edits show) and refreshes after anything that
+    // can change it. Hidden on a narrow terminal, where there is no room for a column.
+    const harnessView = new HarnessView(() => runtime.repl.session.harnessView(), {
+        // The view asks; the host fetches (the listing query is async) and hands it back.
+        requestSource: (indicator) => {
+            void runtime.repl.session.listing(indicator).then((text) => {
+                harnessView.setSource(indicator, text.split('\n'));
+                tui.requestRender();
+            });
+        },
+        // Escape with nothing drilled into: hand the keyboard back to the editor.
+        onExit: () => {
+            if (editor)
+                tui.setFocus(editor);
+            tui.requestRender();
+        },
+    });
+    harnessView.refresh();
+    let harnessVisible = options.harnessView ?? false;
+    let servicesVisible = false;
+    let servicesLogs = false;
+    const servicesPanel = new ServicesPanel({
+        getProcesses: () => runtime.repl.session.processes(),
+        getLog: () => runtime.repl.session.processLog(200),
+        isVisible: () => servicesVisible,
+        mode: () => (servicesLogs ? 'logs' : 'summary'),
+        currentHarnessVersion: () => runtime.repl.session.currentHarnessVersion(),
+    });
+    const refreshHarness = () => {
+        if (!harnessVisible)
+            return;
+        harnessView.refresh();
+        tui.requestRender();
+    };
+    // Poll while the view is open. It is meant to be watched, and a change has to be
+    // visible when it happens, not at the next turn boundary.
+    const harnessTimer = setInterval(refreshHarness, 600);
+    const servicesTimer = setInterval(() => {
+        if (!servicesVisible)
+            return;
+        const active = runtime.repl.session
+            .processes()
+            .some((process) => ['running', 'runnable', 'waiting', 'input'].includes(process.state));
+        if (active || servicesLogs)
+            tui.requestRender();
+    }, 600);
+    // Transcript grows and scrolls; everything below it stays put.
+    const scroll = new ScrollView(document, {
+        follow: 'end',
+        primary: true,
+        scrollbar: 'auto',
+        scrollbarTrackStyle: scrollbarStyles.track,
+        scrollbarThumbStyle: scrollbarStyles.thumb,
+    });
+    // Margins: a blank row above the transcript and one between it and the editor, so
+    // the first and last line of output are not jammed against the chrome. Fixed
+    // spacers rather than padding inside the scroll view: they do not scroll away and
+    // do not consume scrollback.
+    const dock = new VStack([
+        { component: working, basis: 'auto', grow: 0, shrink: 1, minSize: 0 },
+        { component: servicesPanel, basis: 'auto', grow: 0, shrink: 1, minSize: 0 },
+        { component: new Spacer(1), basis: 'auto', grow: 0, shrink: 1, minSize: 1 },
+        { component: editorContainer, basis: 'auto', grow: 0, shrink: 1, minSize: 1 },
+        { component: statusBar, basis: 'auto', grow: 0, shrink: 1, minSize: 1 },
+    ]);
+    // Rebuilt rather than mutated: a stack entry's basis is read from the entries given
+    // at construction, so resizing means handing the TUI a new root.
+    let harnessWidth = 34;
+    const applyLayout = () => {
+        const columns = new HStack([
+            { component: scroll, basis: 0, grow: 1, shrink: 1, minSize: 20 },
+            {
+                component: harnessView,
+                basis: harnessWidth,
+                grow: 0,
+                shrink: 0,
+                minSize: 20,
+                visible: (viewport) => harnessVisible && viewport.width >= 96,
+            },
+        ], { gap: 1 });
+        tui.setLayoutRoot(new VStack([
+            { component: new Spacer(1), basis: 'auto', grow: 0, shrink: 1, minSize: 1 },
+            { component: columns, basis: 0, grow: 1, shrink: 1, minSize: 1 },
+            { component: dock, basis: 'auto', grow: 0, shrink: 1, minSize: 1 },
+        ]));
+    };
+    applyLayout();
     tui.start();
     await printBanner(runtime, loaded);
+    await renderResumedSession(runtime);
     tui.requestRender();
     try {
         while (true) {
-            const line = await ask(runtime.promptPrefix);
-            if (line === null)
-                break;
+            // A slash command typed while a turn/command was running: run it now that
+            // the REPL is idle, before asking for fresh input.
+            let line;
+            if (pendingCommands.length > 0) {
+                line = pendingCommands.shift();
+                tui.requestRender();
+            }
+            else {
+                line = await ask(runtime.promptPrefix);
+                if (line === null)
+                    break;
+            }
             const input = classifyReplInput(line);
             if (input.kind === 'halt')
                 break;
+            // The pickers are overlays over the transcript, so they need the TUI and are
+            // handled here rather than in the command dispatcher the readline path shares.
+            if (input.kind === 'model' && !input.model) {
+                await pickModel();
+                continue;
+            }
+            if (input.kind === 'reasoning') {
+                await pickReasoningLevel(input.level);
+                continue;
+            }
+            if (input.kind === 'show-reasoning') {
+                await pickReasoningMode();
+                continue;
+            }
+            if (input.kind === 'harness') {
+                await handleHarnessCommand(input.width);
+                continue;
+            }
+            if (input.kind === 'login') {
+                await runLogin();
+                continue;
+            }
+            if (input.kind === 'ps' && (input.watch || input.logs)) {
+                if (input.logs) {
+                    // Toggle the follow-the-log view; it is always visible when on.
+                    const turningOn = !(servicesVisible && servicesLogs);
+                    servicesLogs = turningOn;
+                    servicesVisible = true;
+                }
+                else {
+                    servicesVisible = !servicesVisible;
+                }
+                tui.requestRender();
+                continue;
+            }
             const controller = new AbortController();
             holder.turn = controller;
             runState.running = true;
             runState.steerable = input.kind === 'prompt';
+            runState.bufferable = input.kind === 'goal';
             bufferedInput.length = 0;
             tui.requestRender();
             try {
@@ -1171,8 +1776,11 @@ export async function runTui(runtime, options, onExit, loaded = []) {
     }
     finally {
         tui.stop();
-        process.off('SIGINT', cancelTurn);
+        process.off('SIGINT', exitRepl);
         process.stdout.off('resize', onResize);
+        clearInterval(harnessTimer);
+        clearInterval(servicesTimer);
+        working.stop();
         // Restore stdout so the exit footer and any later output are visible.
         runtime.renderer.setSink((text) => process.stdout.write(text), (text) => process.stderr.write(text));
     }
@@ -1194,6 +1802,9 @@ export async function startRepl(options) {
                 channel: message.channel,
             });
         }
+        if (options.execution === 'worker') {
+            runtime.renderer.writeLine('note: subagents run in a worker thread (--execution worker)');
+        }
     }
     catch (error) {
         process.stderr.write(`ERROR: ${error.message}\n`);
@@ -1239,7 +1850,7 @@ export async function startRepl(options) {
         if (goals.length > 0) {
             let exitCode = 0;
             const controller = new AbortController();
-            const removeSigint = installSigint(runtime, { turn: controller });
+            const removeSigint = installSigint({ turn: controller });
             try {
                 for (const goal of goals) {
                     if (controller.signal.aborted)
@@ -1271,6 +1882,7 @@ export async function startRepl(options) {
             return await runTui(runtime, options, saveHarnessOnExit, options.load ?? []);
         }
         await printBanner(runtime, options.load ?? []);
+        await renderResumedSession(runtime);
         return await runInteractive(runtime, options, saveHarnessOnExit);
     }
     finally {
@@ -1330,6 +1942,14 @@ export function registerReplCommand(program) {
         .option('--no-tools', 'register no capability host tools')
         .option('--sandbox', 'run shell tools in AgentVM')
         .option('--require-sandbox', 'refuse to run unless the shell is sandboxed (bwrap/AgentVM/sandbox-exec)')
+        .option('--harness-view', 'open the live harness side view (experiment)')
+        .option('--execution <mode>', 'process execution mode: worker (L2, default) or inline (L1)', (value) => {
+        if (value !== 'inline' && value !== 'worker') {
+            throw new Error(`invalid --execution: ${value} (use inline or worker)`);
+        }
+        return value;
+    })
+        .option('--workers <n>', 'worker pool size for --execution worker', parseInt)
         .option('--no-ask', 'make ask_user / input/2 fail instead of prompting')
         .option('--image-model <provider:id>', 'image model for generation (default: first available)')
         .option('--no-open', 'do not hand images to the OS viewer on terminals without inline images')
@@ -1375,6 +1995,9 @@ export function registerReplCommand(program) {
             noTools: options.tools === false,
             sandbox: options.sandbox,
             requireSandbox: options.requireSandbox,
+            harnessView: options.harnessView,
+            execution: options.execution,
+            workers: options.workers,
             noAsk: options.ask === false,
             imageModel: options.imageModel,
             open: options.open,