janissary 0.5.0

package/dist/browser.js

@@ -0,0 +1,124 @@
+import { spawn } from 'node:child_process';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { chromium } from 'playwright';
+import { randomBrowserProfile, acceptLanguage, DEFAULT_CHROME_MAJOR } from './user-agent.js';
+// Pull the major version out of a Playwright version string like "149.0.7827.55" so the
+// generated UA claims the same Chrome version the engine actually reports via client hints.
+function chromeMajor(version) {
+    const major = Number(version.split('.', 1)[0]);
+    return Number.isFinite(major) ? major : DEFAULT_CHROME_MAJOR;
+}
+// A headless/headed browser is owned per janissary tab: each tab launches its own
+// Playwright process (so modes can differ between tabs) and holds one or more isolated
+// windows. A "window" is a BrowserContext (its own cookies/storage) plus a single Page —
+// the viewport. The Browser handle stays private to the TabBrowser; callers only ever see
+// the BrowserWindow surface and the TabBrowser lifecycle methods.
+// Cap on `content()` output so a large page does not blow up the prompt fed back to an
+// ACP agent. Truncation is flagged in the returned text.
+const CONTENT_LIMIT = 10_000;
+function makeWindow(id, page) {
+    return {
+        id,
+        goto: async (url) => {
+            await page.goto(url, { waitUntil: 'load' });
+            const title = await page.title();
+            return `${title || '(untitled)'} — ${page.url()}`;
+        },
+        eval: async (js) => {
+            const result = await page.evaluate(js);
+            return result === undefined ? 'undefined' : JSON.stringify(result, undefined, 2);
+        },
+        shot: async () => {
+            const temporaryDirectory = mkdtempSync(path.join(tmpdir(), 'janissary-'));
+            const screenshotPath = path.join(temporaryDirectory, `${id}-${Date.now()}.png`);
+            await page.screenshot({ path: screenshotPath });
+            if (process.platform === 'darwin') {
+                // Open the screenshot detached so it never blocks the main process.
+                const child = spawn('open', ['-a', 'Preview', screenshotPath], { stdio: 'ignore', detached: true });
+                child.on('error', () => { });
+                child.unref();
+            }
+            return screenshotPath;
+        },
+        content: async () => {
+            const title = await page.title();
+            const body = await page.evaluate(() => document.body?.textContent ?? ''); // eslint-disable-line unicorn/no-optional-chaining-on-undeclared-variable
+            const text = `${title}\n\n${body}`.trim();
+            return text.length > CONTENT_LIMIT
+                ? `${text.slice(0, CONTENT_LIMIT)}\n… (truncated, ${text.length - CONTENT_LIMIT} more chars)`
+                : text;
+        },
+        url: () => page.url(),
+    };
+}
+/**
+ * Launch a tab's browser. The mode is fixed for the lifetime of the returned TabBrowser's
+ * Playwright process; to switch modes, close all windows (which ends the process) and
+ * launch again.
+ */
+export async function launchTabBrowser(isHeadless) {
+    // `channel: 'chromium'` selects Chromium's new headless mode (a real browser run
+    // headless) rather than the legacy headless shell, which is far more detectable.
+    // `--disable-blink-features=AutomationControlled` drops the automation flag that sets
+    // navigator.webdriver and the "Chrome is being controlled by automated test software"
+    // banner.
+    const browser = await chromium.launch({
+        channel: 'chromium',
+        headless: isHeadless,
+        args: ['--disable-blink-features=AutomationControlled'],
+    });
+    const major = chromeMajor(browser.version());
+    const windows = new Map();
+    return {
+        mode: isHeadless ? 'headless' : 'headed',
+        openWindow: async (id) => {
+            // A fresh, internally consistent fingerprint per window so isolated windows don't
+            // share an identical signature: UA (version pinned to the real engine), matching
+            // client-hint platform header, Accept-Language, timezone, and a common viewport.
+            const profile = randomBrowserProfile(major);
+            const context = await browser.newContext({
+                userAgent: profile.userAgent,
+                locale: profile.locale,
+                timezoneId: profile.timezoneId,
+                viewport: profile.viewport,
+                extraHTTPHeaders: {
+                    'Accept-Language': acceptLanguage(profile.locale),
+                    'Sec-CH-UA-Platform': `"${profile.platform}"`,
+                },
+            });
+            // Ensure navigator.webdriver is never true in any frame of this context.
+            await context.addInitScript(() => {
+                Object.defineProperty(navigator, 'webdriver', { get: () => false });
+            });
+            const page = await context.newPage();
+            const window = makeWindow(id, page);
+            windows.set(id, { window, context });
+            return window;
+        },
+        closeWindow: async (id) => {
+            const entry = windows.get(id);
+            if (!entry)
+                return;
+            windows.delete(id);
+            try {
+                await entry.context.close();
+            }
+            catch {
+                /* already gone */
+            }
+        },
+        window: (id) => windows.get(id)?.window,
+        windowIds: () => [...windows.keys()],
+        close: async () => {
+            windows.clear();
+            try {
+                await browser.close();
+            }
+            catch {
+                /* already gone */
+            }
+        },
+    };
+}

package/dist/buffer.js

@@ -0,0 +1,42 @@
+import { expandTabs } from './tab/index.js';
+function isEmptyEntry(entry) {
+    return !entry.from && !entry.input && !entry.output;
+}
+export function tryCollapseToolSteps(log, index) {
+    const entry = log[index];
+    if (!entry.acp || entry.from)
+        return null;
+    let count = 0;
+    let index_ = index;
+    while (index_ < log.length) {
+        const logEntry = log[index_];
+        if (isEmptyEntry(logEntry)) {
+            index_++;
+            continue;
+        }
+        if (logEntry.acp && !logEntry.from) {
+            count++;
+            index_++;
+            continue;
+        }
+        break;
+    }
+    return { count, newIndex: index_ - 1 };
+}
+export function formatMessageContent(entry, parts) {
+    const kind = entry.msgKind ?? 'info';
+    const lines = [];
+    if (kind === 'response') {
+        lines.push({ type: 'message', text: '', from: entry.from, fromColor: entry.fromColor, msgKind: 'response' });
+        for (const line of parts) {
+            lines.push({ type: 'output', text: expandTabs(line), fromColor: entry.fromColor });
+        }
+    }
+    else {
+        lines.push({ type: 'message', text: expandTabs(parts[0] ?? ''), from: entry.from, fromColor: entry.fromColor, msgKind: kind });
+        for (const extra of parts.slice(1)) {
+            lines.push({ type: 'output', text: expandTabs(extra), fromColor: entry.fromColor });
+        }
+    }
+    return lines;
+}

package/dist/bus.js

@@ -0,0 +1,52 @@
+// Generic typed pub/sub bus. Channels are named keys of the ChannelMap type parameter; within
+// each channel events are discriminated by a `type` string. Listeners are isolated via per-call
+// try/catch so a throwing subscriber never breaks the emit path.
+export class MessageBus {
+    listeners = new Map();
+    key(channel, type) {
+        return `${String(channel)}:${type}`;
+    }
+    on(channel, types, listener) {
+        const typeArr = Array.isArray(types) ? types : [types];
+        for (const type of typeArr) {
+            const k = this.key(channel, type);
+            const set = this.listeners.get(k) ?? new Set();
+            set.add(listener);
+            this.listeners.set(k, set);
+        }
+        return {
+            unsubscribe: () => {
+                for (const type of typeArr) {
+                    this.listeners.get(this.key(channel, type))?.delete(listener);
+                }
+            },
+        };
+    }
+    once(channel, types, listener) {
+        const ref = {};
+        const wrapper = (event) => {
+            ref.sub?.unsubscribe();
+            listener(event);
+        };
+        ref.sub = this.on(channel, types, wrapper);
+        return ref.sub;
+    }
+    emit(channel, event) {
+        const set = this.listeners.get(this.key(channel, event.type));
+        if (!set)
+            return;
+        const snapshot = [...set];
+        for (const fn of snapshot) {
+            try {
+                fn(event);
+            }
+            catch {
+                // Isolate subscriber errors so a throwing listener cannot break the emit path.
+            }
+        }
+    }
+    clear() {
+        this.listeners.clear();
+    }
+}
+export const messageBus = new MessageBus();

package/dist/capture/manager.js

@@ -0,0 +1,48 @@
+import { isInteractive } from '../interactive.js';
+import { commands } from '../commands/index.js';
+import { routeUnknownCommand } from './router.js';
+export class CaptureManager {
+    managers;
+    constructor(managers) {
+        this.managers = managers;
+    }
+    run(label, text, callback) {
+        if (/^shell\b/i.test(text)) {
+            const command = text.replace(/^shell\b\s*/i, '');
+            if (command && isInteractive(command)) {
+                callback(`Cannot run interactive command remotely: ${command}`);
+                return;
+            }
+            this.managers.shell.run(label, command, { onComplete: callback });
+            return;
+        }
+        const trimmed = text.replace(/^\//, '');
+        const index = this.managers.tab.findIndex(label);
+        if (index === -1) {
+            callback('Tab not found');
+            return;
+        }
+        for (const c of commands) {
+            if (c.match(trimmed)) {
+                this.dispatchMatchedCommand(c, trimmed, label, index, callback);
+                return;
+            }
+        }
+        routeUnknownCommand(text, trimmed, label, this.managers, (l, t, cb) => this.run(l, t, cb), callback);
+    }
+    dispatchMatchedCommand(c, trimmed, label, index, callback) {
+        if (c.name === 'acp') {
+            this.managers.acp.run(label, trimmed, callback);
+            return;
+        }
+        if (c.name === 'browser') {
+            this.managers.browser.runInteractive(trimmed, label, callback);
+            return;
+        }
+        const tab = this.managers.tab.tabs.find((t) => t.label === label);
+        const before = tab?.log.length ?? 0;
+        this.managers.command.executeCommand(c.name, trimmed, label, index);
+        const after = this.managers.tab.tabs.find((t) => t.label === label)?.log.length ?? 0;
+        callback(after > before ? this.managers.tab.tabs.find((t) => t.label === label).log[after - 1].output : '');
+    }
+}

package/dist/capture/router.js

@@ -0,0 +1,18 @@
+import { getOutput } from '../commands.js';
+import { toPrefixedCommand } from '../recognizers/index.js';
+import { resolveRouteChoice } from '../route-choice.js';
+export function routeUnknownCommand(text, trimmed, label, managers, run, callback) {
+    const output = getOutput(trimmed);
+    if (output !== null && !output.startsWith('Unknown command:')) {
+        managers.tab.append(label, { input: text, output, markdown: trimmed === 'help' });
+        callback(output);
+        return;
+    }
+    const openDbs = managers.database.openDbs(label);
+    const choice = resolveRouteChoice(trimmed, openDbs);
+    if (choice) {
+        run(label, toPrefixedCommand(trimmed, choice), callback);
+        return;
+    }
+    callback(output ?? `Unknown command: "${trimmed}".`);
+}

package/dist/capture-manager.js

@@ -0,0 +1,48 @@
+import { isInteractive } from './interactive.js';
+import { commands } from './commands/index.js';
+import { routeUnknownCommand } from './capture-router.js';
+export class CaptureManager {
+    managers;
+    constructor(managers) {
+        this.managers = managers;
+    }
+    run(label, text, callback) {
+        if (/^shell\b/i.test(text)) {
+            const command = text.replace(/^shell\b\s*/i, '');
+            if (command && isInteractive(command)) {
+                callback(`Cannot run interactive command remotely: ${command}`);
+                return;
+            }
+            this.managers.shell.run(label, command, { onComplete: callback });
+            return;
+        }
+        const trimmed = text.replace(/^\//, '');
+        const index = this.managers.tab.findIndex(label);
+        if (index === -1) {
+            callback('Tab not found');
+            return;
+        }
+        for (const c of commands) {
+            if (c.match(trimmed)) {
+                this.dispatchMatchedCommand(c, trimmed, label, index, callback);
+                return;
+            }
+        }
+        routeUnknownCommand(text, trimmed, label, this.managers, (l, t, cb) => this.run(l, t, cb), callback);
+    }
+    dispatchMatchedCommand(c, trimmed, label, index, callback) {
+        if (c.name === 'acp') {
+            this.managers.acp.run(label, trimmed, callback);
+            return;
+        }
+        if (c.name === 'browser') {
+            this.managers.browser.runInteractive(trimmed, label, callback);
+            return;
+        }
+        const tab = this.managers.tab.tabs.find((t) => t.label === label);
+        const before = tab?.log.length ?? 0;
+        this.managers.command.executeCommand(c.name, trimmed, label, index);
+        const after = this.managers.tab.tabs.find((t) => t.label === label)?.log.length ?? 0;
+        callback(after > before ? this.managers.tab.tabs.find((t) => t.label === label).log[after - 1].output : '');
+    }
+}

package/dist/capture-router.js

@@ -0,0 +1,20 @@
+import { getOutput } from './commands.js';
+import { analyzeCommand, toPrefixedCommand } from './recognizers/index.js';
+export function routeUnknownCommand(text, trimmed, label, managers, run, callback) {
+    const output = getOutput(trimmed);
+    if (output !== null && !output.startsWith('Unknown command:')) {
+        managers.tab.append(label, { input: text, output, markdown: trimmed === 'help' });
+        callback(output);
+        return;
+    }
+    const openDbs = managers.database.openDbs(label);
+    const decision = analyzeCommand(trimmed, { openDbs });
+    if (decision.kind === 'route' && (decision.route !== 'db' || openDbs.length === 1)) {
+        const choice = decision.route === 'db'
+            ? { label: '', route: 'db', dbName: openDbs[0] }
+            : { label: '', route: decision.route };
+        run(label, toPrefixedCommand(trimmed, choice), callback);
+        return;
+    }
+    callback(output ?? `Unknown command: "${trimmed}".`);
+}

package/dist/chrome-extension-loader.js

@@ -0,0 +1,62 @@
+const RESPONSE_TIMEOUT_MS = 20_000;
+// Sends a single Chrome DevTools Protocol command over Chrome's `--remote-debugging-pipe`
+// file descriptors (fd 3 write, fd 4 read) and waits for the matching response. Messages on
+// the pipe are newline-free JSON terminated by a NUL byte, per Chromium's pipe transport.
+function sendCdpCommand(writePipe, readPipe, method, params) {
+    return new Promise((resolve, reject) => {
+        const id = 1;
+        let buffer = '';
+        const cleanup = () => {
+            clearTimeout(timeout);
+            readPipe.off('data', onData);
+        };
+        const timeout = setTimeout(() => {
+            cleanup();
+            reject(new Error(`CDP command ${method} timed out after ${RESPONSE_TIMEOUT_MS}ms`));
+        }, RESPONSE_TIMEOUT_MS);
+        function onData(chunk) {
+            buffer += chunk.toString('utf8');
+            let sep = buffer.indexOf('\0');
+            while (sep !== -1) {
+                const raw = buffer.slice(0, sep);
+                buffer = buffer.slice(sep + 1);
+                sep = buffer.indexOf('\0');
+                let message;
+                try {
+                    message = JSON.parse(raw);
+                }
+                catch {
+                    continue;
+                }
+                if (message.id === id) {
+                    cleanup();
+                    if (message.error) {
+                        reject(new Error(message.error.message));
+                    }
+                    else {
+                        resolve(message.result);
+                    }
+                    return;
+                }
+            }
+        }
+        readPipe.on('data', onData);
+        writePipe.write(`${JSON.stringify({ id, method, params })}\0`);
+    });
+}
+// Loads the bundled Frame Enabler extension into an already-launched, branded Chrome over the
+// CDP `--remote-debugging-pipe` file descriptors (`Extensions.loadUnpacked`) — the sanctioned
+// replacement for the `--load-extension` launch flag Google removed from branded Chrome 137+.
+// `Extensions.loadUnpacked` is only reachable over the pipe transport, not `--remote-debugging-port`
+// / a WebSocket connection, so `writePipe`/`readPipe` must be Chrome's inherited fd 3/4 streams.
+// Never throws: any failure is reported as a single stderr warning, since page-tab framing is a
+// nice-to-have, not core functionality.
+export async function loadFrameEnablerExtension(writePipe, readPipe, extDir) {
+    try {
+        await sendCdpCommand(writePipe, readPipe, 'Extensions.loadUnpacked', { path: extDir });
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`warning: Chrome frame-enabler extension failed to load (${reason}) — sites that block iframing may not render in page tabs\n`);
+    }
+}

package/dist/cli-args.js

@@ -0,0 +1,80 @@
+import { parseArgs } from 'node:util';
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+export class CliUsageError extends Error {
+}
+export function parseCliArgs(argv) {
+    let values;
+    let positionals;
+    try {
+        ({ values, positionals } = parseArgs({
+            args: argv,
+            options: {
+                help: { type: 'boolean' },
+                version: { type: 'boolean' },
+                relaunch: { type: 'boolean' },
+                'no-open': { type: 'boolean' },
+                port: { type: 'string' },
+            },
+            strict: true,
+            allowPositionals: true,
+        }));
+    }
+    catch (error) {
+        const code = error.code;
+        if (typeof code === 'string' && code.startsWith('ERR_PARSE_ARGS')) {
+            const raw = error instanceof Error ? error.message : String(error);
+            const cleaned = raw.replace(/^TypeError \[[^\]]+]: /, '');
+            throw new CliUsageError(cleaned);
+        }
+        throw error;
+    }
+    const port = typeof values.port === 'string' ? Number(values.port) : undefined;
+    if (port !== undefined && !(Number.isSafeInteger(port) && port >= 1 && port <= 65_535)) {
+        throw new CliUsageError(`invalid --port value: ${values.port}`);
+    }
+    let projectDir;
+    if (positionals.length > 0) {
+        const raw = positionals[0];
+        const resolved = path.resolve(raw);
+        if (!existsSync(resolved) || !statSync(resolved).isDirectory()) {
+            throw new CliUsageError(`invalid project directory: ${raw} is not a directory`);
+        }
+        projectDir = resolved;
+    }
+    if (positionals.length > 1) {
+        throw new CliUsageError(`unexpected argument: ${positionals[1]}`);
+    }
+    return {
+        help: Boolean(values.help),
+        version: Boolean(values.version),
+        relaunch: Boolean(values.relaunch),
+        noOpen: Boolean(values['no-open']),
+        port,
+        projectDir,
+    };
+}
+export function usageText() {
+    return `Usage: janus [options] [<project-dir>]
+
+A terminal UI shell with built-in commands and shell execution.
+
+Arguments:
+  <project-dir>  Target directory (default: current directory)
+
+Options:
+  --port=<n>     Port to listen on (default: auto)
+  --no-open      Start the server without opening the app window
+  --relaunch     Reattach to existing state instead of clearing it
+  --help         Show this help
+  --version      Show version
+
+Environment:
+  JANUS_DEBUG=1  print stack traces on failure
+`;
+}
+export function appVersion() {
+    const packagePath = path.join(import.meta.dirname, '..', 'package.json');
+    const pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
+    return `${pkg.name} ${pkg.version}`;
+}

package/dist/command-manager.js

@@ -0,0 +1,126 @@
+import { resolveCommand } from './resolve.js';
+import { isInteractive } from './interactive.js';
+import { commands } from './commands/index.js';
+import { toPrefixedCommand } from './recognizers/index.js';
+import { messageBus } from './bus.js';
+import { resolveUnknownCommand } from './command-router.js';
+import { recordGlobalHistory } from './global-history.js';
+export class CommandManager {
+    managers;
+    pendingRoute = null;
+    constructor(managers) {
+        this.managers = managers;
+        this.managers.tab.setOnIdle((label) => this.drainQueue(label));
+    }
+    routeView() {
+        if (!this.pendingRoute)
+            return null;
+        return { cmd: this.pendingRoute.cmd, choices: this.pendingRoute.choices.map((c) => c.label) };
+    }
+    chooseRoute(index) {
+        const pending = this.pendingRoute;
+        this.pendingRoute = null;
+        if (pending && index >= 0 && index < pending.choices.length) {
+            const index_ = this.managers.tab.findIndex(pending.label);
+            if (index_ !== -1)
+                this.run(toPrefixedCommand(pending.cmd, pending.choices[index]), pending.label, index_);
+        }
+        if (pending)
+            this.drainQueue(pending.label);
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    dispatch(text) {
+        const trimmed = this.managers.tab.recordHistory(this.managers.tab.activeTab, text);
+        if (trimmed)
+            recordGlobalHistory(trimmed, this.managers.tab.cur().label);
+        this.dispatchOrRun(trimmed, this.managers.tab.cur().label, this.managers.tab.activeTab);
+    }
+    dispatchTo(label, text) {
+        const index = this.managers.tab.findIndex(label);
+        if (index === -1)
+            return;
+        const trimmed = this.managers.tab.recordHistory(index, text);
+        if (trimmed)
+            recordGlobalHistory(trimmed, label);
+        this.dispatchOrRun(trimmed, label, index);
+    }
+    // Gate seam: agent tabs queue while busy (or while idle with entries already waiting, to
+    // preserve FIFO) instead of running immediately. Non-agent tabs and empty input bypass the gate.
+    dispatchOrRun(trimmed, label, index) {
+        if (!trimmed) {
+            this.run(trimmed, label, index);
+            return;
+        }
+        const tab = this.managers.tab.tabs[index];
+        const isAgentTab = tab !== undefined && (tab.view === undefined || tab.view === 'agent');
+        const wasIdle = !this.managers.tab.isBusy(label);
+        const alreadyQueued = this.managers.tab.queueFor(label).length > 0;
+        if (isAgentTab && (!wasIdle || alreadyQueued)) {
+            this.managers.tab.enqueue(label, trimmed);
+            this.managers.tab.append(label, { input: '', output: `Queued: ${trimmed}` });
+            if (wasIdle)
+                this.drainQueue(label);
+            return;
+        }
+        this.run(trimmed, label, index);
+    }
+    // Runs queued commands FIFO until the tab goes busy, its queue empties, or a route chooser
+    // becomes pending (resumed by `chooseRoute`). Registered as `TabManager`'s onIdle hook.
+    drainQueue(label) {
+        for (;;) {
+            const index = this.managers.tab.findIndex(label);
+            if (index === -1 || this.managers.tab.isBusy(label) || this.pendingRoute)
+                return;
+            const command = this.managers.tab.dequeue(label);
+            if (command === undefined)
+                return;
+            this.run(command, label, index);
+        }
+    }
+    run(input, label, index) {
+        if (/^harness\b/i.test(input)) {
+            this.managers.tab.append(label, { input, output: '' });
+            const error = this.managers.harness.run(input);
+            if (error)
+                this.managers.tab.append(label, { input: '', output: error });
+            return;
+        }
+        if (/^ssh\b/i.test(input)) {
+            this.managers.tab.append(label, { input, output: '' });
+            const error = this.managers.ssh.run(input);
+            if (error)
+                this.managers.tab.append(label, { input: '', output: error });
+            return;
+        }
+        const res = resolveCommand(input);
+        switch (res.kind) {
+            case 'empty': {
+                return;
+            }
+            case 'shell': {
+                if (res.cmd && isInteractive(res.cmd))
+                    this.managers.pty.openInlinePty(label, res.cmd, res.cmd.split(/\s+/, 1)[0]);
+                else
+                    this.managers.shell.run(label, res.cmd);
+                return;
+            }
+            case 'output': {
+                this.managers.tab.append(label, { input, output: res.output, markdown: true });
+                return;
+            }
+            case 'unknown': {
+                resolveUnknownCommand(res.cmd, label, this.managers, (input, l, idx) => this.run(input, l, idx), (p) => { this.pendingRoute = p; });
+                return;
+            }
+            case 'app': {
+                this.executeCommand(res.name, res.cmd, label, index);
+                return;
+            }
+        }
+    }
+    executeCommand(name, command, label, index) {
+        const cmd = commands.find((c) => c.name === name);
+        if (cmd)
+            cmd.run(command, { label, index }, this.managers);
+    }
+}

package/dist/command-router.js

@@ -0,0 +1,14 @@
+import { messageBus } from './bus.js';
+import { toPrefixedCommand, routeChoices } from './recognizers/index.js';
+import { resolveRouteChoice } from './route-choice.js';
+export function resolveUnknownCommand(cmd, label, managers, run, setPending) {
+    const openDbs = managers.database.openDbs(label);
+    const choice = resolveRouteChoice(cmd, openDbs);
+    if (choice) {
+        run(toPrefixedCommand(cmd, choice), label, managers.tab.findIndex(label));
+    }
+    else {
+        setPending({ label, cmd, choices: routeChoices(openDbs) });
+        messageBus.emit('state', { type: 'dirty' });
+    }
+}

package/dist/commands/acp-reset.js

@@ -0,0 +1,13 @@
+export const command = {
+    name: 'acp-reset',
+    match: (command_) => /^acp\s+reset\b/i.test(command_),
+    run: (_command, tab, managers) => {
+        const hadSession = managers.acp.close(tab.label);
+        managers.tab.append(tab.label, {
+            input: _command,
+            output: hadSession
+                ? 'ACP session reset — next acp prompt will start fresh.'
+                : 'No active ACP session to reset.',
+        });
+    },
+};

package/dist/commands/acp.js

@@ -0,0 +1,5 @@
+export const command = {
+    name: 'acp',
+    match: (command_) => /^acp\b/i.test(command_),
+    run: (command, tab, managers) => { managers.acp.run(tab.label, command); },
+};

package/dist/commands/agent.js

@@ -0,0 +1,5 @@
+export const command = {
+    name: 'agent',
+    match: (command_) => /^agent\b/i.test(command_),
+    run: (command, context, managers) => { managers.profile.newAgent(command); },
+};