janissary 0.5.0

package/dist/connection/close.js

@@ -0,0 +1,41 @@
+import { messageBus } from '../bus.js';
+import { SHELL_NAME } from '../shell-manager.js';
+export function closeConnection(kind, id, managers, label, out) {
+    switch (kind) {
+        case 'sqlite': {
+            out(managers.database.close(id) ? `Closed connection sqlite:${id}.` : `No open connection sqlite:${id}.`);
+            break;
+        }
+        case 'shell': {
+            if (managers.shell.close(label))
+                out(`Closed connection shell:${SHELL_NAME}.`);
+            else
+                out(`No open connection shell:${id}.`);
+            break;
+        }
+        case 'acp': {
+            if (managers.acp.close(label)) {
+                messageBus.emit('state', { type: 'dirty' });
+                out('Closed connection acp:opencode.');
+            }
+            else
+                out('No open connection acp:opencode.');
+            break;
+        }
+        case 'ssh': {
+            const tabs = managers.tab.tabs;
+            const tab = tabs.find((t) => t.harness?.name === 'ssh' && t.label === id)
+                ?? tabs.find((t) => t.harness?.name === 'ssh' && t.harness.destination === id);
+            if (tab?.harness) {
+                managers.pty.kill(tab.harness.ptyId);
+                out(`Closed connection ssh:${id}.`);
+            }
+            else
+                out(`No open connection ssh:${id}.`);
+            break;
+        }
+        default: {
+            out(`Closing ${kind} connections is not yet available in the web UI.`);
+        }
+    }
+}

package/dist/connection/manager.js

@@ -0,0 +1,93 @@
+import { parseConnectionCommand } from '../connections.js';
+import { SHELL_NAME } from '../shell-manager.js';
+import { closeConnection } from './close.js';
+// The global `connection list` lines: shell/acp are per-issuing-tab, the rest (terminals, ssh
+// tabs, sqlite) span every tab, since they have no command bar of their own to list from.
+function listLines(managers, label) {
+    const lines = [];
+    if (managers.shell.has(label))
+        lines.push(`shell:${SHELL_NAME}`);
+    if (managers.acp.has(label))
+        lines.push('acp:opencode');
+    const b = managers.browser.info(label);
+    if (b)
+        for (const id of b.ids)
+            lines.push(`browser:${id}`);
+    for (const program of managers.pty.terminalsFor(label))
+        lines.push(`terminal:${program}`);
+    for (const t of managers.tab.tabs) {
+        if (t.harness?.name === 'ssh' && t.harness.destination)
+            lines.push(`ssh:${t.harness.destination}`);
+    }
+    for (const n of managers.database.listOpen())
+        lines.push(`sqlite:${n}`);
+    return lines;
+}
+export class ConnectionManager {
+    managers;
+    constructor(managers) {
+        this.managers = managers;
+    }
+    connectionsFor(label) {
+        const rows = [];
+        if (this.managers.shell.has(label)) {
+            rows.push({ text: `${SHELL_NAME}:${this.managers.tab.shorten(this.managers.tab.cwdOf(label) ?? process.cwd())}`, kind: 'shell' });
+        }
+        const acp = this.managers.acp.label(label);
+        if (acp)
+            rows.push({ text: `acp:${acp}`, kind: 'acp' });
+        rows.push(...this.managers.monitor.connectionsFor(label));
+        const b = this.managers.browser.info(label);
+        if (b)
+            for (const id of b.ids)
+                rows.push({ text: `browser:${id} (${b.mode})`, kind: 'browser' });
+        const tab = this.managers.tab.tabs.find((t) => t.label === label);
+        if (tab?.harness?.name === 'ssh' && tab.harness.destination) {
+            rows.push({ text: `ssh:${tab.harness.destination}`, kind: 'ssh' });
+        }
+        else {
+            for (const program of this.managers.pty.terminalsFor(label))
+                rows.push({ text: `terminal:${program}`, kind: 'terminal' });
+        }
+        for (const n of this.managers.database.openDbs(label))
+            rows.push({ text: `sqlite:${n}`, kind: 'sqlite' });
+        return rows;
+    }
+    run(command, label) {
+        const parsed = parseConnectionCommand(command);
+        const out = (text) => this.managers.tab.append(label, { input: command, output: text });
+        if ('error' in parsed) {
+            out(parsed.error);
+            return;
+        }
+        if (parsed.action === 'list') {
+            const lines = listLines(this.managers, label);
+            out(lines.length > 0 ? lines.join('\n') : 'No open connections.');
+            return;
+        }
+        if (parsed.kind === 'browser') {
+            this.managers.tab.startRunning(label, command);
+            void this.managers.browser.run(label, `browser window close ${parsed.id}`).then((o) => this.managers.tab.finishRunning(label, o));
+            return;
+        }
+        closeConnection(parsed.kind, parsed.id, this.managers, label, out);
+    }
+    completionConnections(label) {
+        const out = [];
+        if (this.managers.shell.has(label))
+            out.push(`shell:${SHELL_NAME}`);
+        if (this.managers.acp.has(label))
+            out.push('acp:opencode');
+        const b = this.managers.browser.info(label);
+        if (b)
+            for (const id of b.ids)
+                out.push(`browser:${id}`);
+        for (const n of this.managers.database.listOpen())
+            out.push(`sqlite:${n}`);
+        for (const t of this.managers.tab.tabs) {
+            if (t.harness?.name === 'ssh')
+                out.push(`ssh:${t.label}`);
+        }
+        return out;
+    }
+}

package/dist/connection/parsing.js

@@ -0,0 +1,28 @@
+const KINDS = ['sqlite', 'shell', 'acp', 'browser', 'ssh'];
+const USAGE = 'Usage: connection <list|close> [kind:id]  (e.g. connection close sqlite:mydb)';
+export function parseConnectionCommand(input) {
+    const rest = input.trim().replace(/^connection\b\s*/i, '').trim();
+    if (!rest)
+        return { error: USAGE };
+    const [actionRaw, target] = rest.split(/\s+/);
+    const action = actionRaw.toLowerCase();
+    if (action === 'list')
+        return { action: 'list' };
+    if (action === 'close') {
+        if (!target)
+            return { error: 'Usage: connection close <kind>:<id>' };
+        const index = target.indexOf(':');
+        if (index === -1) {
+            return { error: `Invalid connection "${target}". Expected <kind>:<id>, e.g. sqlite:mydb.` };
+        }
+        const kind = target.slice(0, index).toLowerCase();
+        if (!KINDS.includes(kind)) {
+            return { error: `Unknown connection kind "${kind}". Expected one of: ${KINDS.join(', ')}.` };
+        }
+        const id = target.slice(index + 1);
+        if (!id)
+            return { error: `Missing id in "${target}".` };
+        return { action: 'close', kind: kind, id };
+    }
+    return { error: USAGE };
+}

package/dist/connection-close.js

@@ -0,0 +1,41 @@
+import { messageBus } from './bus.js';
+import { SHELL_NAME } from './shell-manager.js';
+export function closeConnection(kind, id, managers, label, out) {
+    switch (kind) {
+        case 'sqlite': {
+            out(managers.database.close(id) ? `Closed connection sqlite:${id}.` : `No open connection sqlite:${id}.`);
+            break;
+        }
+        case 'shell': {
+            if (managers.shell.close(label))
+                out(`Closed connection shell:${SHELL_NAME}.`);
+            else
+                out(`No open connection shell:${id}.`);
+            break;
+        }
+        case 'acp': {
+            if (managers.acp.close(label)) {
+                messageBus.emit('state', { type: 'dirty' });
+                out('Closed connection acp:opencode.');
+            }
+            else
+                out('No open connection acp:opencode.');
+            break;
+        }
+        case 'ssh': {
+            const tabs = managers.tab.tabs;
+            const tab = tabs.find((t) => t.harness?.name === 'ssh' && t.label === id)
+                ?? tabs.find((t) => t.harness?.name === 'ssh' && t.harness.destination === id);
+            if (tab?.harness) {
+                managers.pty.kill(tab.harness.ptyId);
+                out(`Closed connection ssh:${id}.`);
+            }
+            else
+                out(`No open connection ssh:${id}.`);
+            break;
+        }
+        default: {
+            out(`Closing ${kind} connections is not yet available in the web UI.`);
+        }
+    }
+}

package/dist/connection-manager.js

@@ -0,0 +1,93 @@
+import { parseConnectionCommand } from './connections.js';
+import { SHELL_NAME } from './shell-manager.js';
+import { closeConnection } from './connection-close.js';
+// The global `connection list` lines: shell/acp are per-issuing-tab, the rest (terminals, ssh
+// tabs, sqlite) span every tab, since they have no command bar of their own to list from.
+function listLines(managers, label) {
+    const lines = [];
+    if (managers.shell.has(label))
+        lines.push(`shell:${SHELL_NAME}`);
+    if (managers.acp.has(label))
+        lines.push('acp:opencode');
+    const b = managers.browser.info(label);
+    if (b)
+        for (const id of b.ids)
+            lines.push(`browser:${id}`);
+    for (const program of managers.pty.terminalsFor(label))
+        lines.push(`terminal:${program}`);
+    for (const t of managers.tab.tabs) {
+        if (t.harness?.name === 'ssh' && t.harness.destination)
+            lines.push(`ssh:${t.harness.destination}`);
+    }
+    for (const n of managers.database.listOpen())
+        lines.push(`sqlite:${n}`);
+    return lines;
+}
+export class ConnectionManager {
+    managers;
+    constructor(managers) {
+        this.managers = managers;
+    }
+    connectionsFor(label) {
+        const rows = [];
+        if (this.managers.shell.has(label)) {
+            rows.push({ text: `${SHELL_NAME}:${this.managers.tab.shorten(this.managers.tab.cwdOf(label) ?? process.cwd())}`, kind: 'shell' });
+        }
+        const acp = this.managers.acp.label(label);
+        if (acp)
+            rows.push({ text: `acp:${acp}`, kind: 'acp' });
+        rows.push(...this.managers.monitor.connectionsFor(label));
+        const b = this.managers.browser.info(label);
+        if (b)
+            for (const id of b.ids)
+                rows.push({ text: `browser:${id} (${b.mode})`, kind: 'browser' });
+        const tab = this.managers.tab.tabs.find((t) => t.label === label);
+        if (tab?.harness?.name === 'ssh' && tab.harness.destination) {
+            rows.push({ text: `ssh:${tab.harness.destination}`, kind: 'ssh' });
+        }
+        else {
+            for (const program of this.managers.pty.terminalsFor(label))
+                rows.push({ text: `terminal:${program}`, kind: 'terminal' });
+        }
+        for (const n of this.managers.database.openDbs(label))
+            rows.push({ text: `sqlite:${n}`, kind: 'sqlite' });
+        return rows;
+    }
+    run(command, label) {
+        const parsed = parseConnectionCommand(command);
+        const out = (text) => this.managers.tab.append(label, { input: command, output: text });
+        if ('error' in parsed) {
+            out(parsed.error);
+            return;
+        }
+        if (parsed.action === 'list') {
+            const lines = listLines(this.managers, label);
+            out(lines.length > 0 ? lines.join('\n') : 'No open connections.');
+            return;
+        }
+        if (parsed.kind === 'browser') {
+            this.managers.tab.startRunning(label, command);
+            void this.managers.browser.run(label, `browser window close ${parsed.id}`).then((o) => this.managers.tab.finishRunning(label, o));
+            return;
+        }
+        closeConnection(parsed.kind, parsed.id, this.managers, label, out);
+    }
+    completionConnections(label) {
+        const out = [];
+        if (this.managers.shell.has(label))
+            out.push(`shell:${SHELL_NAME}`);
+        if (this.managers.acp.has(label))
+            out.push('acp:opencode');
+        const b = this.managers.browser.info(label);
+        if (b)
+            for (const id of b.ids)
+                out.push(`browser:${id}`);
+        for (const n of this.managers.database.listOpen())
+            out.push(`sqlite:${n}`);
+        for (const t of this.managers.tab.tabs) {
+            if (t.harness?.name === 'ssh')
+                out.push(`ssh:${t.label}`);
+        }
+        return out;
+    }
+}

package/dist/connection-parsing.js

@@ -0,0 +1,28 @@
+const KINDS = ['sqlite', 'shell', 'acp', 'browser', 'ssh'];
+const USAGE = 'Usage: connection <list|close> [kind:id]  (e.g. connection close sqlite:mydb)';
+export function parseConnectionCommand(input) {
+    const rest = input.trim().replace(/^connection\b\s*/i, '').trim();
+    if (!rest)
+        return { error: USAGE };
+    const [actionRaw, target] = rest.split(/\s+/);
+    const action = actionRaw.toLowerCase();
+    if (action === 'list')
+        return { action: 'list' };
+    if (action === 'close') {
+        if (!target)
+            return { error: 'Usage: connection close <kind>:<id>' };
+        const index = target.indexOf(':');
+        if (index === -1) {
+            return { error: `Invalid connection "${target}". Expected <kind>:<id>, e.g. sqlite:mydb.` };
+        }
+        const kind = target.slice(0, index).toLowerCase();
+        if (!KINDS.includes(kind)) {
+            return { error: `Unknown connection kind "${kind}". Expected one of: ${KINDS.join(', ')}.` };
+        }
+        const id = target.slice(index + 1);
+        if (!id)
+            return { error: `Missing id in "${target}".` };
+        return { action: 'close', kind: kind, id };
+    }
+    return { error: USAGE };
+}

package/dist/connections.js

@@ -0,0 +1,75 @@
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync, rmSync, existsSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+export { parseConnectionCommand } from './connection/parsing.js';
+// SQLite databases live under .janissary/db/sqlite/<name>.sqlite and, unlike
+// agent state and workspaces, persist across launches — that is the whole point.
+let dbDir = '';
+export function initDbDir(projectDir) {
+    dbDir = path.join(projectDir, '.janissary', 'db', 'sqlite');
+}
+const VALID_DB_NAME = /^[\w-]+$/;
+export function dbPath(name) {
+    if (!VALID_DB_NAME.test(name))
+        throw new Error(`Invalid database name: "${name}"`);
+    return path.join(dbDir, `${name}.sqlite`);
+}
+/** Whether a database file exists on disk. */
+export function databaseFileExists(name) {
+    return !!dbDir && existsSync(dbPath(name));
+}
+/** List database names that have a `.sqlite` file on disk, sorted. */
+export function listDatabaseFiles() {
+    if (!dbDir || !existsSync(dbDir))
+        return [];
+    return readdirSync(dbDir)
+        .filter((f) => f.endsWith('.sqlite'))
+        .map((f) => f.slice(0, -'.sqlite'.length))
+        .toSorted((a, b) => a.localeCompare(b));
+}
+export function removeDatabaseFile(name) {
+    rmSync(dbPath(name), { force: true });
+}
+// Open SQLite connections keyed by database name: opened lazily on the first
+// `db` command targeting a database and kept open — across commands and tabs —
+// until closed explicitly (`connection close sqlite:<name>`) or at app exit.
+// Multiple databases can be connected at once.
+const connections = new Map();
+export function getConnection(name) {
+    let database = connections.get(name);
+    if (!database) {
+        mkdirSync(dbDir, { recursive: true });
+        database = new DatabaseSync(dbPath(name));
+        connections.set(name, database);
+    }
+    return database;
+}
+export function isConnectionOpen(name) {
+    return connections.has(name);
+}
+/** Close one open SQLite connection. Returns whether one was actually open. */
+export function closeConnection(name) {
+    const database = connections.get(name);
+    if (!database)
+        return false;
+    try {
+        database.close();
+    }
+    catch { /* ignore */ }
+    connections.delete(name);
+    return true;
+}
+/** Close every open SQLite connection (called on app exit). */
+export function closeAllConnections() {
+    for (const [, database] of connections) {
+        try {
+            database.close();
+        }
+        catch { /* ignore */ }
+    }
+    connections.clear();
+}
+/** Names of databases with an open connection, sorted. */
+export function listOpenConnections() {
+    return [...connections.keys()].toSorted((a, b) => a.localeCompare(b));
+}

package/dist/controller-events.js

@@ -0,0 +1,34 @@
+import { messageBus } from './bus.js';
+import { notify } from './notifications.js';
+// Wires the message-bus subscriptions the Controller needs for the lifetime of the process:
+// re-emitting state to clients, persisting agent state and notifying on new transcript entries,
+// process exit, and PTY data/exit relaying. Split out of the Controller constructor purely to keep
+// controller.ts under the file-size guideline; this has no state of its own.
+export function wireControllerEvents(managers, sinks) {
+    messageBus.on('state', 'dirty', () => sinks.emitState());
+    messageBus.on('transcript', 'entry:appended', (event) => {
+        if (event.type !== 'entry:appended')
+            return;
+        managers.tab.persist(managers.tab.buildAgentState(event.tab, { schedule: managers.schedule.get(event.tab.label) }));
+        // A cross-agent `msg`/`broadcast` delivery sets `entry.from`; feed the notifications tab
+        // (focus suppression and the per-event toggle are enforced inside `notify`).
+        if (event.entry.from)
+            notify(managers, 'incoming-message', event.tabLabel, event.entry.from);
+    });
+    messageBus.on('app', 'exit', () => sinks.exit?.());
+    messageBus.on('pty', ['data', 'exit'], (event) => {
+        if (event.type === 'data') {
+            sinks.sendPty(event.id, event.data);
+            return;
+        }
+        if (event.type !== 'exit')
+            return;
+        const harnessIndex = managers.tab.tabs.findIndex((tab) => tab.harness?.ptyId === event.id);
+        if (harnessIndex !== -1) {
+            sinks.sendPtyExit(event.id, event.exitCode);
+            managers.tab.closeTab(harnessIndex);
+            return;
+        }
+        sinks.sendPtyExit(event.id, event.exitCode);
+    });
+}

package/dist/controller-file-tree.js

@@ -0,0 +1,36 @@
+export function fileTreeToggle(managers, index, path) {
+    const label = managers.tab.tabs[index]?.label;
+    if (label)
+        managers.fileTree.toggle(label, path);
+}
+export function fileTreeCollapseAll(managers, index) {
+    const label = managers.tab.tabs[index]?.label;
+    if (label)
+        managers.fileTree.collapseAll(label);
+}
+export function fileTreeReroot(managers, index, relPath) {
+    const label = managers.tab.tabs[index]?.label;
+    if (label)
+        managers.fileTree.reroot(label, relPath);
+}
+export function moveFileTreeItem(managers, index, fromRelPath, toRelPath) {
+    const label = managers.tab.tabs[index]?.label;
+    if (label)
+        managers.fileTree.move(label, fromRelPath, toRelPath);
+}
+export function deleteFileTreeItem(managers, index, relPath) {
+    const label = managers.tab.tabs[index]?.label;
+    if (label)
+        managers.fileTree.delete(label, relPath);
+}
+export function undoFileTreeItem(managers, index, overwrite) {
+    const label = managers.tab.tabs[index]?.label;
+    return label ? managers.fileTree.undo(label, overwrite) : {};
+}
+export function redoFileTreeItem(managers, index, overwrite) {
+    const label = managers.tab.tabs[index]?.label;
+    return label ? managers.fileTree.redo(label, overwrite) : {};
+}
+export function openFileNavigatorFor(managers, label) {
+    managers.fileTree.openOrRetarget(label);
+}

package/dist/controller.js

@@ -0,0 +1,201 @@
+import { HarnessManager } from './harness/manager.js';
+import { SshManager } from './ssh-manager.js';
+import { DatabaseManager } from './database/manager.js';
+import { AcpManager } from './acp/manager.js';
+import { ShellManager } from './shell-manager.js';
+import { WorkspaceManager } from './workspace-manager.js';
+import { completeCommandLine } from './completion/index.js';
+import { PseudoterminalManager } from './pseudoterminal-manager.js';
+import { TranscriptStore } from './transcript/store.js';
+import { ScheduleManager } from './schedule/manager.js';
+import { ProfileManager } from './profile/manager.js';
+import { ConnectionManager } from './connection/manager.js';
+import { OpenFileManager } from './open-file-manager.js';
+import { FileTreeManager } from './file-tree-manager.js';
+import * as fileTreeRpc from './controller-file-tree.js';
+import { wireControllerEvents } from './controller-events.js';
+import { EditorWatchManager } from './editor/watch-manager.js';
+import { saveFile } from './editor/save.js';
+import { syncEditorBuffer } from './editor/sync.js';
+import { syncPageSnapshot } from './page/sync.js';
+import { CaptureManager } from './capture/manager.js';
+import { AgentCommunicationManager } from './agent/communication-manager.js';
+import { messageBus } from './bus.js';
+import { BrowserManager } from './browser/tab.js';
+import { CommandManager } from './command-manager.js';
+import { runSuggestion } from './monitor/window.js';
+import { MonitorManager } from './monitor/manager.js';
+import { listPersonas } from './personas.js';
+import { TabManager } from './tab/manager.js';
+export class Controller {
+    sinks;
+    projectDir;
+    managers = {};
+    get rootDir() { return this.projectDir ?? process.cwd(); }
+    constructor(sinks, projectDir) {
+        this.sinks = sinks;
+        this.projectDir = projectDir;
+        this.managers.database = new DatabaseManager();
+        this.managers.tab = new TabManager(this.managers, projectDir);
+        this.managers.workspace = new WorkspaceManager(projectDir);
+        this.managers.browser = new BrowserManager(this.managers);
+        this.managers.acp = new AcpManager(this.managers);
+        this.managers.openFile = new OpenFileManager(this.managers);
+        this.managers.fileTree = new FileTreeManager(this.managers);
+        this.managers.editorWatch = new EditorWatchManager(this.managers);
+        this.managers.pty = new PseudoterminalManager(this.managers);
+        this.managers.schedule = new ScheduleManager(this.managers);
+        this.managers.shell = new ShellManager(this.managers);
+        this.managers.harness = new HarnessManager(this.managers);
+        this.managers.ssh = new SshManager(this.managers);
+        this.managers.profile = new ProfileManager(this.managers);
+        this.managers.connection = new ConnectionManager(this.managers);
+        this.managers.communication = new AgentCommunicationManager(this.managers);
+        this.managers.command = new CommandManager(this.managers);
+        this.managers.capture = new CaptureManager(this.managers);
+        this.managers.monitor = new MonitorManager(this.managers);
+        wireControllerEvents(this.managers, this.sinks);
+        this.managers.schedule.start();
+    }
+    // Restore tabs from persisted agent state (for `--relaunch`). Called before any client connects.
+    rehydrate() {
+        this.managers.tab.rehydrate((name) => TranscriptStore.load(name), (s) => { if (s.schedule)
+            this.managers.schedule.set(s.name, s.schedule); });
+    }
+    view() {
+        return this.managers.tab.view((l) => this.managers.connection.connectionsFor(l), (l) => this.managers.acp.label(l), (l) => this.managers.schedule.view(l));
+    }
+    routeView() {
+        return this.managers.command.routeView();
+    }
+    chooseRoute(index) {
+        this.managers.command.chooseRoute(index);
+    }
+    dispatch(text) {
+        this.managers.command.dispatch(text);
+    }
+    // The absolute path behind an `/open/<id>` ref, or undefined when not registered (drives the route).
+    openFilePath(id) {
+        return this.managers.tab.openFilePath(id);
+    }
+    // Write an editor tab's buffer back to disk (the `saveFile` RPC). Throws on error; the RPC
+    // layer relays the message to the client.
+    saveFile(url, content) {
+        saveFile(this.managers, url, content);
+    }
+    // Cache an editor tab's in-progress buffer as transient draft state (the `editorSync` RPC).
+    // In-memory only; never written to disk.
+    syncEditorBuffer(url, content) {
+        syncEditorBuffer(this.managers, url, content);
+    }
+    // Cache a page tab's currently visible text as transient snapshot state (the `pageSync` RPC).
+    // In-memory only; never written to disk or sent to any client.
+    syncPageSnapshot(url, text) {
+        syncPageSnapshot(this.managers, url, text);
+    }
+    // --- monitor reporting tabs ------------------------------------------------
+    runSuggestion(id) {
+        runSuggestion(this.managers, id);
+    }
+    rateSuggestion(id, up) {
+        this.managers.monitor.rate(id, up);
+    }
+    resetMonitorContext(name) {
+        this.managers.monitor.resetContext(name);
+    }
+    monitorContextSnapshot(name) {
+        this.managers.monitor.snapshotContext(name);
+    }
+    // --- inline terminal cards (PTY) -----------------------------------------
+    ptyInput(id, data) { this.managers.pty.input(id, data); }
+    ptyResize(id, cols, rows) { this.managers.pty.resizeOne(id, cols, rows); }
+    ptyKill(id) { this.managers.pty.kill(id); }
+    resize(cols, rows) { this.managers.pty.resize(cols, rows); }
+    // --- tab management ------------------------------------------------------
+    setActiveTab(index) {
+        this.managers.tab.setActiveTab(index);
+    }
+    moveTab(dir) {
+        this.managers.tab.moveTab(dir);
+    }
+    reorderTab(dir) {
+        this.managers.tab.reorderTab(dir);
+    }
+    closeTab(index) {
+        this.managers.tab.closeTab(index);
+    }
+    renameTab(index, title) {
+        this.managers.tab.renameTab(index, title);
+    }
+    editQueuedCommand(index, text) {
+        this.managers.tab.editQueued(this.managers.tab.cur().label, index, text);
+    }
+    deleteQueuedCommand(index) {
+        this.managers.tab.deleteQueued(this.managers.tab.cur().label, index);
+    }
+    toggleCollapse() {
+        this.managers.tab.toggleCollapse();
+    }
+    // --- file tree tabs (see controller-file-tree.ts) ------------------------
+    fileTreeToggle(index, path) {
+        fileTreeRpc.fileTreeToggle(this.managers, index, path);
+    }
+    fileTreeCollapseAll(index) {
+        fileTreeRpc.fileTreeCollapseAll(this.managers, index);
+    }
+    fileTreeReroot(index, relPath) {
+        fileTreeRpc.fileTreeReroot(this.managers, index, relPath);
+    }
+    moveFileTreeItem(index, fromRelPath, toRelPath) {
+        fileTreeRpc.moveFileTreeItem(this.managers, index, fromRelPath, toRelPath);
+    }
+    deleteFileTreeItem(index, relPath) {
+        fileTreeRpc.deleteFileTreeItem(this.managers, index, relPath);
+    }
+    undoFileTreeItem(index, overwrite) {
+        return fileTreeRpc.undoFileTreeItem(this.managers, index, overwrite);
+    }
+    redoFileTreeItem(index, overwrite) {
+        return fileTreeRpc.redoFileTreeItem(this.managers, index, overwrite);
+    }
+    // Dock/undock any dockable tab (file tree or notifications). The mechanism is view-agnostic —
+    // `TabManager.setDock` operates on any tab index — so both kinds share this one handler.
+    setDock(index, dock) {
+        this.managers.tab.setDock(index, dock);
+    }
+    // Open (or retarget an existing) file navigator at the named tab's cwd — the 📁 metadata-row
+    // button (see controller-file-tree.ts).
+    openFileNavigatorFor(label) {
+        fileTreeRpc.openFileNavigatorFor(this.managers, label);
+    }
+    // Tab-completion for the command line (reuses the shared `completeCommandLine`): filesystem
+    // paths against the active tab's cwd, `msg`/`broadcast` agent names, `connection close` targets,
+    // and `browser` subcommands / window ids.
+    complete(text, cursor) {
+        const tab = this.managers.tab.cur();
+        const cwd = this.managers.tab.cwdOf(tab.label) ?? process.cwd();
+        const agents = this.managers.tab.allLabels();
+        // Monitor targets: every other action tab, plus `group:<n>` for each existing group.
+        const actionTabs = this.managers.tab.tabs.filter((t) => t.view !== 'monitor');
+        const groups = [...new Set(actionTabs.map((t) => t.group))].toSorted((a, b) => a - b).map((g) => `group:${g}`);
+        const targets = [...actionTabs.map((t) => t.label).filter((l) => l !== tab.label), ...groups];
+        return completeCommandLine(text, cursor, cwd, agents, this.managers.connection.completionConnections(tab.label), { personas: listPersonas(), targets });
+    }
+    // Canonical connection strings for `connection close` completion (shell/acp/browser/sqlite).
+    completionConnections(label) {
+        return this.managers.connection.completionConnections(label);
+    }
+    shutdown() {
+        this.managers.fileTree.dispose();
+        this.managers.editorWatch.dispose();
+        this.managers.monitor.closeAll();
+        messageBus.clear();
+        this.managers.schedule.stop();
+        this.managers.shell.closeAll();
+        this.managers.acp.closeAll();
+        this.managers.pty.closeAll();
+        this.managers.browser.closeAll();
+        this.managers.database.closeAll();
+        this.managers.workspace.removeAll();
+    }
+}