janissary 0.5.0

package/dist/profile/manager.js

@@ -0,0 +1,72 @@
+import { makeTab, distinctColor } from '../tab/index.js';
+import { parseProfileCommand, loadProfileEntries, listProfiles, profileExists } from '../profiles.js';
+import { parseAgentCommand, resolveAgentName } from '../commands.js';
+import { openProfileEntries } from './agent-opener.js';
+import { sandboxNotice } from '../sandbox/index.js';
+export class ProfileManager {
+    managers;
+    constructor(managers) {
+        this.managers = managers;
+    }
+    run(command, label) {
+        const parsed = parseProfileCommand(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 names = listProfiles();
+            out(names.length > 0 ? names.join('\n') : 'No profiles.');
+            return;
+        }
+        if (!profileExists(parsed.name)) {
+            out(`No profile named "${parsed.name}".`);
+            return;
+        }
+        const entries = loadProfileEntries(parsed.name);
+        if (entries.length === 0) {
+            out(`Profile "${parsed.name}" has no agents.`);
+            return;
+        }
+        openProfileEntries(entries, this.managers, parsed.name, label, out);
+    }
+    newAgent(command) {
+        const parsed = parseAgentCommand(command);
+        const existing = this.managers.tab.allLabels();
+        const creator = this.managers.tab.cur();
+        const resolved = parsed.name || resolveAgentName(`agent ${parsed.name}`, existing);
+        const out = (text) => this.managers.tab.append(creator.label, { input: command, output: text });
+        if (resolved === null) {
+            out('All agent names are in use.');
+            return;
+        }
+        if (existing.some((l) => l.toLowerCase() === resolved.toLowerCase())) {
+            out(`Agent "${resolved}" is already active.`);
+            return;
+        }
+        let workspaceDir;
+        if (parsed.workspace) {
+            const result = this.managers.workspace.create(resolved);
+            if ('error' in result) {
+                out(result.error);
+                return;
+            }
+            workspaceDir = result.dir;
+        }
+        const dotColor = distinctColor(this.managers.tab.tabs.map((t) => t.dotColor));
+        const group = creator?.group ?? 1;
+        const groupColor = creator?.groupColor ?? dotColor;
+        const tab = makeTab(resolved, dotColor, this.managers.tab.tabs.length + 1, [], [], workspaceDir, group, groupColor);
+        tab.toolStepsExpanded = false;
+        tab.offline = parsed.offline;
+        this.managers.tab.insertTabInGroup(tab);
+        this.managers.tab.setCwd(resolved, workspaceDir ?? process.cwd());
+        this.managers.tab.setActiveTab(this.managers.tab.findIndex(resolved));
+        this.managers.tab.persist(this.managers.tab.buildAgentState(tab));
+        const notice = workspaceDir ? sandboxNotice() : undefined;
+        out(`Agent "${resolved}" ready.${workspaceDir ? ` (workspace: ${this.managers.tab.shorten(workspaceDir)})` : ''}`);
+        if (notice)
+            out(notice);
+    }
+}

package/dist/profile/monitors.js

@@ -0,0 +1,23 @@
+import { parseMonitorCommand } from '../monitor/parsing.js';
+import { formatTargets } from '../monitor/targets.js';
+import { loadProfileMonitors } from '../profiles.js';
+// Start each profile-level monitor (from the profile's `_monitors.json`) once its tabs are open,
+// owned by the launch's issuing tab. Idempotent across relaunch: any existing same-owner monitor
+// for the persona is stopped first, so re-launching a profile refreshes rather than errors. Each
+// outcome (started, or the parse/start error) is pushed to `notes` for the launch report.
+export function startProfileMonitors(profileName, managers, issuingLabel, notes) {
+    for (const monitor of loadProfileMonitors(profileName)) {
+        const parsed = parseMonitorCommand(`monitor ${monitor.persona} ${monitor.targets.join(' ')}`.trim());
+        if ('error' in parsed) {
+            notes.push(`Monitor "${monitor.persona}": ${parsed.error}`);
+            continue;
+        }
+        if ('ask' in parsed)
+            continue;
+        managers.monitor.stop(issuingLabel, parsed.persona);
+        const error = managers.monitor.start(issuingLabel, parsed.persona, parsed.targets);
+        notes.push(error
+            ? `Monitor "${monitor.persona}": ${error}`
+            : `Monitoring ${formatTargets(parsed.targets)} (persona: ${parsed.persona}).`);
+    }
+}

package/dist/profile/notifications.js

@@ -0,0 +1,11 @@
+import { loadProfileNotifications } from '../profiles.js';
+import { openNotificationsTab } from '../notifications-tab.js';
+// Open (or dock) the singleton notifications tab for each profile-level notifications entry (from
+// the profile's `_notifications.json`) once every entry is open, mirroring `openProfileFiles`. The
+// notifications tab is a singleton, so multiple entries just re-dock the same feed.
+export function openProfileNotifications(profileName, managers, notes) {
+    for (const entry of loadProfileNotifications(profileName)) {
+        openNotificationsTab(managers, entry.dock);
+        notes.push(`Opened notifications${entry.dock ? ` (docked ${entry.dock})` : ''}.`);
+    }
+}

package/dist/profile-agent-opener.js

@@ -0,0 +1,136 @@
+import { distinctColor, makeTab } from './tab.js';
+import { HARNESS_COMMANDS } from './harness.js';
+import { isKnownModel } from './harness-models.js';
+import { parseScheduleCommand } from './schedule.js';
+function isHarnessEntry(e) {
+    return 'harness' in e;
+}
+function labelOf(e) {
+    return isHarnessEntry(e) ? e.label : e.name;
+}
+// Authored `schedule` strings (schedule-command grammar minus `in <tab>`) plus `run` one-shots,
+// parsed into the ScheduleEntry[] the harness tab's schedule is set to. A string that errors or
+// carries an `in <tab>` clause is reported and skipped; a duplicate name keeps the first.
+function buildHarnessSchedule(entry, report) {
+    const now = new Date();
+    const entries = [];
+    const ids = new Set();
+    const scheduleLines = entry.schedule ?? [];
+    for (const raw of scheduleLines) {
+        const parsed = parseScheduleCommand(raw, now);
+        if ('error' in parsed) {
+            report(`Schedule "${raw}" for "${entry.label}": ${parsed.error}`);
+            continue;
+        }
+        if (parsed.action !== 'add') {
+            report(`Schedule "${raw}" for "${entry.label}" is not a new schedule.`);
+            continue;
+        }
+        if (parsed.target !== undefined) {
+            report(`Schedule "${raw}" for "${entry.label}" cannot target another tab.`);
+            continue;
+        }
+        if (ids.has(parsed.name)) {
+            report(`Duplicate schedule name "${parsed.name}" for "${entry.label}"; kept the first.`);
+            continue;
+        }
+        ids.add(parsed.name);
+        entries.push({ ...parsed.entry, id: parsed.name });
+    }
+    const runLines = entry.run ?? [];
+    for (const [i, command] of runLines.entries()) {
+        entries.push({ id: `run-${i + 1}`, command, spec: 'once', nextRun: Date.now(), recurring: false });
+    }
+    return entries;
+}
+function openAgentEntry(state, managers, group, groupColor, dotColor) {
+    const log = state.log ?? [];
+    const tab = makeTab(state.name, dotColor, managers.tab.tabs.length + 1, state.cmdHistory ?? [], log, state.workspaceDir, group, groupColor);
+    tab.toolStepsExpanded = false;
+    managers.tab.tabs = [...managers.tab.tabs, tab];
+    if (state.cwd)
+        managers.tab.setCwd(state.name, state.cwd);
+    if (state.context)
+        managers.tab.setContext(state.name, state.context);
+    if (state.schedule)
+        managers.schedule.set(state.name, state.schedule);
+    managers.tab.persist(managers.tab.buildAgentState(tab, { schedule: state.schedule }));
+}
+// Validate and open a harness entry. Returns an error to report and skip on, or undefined once
+// the tab (and its schedule) is set up.
+function openHarnessEntry(entry, managers, group, groupColor, issuingCwd, notes) {
+    if (HARNESS_COMMANDS[entry.harness] === undefined)
+        return `unknown harness "${entry.harness}"`;
+    if (entry.model && !isKnownModel(entry.harness, entry.model)) {
+        return `Unknown model "${entry.model}" for harness "${entry.harness}" — add it to harness-models.json.`;
+    }
+    const withCwd = { ...entry, cwd: entry.cwd ?? issuingCwd };
+    const error = managers.harness.openFromProfile(withCwd, entry.label, group, groupColor);
+    if (error)
+        return error;
+    const schedule = buildHarnessSchedule(entry, (message) => { notes.push(message); });
+    if (schedule.length > 0)
+        managers.schedule.set(entry.label, schedule);
+    return undefined;
+}
+// Relaunch semantics: close every open tab matching an entry's label first, then the caller opens
+// all entries fresh, so label collisions between a closing tab and an opening one cannot arise.
+// The issuing tab is never closed; if it's named by an entry, that entry is skipped instead.
+function closeMatchingTabs(entries, managers, issuingLabel, skipped, notes) {
+    const toOpen = [];
+    for (const entry of entries) {
+        const label = labelOf(entry);
+        if (label.toLowerCase() === issuingLabel.toLowerCase()) {
+            skipped.push(`${label} (cannot relaunch the issuing tab)`);
+            continue;
+        }
+        const index = managers.tab.findIndex(label);
+        if (index !== -1) {
+            managers.tab.closeTab(index);
+            notes.push(`Relaunched "${label}".`);
+        }
+        toOpen.push(entry);
+    }
+    return toOpen;
+}
+export function openProfileEntries(entries, managers, name, issuingLabel, out) {
+    const authoredGroup = entries
+        .map((e) => (isHarnessEntry(e) ? undefined : e.group))
+        .find((g) => typeof g === 'number');
+    const group = authoredGroup ?? Math.max(0, ...managers.tab.tabs.map((t) => t.group)) + 1;
+    const skipped = [];
+    const notes = [];
+    const toOpen = closeMatchingTabs(entries, managers, issuingLabel, skipped, notes);
+    const used = new Set(managers.tab.tabs.map((t) => t.dotColor));
+    const opened = [];
+    let groupColor;
+    const firstNew = managers.tab.tabs.length;
+    const issuingCwd = managers.tab.cwdOf(issuingLabel) ?? process.cwd();
+    for (const entry of toOpen) {
+        const label = labelOf(entry);
+        const dotColor = distinctColor(used, entry.dotColor);
+        used.add(dotColor);
+        groupColor ??= dotColor;
+        if (isHarnessEntry(entry)) {
+            const error = openHarnessEntry(entry, managers, group, groupColor, issuingCwd, notes);
+            if (error) {
+                skipped.push(`${label} (${error})`);
+                continue;
+            }
+        }
+        else {
+            openAgentEntry(entry, managers, group, groupColor, dotColor);
+        }
+        opened.push(label);
+    }
+    if (opened.length > 0)
+        managers.tab.setActiveTab(firstNew);
+    const parts = [];
+    if (opened.length > 0)
+        parts.push(`Launched profile "${name}": ${opened.join(', ')}.`);
+    if (notes.length > 0)
+        parts.push(notes.join(' '));
+    if (skipped.length > 0)
+        parts.push(`Skipped: ${skipped.join('; ')}.`);
+    out(parts.length > 0 ? parts.join(' ') : `Profile "${name}" has no agents to open.`);
+}

package/dist/profile-manager.js

@@ -0,0 +1,72 @@
+import { makeTab, distinctColor } from './tab.js';
+import { parseProfileCommand, loadProfileEntries, listProfiles, profileExists } from './profiles.js';
+import { parseAgentCommand, resolveAgentName } from './commands.js';
+import { openProfileEntries } from './profile-agent-opener.js';
+import { sandboxNotice } from './sandbox.js';
+export class ProfileManager {
+    managers;
+    constructor(managers) {
+        this.managers = managers;
+    }
+    run(command, label) {
+        const parsed = parseProfileCommand(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 names = listProfiles();
+            out(names.length > 0 ? names.join('\n') : 'No profiles.');
+            return;
+        }
+        if (!profileExists(parsed.name)) {
+            out(`No profile named "${parsed.name}".`);
+            return;
+        }
+        const entries = loadProfileEntries(parsed.name);
+        if (entries.length === 0) {
+            out(`Profile "${parsed.name}" has no agents.`);
+            return;
+        }
+        openProfileEntries(entries, this.managers, parsed.name, label, out);
+    }
+    newAgent(command) {
+        const parsed = parseAgentCommand(command);
+        const existing = this.managers.tab.allLabels();
+        const creator = this.managers.tab.cur();
+        const resolved = parsed.name || resolveAgentName(`agent ${parsed.name}`, existing);
+        const out = (text) => this.managers.tab.append(creator.label, { input: command, output: text });
+        if (resolved === null) {
+            out('All agent names are in use.');
+            return;
+        }
+        if (existing.some((l) => l.toLowerCase() === resolved.toLowerCase())) {
+            out(`Agent "${resolved}" is already active.`);
+            return;
+        }
+        let workspaceDir;
+        if (parsed.workspace) {
+            const result = this.managers.workspace.create(resolved);
+            if ('error' in result) {
+                out(result.error);
+                return;
+            }
+            workspaceDir = result.dir;
+        }
+        const dotColor = distinctColor(this.managers.tab.tabs.map((t) => t.dotColor));
+        const group = creator?.group ?? 1;
+        const groupColor = creator?.groupColor ?? dotColor;
+        const tab = makeTab(resolved, dotColor, this.managers.tab.tabs.length + 1, [], [], workspaceDir, group, groupColor);
+        tab.toolStepsExpanded = false;
+        tab.offline = parsed.offline;
+        this.managers.tab.insertTabInGroup(tab);
+        this.managers.tab.setCwd(resolved, workspaceDir ?? process.cwd());
+        this.managers.tab.setActiveTab(this.managers.tab.findIndex(resolved));
+        this.managers.tab.persist(this.managers.tab.buildAgentState(tab));
+        const notice = workspaceDir ? sandboxNotice() : undefined;
+        out(`Agent "${resolved}" ready.${workspaceDir ? ` (workspace: ${this.managers.tab.shorten(workspaceDir)})` : ''}`);
+        if (notice)
+            out(notice);
+    }
+}

package/dist/profiles.js

@@ -0,0 +1,143 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+// A profile is a named, reusable set of agents for a particular use case (writing code,
+// surfing the web, authoring a book, …). Each profile is a directory under the profiles
+// directory holding one `<agentname>.json` file per agent, in the agent-state schema.
+// Profiles live in a top-level, committable `profiles/` dir (not `.janissary/`, which is
+// gitignored and whose `state/` is cleared each launch).
+let profileDir = '';
+export function initProfileDir(projectDir) {
+    profileDir = path.join(projectDir, 'profiles');
+}
+export function profilePath(name) {
+    return path.join(profileDir, name);
+}
+export function profileExists(name) {
+    return profileDir !== '' && existsSync(profilePath(name));
+}
+export function listProfiles() {
+    if (!existsSync(profileDir))
+        return [];
+    try {
+        return readdirSync(profileDir, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name)
+            .toSorted((a, b) => a.localeCompare(b));
+    }
+    catch {
+        return [];
+    }
+}
+// Load every entry file in a profile — agent-state files, or harness entry files (discriminated
+// by a `harness` key). The filename (minus `.json`) is the authoritative name, so it always
+// overrides any `name` field inside the file. Entries are ordered by their `number` field
+// (mirroring `--relaunch` tab restoration) so a profile controls the order its tabs open; files
+// without a number keep their (alphabetical) readdir order.
+export function loadProfileEntries(name) {
+    const directory = profilePath(name);
+    if (!existsSync(directory))
+        return [];
+    try {
+        return readdirSync(directory)
+            // `_`-prefixed files are reserved profile-level config (e.g. `_monitors.json`), never entries.
+            .filter((f) => f.endsWith('.json') && !f.startsWith('_'))
+            .map((f) => {
+            try {
+                const parsed = JSON.parse(readFileSync(path.join(directory, f), 'utf8'));
+                const label = f.replace(/\.json$/, '');
+                return 'harness' in parsed ? { ...parsed, label } : { ...parsed, name: label };
+            }
+            catch {
+                // skip invalid entry files
+            }
+        })
+            .filter((s) => s !== undefined)
+            .toSorted((a, b) => (a.number ?? Infinity) - (b.number ?? Infinity));
+    }
+    catch {
+        return [];
+    }
+}
+function isProfileMonitor(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const monitor = value;
+    return typeof monitor.persona === 'string'
+        && Array.isArray(monitor.targets)
+        && monitor.targets.every((target) => typeof target === 'string');
+}
+// Profile-level monitors live in a reserved `_monitors.json` file — a JSON array of
+// `{ persona, targets }` — kept out of the entry set by the leading underscore (it is not an
+// agent or harness tab). Returns [] when the file is absent, unparseable, or not an array;
+// malformed elements are dropped.
+export function loadProfileMonitors(name) {
+    const file = path.join(profilePath(name), '_monitors.json');
+    if (!existsSync(file))
+        return [];
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        return Array.isArray(parsed) ? parsed.filter(isProfileMonitor) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function isProfileFilesEntry(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const entry = value;
+    return (entry.dock === undefined || (typeof entry.dock === 'string' && ['left', 'right'].includes(entry.dock)))
+        && (entry.in === undefined || typeof entry.in === 'string');
+}
+// Profile-level file-tree tabs live in a reserved `_files.json` file — a JSON array of
+// `{ dock?, in? }` — kept out of the entry set by the leading underscore. Returns [] when the file
+// is absent, unparseable, or not an array; malformed elements are dropped.
+export function loadProfileFiles(name) {
+    const file = path.join(profilePath(name), '_files.json');
+    if (!existsSync(file))
+        return [];
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        return Array.isArray(parsed) ? parsed.filter(isProfileFilesEntry) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function isProfileNotificationsEntry(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const entry = value;
+    return entry.dock === undefined || (typeof entry.dock === 'string' && ['left', 'right'].includes(entry.dock));
+}
+// Profile-level notifications tabs live in a reserved `_notifications.json` file — a JSON array of
+// `{ dock? }` — kept out of the entry set by the leading underscore. Returns [] when the file is
+// absent, unparseable, or not an array; malformed elements are dropped.
+export function loadProfileNotifications(name) {
+    const file = path.join(profilePath(name), '_notifications.json');
+    if (!existsSync(file))
+        return [];
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        return Array.isArray(parsed) ? parsed.filter(isProfileNotificationsEntry) : [];
+    }
+    catch {
+        return [];
+    }
+}
+export const PROFILE_USAGE = 'Usage: profile launch <name> | profile list';
+export function parseProfileCommand(command) {
+    const rest = command.replace(/^profile\b\s*/i, '').trim();
+    if (!rest)
+        return { error: PROFILE_USAGE };
+    const tokens = rest.split(/\s+/);
+    const head = tokens[0].toLowerCase();
+    if (head === 'list')
+        return { action: 'list' };
+    if (head === 'launch') {
+        if (!tokens[1])
+            return { error: 'Usage: profile launch <name>' };
+        return { action: 'launch', name: tokens[1] };
+    }
+    return { error: PROFILE_USAGE };
+}

package/dist/protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/pseudoterminal-manager.js

@@ -0,0 +1,106 @@
+import { spawnPty } from './pty.js';
+import { messageBus } from './bus.js';
+import { getGithubToken } from './github-token.js';
+// Owns the live PTY sessions (keyed by their id) backing harness tabs, full-tab interactive command
+// takeovers, and inline terminal cards, plus the dimensions new PTYs are spawned at. The controller
+// owns the tabs these PTYs belong to; this module owns the sessions and their I/O, handing
+// tab-affecting events back through the host.
+export class PseudoterminalManager {
+    managers;
+    ptys = new Map();
+    cols = 80;
+    rows = 24;
+    constructor(managers) {
+        this.managers = managers;
+    }
+    // Spawn a PTY running `command` (with `program` as its display label) in `cwd`, register it under
+    // the owning tab's `label`, and return its id. Output and exit route back through the host.
+    // `workspaceDir`/`offline`, when the owning tab is workspaced, confine the process via Seatbelt.
+    spawn(label, program, command, cwd, workspaceDir, offline) {
+        const session = spawnPty(program, command, cwd, {
+            onData: (id, data) => messageBus.emit('pty', { type: 'data', id, data }),
+            onExit: (id, exitCode) => this.handleExit(id, exitCode),
+        }, this.cols, this.rows, { workspaceDir, offline, githubToken: workspaceDir ? getGithubToken() : undefined });
+        this.ptys.set(session.id, { session, tabLabel: label });
+        return session.id;
+    }
+    // Forward client keystrokes to a PTY.
+    input(id, data) { this.ptys.get(id)?.session.write(data); }
+    // Resize a single PTY (a client viewport change) and mirror the new size onto the bus so
+    // server-side observers (the harness screen reader) track the real PTY's dimensions.
+    resizeOne(id, cols, rows) {
+        const entry = this.ptys.get(id);
+        if (!entry)
+            return;
+        entry.session.resize(cols, rows);
+        messageBus.emit('pty', { type: 'resize', id, cols, rows });
+    }
+    // Kill a single PTY; its exit then flows through `handleExit`.
+    kill(id) { this.ptys.get(id)?.session.kill(); }
+    // Set the dimensions new PTYs spawn at (the client's terminal size).
+    resize(cols, rows) { this.cols = cols; this.rows = rows; }
+    // The dimensions new PTYs spawn at, for observers that mirror a PTY's screen.
+    spawnDimensions() { return { cols: this.cols, rows: this.rows }; }
+    // The program names of a tab's live PTYs, for the connections panel and completion (`terminal:<program>`).
+    terminalsFor(label) {
+        const programs = [];
+        for (const [, entry] of this.ptys)
+            if (entry.tabLabel === label)
+                programs.push(entry.session.program);
+        return programs;
+    }
+    // Create an inline terminal card: spawn a PTY running `command` in the tab's cwd and attach its
+    // id to `tab.activePty` so the client renders a terminal widget in the transcript. A workspaced
+    // tab's own `workspaceDir`/`offline` carry over to inline PTYs (e.g. `shell vim` inside it).
+    openInlinePty(label, command, program) {
+        const cwd = this.managers.tab.cwdOf(label) ?? process.cwd();
+        const tab = this.managers.tab.tabs.find((t) => t.label === label);
+        const id = this.spawn(label, program, command, cwd, tab?.workspaceDir, tab?.offline);
+        for (const t of this.managers.tab.tabs) {
+            if (t.label === label) {
+                t.activePty = id;
+                break;
+            }
+        }
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    // Kill and forget every PTY belonging to a tab (on tab close).
+    closeTab(label) {
+        for (const [id, entry] of this.ptys)
+            if (entry.tabLabel === label) {
+                entry.session.kill();
+                this.ptys.delete(id);
+            }
+    }
+    // Kill every PTY (app shutdown).
+    closeAll() {
+        for (const [, entry] of this.ptys)
+            entry.session.kill();
+        this.ptys.clear();
+    }
+    // Drop the exited PTY from the registry, clear `activePty` on full-tab takeovers, update inline
+    // terminal card entries, then let the controller handle harness updates and client notification.
+    handleExit(id, exitCode) {
+        const hadEntry = this.ptys.delete(id);
+        // Clear activePty for full-tab interactive PTY takeovers.
+        for (const tab of this.managers.tab.tabs) {
+            if (tab.activePty === id)
+                tab.activePty = undefined;
+        }
+        // Update inline terminal card status in the log.
+        if (hadEntry) {
+            for (const tab of this.managers.tab.tabs) {
+                const index = tab.log.findIndex((e) => e.terminal?.ptyId === id);
+                if (index !== -1) {
+                    const log = [...tab.log];
+                    log[index] = { ...log[index], terminal: { ...log[index].terminal, status: 'exited', exitCode } };
+                    tab.log = log;
+                    this.managers.tab.persist(this.managers.tab.buildAgentState(tab));
+                    messageBus.emit('transcript', { type: 'entry:appended', tabLabel: tab.label, entry: log[index], tab });
+                }
+            }
+        }
+        messageBus.emit('pty', { type: 'exit', id, exitCode });
+        messageBus.emit('state', { type: 'dirty' });
+    }
+}

package/dist/pty.js

@@ -0,0 +1,41 @@
+import * as pty from 'node-pty';
+import { sandboxSpawn } from './sandbox/index.js';
+let counter = 0;
+/**
+ * Spawn `cmd` in a pseudo-terminal. `program` is the display label for the card. Unlike the old
+ * output is delivered to a callback (the server forwards it to the client's xterm)
+ * rather than written to the real stdout, so many can run concurrently across tabs.
+ * `sandbox`, when given a `workspaceDir`, confines the process to that workspace (see sandbox.ts);
+ * omitted or workspaceDir-less, the command runs exactly as before.
+ */
+export function spawnPty(program, command, cwd, handlers, cols = 80, rows = 24, sandbox) {
+    const id = `pty${++counter}`;
+    const shell = process.env.SHELL || 'bash';
+    const { command: file, args, env } = sandboxSpawn({ ...sandbox, selfBinaryHint: program }, shell, ['-lc', command]);
+    const proc = pty.spawn(file, args, {
+        name: 'xterm-256color',
+        cols: Math.max(1, cols),
+        rows: Math.max(1, rows),
+        cwd: cwd || process.cwd(),
+        env,
+    });
+    proc.onData((d) => handlers.onData(id, d));
+    proc.onExit(({ exitCode }) => handlers.onExit(id, exitCode));
+    return {
+        id,
+        program,
+        write: (data) => proc.write(data),
+        resize: (c, r) => {
+            try {
+                proc.resize(Math.max(1, c), Math.max(1, r));
+            }
+            catch { /* process may have exited */ }
+        },
+        kill: () => {
+            try {
+                proc.kill();
+            }
+            catch { /* already gone */ }
+        },
+    };
+}

package/dist/recognizers/acp.js

@@ -0,0 +1,38 @@
+import { FUNCTION_WORDS } from './lexicon.js';
+// Words that typically open a question or an instruction to an agent.
+const PROMPT_WORDS = new Set([
+    'what', 'how', 'why', 'when', 'who', 'where', 'which', 'whose', 'can', 'could', 'should',
+    'would', 'will', 'is', 'are', 'am', 'do', 'does', 'did', 'please', 'explain', 'describe',
+    'write', 'summarize', 'summarise', 'list', 'tell', 'give', 'show', 'find', 'create',
+    'generate', 'make', 'help', 'translate', 'convert', 'fix', 'refactor', 'implement', 'add',
+    'remove', 'compare', 'suggest', 'review', 'draft', 'rewrite', 'analyze', 'analyse',
+]);
+// Shell metacharacters / SQL-ish punctuation that argue against this being plain prose.
+const SYMBOLIC = /[|&;<>`$\\]|\$\(/;
+// Recognize a natural-language prompt for the agent (acp). This is the prose catch-all: a
+// trailing `?`, an opening question/instruction word, or simply several mostly-alphabetic
+// words all read as a prompt.
+export const acpRecognizer = {
+    route: 'acp',
+    recognize: (command) => {
+        const trimmed = command.trim();
+        const words = trimmed.split(/\s+/);
+        const first = words[0]?.toLowerCase() ?? '';
+        const letters = (trimmed.match(/[A-Za-z]/g) ?? []).length;
+        const alphaRatio = trimmed.length > 0 ? letters / trimmed.length : 0;
+        let score = 0;
+        score = /\?\s*$/.test(trimmed) ? 0.8 : score;
+        if (PROMPT_WORDS.has(first))
+            score = Math.max(score, 0.6);
+        if (words.length >= 3 && !SYMBOLIC.test(trimmed) && alphaRatio > 0.7) {
+            score = Math.max(score, 0.5);
+        }
+        // A question/instruction opener followed by grammatical words reads as a real sentence
+        // ("which file is the longest"), not a command — strong enough to dispatch on its own.
+        const functionInRest = words.slice(1).filter((w) => FUNCTION_WORDS.has(w.toLowerCase())).length;
+        if (PROMPT_WORDS.has(first) && functionInRest >= 1)
+            score += 0.2;
+        score = Math.min(score, 0.95);
+        return { match: score >= 0.4, reliability: score };
+    },
+};