janissary 0.5.0

package/dist/commands/broadcast.js

@@ -0,0 +1,22 @@
+import { parseBroadcastCommand } from '../messaging.js';
+export const command = {
+    name: 'broadcast',
+    match: (command_) => /^broadcast\b/i.test(command_),
+    run: (command_, tab, managers) => {
+        const parsed = parseBroadcastCommand(command_);
+        if ('error' in parsed) {
+            managers.tab.append(tab.label, { input: command_, output: parsed.error });
+            return;
+        }
+        const targets = parsed.targets === 'all'
+            ? managers.tab.allLabels().filter((l) => l !== tab.label)
+            : parsed.targets;
+        const missing = [];
+        for (const to of targets) {
+            if (!managers.communication.send({ from: tab.label, to, kind: parsed.kind, text: parsed.text }))
+                missing.push(to);
+        }
+        if (missing.length > 0)
+            managers.tab.append(tab.label, { input: command_, output: `No agent named: ${missing.join(', ')}.` });
+    },
+};

package/dist/commands/browser.js

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

package/dist/commands/clear.js

@@ -0,0 +1,5 @@
+export const command = {
+    name: 'clear',
+    match: (command_) => command_.toLowerCase() === 'clear',
+    run: (_command, tab, managers) => { managers.tab.clearTranscript(tab.label); },
+};

package/dist/commands/close.js

@@ -0,0 +1,42 @@
+// Parse a `close` command: bare `close` closes the active tab (quitting the app if it is the
+// only tab); `close page <n>` closes the numbered page tab; `close <name>` closes the tab with
+// that label. `exit` is an alias of `close`.
+export function parseClose(command_) {
+    const rest = command_.replace(/^(?:close|exit)\b\s*/i, '').trim();
+    if (!rest)
+        return { target: 'active' };
+    const pageMatch = rest.match(/^page\b\s*(\d+)\s*$/i);
+    if (pageMatch)
+        return { target: 'page', number: Number(pageMatch[1]) };
+    return { target: 'tabname', name: rest.trim() };
+}
+export const command = {
+    name: 'close',
+    match: (command_) => /^(?:close|exit)\b/i.test(command_),
+    run: (command_, tab, managers) => {
+        const parsed = parseClose(command_);
+        if ('error' in parsed) {
+            managers.tab.append(tab.label, { input: command_, output: parsed.error });
+            return;
+        }
+        if (parsed.target === 'page') {
+            const pageTab = managers.tab.tabs.findIndex((t) => t.page?.number === parsed.number);
+            if (pageTab === -1) {
+                managers.tab.append(tab.label, { input: command_, output: `No page numbered ${parsed.number}.` });
+                return;
+            }
+            managers.tab.closeTab(pageTab);
+        }
+        else if (parsed.target === 'tabname') {
+            const nameTab = managers.tab.tabs.findIndex((t) => t.label.toLowerCase() === parsed.name.toLowerCase());
+            if (nameTab === -1) {
+                managers.tab.append(tab.label, { input: command_, output: `No tab named "${parsed.name}".` });
+                return;
+            }
+            managers.tab.closeTab(nameTab);
+        }
+        else {
+            managers.tab.closeTab(tab.index);
+        }
+    },
+};

package/dist/commands/connection.js

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

package/dist/commands/db.js

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

package/dist/commands/edit.js

@@ -0,0 +1,18 @@
+// `edit <file>` — open the in-app plain-text editor on any file, regardless of which opener owns
+// its extension (`open readme.md` keeps the rendered view; `edit readme.md` opens the editor).
+export const command = {
+    name: 'edit',
+    match: (command_) => /^edit\b/i.test(command_),
+    run: (command, tab, managers) => {
+        const target = command.replace(/^edit\b\s*/i, '').trim();
+        if (!target) {
+            managers.tab.append(tab.label, { input: command, output: 'Usage: edit <file>' });
+            return;
+        }
+        const lineMatch = /^(.+):(\d+)$/.exec(target);
+        const path = lineMatch ? lineMatch[1] : target;
+        const line = lineMatch ? Number(lineMatch[2]) : undefined;
+        managers.tab.append(tab.label, { input: command, output: '' });
+        managers.openFile.edit(command, path, tab.label, line);
+    },
+};

package/dist/commands/files.js

@@ -0,0 +1,13 @@
+// `files [path]` opens a file tree tab rooted at the issuing tab's cwd, or at `path` when given.
+// `files left [path]` / `files right [path]` dock the tree into that sidebar instead of the
+// central tab strip (a directory literally named `left`/`right` is still reachable, e.g. `files
+// ./left`, since the keyword is only recognized as the first word). `files in <label> [on <side>]`
+// / `files on <side> [in <label>]` root the tree at another tab's cwd and/or dock it explicitly.
+export const command = {
+    name: 'files',
+    match: (command_) => /^files\b/i.test(command_),
+    run: (command_, tab, managers) => {
+        managers.tab.append(tab.label, { input: command_, output: '' });
+        managers.fileTree.open(command_, tab.label);
+    },
+};

package/dist/commands/hist.js

@@ -0,0 +1,7 @@
+export const command = {
+    name: 'hist',
+    match: (command_) => command_.toLowerCase() === 'hist',
+    // The history picker is interactive (client-side, Ctrl+R); reaching the server non-interactively
+    // (e.g. via a scheduled dispatch) is a no-op.
+    run: () => { },
+};

package/dist/commands/index.js

@@ -0,0 +1,62 @@
+import { command as agent } from './agent.js';
+import { command as next } from './next.js';
+import { command as message } from './msg.js';
+import { command as broadcast } from './broadcast.js';
+import { command as acp } from './acp.js';
+import { command as acpReset } from './acp-reset.js';
+import { command as database } from './db.js';
+import { command as browser } from './browser.js';
+import { command as connection } from './connection.js';
+import { command as clear } from './clear.js';
+import { command as state } from './state.js';
+import { command as hist } from './hist.js';
+import { command as close } from './close.js';
+import { command as quit } from './quit.js';
+import { command as schedule } from './schedule.js';
+import { command as profile } from './profile.js';
+import { command as open } from './open.js';
+import { command as edit } from './edit.js';
+import { command as send } from './send.js';
+import { command as queue } from './queue.js';
+import { command as rename } from './rename.js';
+import { command as search } from './search.js';
+import { command as files } from './files.js';
+import { command as notifications } from './notifications.js';
+import { command as notify } from './notify.js';
+import { command as syntax } from './syntax.js';
+import { command as theme } from './theme.js';
+import { command as tasks } from './tasks.js';
+import { monitor, unmonitor, monitors } from './monitor.js';
+export const commands = [
+    agent,
+    next,
+    message,
+    broadcast,
+    acpReset,
+    acp,
+    database,
+    browser,
+    connection,
+    clear,
+    state,
+    hist,
+    close,
+    quit,
+    schedule,
+    profile,
+    open,
+    edit,
+    send,
+    queue,
+    rename,
+    search,
+    files,
+    notifications,
+    notify,
+    syntax,
+    theme,
+    tasks,
+    monitors,
+    monitor,
+    unmonitor,
+];

package/dist/commands/monitor.js

@@ -0,0 +1,61 @@
+import { parseMonitorCommand, parseUnmonitorCommand } from '../monitor/parsing.js';
+// `monitor <persona> [target...]` — start a persona-driven AI monitor. No targets:
+// inline mode, watching the current tab and reporting into its transcript. With targets
+// (tab labels or `group:<n>`): external mode, reporting into the persona's reporting tab.
+// `monitor ask <persona> <question>` — query a running monitor's ACP directly.
+export const monitor = {
+    name: 'monitor',
+    match: (command_) => /^monitor(\s|$)/i.test(command_),
+    run: (command_, tab, managers) => {
+        const out = (text) => managers.tab.append(tab.label, { input: command_, output: text });
+        const parsed = parseMonitorCommand(command_);
+        if ('error' in parsed) {
+            out(parsed.error);
+            return;
+        }
+        if ('ask' in parsed) {
+            const askError = managers.monitor.ask(tab.label, parsed.persona, parsed.question);
+            if (askError)
+                out(askError);
+            return;
+        }
+        const error = managers.monitor.start(tab.label, parsed.persona, parsed.targets);
+        if (error) {
+            out(error);
+            return;
+        }
+        const watched = parsed.targets.length === 0
+            ? tab.label
+            : parsed.targets.map((t) => (t.kind === 'tab' ? t.label : `group ${t.group}`)).join(', ');
+        out(`→ Now monitoring ${watched} (persona: ${parsed.persona})`);
+    },
+};
+// `unmonitor <persona> [target]` / `unmonitor --all` — stop monitors started from this tab.
+export const unmonitor = {
+    name: 'unmonitor',
+    match: (command_) => /^unmonitor(\s|$)/i.test(command_),
+    run: (command_, tab, managers) => {
+        const out = (text) => managers.tab.append(tab.label, { input: command_, output: text });
+        const parsed = parseUnmonitorCommand(command_);
+        if ('error' in parsed) {
+            out(parsed.error);
+            return;
+        }
+        if ('all' in parsed) {
+            const stopped = managers.monitor.stopAll(tab.label);
+            out(stopped > 0 ? `→ Stopped ${stopped} monitor${stopped === 1 ? '' : 's'}` : 'No monitors running from this tab.');
+            return;
+        }
+        const stopped = managers.monitor.stop(tab.label, parsed.persona, parsed.target);
+        out(stopped ? `→ Stopped ${parsed.persona} monitor` : `No "${parsed.persona}" monitor running from this tab.`);
+    },
+};
+// `monitors` — list all active monitors.
+export const monitors = {
+    name: 'monitors',
+    match: (command_) => /^monitors$/i.test(command_),
+    run: (command_, tab, managers) => {
+        const lines = managers.monitor.list();
+        managers.tab.append(tab.label, { input: command_, output: lines.length > 0 ? lines.join('\n') : 'No active monitors.' });
+    },
+};

package/dist/commands/msg.js

@@ -0,0 +1,17 @@
+import { parseMsgCommand as parseMessageCommand } from '../messaging.js';
+export const command = {
+    name: 'msg',
+    match: (command_) => /^msg\b/i.test(command_),
+    run: (command_, tab, managers) => {
+        const parsed = parseMessageCommand(command_);
+        if ('error' in parsed) {
+            managers.tab.append(tab.label, { input: command_, output: parsed.error });
+            return;
+        }
+        if (!managers.communication.send({ from: tab.label, to: parsed.to, kind: parsed.kind, text: parsed.text })) {
+            managers.tab.append(tab.label, { input: command_, output: `No agent named "${parsed.to}".` });
+            return;
+        }
+        managers.tab.append(tab.label, { input: command_, output: `→ ${parsed.to} (${parsed.kind}): ${parsed.text}` });
+    },
+};

package/dist/commands/next.js

@@ -0,0 +1,7 @@
+export const command = {
+    name: 'next',
+    match: (command_) => command_.toLowerCase() === 'next',
+    run: (_command, context, managers) => {
+        managers.tab.setActiveTab((managers.tab.activeTab + 1) % managers.tab.tabs.length);
+    },
+};

package/dist/commands/notifications.js

@@ -0,0 +1,16 @@
+import { openNotificationsTab } from '../notifications-tab.js';
+// `notifications` opens (or focuses) the singleton notifications tab. `notifications left` /
+// `notifications right` dock it into that sidebar, mirroring `files [left|right]`. Bare
+// `notifications` on a docked tab undocks it back to center and makes it active. The tab is a
+// singleton — a second invocation reuses the existing one.
+export const command = {
+    name: 'notifications',
+    match: (command_) => /^notifications\b/i.test(command_),
+    run: (command_, tab, managers) => {
+        managers.tab.append(tab.label, { input: command_, output: '' });
+        const rest = command_.replace(/^notifications\b\s*/i, '');
+        const keyword = /^(left|right)\b/i.exec(rest);
+        const dock = keyword ? keyword[1].toLowerCase() : undefined;
+        openNotificationsTab(managers, dock);
+    },
+};

package/dist/commands/notify.js

@@ -0,0 +1,20 @@
+import { notify } from '../notifications.js';
+// `notify <message>` pushes a custom line into the notifications feed, attributed to the issuing
+// tab. It is the deliberate counterpart to the four ambient events: an explicit signal that
+// bypasses focus suppression and the per-event toggles (an agent that calls `notify` always means
+// to signal, even from the focused tab). It never opens the tab — if the feed is closed the
+// message is dropped (drop-if-closed). Available from any tab, agents included. `notify` with no
+// message is a usage error and records nothing in the feed.
+export const command = {
+    name: 'notify',
+    match: (command_) => /^notify\b/i.test(command_),
+    run: (command_, tab, managers) => {
+        const message = command_.replace(/^notify\b\s*/i, '').trim();
+        managers.tab.append(tab.label, { input: command_, output: '' });
+        if (!message) {
+            managers.tab.append(tab.label, { input: '', output: 'Usage: notify <message>.' });
+            return;
+        }
+        notify(managers, 'manual', tab.label, message);
+    },
+};

package/dist/commands/open.js

@@ -0,0 +1,41 @@
+// Parse an `open` command line. The leading `open` keyword is stripped; the optional `external` and
+// `page` keywords (in any order) are consumed; everything remaining is the target. A target with an
+// http/https scheme, or preceded by `page`, is routed to the web opener (`web: true`); otherwise it
+// goes to the file opener. The target is kept verbatim (paths may contain spaces).
+export function parseOpen(command_) {
+    let rest = command_.replace(/^open\b\s*/i, '');
+    let isExternal = false;
+    let isPage = false;
+    // Consume optional keywords in any order.
+    let changed = true;
+    while (changed) {
+        changed = false;
+        const extMatch = rest.match(/^external\b\s*/i);
+        if (extMatch) {
+            isExternal = true;
+            rest = rest.slice(extMatch[0].length);
+            changed = true;
+        }
+        const pageMatch = rest.match(/^page\b\s*/i);
+        if (pageMatch) {
+            isPage = true;
+            rest = rest.slice(pageMatch[0].length);
+            changed = true;
+        }
+    }
+    const target = rest.trim();
+    if (!target)
+        return { error: 'Usage: open [external] [page] <target>' };
+    const web = isPage || /^https?:\/\//i.test(target);
+    return { external: isExternal, web, target };
+}
+// Whether an `open` argument is a shell wildcard pattern (expanded to a list of files) rather than a
+// single literal path. Detects the common glob metacharacters: `* ? [ ] { }`.
+export function isGlobPattern(argument) {
+    return /[*?[\]{}]/.test(argument);
+}
+export const command = {
+    name: 'open',
+    match: (command_) => /^open\b/i.test(command_),
+    run: (command, tab, managers) => { managers.openFile.run(command, tab.label); },
+};

package/dist/commands/profile.js

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

package/dist/commands/queue.js

@@ -0,0 +1,37 @@
+import { resolveTarget } from './resolve-target.js';
+/** Parse a `queue <agent> <command...>` command (the leading `queue` is optional). */
+export function parseQueueCommand(input) {
+    const body = input.trim().replace(/^queue\b\s*/i, '');
+    const parts = body.split(/\s+/).filter(Boolean);
+    const label = parts[0];
+    const text = parts.slice(1).join(' ');
+    if (!label || !text)
+        return { error: 'Usage: queue <agent> <command>' };
+    return { label, text };
+}
+export const command = {
+    name: 'queue',
+    match: (command_) => /^queue\b/i.test(command_),
+    run: (command_, tab, managers) => {
+        // Bare `queue` is the interactive picker (Ctrl+E), handled client-side; reaching the server
+        // non-interactively (e.g. via a scheduled dispatch) is a no-op.
+        if (/^queue\s*$/i.test(command_.trim()))
+            return;
+        const append = (text) => managers.tab.append(tab.label, { input: command_, output: text });
+        const parsed = parseQueueCommand(command_);
+        if ('error' in parsed) {
+            append(parsed.error);
+            return;
+        }
+        const target = resolveTarget(parsed.label, managers, append);
+        if (!target)
+            return;
+        if (target.view !== undefined && target.view !== 'agent') {
+            append(`Tab "${parsed.label}" has no command queue.`);
+            return;
+        }
+        managers.tab.enqueue(target.label, parsed.text);
+        managers.command.drainQueue(target.label);
+        append(`→ ${parsed.label} (queued): ${parsed.text}`);
+    },
+};

package/dist/commands/quit.js

@@ -0,0 +1,6 @@
+import { messageBus } from '../bus.js';
+export const command = {
+    name: 'quit',
+    match: (command_) => command_.trim().toLowerCase() === 'quit',
+    run: () => { messageBus.emit('app', { type: 'exit' }); },
+};

package/dist/commands/rename.js

@@ -0,0 +1,12 @@
+export const command = {
+    name: 'rename',
+    match: (command_) => /^rename\b/i.test(command_),
+    run: (command_, tab, managers) => {
+        const rest = command_.replace(/^rename\b\s*/i, '').trim();
+        managers.tab.renameTab(tab.index, rest);
+        const output = rest
+            ? `Tab "${tab.label}" now displays as "${rest}" (msg/routing still use "${tab.label}").`
+            : `Tab "${tab.label}" alias cleared.`;
+        managers.tab.append(tab.label, { input: command_, output });
+    },
+};

package/dist/commands/resolve-target.js

@@ -0,0 +1,12 @@
+// Resolve a command's target tab by its label or display alias (see `rename`), appending the
+// standard "not found" message and returning undefined if there's no match — shared by
+// `queue` and `send`, which both address a tab this way.
+export function resolveTarget(label, managers, append) {
+    const key = label.toLowerCase();
+    const target = managers.tab.tabs.find((t) => t.label.toLowerCase() === key || t.title?.toLowerCase() === key);
+    if (!target) {
+        append(`No tab named "${label}".`);
+        return undefined;
+    }
+    return target;
+}

package/dist/commands/schedule.js

@@ -0,0 +1,74 @@
+import { parseScheduleCommand, formatSchedule } from '../schedule/index.js';
+// Resolve the tab a schedule operation applies to: the issuing tab by default, or the
+// `in <tab>` target. Agent and harness tabs can hold schedules; image/page/markdown views
+// cannot run commands, so scheduling into them is rejected.
+function resolveTargetTab(target, own, managers) {
+    const label = target ?? own;
+    const tab = managers.tab.tabs.find((t) => t.label === label);
+    if (!tab)
+        return { error: `No tab named "${label}".` };
+    if (tab.view !== undefined && tab.view !== 'agent' && tab.view !== 'harness') {
+        return { error: `Tab "${label}" cannot run scheduled commands.` };
+    }
+    return tab;
+}
+// Persist a tab's schedule alongside its agent state. Harness tabs have no persisted agent
+// state (they cannot be rehydrated), so their schedules live in memory only.
+function persistSchedule(tab, managers) {
+    if (tab.view === 'harness')
+        return;
+    managers.tab.persist(managers.tab.buildAgentState(tab, { schedule: managers.schedule.get(tab.label) }));
+}
+export const command = {
+    name: 'schedule',
+    match: (command_) => /^schedule\b/i.test(command_),
+    run: (command_, tab, managers) => {
+        const parsed = parseScheduleCommand(command_.replace(/^schedule\b\s*/i, ''), new Date());
+        const append = (text) => managers.tab.append(tab.label, { input: command_, output: text });
+        if ('error' in parsed) {
+            append(parsed.error);
+            return;
+        }
+        const target = resolveTargetTab(parsed.target, tab.label, managers);
+        if ('error' in target) {
+            append(target.error);
+            return;
+        }
+        const suffix = target.label === tab.label ? '' : ` in ${target.label}`;
+        const current = managers.schedule.get(target.label) ?? [];
+        if (parsed.action === 'list') {
+            append(formatSchedule(current));
+            return;
+        }
+        let next;
+        let message;
+        if (parsed.action === 'add') {
+            if (current.some((e) => e.id === parsed.name)) {
+                append(`A scheduled command named "${parsed.name}" already exists${suffix}.`);
+                return;
+            }
+            const entry = { ...parsed.entry, id: parsed.name };
+            next = [...current, entry];
+            message = `Scheduled ${entry.id}${suffix}: ${entry.spec} — ${entry.command}`;
+        }
+        else if (parsed.action === 'cancel') {
+            next = current.filter((e) => e.id !== parsed.id);
+            if (next.length === current.length) {
+                append(`No scheduled command "${parsed.id}"${suffix}.`);
+                return;
+            }
+            message = `Cancelled ${parsed.id}${suffix}.`;
+        }
+        else {
+            if (current.length === 0) {
+                append(`No scheduled commands${suffix}.`);
+                return;
+            }
+            next = [];
+            message = `Cleared ${current.length} scheduled command${current.length === 1 ? '' : 's'}${suffix}.`;
+        }
+        managers.schedule.set(target.label, next);
+        persistSchedule(target, managers);
+        append(message);
+    },
+};

package/dist/commands/search.js

@@ -0,0 +1,26 @@
+import { flattenBuffer } from '../tab/formatting.js';
+import { compilePattern, findMatches } from '../search-matches.js';
+export const SEARCH_USAGE = 'Usage: search transcript <pattern>';
+// Server half of transcript search: the web client handles matching/highlighting itself
+// (it already holds the flattened transcript), so this command only covers the no-match
+// report and non-interactive dispatch (e.g. scripted/`send`-delivered commands).
+export const command = {
+    name: 'search',
+    match: (command_) => /^search\s+transcript\b/i.test(command_),
+    run: (command_, tab, managers) => {
+        const pattern = command_.replace(/^search\s+transcript\b\s*/i, '').trim();
+        const append = (output) => managers.tab.append(tab.label, { input: command_, output });
+        if (!pattern || !compilePattern(pattern)) {
+            append(SEARCH_USAGE);
+            return;
+        }
+        const target = managers.tab.tabs.find((t) => t.label === tab.label);
+        const lines = flattenBuffer(target?.log ?? []);
+        const matches = findMatches(lines, pattern);
+        if (matches.length === 0) {
+            append('No matches found in the transcript.');
+            return;
+        }
+        append(lines[matches.at(-1)].text);
+    },
+};

package/dist/commands/send.js

@@ -0,0 +1,51 @@
+import { resolveTarget } from './resolve-target.js';
+/** Parse a `send <label> <text...>` command (the leading `send` is optional). */
+export function parseSendCommand(input) {
+    const body = input.trim().replace(/^send\b\s*/i, '');
+    const parts = body.split(/\s+/).filter(Boolean);
+    if (parts.length === 0)
+        return { error: 'Usage: send <label> <text>' };
+    const label = parts[0];
+    const text = parts.slice(1).join(' ');
+    if (!text)
+        return { error: 'No text to send.' };
+    return { label, text };
+}
+function deliverTo(target, text, managers) {
+    if (target.view === 'harness') {
+        if (target.harness?.status !== 'running')
+            return `Tab "${target.label}" is not a running harness.`;
+        // Split from the text so a long line's trailing \r can't land in the same burst the harness's
+        // own input parser treats as a paste (see schedule-manager.ts's `fire`).
+        const ptyId = target.harness.ptyId;
+        managers.pty.input(ptyId, text);
+        setTimeout(() => managers.pty.input(ptyId, '\r'), 50);
+        return null;
+    }
+    if (target.view === undefined || target.view === 'agent') {
+        managers.command.dispatchTo(target.label, text);
+        return null;
+    }
+    return `Tab "${target.label}" does not accept input.`;
+}
+export const command = {
+    name: 'send',
+    match: (command_) => /^send\b/i.test(command_),
+    run: (command_, tab, managers) => {
+        const append = (text) => managers.tab.append(tab.label, { input: command_, output: text });
+        const parsed = parseSendCommand(command_);
+        if ('error' in parsed) {
+            append(parsed.error);
+            return;
+        }
+        const target = resolveTarget(parsed.label, managers, append);
+        if (!target)
+            return;
+        const error = deliverTo(target, parsed.text, managers);
+        if (error) {
+            append(error);
+            return;
+        }
+        append(`→ ${parsed.label}: ${parsed.text}`);
+    },
+};

package/dist/commands/state.js

@@ -0,0 +1,9 @@
+import { loadAgentState } from '../agent/state.js';
+import { formatState } from '../state-format.js';
+export const command = {
+    name: 'state',
+    match: (command_) => command_.toLowerCase() === 'state',
+    run: (command, tab, managers) => {
+        managers.tab.append(tab.label, { input: command, output: formatState(tab.label, loadAgentState(tab.label) ?? null) });
+    },
+};

package/dist/commands/syntax.js

@@ -0,0 +1,36 @@
+import { getConfig, updateConfig } from '../config.js';
+import { SYNTAX_THEMES } from '../syntax-themes.js';
+const USAGE = 'Usage: syntax theme [name]';
+function listThemes() {
+    const active = getConfig().syntaxTheme;
+    return SYNTAX_THEMES.map((name) => (name === active ? `* ${name}` : `  ${name}`)).join('\n');
+}
+export const command = {
+    name: 'syntax',
+    match: (command_) => /^syntax\b/i.test(command_),
+    run: (command_, tab, managers) => {
+        const rest = command_.replace(/^syntax\b\s*/i, '').trim();
+        if (!/^theme\b/i.test(rest)) {
+            managers.tab.append(tab.label, { input: command_, output: USAGE });
+            return;
+        }
+        const name = rest.replace(/^theme\b\s*/i, '').trim();
+        if (!name) {
+            managers.tab.append(tab.label, { input: command_, output: `Available themes:\n${listThemes()}` });
+            return;
+        }
+        const canonical = SYNTAX_THEMES.find((theme) => theme.toLowerCase() === name.toLowerCase());
+        if (!canonical) {
+            managers.tab.append(tab.label, {
+                input: command_,
+                output: `Unknown theme "${name}". Available themes:\n${listThemes()}`,
+            });
+            return;
+        }
+        const persisted = updateConfig({ syntaxTheme: canonical });
+        const output = persisted
+            ? `Syntax theme set to "${canonical}".`
+            : `Syntax theme set to "${canonical}" for this session (config write failed — won't persist).`;
+        managers.tab.append(tab.label, { input: command_, output });
+    },
+};