janissary 0.5.0

package/dist/acp-loop.js

@@ -0,0 +1,75 @@
+// Autonomous tool loop for an ACP agent: the agent emits a single command, the
+// host runs it, feeds the output back, and repeats until the agent answers
+// without a command (or a step cap is reached). The control flow is pure — all
+// side effects (rendering the transcript, executing the command) are injected,
+// which keeps it testable independently of the live agent.
+/**
+ * Drive the loop. Each turn streams the agent reply, then looks for a command:
+ * if one is found and the step budget remains, it is executed, its output is
+ * fed back as a follow-up prompt, and the loop continues; otherwise the loop
+ * ends. The primer is prepended only to the very first prompt.
+ */
+export function runAcpToolLoop(session, userPrompt, dependencies, h) {
+    const maxSteps = dependencies.maxSteps ?? 8;
+    // Start a turn's transcript entry, then issue the prompt into it.
+    function turn(turnPrompt, isFirst, step) {
+        h.startTurn(isFirst);
+        promptOnce(turnPrompt, isFirst, step, 0);
+    }
+    // Send one prompt for the current turn. A freshly connected agent sometimes
+    // returns an empty first reply (cold start — the model/provider loads lazily on
+    // the first prompt); retry the first turn once, reusing the same entry, before
+    // treating an empty reply as a final (no-command) answer.
+    function promptOnce(turnPrompt, isFirst, step, attempt) {
+        let buffer = '';
+        const sent = isFirst && dependencies.primer ? `${dependencies.primer}\n\n${userPrompt}` : turnPrompt;
+        session.prompt(sent, {
+            onChunk: (text) => { buffer += text; h.chunk(buffer); },
+            onEnd: async () => {
+                if (!buffer.trim() && isFirst && attempt === 0) {
+                    promptOnce(turnPrompt, isFirst, step, attempt + 1);
+                    return;
+                }
+                const command = dependencies.extractCommand(buffer);
+                const display = filterCommandFromDisplay(buffer, command);
+                h.endTurn(display);
+                if (command && step < maxSteps) {
+                    // Only await when the command is actually async (e.g. browser); a sync command
+                    // (db) must complete in the same tick so callers/tests observing synchronously
+                    // see the full loop.
+                    const returnValue = dependencies.runCommand(command);
+                    const result = returnValue instanceof Promise ? await returnValue : returnValue;
+                    h.ranCommand(command, result);
+                    const followUp = `Output of \`${command}\`:\n${result}\n\n` +
+                        'If the task is complete, reply with the final answer and no command. ' +
+                        'Otherwise issue the next command. ' +
+                        'Be concise: do not explain what you are doing. Only output commands and the final answer.';
+                    turn(followUp, false, step + 1);
+                }
+                else {
+                    h.finished(command ? 'capped' : 'answered', maxSteps);
+                }
+            },
+            onError: (message) => h.error(message),
+        });
+    }
+    turn(userPrompt, true, 0);
+}
+function filterCommandFromDisplay(display, command) {
+    if (!command)
+        return display;
+    const lines = display.split('\n');
+    const cleaned = lines.map((l) => l.replace(/^[\s`$>]+/, '').replace(/`+\s*$/, '').trim());
+    const index = cleaned.indexOf(command);
+    if (index === -1)
+        return display;
+    lines.splice(index, 1);
+    // Remove adjacent code fence markers left behind by the removed command.
+    if (index < lines.length && /^`{3,}\s*$/.test(lines[index]))
+        lines.splice(index, 1);
+    if (index > 0 && /^`{3,}\s*$/.test(lines[index - 1]))
+        lines.splice(index - 1, 1);
+    while (lines.length > 0 && lines.at(-1).trim() === '')
+        lines.pop();
+    return lines.join('\n');
+}

package/dist/acp-manager.js

@@ -0,0 +1,109 @@
+import { connectAcp } from './acp.js';
+import { runAcpToolLoop } from './acp-loop.js';
+import { extractBrowserCommand, BROWSER_PRIMER } from './browser-command.js';
+import { messageBus } from './bus.js';
+import { makeUpdateRunning } from './acp-runner.js';
+// The ACP agent the manager connects to and the model it runs. Hardcoded for now (the only provider
+// wired up); the model string drives the `provider/model` label shown in the connections panel.
+const ACP_COMMAND = 'opencode';
+const ACP_ARGS = ['acp'];
+const ACP_MODEL = 'google/gemini-3.1-flash-lite';
+// Split a `provider/model` config string into its parts; a bare `model` with no slash has no
+// provider. Drives the connections-panel label.
+function parseModel(model) {
+    const slash = model.indexOf('/');
+    return slash === -1 ? { model } : { provider: model.slice(0, slash), model: model.slice(slash + 1) };
+}
+// Owns the per-tab ACP sessions (keyed by tab label) and their reported model info. Sessions connect
+// lazily on first use and persist across prompts; the manager spawns/reuses them, exposes the
+// connection label, and tears them down. The prompt/tool-loop orchestration stays with the caller —
+// the manager only hands back the live session.
+export class AcpManager {
+    managers;
+    sessions = new Map();
+    info = new Map();
+    constructor(managers) {
+        this.managers = managers;
+    }
+    // Whether a tab has a connected (or connecting) ACP session. Drives the connections panel and completion.
+    has(label) {
+        return this.sessions.has(label);
+    }
+    // The `provider/model` (or bare `model`) string for a tab's session, or undefined when none is
+    // connected. Display-only; populated on the connection handshake.
+    label(label) {
+        const info = this.info.get(label);
+        if (!info)
+            return undefined;
+        return info.provider ? `${info.provider}/${info.model ?? ''}` : info.model;
+    }
+    // The tab's ACP session, connecting one on first use and reusing it thereafter. The agent runs in
+    // `cwd`; `hooks.onConnect` fires after the handshake, by which point the session's model info is
+    // recorded (so `label` resolves).
+    session(label, cwd, hooks) {
+        let session = this.sessions.get(label);
+        if (!session) {
+            const info = parseModel(ACP_MODEL);
+            const tab = this.managers.tab.tabs.find((t) => t.label === label);
+            session = connectAcp({
+                command: ACP_COMMAND, args: ACP_ARGS, cwd,
+                onError: hooks.onError,
+                onConnect: () => { this.info.set(label, info); hooks.onConnect(); },
+                env: { OPENCODE_CONFIG_CONTENT: JSON.stringify({ model: ACP_MODEL }) },
+                workspaceDir: tab?.workspaceDir,
+                offline: tab?.offline,
+            });
+            this.sessions.set(label, session);
+        }
+        return session;
+    }
+    // Kill and forget a tab's session (and its info). Returns whether one was open — the
+    // `connection close acp` path re-renders and reports only when it actually closed one.
+    close(label) {
+        const session = this.sessions.get(label);
+        if (!session)
+            return false;
+        session.kill();
+        this.sessions.delete(label);
+        this.info.delete(label);
+        return true;
+    }
+    // Kill every session and forget all info (app shutdown).
+    closeAll() {
+        for (const [, session] of this.sessions)
+            session.kill();
+        this.sessions.clear();
+        this.info.clear();
+    }
+    run(label, command, onDone) {
+        const prompt = command.replace(/^acp\b\s*/i, '').trim();
+        if (!prompt) {
+            this.managers.tab.append(label, { input: command, output: 'Usage: acp <prompt>.' });
+            return;
+        }
+        const session = this.session(label, this.managers.tab.cwdOf(label) ?? process.cwd(), {
+            onError: (m) => this.managers.tab.append(label, { input: '', output: `ACP: ${m}` }),
+            onConnect: () => messageBus.emit('state', { type: 'dirty' }),
+        });
+        const updateRunning = makeUpdateRunning(label, this.managers);
+        let lastAnswer = '';
+        runAcpToolLoop(session, prompt, {
+            primer: `${this.managers.database.primer}\n\n${BROWSER_PRIMER}\n\nWrite your replies in GitHub-flavored Markdown (headings, lists, tables, fenced code blocks, etc.); the tab renders them as formatted Markdown.`,
+            runCommand: (c) => (/^browser\b/i.test(c) ? this.managers.browser.run(label, c) : this.managers.database.runInTab(label, c)),
+            extractCommand: (t) => extractBrowserCommand(t) ?? this.managers.database.extract(t) ?? null,
+        }, {
+            startTurn: (isFirst) => { this.managers.tab.addBusy(label); this.managers.tab.append(label, { input: isFirst ? prompt : '', output: '', running: true, markdown: true }); },
+            chunk: (buffer) => updateRunning(buffer, true),
+            endTurn: (final) => { updateRunning(final, false); lastAnswer = final; },
+            ranCommand: (c, result) => this.managers.tab.append(label, { input: c, output: result, acp: true }),
+            finished: (reason, maxSteps) => {
+                this.managers.tab.deleteBusy(label);
+                if (reason === 'capped')
+                    this.managers.tab.append(label, { input: '', output: `(stopped after ${maxSteps} tool steps)` });
+                messageBus.emit('state', { type: 'dirty' });
+                onDone?.(lastAnswer);
+            },
+            error: (m) => { updateRunning(`ACP error: ${m}`, false); this.managers.tab.deleteBusy(label); onDone?.(`ACP error: ${m}`); },
+        });
+    }
+}

package/dist/acp-runner.js

@@ -0,0 +1,18 @@
+import { messageBus } from './bus.js';
+export function makeUpdateRunning(label, managers) {
+    return (output, running) => {
+        const t = managers.tab.tabs.find((x) => x.label === label);
+        if (t) {
+            const log = [...t.log];
+            const index = log.findLastIndex((e) => e.running);
+            if (index !== -1)
+                log[index] = { ...log[index], output, running };
+            t.log = log;
+            if (!running)
+                managers.tab.persist(managers.tab.buildAgentState(t));
+        }
+        if (!running && output && t)
+            messageBus.emit('transcript', { type: 'entry:appended', tabLabel: label, entry: { input: '', output }, tab: t });
+        messageBus.emit('state', { type: 'dirty' });
+    };
+}

package/dist/acp.js

@@ -0,0 +1,91 @@
+import { spawn } from 'node:child_process';
+import { Readable, Writable } from 'node:stream';
+import { ClientSideConnection, ndJsonStream, PROTOCOL_VERSION, } from '@agentclientprotocol/sdk';
+import { sandboxSpawn } from './sandbox.js';
+import { getGithubToken } from './github-token.js';
+/**
+ * Connect to an arbitrary ACP agent launched as a subprocess and drive it as an ACP
+ * client over stdio. This is agent-agnostic — the caller supplies the command to run
+ * (e.g. `npx @agentclientprotocol/claude-agent-acp` or `opencode acp`).
+ *
+ * MVP scope: streams `agent_message_chunk` text into the prompt handler, auto-denies tool
+ * permission requests, and advertises no fs/terminal capabilities (so the agent never
+ * calls those back).
+ *
+ * `workspaceDir`/`offline` confine the subprocess to that workspace via a Seatbelt sandbox (see
+ * sandbox.ts); omitted (monitor sessions never set them), the command runs exactly as before.
+ */
+export function connectAcp(options) {
+    const baseEnv = options.env ? { ...process.env, ...options.env } : process.env;
+    const { command, args, env } = sandboxSpawn({
+        workspaceDir: options.workspaceDir,
+        offline: options.offline,
+        githubToken: options.workspaceDir ? getGithubToken() : undefined,
+    }, options.command, options.args, baseEnv);
+    const proc = spawn(command, args, {
+        cwd: options.cwd,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env,
+    });
+    proc.on('error', (error) => options.onError(`failed to start ACP agent: ${error.message}`));
+    // The current in-flight prompt's handlers; session updates are routed here.
+    let current;
+    const client = {
+        async sessionUpdate(parameters) {
+            const update = parameters.update;
+            if (update.sessionUpdate === 'agent_message_chunk' && update.content.type === 'text') {
+                current?.onChunk(update.content.text);
+            }
+        },
+        // MVP: auto-deny tool permission (read-only). A real permission UI replaces this.
+        async requestPermission() {
+            return { outcome: { outcome: 'cancelled' } };
+        },
+    };
+    const input = Readable.toWeb(proc.stdout);
+    const output = Writable.toWeb(proc.stdin);
+    const conn = new ClientSideConnection(() => client, ndJsonStream(output, input));
+    let sessionId;
+    let ready;
+    const ensureSession = () => {
+        ready ??= (async () => {
+            const init = await conn.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+            const response = await conn.newSession({ cwd: options.cwd, mcpServers: [] });
+            sessionId = response.sessionId;
+            // Provider from the agent's reported name (fallback: the command basename);
+            // model is best-effort from the session's current mode (ACP has no model field).
+            const provider = init.agentInfo?.name ?? options.command.replace(/^.*[\\/]/, '');
+            const modes = response.modes;
+            const model = modes
+                ? modes.availableModes.find((m) => m.id === modes.currentModeId)?.name ?? modes.currentModeId
+                : undefined;
+            options.onConnect?.({ provider, model });
+        })();
+        return ready;
+    };
+    return {
+        prompt: (text, handlers) => {
+            current = handlers;
+            void (async () => {
+                try {
+                    await ensureSession();
+                    const response = await conn.prompt({ sessionId: sessionId, prompt: [{ type: 'text', text }] });
+                    handlers.onEnd(response.stopReason);
+                }
+                catch (error) {
+                    handlers.onError(error instanceof Error ? error.message : String(error));
+                }
+                finally {
+                    if (current === handlers)
+                        current = undefined;
+                }
+            })();
+        },
+        kill: () => {
+            try {
+                proc.kill();
+            }
+            catch { /* already gone */ }
+        },
+    };
+}

package/dist/agent/commands.js

@@ -0,0 +1,29 @@
+import agentNames from '../../agent-names.json' with { type: 'json' };
+import { getConfig } from '../config.js';
+export function resolveAgentName(input, existingLabels) {
+    const trimmed = input.trim();
+    const match = trimmed.match(/^agent\s+(.+)/i);
+    if (match) {
+        return match[1].trim().toLowerCase().slice(0, getConfig().tabNameMaxLength);
+    }
+    const lowerExisting = new Set(existingLabels.map((l) => l.toLowerCase()));
+    const pool = agentNames.filter((n) => !lowerExisting.has(n));
+    if (pool.length === 0)
+        return null;
+    return pool[Math.floor(Math.random() * pool.length)];
+}
+export function parseAgentCommand(input) {
+    const trimmed = input.trim();
+    const isWorkspace = /\s(-w|--workspace)\b/i.test(trimmed);
+    const isOffline = /\s--offline\b/i.test(trimmed);
+    const stripped = trimmed
+        .replaceAll(/\s+(-w|--workspace|--offline)(?=\s|$)/gi, '')
+        .replaceAll(/\s+/g, ' ')
+        .trim();
+    const nameMatch = stripped.match(/^agent\s+(.+)/i);
+    return {
+        name: nameMatch ? nameMatch[1].trim().toLowerCase().slice(0, getConfig().tabNameMaxLength) : '',
+        workspace: isWorkspace,
+        offline: isOffline,
+    };
+}

package/dist/agent/communication-manager.js

@@ -0,0 +1,71 @@
+export class AgentCommunicationManager {
+    managers;
+    queues = new Map();
+    processing = new Set();
+    nextId = 0;
+    constructor(managers) {
+        this.managers = managers;
+    }
+    // Recipients may be addressed by their label or by their display alias (see `rename`);
+    // either way, routing and queuing key off the tab's canonical label.
+    send(message) {
+        const to = message.to.toLowerCase();
+        const target = this.managers.tab.tabs.find((t) => t.label.toLowerCase() === to || t.title?.toLowerCase() === to);
+        if (!target)
+            return false;
+        const full = { ...message, to: target.label, id: ++this.nextId };
+        const q = this.queues.get(target.label) ?? [];
+        q.push(full);
+        this.queues.set(target.label, q);
+        this.pump(target.label);
+        return true;
+    }
+    pump(label) {
+        if (this.processing.has(label))
+            return;
+        const queue = this.queues.get(label);
+        if (!queue || queue.length === 0)
+            return;
+        this.processing.add(label);
+        const message = queue.shift();
+        this.handle(message, () => {
+            this.processing.delete(label);
+            if ((this.queues.get(label)?.length ?? 0) > 0)
+                setTimeout(() => this.pump(label), 0);
+        });
+    }
+    handle(message, done) {
+        const agentColor = (label) => this.managers.tab.tabs.find((t) => t.label === label)?.dotColor ?? '#e4e5e7';
+        const appendContext = (label, text) => {
+            this.managers.tab.appendContext(label, text);
+            const tab = this.managers.tab.tabs.find((t) => t.label === label);
+            if (tab)
+                this.managers.tab.persist(this.managers.tab.buildAgentState(tab, { schedule: this.managers.schedule.get(tab.label) }));
+        };
+        if (message.kind === 'info') {
+            this.managers.tab.append(message.to, { input: '', output: message.text, from: message.from, fromColor: agentColor(message.from), msgKind: 'info' });
+            appendContext(message.to, `${message.from}: ${message.text}`);
+            done();
+            return;
+        }
+        if (message.kind === 'response') {
+            this.managers.tab.append(message.to, { input: '', output: message.text, from: `response from ${message.from}`, fromColor: agentColor(message.from), msgKind: 'response' });
+            appendContext(message.to, `${message.from}: ${message.text}`);
+            done();
+            return;
+        }
+        if (message.kind === 'command') {
+            this.managers.tab.append(message.to, { input: '', output: `sent command: ${message.text}`, from: message.from, fromColor: agentColor(message.from), msgKind: 'info' });
+            this.managers.capture.run(message.to, message.text, () => done());
+            return;
+        }
+        if (message.kind === 'request') {
+            this.managers.tab.append(message.to, { input: '', output: `sent request: ${message.text}`, from: message.from, fromColor: agentColor(message.from), msgKind: 'info' });
+            this.managers.capture.run(message.to, message.text, (output) => {
+                this.send({ from: message.to, to: message.from, kind: 'response', text: output });
+                done();
+            });
+            return;
+        }
+    }
+}

package/dist/agent/state.js

@@ -0,0 +1,58 @@
+import { mkdirSync, writeFileSync, existsSync, readFileSync, readdirSync, rmSync } from 'node:fs';
+import path from 'node:path';
+let stateDirectory = '';
+export function initAgentStateDirectory(projectDirectory) {
+    stateDirectory = path.join(projectDirectory, '.janissary', 'state');
+}
+export function ensureStateDirectory() {
+    mkdirSync(stateDirectory, { recursive: true });
+}
+const VALID_NAME = /^[\w-]+$/;
+export function agentStatePath(name) {
+    if (!VALID_NAME.test(name))
+        throw new Error(`Invalid agent name: "${name}"`);
+    return path.join(stateDirectory, `${name}.json`);
+}
+function isAgentState(x) {
+    return (typeof x === 'object' && x !== null &&
+        typeof x.name === 'string' &&
+        typeof x.dotColor === 'string' &&
+        typeof x.active === 'boolean');
+}
+export function loadAgentState(name) {
+    const path = agentStatePath(name);
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return isAgentState(parsed) ? parsed : undefined;
+    }
+    catch {
+        // skip invalid agent state files
+    }
+}
+export function saveAgentState(state) {
+    ensureStateDirectory();
+    writeFileSync(agentStatePath(state.name), JSON.stringify(state, null, 2) + '\n');
+}
+export function clearStateDirectory() {
+    if (!stateDirectory)
+        return;
+    try {
+        rmSync(stateDirectory, { recursive: true, force: true });
+    }
+    catch { /* ignore */ }
+}
+export function listAgentStates() {
+    if (!existsSync(stateDirectory))
+        return [];
+    try {
+        return readdirSync(stateDirectory)
+            .filter((f) => f.endsWith('.json'))
+            .map((f) => loadAgentState(f.replace(/\.json$/, '')))
+            .filter((s) => s !== undefined);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/agent-commands.js

@@ -0,0 +1,29 @@
+import agentNames from '../agent-names.json' with { type: 'json' };
+import { getConfig } from './config.js';
+export function resolveAgentName(input, existingLabels) {
+    const trimmed = input.trim();
+    const match = trimmed.match(/^agent\s+(.+)/i);
+    if (match) {
+        return match[1].trim().toLowerCase().slice(0, getConfig().tabNameMaxLength);
+    }
+    const lowerExisting = new Set(existingLabels.map((l) => l.toLowerCase()));
+    const pool = agentNames.filter((n) => !lowerExisting.has(n));
+    if (pool.length === 0)
+        return null;
+    return pool[Math.floor(Math.random() * pool.length)];
+}
+export function parseAgentCommand(input) {
+    const trimmed = input.trim();
+    const isWorkspace = /\s(-w|--workspace)\b/i.test(trimmed);
+    const isOffline = /\s--offline\b/i.test(trimmed);
+    const stripped = trimmed
+        .replaceAll(/\s+(-w|--workspace|--offline)(?=\s|$)/gi, '')
+        .replaceAll(/\s+/g, ' ')
+        .trim();
+    const nameMatch = stripped.match(/^agent\s+(.+)/i);
+    return {
+        name: nameMatch ? nameMatch[1].trim().toLowerCase().slice(0, getConfig().tabNameMaxLength) : '',
+        workspace: isWorkspace,
+        offline: isOffline,
+    };
+}

package/dist/agent-communication-manager.js

@@ -0,0 +1,71 @@
+export class AgentCommunicationManager {
+    managers;
+    queues = new Map();
+    processing = new Set();
+    nextId = 0;
+    constructor(managers) {
+        this.managers = managers;
+    }
+    // Recipients may be addressed by their label or by their display alias (see `rename`);
+    // either way, routing and queuing key off the tab's canonical label.
+    send(message) {
+        const to = message.to.toLowerCase();
+        const target = this.managers.tab.tabs.find((t) => t.label.toLowerCase() === to || t.title?.toLowerCase() === to);
+        if (!target)
+            return false;
+        const full = { ...message, to: target.label, id: ++this.nextId };
+        const q = this.queues.get(target.label) ?? [];
+        q.push(full);
+        this.queues.set(target.label, q);
+        this.pump(target.label);
+        return true;
+    }
+    pump(label) {
+        if (this.processing.has(label))
+            return;
+        const queue = this.queues.get(label);
+        if (!queue || queue.length === 0)
+            return;
+        this.processing.add(label);
+        const message = queue.shift();
+        this.handle(message, () => {
+            this.processing.delete(label);
+            if ((this.queues.get(label)?.length ?? 0) > 0)
+                setTimeout(() => this.pump(label), 0);
+        });
+    }
+    handle(message, done) {
+        const agentColor = (label) => this.managers.tab.tabs.find((t) => t.label === label)?.dotColor ?? '#e4e5e7';
+        const appendContext = (label, text) => {
+            this.managers.tab.appendContext(label, text);
+            const tab = this.managers.tab.tabs.find((t) => t.label === label);
+            if (tab)
+                this.managers.tab.persist(this.managers.tab.buildAgentState(tab, { schedule: this.managers.schedule.get(tab.label) }));
+        };
+        if (message.kind === 'info') {
+            this.managers.tab.append(message.to, { input: '', output: message.text, from: message.from, fromColor: agentColor(message.from), msgKind: 'info' });
+            appendContext(message.to, `${message.from}: ${message.text}`);
+            done();
+            return;
+        }
+        if (message.kind === 'response') {
+            this.managers.tab.append(message.to, { input: '', output: message.text, from: `response from ${message.from}`, fromColor: agentColor(message.from), msgKind: 'response' });
+            appendContext(message.to, `${message.from}: ${message.text}`);
+            done();
+            return;
+        }
+        if (message.kind === 'command') {
+            this.managers.tab.append(message.to, { input: '', output: `sent command: ${message.text}`, from: message.from, fromColor: agentColor(message.from), msgKind: 'info' });
+            this.managers.capture.run(message.to, message.text, () => done());
+            return;
+        }
+        if (message.kind === 'request') {
+            this.managers.tab.append(message.to, { input: '', output: `sent request: ${message.text}`, from: message.from, fromColor: agentColor(message.from), msgKind: 'info' });
+            this.managers.capture.run(message.to, message.text, (output) => {
+                this.send({ from: message.to, to: message.from, kind: 'response', text: output });
+                done();
+            });
+            return;
+        }
+    }
+}

package/dist/agent-state.js

@@ -0,0 +1,58 @@
+import { mkdirSync, writeFileSync, existsSync, readFileSync, readdirSync, rmSync } from 'node:fs';
+import path from 'node:path';
+let stateDirectory = '';
+export function initAgentStateDirectory(projectDirectory) {
+    stateDirectory = path.join(projectDirectory, '.janissary', 'state');
+}
+export function ensureStateDirectory() {
+    mkdirSync(stateDirectory, { recursive: true });
+}
+const VALID_NAME = /^[\w-]+$/;
+export function agentStatePath(name) {
+    if (!VALID_NAME.test(name))
+        throw new Error(`Invalid agent name: "${name}"`);
+    return path.join(stateDirectory, `${name}.json`);
+}
+function isAgentState(x) {
+    return (typeof x === 'object' && x !== null &&
+        typeof x.name === 'string' &&
+        typeof x.dotColor === 'string' &&
+        typeof x.active === 'boolean');
+}
+export function loadAgentState(name) {
+    const path = agentStatePath(name);
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return isAgentState(parsed) ? parsed : undefined;
+    }
+    catch {
+        // skip invalid agent state files
+    }
+}
+export function saveAgentState(state) {
+    ensureStateDirectory();
+    writeFileSync(agentStatePath(state.name), JSON.stringify(state, null, 2) + '\n');
+}
+export function clearStateDirectory() {
+    if (!stateDirectory)
+        return;
+    try {
+        rmSync(stateDirectory, { recursive: true, force: true });
+    }
+    catch { /* ignore */ }
+}
+export function listAgentStates() {
+    if (!existsSync(stateDirectory))
+        return [];
+    try {
+        return readdirSync(stateDirectory)
+            .filter((f) => f.endsWith('.json'))
+            .map((f) => loadAgentState(f.replace(/\.json$/, '')))
+            .filter((s) => s !== undefined);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/app-themes.js

@@ -0,0 +1,13 @@
+// Names of the application color themes available for `theme <name>`. Shared between the server
+// (persisted config, command validation) and the web client (picker list, `data-theme` values) via
+// the `@shared` alias, so this file must stay free of Node imports. The palettes themselves live
+// only in web/src/theme.css as `[data-theme="<name>"]` blocks.
+export const APP_THEMES = [
+    'dark',
+    'light',
+    'solarized-dark',
+    'solarized-light',
+    'nord',
+    'dracula',
+];
+export const DEFAULT_APP_THEME = 'dark';