janissary 0.5.0

package/dist/tab.js

@@ -0,0 +1,57 @@
+export { expandTabs, wordWrap, flattenBuffer } from './tab-formatting.js';
+export { distinctColor, dotColors } from './tab-colors.js';
+export { stripComments, renumberTabs, canMoveTab, swapTabsLeft, swapTabsRight, insertTabInGroup, uniqueLabel } from './tab-utils.js';
+export const makeTab = (label, dotColor, number = 1, commandHistory = [], log = [], workspaceDirectory, group = 1, groupColor = dotColor) => ({
+    label,
+    dotColor,
+    number,
+    group,
+    groupColor,
+    log,
+    cmdHistory: commandHistory,
+    cmdHistoryIdx: -1,
+    scrollOffset: 0,
+    workspaceDir: workspaceDirectory,
+});
+// An image view tab (opened via `open <image>`). It carries no transcript/history/shell — just the
+// image payload — and is always titled `image` while keeping a unique `label` so several can coexist.
+export const makeImageTab = (label, dotColor, number, group, groupColor, image) => ({
+    ...makeTab(label, dotColor, number, [], [], undefined, group, groupColor),
+    view: 'image',
+    title: 'image',
+    image,
+});
+// A page view tab (opened via `open https://…` or `open page …`). Renders an iframe; carries no
+// transcript/history/shell. The title shows the domain (e.g. "slashdot.org").
+export const makePageTab = (label, dotColor, number, group, groupColor, page) => ({
+    ...makeTab(label, dotColor, number, [], [], undefined, group, groupColor),
+    view: 'page',
+    title: page.domain,
+    page,
+});
+// A markdown view tab (opened via `open <file>.md`). Renders the file as formatted Markdown.
+export const makeMarkdownTab = (label, dotColor, number, group, groupColor, markdown) => ({
+    ...makeTab(label, dotColor, number, [], [], undefined, group, groupColor),
+    view: 'markdown',
+    title: 'markdown',
+    markdown,
+});
+// An editor view tab (opened via `open <text file>` or `edit <file>`). Hosts the plain-text editor.
+export const makeEditorTab = (label, dotColor, number, group, groupColor, editor) => ({
+    ...makeTab(label, dotColor, number, [], [], undefined, group, groupColor),
+    view: 'editor',
+    title: editor.name,
+    editor,
+});
+// A harness view tab (opened via `harness <name>`). The entire tab body is a live PTY terminal.
+export const makeHarnessTab = (label, dotColor, number, group, groupColor, harness, workspaceDirectory) => ({
+    ...makeTab(label, dotColor, number, [], [], workspaceDirectory, group, groupColor),
+    view: 'harness', title: label, harness,
+});
+// A file tree view tab (opened via `files [path]`). Shows a directory tree rooted at `files.root`.
+export const makeFilesTab = (label, dotColor, number, group, groupColor, files) => ({
+    ...makeTab(label, dotColor, number, [], [], undefined, group, groupColor),
+    view: 'files',
+    title: 'navigator',
+    files,
+});

package/dist/tasks.js

@@ -0,0 +1,32 @@
+import { readdirSync } from 'node:fs';
+import path from 'node:path';
+// Depth-first walk of one directory: returns its entries (files and subdirectories, recursed
+// into) as a flat, pre-order `TaskRow[]` — a directory row immediately followed by its children,
+// so the array is already in display order. Sorted alphabetically within each directory.
+function walk(dir, relativeDir, depth) {
+    const entries = readdirSync(dir, { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory() || (dirent.isFile() && dirent.name.endsWith('.md')))
+        .toSorted((a, b) => a.name.localeCompare(b.name));
+    const rows = [];
+    for (const dirent of entries) {
+        const relPath = relativeDir ? `${relativeDir}/${dirent.name}` : dirent.name;
+        if (dirent.isDirectory()) {
+            rows.push({ path: relPath, name: dirent.name, depth, dir: true }, ...walk(path.join(dir, dirent.name), relPath, depth + 1));
+        }
+        else {
+            rows.push({ path: relPath, name: dirent.name, depth, dir: false });
+        }
+    }
+    return rows;
+}
+// Executable task prompts: markdown files under `ai/tasks/` (`build-a-feature.md`,
+// `fix-a-small-issue.md`, …), recursed into any subdirectory. The `.md` extension is kept in
+// `path`: the picker inserts `execute ./ai/tasks/<path>` verbatim.
+export function listTasks(root = process.cwd()) {
+    try {
+        return walk(path.join(root, 'ai', 'tasks'), '', 0);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/transcript/logger.js

@@ -0,0 +1,36 @@
+import { mkdirSync, appendFileSync } from 'node:fs';
+import path from 'node:path';
+import { getDateStr, getTimeStr } from '../datetime.js';
+import { messageBus } from '../bus.js';
+let logDir = '';
+export class TranscriptLogger {
+    static get logDir() {
+        return logDir;
+    }
+    static append(entry) {
+        if (!logDir)
+            return;
+        const logPath = path.join(logDir, `${getDateStr()}.json`);
+        appendFileSync(logPath, JSON.stringify(entry) + '\n');
+    }
+    sub;
+    constructor(projectDir) {
+        if (projectDir) {
+            logDir = path.join(projectDir, '.janissary', 'log');
+            mkdirSync(logDir, { recursive: true });
+        }
+        this.sub = messageBus.on('transcript', 'entry:appended', (event) => {
+            if (event.type !== 'entry:appended')
+                return;
+            const { tabLabel, entry } = event;
+            const ts = getTimeStr();
+            if (entry.input)
+                TranscriptLogger.append({ timestamp: ts, agent: tabLabel, text: entry.input });
+            if (entry.output)
+                TranscriptLogger.append({ timestamp: ts, agent: tabLabel, text: entry.output });
+        });
+    }
+    unsubscribe() {
+        this.sub.unsubscribe();
+    }
+}

package/dist/transcript/store.js

@@ -0,0 +1,66 @@
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { messageBus } from '../bus.js';
+const VALID_NAME = /^[\w-]+$/;
+let transcriptDir = '';
+// Subscribes to the bus and persists transcript files whenever entries are appended or a tab is
+// cleared. tab:removed keeps the file for history. In-place edits (streaming, runShell completion)
+// are persisted by direct calls to save() from the controller since there is no bus event for them.
+export class TranscriptStore {
+    static path(label) {
+        if (!VALID_NAME.test(label))
+            throw new Error(`Invalid transcript label: "${label}"`);
+        return path.join(transcriptDir, `${label}.json`);
+    }
+    static load(label) {
+        if (!transcriptDir)
+            return undefined;
+        const p = this.path(label);
+        if (!existsSync(p))
+            return undefined;
+        try {
+            return JSON.parse(readFileSync(p, 'utf8'));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    static save(label, log) {
+        if (!transcriptDir)
+            return;
+        try {
+            mkdirSync(transcriptDir, { recursive: true });
+            writeFileSync(this.path(label), JSON.stringify(log));
+        }
+        catch { /* ignore */ }
+    }
+    static clearTab(label) {
+        if (!transcriptDir)
+            return;
+        try {
+            mkdirSync(transcriptDir, { recursive: true });
+            writeFileSync(this.path(label), '[]');
+        }
+        catch { /* ignore */ }
+    }
+    static clear() {
+        if (!transcriptDir)
+            return;
+        try {
+            rmSync(transcriptDir, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    }
+    constructor(projectDir) {
+        if (projectDir)
+            transcriptDir = path.join(projectDir, '.janissary', 'transcripts');
+        messageBus.on('transcript', 'entry:appended', (event) => {
+            if (event.type === 'entry:appended')
+                TranscriptStore.save(event.tabLabel, event.tab.log);
+        });
+        messageBus.on('transcript', 'tab:cleared', (event) => {
+            if (event.type === 'tab:cleared')
+                TranscriptStore.clearTab(event.tabLabel);
+        });
+    }
+}

package/dist/types.js

@@ -0,0 +1,6 @@
+/* eslint-disable max-lines */
+// Shared type declarations for the top-level `src/` modules. Types live here rather than
+// alongside their implementations so each directory has a single types file (the
+// `src/commands/` directory has its own `commands/types.ts`). Runtime values (functions,
+// constants) stay in their respective modules; only types are collected here.
+export {};

package/dist/user-agent.js

@@ -0,0 +1,65 @@
+// A randomized-but-coherent browser fingerprint per window (BrowserContext). The point is
+// twofold: (1) isolated windows shouldn't share an identical fingerprint, and (2) every
+// signal we expose must be internally consistent — a user agent that disagrees with the
+// platform, locale, timezone, or client-hint headers is itself a bot tell. So a profile
+// bundles the UA string with the matching `Sec-CH-UA-Platform` value, an Accept-Language
+// header, a timezone plausible for the platform, and a common desktop viewport.
+//
+// The Chrome *version* is pinned to the real Chromium build at the call site (passed in as
+// `chromeMajor`) so the UA string and the engine-emitted client hints report the same
+// version. Only the platform/locale/timezone/viewport are randomized.
+const PLATFORMS = [
+    {
+        token: 'Windows NT 10.0; Win64; x64',
+        platform: 'Windows',
+        timezones: ['America/New_York', 'America/Chicago', 'America/Los_Angeles', 'Europe/London'],
+    },
+    {
+        token: 'Macintosh; Intel Mac OS X 10_15_7',
+        platform: 'macOS',
+        timezones: ['America/New_York', 'America/Los_Angeles', 'Europe/London'],
+    },
+    {
+        token: 'X11; Linux x86_64',
+        platform: 'Linux',
+        timezones: ['Europe/Berlin', 'Europe/Paris', 'America/New_York'],
+    },
+];
+// Common desktop resolutions; nothing exotic that would stand out.
+const VIEWPORTS = [
+    { width: 1920, height: 1080 },
+    { width: 1536, height: 864 },
+    { width: 1440, height: 900 },
+    { width: 1366, height: 768 },
+    { width: 1280, height: 720 },
+];
+const LOCALES = ['en-US', 'en-GB'];
+// Fallback when the real Chromium version can't be read; kept recent.
+export const DEFAULT_CHROME_MAJOR = 149;
+function pick(array, rand) {
+    return array[Math.floor(rand() * array.length)];
+}
+/**
+ * Generate a coherent browser profile. `chromeMajor` should be the real engine's major
+ * version so the UA matches the client hints; `rand` is injectable for deterministic tests.
+ */
+export function randomBrowserProfile(chromeMajor = DEFAULT_CHROME_MAJOR, rand = Math.random) {
+    const p = pick(PLATFORMS, rand);
+    const userAgent = `Mozilla/5.0 (${p.token}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeMajor}.0.0.0 Safari/537.36`;
+    return {
+        userAgent,
+        platform: p.platform,
+        locale: pick(LOCALES, rand),
+        timezoneId: pick(p.timezones, rand),
+        viewport: pick(VIEWPORTS, rand),
+    };
+}
+/** Just the UA string from a fresh profile (convenience for callers that only need that). */
+export function randomUserAgent(chromeMajor = DEFAULT_CHROME_MAJOR, rand = Math.random) {
+    return randomBrowserProfile(chromeMajor, rand).userAgent;
+}
+/** Build an `Accept-Language` header value consistent with a profile's locale. */
+export function acceptLanguage(locale) {
+    const base = locale.split('-', 1)[0];
+    return locale === base ? `${locale};q=0.9` : `${locale},${base};q=0.9`;
+}

package/dist/word-wrapping.js

@@ -0,0 +1,42 @@
+function wrapLine(line, width) {
+    const out = [];
+    let current = '';
+    for (const word of line.split(' ')) {
+        if (word.length > width) {
+            if (current)
+                out.push(current);
+            let w = word;
+            while (w.length > width) {
+                out.push(w.slice(0, width));
+                w = w.slice(width);
+            }
+            current = w;
+        }
+        else if (current === '') {
+            current = word;
+        }
+        else if (current.length + 1 + word.length <= width) {
+            current += ' ' + word;
+        }
+        else {
+            out.push(current);
+            current = word;
+        }
+    }
+    if (current)
+        out.push(current);
+    return out;
+}
+export function wordWrap(text, width) {
+    if (width <= 0)
+        return text;
+    const out = [];
+    for (const line of text.split('\n')) {
+        if (line.length <= width) {
+            out.push(line);
+            continue;
+        }
+        out.push(...wrapLine(line, width));
+    }
+    return out.join('\n');
+}

package/dist/workspace-manager.js

@@ -0,0 +1,40 @@
+import { findRepoRoot, createWorkspace, removeWorkspace } from './workspace.js';
+const NO_REPO = 'No git repository found. Cannot create workspace.';
+// Owns the set of workspace clones the app has created — an independent `git clone` of the repo's
+// `origin` remote, made for an agent (`agent --workspace`) or a harness tab (`harness <name>
+// --workspace`) so it works in isolation. Tracks each clone so it can be removed when its tab
+// closes or at shutdown.
+export class WorkspaceManager {
+    dirs = new Set();
+    projectDir;
+    constructor(projectDir) {
+        this.projectDir = projectDir ?? process.cwd();
+    }
+    // Create a workspace clone named `name` from the repo detected at the launch cwd, tracking it for
+    // cleanup. Returns the new directory, or an `{ error }` to surface when there's no repo / the clone
+    // fails. Shared by the agent and harness `--workspace` paths so both behave identically.
+    create(name) {
+        const root = findRepoRoot(this.projectDir);
+        if (!root)
+            return { error: NO_REPO };
+        try {
+            const dir = createWorkspace(name, root);
+            this.dirs.add(dir);
+            return { dir };
+        }
+        catch (error) {
+            return { error: `Failed to create workspace: ${error instanceof Error ? error.message : String(error)}` };
+        }
+    }
+    // Remove a workspace clone and stop tracking it (on tab close).
+    remove(dir) {
+        removeWorkspace(dir);
+        this.dirs.delete(dir);
+    }
+    // Remove every workspace clone (app shutdown).
+    removeAll() {
+        for (const dir of this.dirs)
+            removeWorkspace(dir);
+        this.dirs.clear();
+    }
+}

package/dist/workspace.js

@@ -0,0 +1,120 @@
+import { existsSync, mkdirSync, rmSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { homedir } from 'node:os';
+import { execSync } from 'node:child_process';
+let workspaceBaseDir = '';
+export function initWorkspaceDir(projectDir) {
+    workspaceBaseDir = path.join(projectDir, '.janissary', 'workspace');
+}
+export function ensureWorkspaceDir() {
+    mkdirSync(workspaceBaseDir, { recursive: true });
+}
+export function workspacePath(name) {
+    if (!workspaceBaseDir)
+        throw new Error('Workspace dir not initialized. Call initWorkspaceDir first.');
+    return path.join(workspaceBaseDir, name);
+}
+export function findRepoRoot(from) {
+    let directory = from;
+    while (true) {
+        if (existsSync(path.join(directory, '.git')))
+            return directory;
+        const parent = path.dirname(directory);
+        if (parent === directory)
+            return undefined;
+        directory = parent;
+    }
+}
+export function trustWorkspace(workspaceDir) {
+    const claudeJson = path.join(homedir(), '.claude.json');
+    let data = {};
+    try {
+        data = JSON.parse(readFileSync(claudeJson, 'utf8'));
+    }
+    catch { /* file absent or unparseable — start fresh */ }
+    const projects = (data['projects'] ?? {});
+    projects[workspaceDir] = { ...projects[workspaceDir], hasTrustDialogAccepted: true };
+    data['projects'] = projects;
+    writeFileSync(claudeJson, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+// The workspace's private scratch dir, a sibling of the clone (`<name>.tmp`) — exported as
+// `TMPDIR` for a sandboxed workspace so scratch writes don't need to share global `/tmp` across
+// agents (see `sandbox.ts`).
+export function workspaceTempPath(name) {
+    return `${workspacePath(name)}.tmp`;
+}
+export function getRemoteUrl(repoPath) {
+    // Intentional: user-driven workspace creation; only local-user commands reach this sink.
+    const url = execSync('git remote get-url origin', { cwd: repoPath, stdio: 'pipe' }).toString().trim();
+    if (!url)
+        throw new Error(`No "origin" remote configured for ${repoPath}`);
+    return url;
+}
+// Handles `git@github.com:owner/repo.git` and `ssh://git@github.com/owner/repo.git`; an
+// already-HTTPS URL passes through unchanged.
+export function toHttpsUrl(url) {
+    const scpMatch = /^git@([^:]+):(.+?)(\.git)?$/.exec(url);
+    if (scpMatch)
+        return `https://${scpMatch[1]}/${scpMatch[2]}.git`;
+    const sshMatch = /^ssh:\/\/git@([^/]+)\/(.+?)(\.git)?$/.exec(url);
+    if (sshMatch)
+        return `https://${sshMatch[1]}/${sshMatch[2]}.git`;
+    return url;
+}
+export function createWorkspace(name, repoPath) {
+    ensureWorkspaceDir();
+    const target = workspacePath(name);
+    const remoteUrl = getRemoteUrl(repoPath);
+    // Clone over whatever transport already works on the host (this runs unsandboxed, so SSH is
+    // fine here) — intentional: user-driven workspace creation; only local-user commands reach this
+    // sink.
+    execSync(`git clone "${remoteUrl}" "${target}"`, { stdio: 'pipe' });
+    // Rewrite the clone's own origin to HTTPS: later git operations from *inside* the workspace run
+    // in the Seatbelt sandbox, which denies `~/.ssh` and scrubs `SSH_AUTH_SOCK`, so SSH can't
+    // authenticate there — only HTTPS + the injected `GH_TOKEN` can (see sandbox.ts).
+    execSync(`git remote set-url origin "${toHttpsUrl(remoteUrl)}"`, { cwd: target, stdio: 'pipe' });
+    // Local-only credential helper (never touches global git config) — `gh auth git-credential`
+    // checks `GH_TOKEN` in its environment before falling back to its keychain-stored OAuth token,
+    // so once the sandbox injects `GH_TOKEN` (see sandbox.ts), `git push` authenticates via it.
+    execSync('git config --local credential.helper "!gh auth git-credential"', { cwd: target, stdio: 'pipe' });
+    trustWorkspace(target);
+    mkdirSync(workspaceTempPath(name), { recursive: true });
+    return target;
+}
+export function untrustWorkspace(workspaceDir) {
+    const claudeJson = path.join(homedir(), '.claude.json');
+    let data;
+    try {
+        data = JSON.parse(readFileSync(claudeJson, 'utf8'));
+    }
+    catch {
+        return;
+    }
+    const projects = data['projects'];
+    if (!projects || !Object.hasOwn(projects, workspaceDir))
+        return;
+    delete projects[workspaceDir];
+    writeFileSync(claudeJson, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+export function removeWorkspace(directory) {
+    untrustWorkspace(directory);
+    try {
+        rmSync(directory, { recursive: true, force: true });
+    }
+    catch { /* ignore */ }
+    try {
+        rmSync(`${directory}.tmp`, { recursive: true, force: true });
+    }
+    catch { /* ignore */ }
+}
+export function clearWorkspaceDir() {
+    if (!workspaceBaseDir)
+        return;
+    try {
+        const entries = readdirSync(workspaceBaseDir);
+        for (const entry of entries) {
+            rmSync(path.join(workspaceBaseDir, entry), { recursive: true, force: true });
+        }
+    }
+    catch { /* ignore */ }
+}

package/help.md

@@ -0,0 +1,97 @@
+### Commands
+
+| Command | Description |
+| ------- | ----------- |
+| `help` | List available commands |
+| `state` | Show agent state fields (truncated) |
+| `clear` | Clear the output log |
+| `quit` | Exit the application (asks for confirmation) |
+| `close` | Close the current tab (exits if last); `close page #` closes a numbered page tab; `close <tabname>` closes a tab by its label. `exit` is an alias |
+| `agent` | Create a new agent tab (add `--workspace` / `-w` to clone the repo, isolated by default — see Workspace; add `--offline` to also deny network access) |
+| `next` | Switch to the next tab |
+| `hist` | Open command history picker |
+| `tasks` | Open the task picker listing executable `ai/*.md` task files (Ctrl+A) |
+| `nav` | Open the fuzzy tab navigator (Ctrl+G); `nav <query>` pre-fills the search |
+| `msg` | Send a message to another agent |
+| `broadcast` | Send a message to several or all agents |
+| `acp` | Send a prompt to the OpenCode ACP agent |
+| `db` | Create, delete, query, or list SQLite databases |
+| `browser` | Drive a headless/headed web browser (open, goto, content, eval, shot) |
+| `open` | Open images/files in a tab, or web pages embedded (`open https://…` / `open page …`) — sites that refuse framing render too; `open external` uses the OS viewer/browser |
+| `edit` | Open a file in the plain-text editor (`edit <file>` or `edit <file>:<line>` to jump to a line) |
+| `rename` | Rename the current tab's display name (`rename <name>`); bare `rename` clears the alias |
+| `connection` | List or close open connections (sqlite/shell/acp/browser) |
+| `schedule` | Run a command later — once or on a recurring schedule |
+| `profile` | Launch a saved set of agents for a use case |
+| `harness` | Open an AI coding harness (claude/opencode/codex) in a full-tab terminal (add `-w` / `--workspace` to clone the repo, `-y` / `--yes` to auto-approve claude's permission prompts — claude only, requires `-w`); `harness capture <name>` snapshots a harness tab's screen into an editor tab |
+| `ssh` | Open an SSH session to a remote host in a full-tab terminal |
+| `search` | `search transcript <pattern>` searches the current tab's transcript with a regex (Cmd+F opens it empty) |
+| `files` | `files [path]` opens a file tree tab rooted at the issuing tab's cwd, or at `path` |
+| `notifications` | `notifications [left\|right]` opens (or docks) the notifications tab — a feed of background-tab events (see `.janissary/config.json` to enable events) |
+| `notify` | `notify <message>` pushes a custom line into the notifications feed (dropped if the tab is closed) |
+| `send` | Deliver a line of input to any tab — types into a harness, or runs a command in an agent tab |
+| `queue` | Queue a command for another agent tab (`queue <agent> <command>`); bare `queue` opens the interactive queue picker (Ctrl+E) |
+| `monitor` | Start a persona-driven AI monitor — inline on the current tab, or watching other tabs/groups into a reporting tab |
+| `unmonitor` | Stop a monitor (`unmonitor <persona>`) or all monitors started from this tab (`--all`) |
+| `monitors` | List active monitors with their targets and suggestion counts |
+| `theme` | Set the application UI theme (`theme <name>`); `theme` alone lists available themes; `theme sync` sets the syntax theme to match the app theme name |
+| `syntax` | `syntax theme <name>` sets the editor tab's syntax-highlighting theme (applies to every open editor tab); `syntax theme` alone opens a theme-picker modal |
+
+### Key Bindings
+
+| Key | Action |
+| --- | ------ |
+| `←` / `→` | Move cursor in the input field |
+| `↑` / `↓` | Previous / next command in history |
+| `Shift+←` / `Shift+→` / `Cmd+Shift+[` / `Cmd+Shift+]` | Switch to the previous / next tab |
+| `Ctrl+←` / `Ctrl+→` | Move the current tab left / right |
+| `Shift+↑` / `Shift+↓` | Scroll the transcript up / down (accelerated — distance doubles each second) |
+| `Ctrl+↑` / `Ctrl+↓` | Scroll the transcript up / down (accelerated) |
+| `Page Up` / `Page Down` | Scroll the transcript up / down by half terminal height |
+| `Escape` | Reset scroll to bottom |
+| `Ctrl+P` / `Ctrl+N` | Scroll the transcript up / down one line (fixed) |
+| `Ctrl+R` | Open command history picker |
+| `Ctrl+G` | Open the fuzzy tab navigator (also closes it if already open) |
+| `Ctrl+E` | Open the queue picker to send a command to another agent tab |
+| `Ctrl+A` | Open the task picker (executable `ai/*.md` files); Return populates the command line without running |
+| `Ctrl+T` | Expand / collapse agent tool steps in the transcript |
+| `Cmd+T` | Open a new agent tab (same as typing `agent`) |
+| `Cmd+F` | Open the search bar in the transcript |
+| `Cmd+W` / `Ctrl+W` | Close the current tab |
+| `Tab` | Complete a file path, an agent name for `msg` / `broadcast`, a connection string for `connection close`, a `browser` subcommand / window id, or a `monitor` persona / target |
+| `Shift+Tab` | Move keyboard focus to the next application section (left → center → right sidebar/panel → reporting), looping; the visible tab in that section gets focus |
+| `Enter` | Execute the current command |
+| `Ctrl+C` | Exit |
+
+**Image tab controls** (active only while an image tab is focused):
+
+| Key | Action |
+| --- | ------ |
+| `Page Up` / scroll-wheel up | Zoom in (10% per step, up to 800%) |
+| `Page Down` / scroll-wheel down | Zoom out (10% per step, down to 10%) |
+| `↑` / `↓` / `←` / `→` | Pan the image |
+| Click and drag | Pan freely |
+| `Escape` | Reset zoom to 100% and center the view |
+
+**Markdown tab controls** (active only while a markdown tab is focused):
+
+| Key | Action |
+| --- | ------ |
+| `↑` / `↓` | Scroll up / down by a line |
+| `Page Up` / `Page Down` | Scroll up / down by a page |
+| Mouse wheel | Scroll up / down |
+
+**File tree tab controls** (active only while a file tree tab is focused):
+
+| Key | Action |
+| --- | ------ |
+| `↑` / `↓` | Move selection to the previous / next visible row |
+| `→` | Collapsed directory: expand. Expanded directory: move to its first child. File: no-op |
+| `←` | Expanded directory: collapse. Otherwise: move selection to the parent directory |
+| `Enter` / `Space` | File: open. Directory: toggle expand/collapse |
+| `Alt+Enter` | File: open in the plain-text editor (mirrors Alt+click) |
+| `Home` / `End` | Select the first / last visible row |
+| `Page Up` / `Page Down` | Move selection by one viewport of rows |
+| Printable characters | Type-ahead: jump to the next visible row whose name starts with what's typed |
+
+`Tab` completes the word at the cursor: filesystem paths against the tab's working directory; at the recipient position of `msg` / `broadcast`, active agent names (`broadcast` also offers `all` and completes each entry of a comma-separated list); at the target of `connection close`, the tab's open connection strings (`sqlite:<name>`, `shell:<shell>`, `acp:opencode`, `browser:<id>`); and for the `browser` command, its subcommands (`open`, `goto`, `content`, …) plus the tab's open window ids where one is expected (`browser use`, `browser window close`). For `monitor` / `unmonitor`, the first argument completes against persona names (from `ai/personas/`) and later arguments against tab labels and `group:<n>` tokens (`unmonitor` also offers `--all`).