deepclause-sdk 0.1.3 → 0.2.2

package/dist/cli/repl.js

@@ -15,7 +15,12 @@ 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';
@@ -23,7 +28,7 @@ import { initTuiTheme, scrollbarStyles } from '../repl/tui/theme.js';
 import { SizedTerminal } from '../repl/tui/terminal.js';
 import { ReplStatusTracker } from '../repl/status.js';
 import { StatusBarComponent } from '../repl/tui/status-bar.js';
-import { Container, ScrollView, Spacer, TuiAltScreen, VStack, 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';
@@ -77,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.
  *
@@ -119,6 +131,9 @@ 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 };
@@ -144,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 };
         }
@@ -456,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,
@@ -484,7 +530,7 @@ export async function createReplRuntime(options) {
                 + "or run 'deepclause set-backend pi'.";
         }
     }
-    return {
+    const runtime = {
         repl,
         renderer,
         workspace,
@@ -511,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 = (() => {
@@ -562,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} — runtime state was reset ──`);
+    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;
@@ -577,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;
@@ -755,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)',
@@ -766,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',
@@ -1016,7 +1147,9 @@ export async function runTui(runtime, options, onExit, loaded = []) {
         },
     });
     runtime.renderer = renderer;
-    const runState = { running: false, steerable: false };
+    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({
@@ -1027,6 +1160,15 @@ 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();
     renderer.setImageSink((lines) => document.appendImageLines(lines));
@@ -1077,16 +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);
@@ -1144,6 +1328,10 @@ export async function runTui(runtime, options, onExit, loaded = []) {
         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;
@@ -1290,6 +1478,36 @@ export async function runTui(runtime, options, onExit, loaded = []) {
         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) {
@@ -1316,6 +1534,121 @@ export async function runTui(runtime, options, onExit, loaded = []) {
         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',
@@ -1330,23 +1663,51 @@ export async function runTui(runtime, options, onExit, loaded = []) {
     // 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 },
     ]);
-    tui.setLayoutRoot(new VStack([
-        { component: new Spacer(1), basis: 'auto', grow: 0, shrink: 1, minSize: 1 },
-        { component: scroll, basis: 0, grow: 1, shrink: 1, minSize: 1 },
-        { component: dock, 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;
@@ -1364,10 +1725,32 @@ export async function runTui(runtime, options, onExit, loaded = []) {
                 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 {
@@ -1395,6 +1778,8 @@ export async function runTui(runtime, options, onExit, loaded = []) {
         tui.stop();
         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));
@@ -1417,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`);
@@ -1494,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 {
@@ -1553,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')
@@ -1598,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,