janissary 0.5.0

package/dist/monitor/harness-feed.js

@@ -0,0 +1,21 @@
+import { resolveTargetTabs } from './targets.js';
+// Turn harness-view targets into monitor buffer entries. Harness tabs have no `LogEntry` transcript,
+// so a monitor watching one instead receives that tab's latest rendered screen (the coherent,
+// de-ANSI'd text the screen reader already computes) as a `LogEntry` tagged with the tab label.
+// Entries are emitted only when the capture is newer than the last one fed for that tab (deduped by
+// `capturedAt`), so an idle harness — whose screen reader keeps returning the same capture — never
+// re-prompts the monitor. Non-harness targets are ignored here; they flow through the tab log and
+// the `entry:appended` channel instead.
+export function harnessFeedEntries(managers, targets, harnessSeen) {
+    const entries = [];
+    for (const tab of resolveTargetTabs(managers.tab.tabs, targets)) {
+        if (tab.view !== 'harness')
+            continue;
+        const latest = managers.harness.latestScreenText(tab.label);
+        if (!latest || harnessSeen.get(tab.label) === latest.capturedAt)
+            continue;
+        harnessSeen.set(tab.label, latest.capturedAt);
+        entries.push({ tabLabel: tab.label, entry: { input: '', output: latest.text } });
+    }
+    return entries;
+}

package/dist/monitor/info.js

@@ -0,0 +1,29 @@
+import { formatTargets } from './targets.js';
+// Read-only projections of the live monitor registry: the `monitors` command listing
+// and the connections-panel rows.
+export function listMonitors(monitors) {
+    return [...monitors].map((reg) => {
+        const targets = formatTargets(reg.targets);
+        const mode = reg.inline ? 'inline' : 'external';
+        return `${reg.persona.name}: ${targets} ← ${reg.owner} (${mode}, ${reg.delivered} suggestion${reg.delivered === 1 ? '' : 's'})`;
+    });
+}
+// Joins provider and model into a single "provider/model" label, dropping whichever is absent.
+export function formatConnection(info) {
+    return [info.provider, info.model].filter(Boolean).join('/');
+}
+// A persona's body opens with a single declarative sentence (e.g. "You are a security
+// monitor."); take up to its first period as a concise one-sentence summary.
+export function personaSummary(persona) {
+    const period = persona.body.indexOf('.');
+    return period === -1 ? persona.body.trim() : persona.body.slice(0, period + 1);
+}
+// Rows for a tab's monitors (e.g. `monitor:security (opencode/…)`).
+export function monitorConnections(monitors, owner) {
+    return [...monitors]
+        .filter((reg) => reg.owner === owner)
+        .map((reg) => {
+        const info = reg.info ? ` (${formatConnection(reg.info)})` : '';
+        return { text: `monitor:${reg.persona.name}${info}`, kind: 'acp' };
+    });
+}

package/dist/monitor/manager.js

@@ -0,0 +1,221 @@
+import { messageBus } from '../bus.js';
+import { loadPersona } from '../personas.js';
+import { parseSuggestion } from './parsing.js';
+import { openMonitorTab, pushSuggestion, rateSuggestion, updateMonitorMeta } from './window.js';
+import { openMonitorSession, respawnMonitorSession } from './session.js';
+import { spawnMonitorSession } from './acp.js';
+import { validateTargets, matchesTargets, targetColor, formatTargets, resolveTargetAliases } from './targets.js';
+import { stopMonitor, closeIfUnfed } from './stop.js';
+import { seedFeedEntries, flushFeedEntries } from './feeds.js';
+import { generateSessionDelimiter, frameEntry } from './framing.js';
+import { recordContext, snapshotMonitorContext } from './context.js';
+import { listMonitors, monitorConnections } from './info.js';
+import { askMonitor } from './ask.js';
+import { recordReply } from './reply.js';
+import { notify } from '../notifications.js';
+import { isRateLimitError } from '../acp/rate-limit.js';
+import { SUGGESTION_PREFIX, buildSuggestion, formatInlineSuggestion } from './suggestion.js';
+export { SUGGESTION_PREFIX } from './suggestion.js';
+export const MONITOR_FLUSH_MS = 30_000;
+// Owns all live monitors, keyed by `${ownerLabel}:${persona}`. Each monitor is a
+// dedicated, tool-less ACP session primed with its persona; transcript entries from its
+// targets buffer up and flush as one prompt every 30s (never when the buffer is empty,
+// never while a previous prompt is still streaming). Suggestions route to the owner
+// tab's transcript (inline mode) or the persona's reporting tab (external mode).
+export class MonitorManager {
+    managers;
+    spawn;
+    flushMs;
+    monitors = new Map();
+    counter = 0;
+    constructor(managers, spawn = spawnMonitorSession, flushMs = MONITOR_FLUSH_MS) {
+        this.managers = managers;
+        this.spawn = spawn;
+        this.flushMs = flushMs;
+    }
+    // Start a monitor; returns an error message, or null on success. No targets = inline
+    // mode (watch the owner tab, report into its transcript).
+    start(owner, personaName, targets) {
+        const key = `${owner}:${personaName}`;
+        if (this.monitors.has(key))
+            return `Already monitoring with persona "${personaName}".`;
+        const inline = targets.length === 0;
+        const resolved = inline
+            ? [{ kind: 'tab', label: owner }]
+            : resolveTargetAliases(this.managers.tab.tabs, targets);
+        const targetError = validateTargets(this.managers.tab.tabs, personaName, inline, resolved);
+        if (targetError)
+            return targetError;
+        let persona;
+        try {
+            persona = loadPersona(personaName);
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+        const reg = {
+            owner, inline, persona, targets: resolved, buffer: [], harnessSeen: new Map(), editorSeen: new Map(), pageSeen: new Map(), delimiter: generateSessionDelimiter(), inFlight: true, delivered: 0,
+            contextBytes: 0, contextText: [],
+            session: undefined, timer: undefined, subs: [],
+        };
+        this.openSession(reg);
+        this.subscribe(key, reg);
+        reg.buffer.push(...seedFeedEntries(this.managers, this.managers.tab.tabs, resolved, reg));
+        reg.timer = setInterval(() => this.flush(key), this.flushMs);
+        this.monitors.set(key, reg);
+        // External mode: open the reporting tab right away (empty feed) so starting the
+        // monitor is visible immediately, not only when the first suggestion lands.
+        if (!inline) {
+            openMonitorTab(this.managers, personaName, targetColor(this.managers.tab.tabs, resolved));
+            updateMonitorMeta(this.managers, personaName, formatTargets(resolved), reg.contextBytes);
+        }
+        return null;
+    }
+    // Spawn the monitor's dedicated session and prime it with the persona body + reply
+    // format; `inFlight` holds flushes off until priming settles.
+    openSession(reg) {
+        openMonitorSession(reg, this.managers, this.spawn);
+    }
+    // A prompt failed (typically the ACP subprocess died). Replace the session with a
+    // fresh, re-primed one so the monitor recovers instead of staying dead.
+    respawn(reg) {
+        respawnMonitorSession(reg, this.managers, this.spawn);
+        if (!reg.inline)
+            updateMonitorMeta(this.managers, reg.persona.name, formatTargets(reg.targets), reg.contextBytes);
+    }
+    subscribe(key, reg) {
+        reg.subs.push(messageBus.on('transcript', 'entry:appended', (event) => {
+            if (event.type !== 'entry:appended' || !matchesTargets(this.managers.tab.tabs, reg.targets, event.tabLabel))
+                return;
+            // Never feed a monitor its own (or a sibling monitor's) inline suggestions.
+            if (event.entry.output.startsWith(SUGGESTION_PREFIX))
+                return;
+            reg.buffer.push({ tabLabel: event.tabLabel, entry: event.entry });
+        }), messageBus.on('transcript', 'tab:removed', (event) => {
+            if (event.type !== 'tab:removed')
+                return;
+            if (event.tabLabel === reg.owner) {
+                this.handleOwnerClosed(reg.owner);
+                return;
+            }
+            // The reporting tab itself was closed directly: tear the monitor down fully,
+            // regardless of remaining targets, so its session doesn't linger and the same
+            // owner/persona can be started again.
+            if (!reg.inline && event.tabLabel === reg.persona.name) {
+                this.stop(reg.owner, reg.persona.name);
+                return;
+            }
+            // Only tab targets drop out; group targets persist (the group may gain new tabs).
+            if (reg.targets.some((t) => t.kind === 'tab' && t.label === event.tabLabel)) {
+                this.stop(reg.owner, reg.persona.name, { kind: 'tab', label: event.tabLabel });
+            }
+        }));
+    }
+    // The 30-second batch. No new transcripts → no ACP query at all; also skipped while a
+    // previous prompt (including the persona priming) is still streaming.
+    flush(key) {
+        const reg = this.monitors.get(key);
+        if (!reg || reg.inFlight)
+            return;
+        // Harness tabs never emit `entry:appended`, so top up from their rendered screen here — the
+        // live channel for harness targets. An idle harness yields nothing, keeping the "no new
+        // content → no ACP prompt" guarantee below intact.
+        reg.buffer.push(...flushFeedEntries(this.managers, reg.targets, reg));
+        if (reg.buffer.length === 0)
+            return;
+        const batch = reg.buffer;
+        reg.buffer = [];
+        const body = batch
+            .map(({ tabLabel, entry }) => frameEntry(tabLabel, entry, reg.delimiter))
+            .join('\n\n');
+        const prompt = `[Monitor update]\n${body}`;
+        recordContext(reg, prompt, 'input');
+        reg.inFlight = true;
+        let reply = '';
+        reg.session.prompt(prompt, {
+            onChunk: (text) => { reply += text; },
+            onEnd: () => {
+                reg.inFlight = false;
+                recordReply(reg, this.managers, reply);
+                const suggestion = parseSuggestion(reply);
+                if (suggestion)
+                    this.deliver(reg, batch.at(-1).tabLabel, suggestion);
+            },
+            onError: (message) => {
+                this.managers.tab.append(reg.owner, { input: '', output: `monitor ${reg.persona.name}: ${message} — restarting monitor session` });
+                if (isRateLimitError(message))
+                    notify(this.managers, 'rate-limited', reg.owner);
+                this.respawn(reg);
+            },
+        });
+    }
+    deliver(reg, about, parsed) {
+        reg.delivered += 1;
+        const suggestion = buildSuggestion(parsed, reg.persona.name, about, `s-${++this.counter}`);
+        if (reg.inline) {
+            this.managers.tab.append(reg.owner, { input: '', output: formatInlineSuggestion(reg.persona.name, suggestion) });
+            return;
+        }
+        pushSuggestion(this.managers, reg.persona.name, targetColor(this.managers.tab.tabs, reg.targets), suggestion);
+    }
+    // Query a running monitor's ACP session directly; the reply lands in the owner tab's
+    // transcript. Shares the `inFlight` slot with flushes, so a question never interleaves
+    // with a monitor-update prompt. Returns an error message, or null when the question is
+    // on its way.
+    ask(owner, personaName, question) {
+        const reg = this.monitors.get(`${owner}:${personaName}`);
+        if (!reg)
+            return `No "${personaName}" monitor running from this tab.`;
+        if (reg.inFlight)
+            return `The ${personaName} monitor is busy; try again in a moment.`;
+        askMonitor(reg, owner, personaName, question, this.managers, () => this.respawn(reg));
+        return null;
+    }
+    // Thumbs up/down on a reporting-tab suggestion (see monitor-window `rateSuggestion`).
+    rate(id, up) {
+        rateSuggestion(this.monitors.values(), this.managers, id, up);
+    }
+    // Reset every monitor feeding `name`'s reporting tab to just its persona context.
+    resetContext(name) { for (const reg of this.monitors.values())
+        if (!reg.inline && reg.persona.name === name)
+            this.respawn(reg); }
+    // Open a point-in-time snapshot of `name`'s monitor context in an editor tab (see monitor-context).
+    snapshotContext(name) {
+        snapshotMonitorContext(this.monitors.values(), this.managers, name);
+    }
+    // Stop one persona's monitor (or drop a single target from it). Returns false when no
+    // such monitor exists.
+    stop(owner, personaName, target) {
+        return stopMonitor(this.monitors, this.managers, owner, personaName, target);
+    }
+    // The owning agent tab closed: stop its monitors, and close any reporting tab that no
+    // longer has a live monitor feeding it (another tab may still run the same persona).
+    handleOwnerClosed(owner) {
+        const personas = [...this.monitors.values()]
+            .filter((reg) => reg.owner === owner && !reg.inline)
+            .map((reg) => reg.persona.name);
+        this.stopAll(owner);
+        for (const name of personas)
+            closeIfUnfed(this.monitors, this.managers, name);
+    }
+    stopAll(owner) {
+        const mine = [...this.monitors.values()].filter((r) => r.owner === owner);
+        for (const reg of mine)
+            this.stop(reg.owner, reg.persona.name);
+        return mine.length;
+    }
+    // Lines for the `monitors` command.
+    list() {
+        return listMonitors(this.monitors.values());
+    }
+    // Connections-panel rows for a tab's monitors (e.g. `monitor:security (opencode/…)`).
+    connectionsFor(owner) {
+        return monitorConnections(this.monitors.values(), owner);
+    }
+    closeAll() {
+        // Snapshot first: `stop` mutates the map while we iterate.
+        const all = [...this.monitors.values()];
+        for (const reg of all)
+            this.stop(reg.owner, reg.persona.name);
+    }
+}

package/dist/monitor/page-feed.js

@@ -0,0 +1,21 @@
+import { resolveTargetTabs } from './targets.js';
+import { diffFeedEntry } from './feed-diff.js';
+// Turn page-view targets into monitor buffer entries. Page tabs have no `LogEntry` transcript, so a
+// monitor watching one instead receives the text currently visible in that page's viewport, read
+// synchronously from a per-tab cache (`tab.pageSnapshot`) the extension content script keeps fresh
+// out of band via the `pageSync` RPC — never the DOM inline, since the flush this feeds is
+// synchronous. The first feed to a given monitor for a given tab is the full current content; every
+// one after that is a unified diff against what was last fed to *that* monitor, emitted only when
+// the content actually changed. Every entry is byte-capped. Non-page targets are ignored here.
+export function pageFeedEntries(managers, targets, pageSeen) {
+    const entries = [];
+    for (const tab of resolveTargetTabs(managers.tab.tabs, targets)) {
+        if (tab.view !== 'page' || !tab.pageSnapshot)
+            continue;
+        const current = tab.pageSnapshot.text;
+        const entry = diffFeedEntry(pageSeen, tab.label, current, tab.page?.domain ?? tab.label);
+        if (entry)
+            entries.push(entry);
+    }
+    return entries;
+}

package/dist/monitor/parsing.js

@@ -0,0 +1,82 @@
+// A target argument: `group:<n>` or a tab label.
+function parseTarget(word) {
+    const group = /^group:(\d+)$/i.exec(word);
+    if (group)
+        return { kind: 'group', group: Number(group[1]) };
+    if (word.includes(':'))
+        return { error: `Bad target "${word}" (expected a tab label or group:<n>).` };
+    return { kind: 'tab', label: word };
+}
+// `monitor <persona> [target...]` — no targets means inline mode (watch the current tab).
+// `monitor ask <persona> <question>` — query the running monitor's ACP directly.
+export function parseMonitorCommand(input) {
+    const words = input.trim().split(/\s+/).slice(1);
+    if (words[0] === 'ask') {
+        const persona = words[1];
+        const question = words.slice(2).join(' ');
+        if (!persona || !question)
+            return { error: 'Usage: monitor ask <persona> <question>' };
+        return { ask: true, persona, question };
+    }
+    const persona = words[0];
+    if (!persona)
+        return { error: 'Usage: monitor <persona> [tab|group:<n> ...]' };
+    if (words[1] === 'ask')
+        return { error: `Did you mean: monitor ask ${persona} <question>?` };
+    const targets = [];
+    for (const word of words.slice(1)) {
+        const target = parseTarget(word);
+        if ('error' in target)
+            return target;
+        targets.push(target);
+    }
+    return { persona, targets };
+}
+// `unmonitor --all` | `unmonitor <persona> [target]`
+export function parseUnmonitorCommand(input) {
+    const words = input.trim().split(/\s+/).slice(1);
+    if (words[0] === '--all')
+        return { all: true };
+    const persona = words[0];
+    if (!persona)
+        return { error: 'Usage: unmonitor <persona> [tab|group:<n>] | unmonitor --all' };
+    if (words.length === 1)
+        return { persona };
+    const target = parseTarget(words[1]);
+    if ('error' in target)
+        return target;
+    return { persona, target };
+}
+// Extract a deliverable report from the monitoring AI's reply. The reply may contain
+// anything; only the marker lines count:
+//   [SUMMARY]: <text>                — a recap of activity (harness/page), no command
+//   [SUGGESTION]: <text>             — an actionable suggestion
+//   [COMMAND]: <optional command>    — a command that accompanies a suggestion
+// An actionable suggestion wins when both markers are present; a summary carries no
+// command. No marker → nothing to deliver (the persona is told silence is fine).
+// Extract the text following a `[MARKER]:` line, up to (but not including) the next
+// bracket-marker line or the end of the reply — so a marker's own text may span multiple lines
+// (e.g. a summary that continues onto bullet points).
+function captureMarker(reply, marker) {
+    const re = new RegExp(String.raw `(?:^|\n)\[${marker}]:\s*([\s\S]*?)(?=\n\[[A-Z]+]:|$)`);
+    return re.exec(reply)?.[1]?.trim();
+}
+export function parseSuggestion(reply) {
+    const suggestion = captureMarker(reply, 'SUGGESTION');
+    if (suggestion) {
+        const command = captureMarker(reply, 'COMMAND');
+        return command ? { text: suggestion, command } : { text: suggestion };
+    }
+    const summary = captureMarker(reply, 'SUMMARY');
+    return summary ? { text: summary } : null;
+}
+// The output-format instructions appended to every persona's startup prompt.
+export const SUGGESTION_FORMAT = [
+    'Reply using exactly one of these formats:',
+    'To recap what a harness or web page is doing (a summary, not a suggestion):',
+    '[SUMMARY]: <one or two short sentences>',
+    'To offer an actionable suggestion:',
+    '[SUGGESTION]: <one short sentence>',
+    '[COMMAND]: <a single command the user could run, only if one clearly applies>',
+    'Only when you have genuinely nothing to report, reply with the single word: OK',
+].join('\n');

package/dist/monitor/reply.js

@@ -0,0 +1,11 @@
+import { formatTargets } from './targets.js';
+import { updateMonitorMeta } from './window.js';
+import { recordContext } from './context.js';
+// Account for a completed prompt's reply and refresh the reporting tab's metadata — shared by
+// flush's and ask's `onEnd` handlers, both of which do this identically once an ACP reply finishes
+// streaming.
+export function recordReply(reg, managers, reply) {
+    recordContext(reg, reply, 'response');
+    if (!reg.inline)
+        updateMonitorMeta(managers, reg.persona.name, formatTargets(reg.targets), reg.contextBytes);
+}

package/dist/monitor/session.js

@@ -0,0 +1,36 @@
+import { messageBus } from '../bus.js';
+import { spawnMonitorSession } from './acp.js';
+import { SUGGESTION_FORMAT } from './parsing.js';
+import { TRUST_FRAMING_INSTRUCTIONS } from './framing.js';
+import { formatConnection, personaSummary } from './info.js';
+import { recordContext } from './context.js';
+export function openMonitorSession(reg, managers, spawn = spawnMonitorSession) {
+    reg.inFlight = true;
+    reg.session = spawn(reg.persona, managers.tab.cwdOf(reg.owner) ?? process.cwd(), {
+        onError: (message) => managers.tab.append(reg.owner, { input: '', output: `monitor ${reg.persona.name}: ${message}` }),
+        onConnect: (info) => {
+            reg.info = info;
+            const connection = formatConnection(info);
+            const summary = personaSummary(reg.persona);
+            managers.tab.append(reg.owner, {
+                input: '',
+                output: `monitor ${reg.persona.name}: connected${connection ? ` (${connection})` : ''} — ${summary}`,
+            });
+            messageBus.emit('state', { type: 'dirty' });
+        },
+    });
+    const primingText = `${reg.persona.body}\n\n${SUGGESTION_FORMAT}\n\n${TRUST_FRAMING_INSTRUCTIONS(reg.delimiter)}`;
+    recordContext(reg, primingText, 'input');
+    reg.session.prompt(primingText, {
+        onChunk: () => { },
+        onEnd: () => { reg.inFlight = false; },
+        onError: () => { reg.inFlight = false; },
+    });
+}
+export function respawnMonitorSession(reg, managers, spawn = spawnMonitorSession) {
+    reg.session.kill();
+    // A fresh session starts a fresh context.
+    reg.contextBytes = 0;
+    reg.contextText = [];
+    openMonitorSession(reg, managers, spawn);
+}

package/dist/monitor/stop.js

@@ -0,0 +1,33 @@
+import { closeMonitorTab, updateMonitorMeta } from './window.js';
+import { formatTargets, resolveTargetAliases } from './targets.js';
+// Stop one persona's monitor (or drop a single target from it). Returns false when no such
+// monitor exists. Split out of MonitorManager to keep that file under the size limit.
+export function stopMonitor(monitors, managers, owner, personaName, target) {
+    const key = `${owner}:${personaName}`;
+    const reg = monitors.get(key);
+    if (!reg)
+        return false;
+    const resolvedTarget = target ? resolveTargetAliases(managers.tab.tabs, [target])[0] : undefined;
+    if (resolvedTarget && !reg.inline) {
+        reg.targets = reg.targets.filter((t) => JSON.stringify(t) !== JSON.stringify(resolvedTarget));
+        if (reg.targets.length > 0) {
+            updateMonitorMeta(managers, personaName, formatTargets(reg.targets), reg.contextBytes);
+            return true;
+        }
+    }
+    for (const sub of reg.subs)
+        sub.unsubscribe();
+    clearInterval(reg.timer);
+    reg.session.kill();
+    monitors.delete(key);
+    if (!reg.inline)
+        closeIfUnfed(monitors, managers, personaName);
+    return true;
+}
+// Close a persona's reporting tab if no live monitor still feeds it (another owner may run
+// the same persona and keep it open).
+export function closeIfUnfed(monitors, managers, personaName) {
+    const stillFed = [...monitors.values()].some((r) => !r.inline && r.persona.name === personaName);
+    if (!stillFed)
+        closeMonitorTab(managers, personaName);
+}

package/dist/monitor/suggestion.js

@@ -0,0 +1,12 @@
+// Marks inline suggestion entries so monitors never feed on their own output.
+export const SUGGESTION_PREFIX = '💡';
+// Builds the suggestion record delivered to either the owner tab's transcript (inline mode) or
+// the persona's reporting tab (external mode).
+export function buildSuggestion(parsed, personaName, about, id) {
+    return { ...parsed, id, timestamp: Date.now(), persona: personaName, about };
+}
+// Formats an inline-mode suggestion as it's appended to the owner tab's transcript.
+export function formatInlineSuggestion(personaName, suggestion) {
+    const command = suggestion.command ? `\n${suggestion.command}` : '';
+    return `${SUGGESTION_PREFIX} ${personaName}: ${suggestion.text}${command}`;
+}

package/dist/monitor/targets.js

@@ -0,0 +1,69 @@
+// Target helpers for the monitor manager: validation, live matching, and the color a
+// reporting tab inherits. All operate on the current tab list — group targets are
+// resolved at event time, so group membership stays dynamic.
+// The current tabs a monitor's targets resolve to: a tab target's tab, or every member of a group
+// target. Shared by the initial-seed loop and the harness feed so both resolve targets identically.
+export function resolveTargetTabs(tabs, targets) {
+    return tabs.filter((t) => targets.some((target) => target.kind === 'tab' ? t.label === target.label : t.group === target.group));
+}
+// The buffer entries to seed a monitor with at start: every existing `LogEntry` of each target tab,
+// tagged with that tab's label.
+export function seedEntries(tabs, targets) {
+    const entries = [];
+    for (const tab of resolveTargetTabs(tabs, targets)) {
+        for (const entry of tab.log)
+            entries.push({ tabLabel: tab.label, entry });
+    }
+    return entries;
+}
+// Resolve a tab-kind target's typed label against a tab's canonical label or display alias
+// (see `rename`), case-insensitively — mirrors `resolveTarget` in commands/resolve-target.ts.
+// A target that matches no tab passes through unchanged, so `validateTargets` still reports
+// it as missing. Group targets pass through unchanged.
+export function resolveTargetAliases(tabs, targets) {
+    return targets.map((target) => {
+        if (target.kind !== 'tab')
+            return target;
+        const key = target.label.toLowerCase();
+        const match = tabs.find((t) => t.label.toLowerCase() === key || t.title?.toLowerCase() === key);
+        return match ? { kind: 'tab', label: match.label } : target;
+    });
+}
+export function validateTargets(tabs, personaName, inline, targets) {
+    for (const target of targets) {
+        if (target.kind === 'tab' && tabs.every((t) => t.label !== target.label || t.view === 'monitor')) {
+            return `No tab named "${target.label}".`;
+        }
+        if (target.kind === 'group' && tabs.every((t) => t.group !== target.group)) {
+            return `No group ${target.group}.`;
+        }
+    }
+    // The reporting tab reuses the persona name as its label; an action tab holding that
+    // label would collide with by-label lookups (e.g. runSuggestion's dispatch).
+    if (!inline && tabs.some((t) => t.label === personaName && t.view !== 'monitor')) {
+        return `A tab named "${personaName}" already exists; rename it or pick another persona.`;
+    }
+    return null;
+}
+// A human-readable rendering of a monitor's targets, e.g. `agent2, group:3`.
+export function formatTargets(targets) {
+    return targets.map((t) => (t.kind === 'tab' ? t.label : `group:${t.group}`)).join(', ');
+}
+export function matchesTargets(tabs, targets, tabLabel) {
+    const tab = tabs.find((t) => t.label === tabLabel);
+    if (!tab || tab.view === 'monitor')
+        return false;
+    return targets.some((t) => (t.kind === 'tab' ? t.label === tabLabel : t.group === tab.group));
+}
+// Reporting tabs carry the monitored tab's color: the first tab target's dot color, or
+// the first member of the first group target.
+export function targetColor(tabs, targets) {
+    for (const target of targets) {
+        const tab = target.kind === 'tab'
+            ? tabs.find((t) => t.label === target.label)
+            : tabs.find((t) => t.group === target.group);
+        if (tab)
+            return target.kind === 'group' ? tab.groupColor : tab.dotColor;
+    }
+    return '#5b9cff';
+}

package/dist/monitor/window.js

@@ -0,0 +1,109 @@
+import { makeTab } from '../tab/index.js';
+import { messageBus } from '../bus.js';
+// Monitor reporting tabs: each external-mode monitor gets its own view-only tab
+// (`view: 'monitor'`) named after its persona (e.g. `security`, `quality`) and colored
+// after the tab it monitors — the reporting strip and body left-border carry that color.
+// Reporting tabs render in the reporting section below the command bar, never in the
+// action strip, and accept no commands; their only interactions are the per-suggestion
+// Run/Dismiss buttons (RPCs handled here).
+const makeMonitorTab = (name, dotColor, number) => ({
+    // Group 0: reporting tabs sit outside the action-tab group system.
+    ...makeTab(name, dotColor, number, [], [], undefined, 0, dotColor),
+    view: 'monitor',
+    title: name,
+    // The reporting tab's label is always its persona name (see `MonitorManager.start`), so
+    // `persona` never changes after creation; `targets`/`contextBytes` are filled in afterward
+    // via `updateMonitorMeta` once the owning monitor registration exists.
+    monitor: { suggestions: [], persona: name, targets: '', contextBytes: 0 },
+});
+// A unique label for a new monitor's reporting tab: the persona name, suffixed
+// (`assistant-2`, …) when that label is already taken by any tab. Each monitor instance
+// gets its own window, so the same persona can watch different targets side by side.
+export function allocateMonitorLabel(managers, persona) {
+    const used = new Set(managers.tab.tabs.map((t) => t.label));
+    if (!used.has(persona))
+        return persona;
+    let n = 2;
+    while (used.has(`${persona}-${n}`))
+        n++;
+    return `${persona}-${n}`;
+}
+// All monitor reporting tabs currently open.
+export function monitorTabs(managers) {
+    return managers.tab.tabs.filter((t) => t.view === 'monitor');
+}
+// Open the named monitor's reporting tab or reuse the existing one. Reporting tabs are
+// appended at the end of the tab list so action-tab indices (including `activeTab`)
+// never shift, and the active tab is left untouched.
+export function openMonitorTab(managers, name, dotColor) {
+    const existing = monitorTabs(managers).find((t) => t.label === name);
+    if (existing)
+        return existing;
+    const tabs = managers.tab.tabs;
+    const tab = makeMonitorTab(name, dotColor, tabs.length + 1);
+    managers.tab.tabs = [...tabs, tab];
+    messageBus.emit('state', { type: 'dirty' });
+    return tab;
+}
+// Append a suggestion to the named monitor's feed (opening its tab if needed).
+export function pushSuggestion(managers, name, dotColor, suggestion) {
+    const tab = openMonitorTab(managers, name, dotColor);
+    tab.monitor.suggestions.push(suggestion);
+    messageBus.emit('state', { type: 'dirty' });
+}
+// Update a persona's reporting tab with its monitor's current targets and running
+// context-byte total. A no-op if the tab or its monitor payload is gone.
+export function updateMonitorMeta(managers, name, targets, contextBytes) {
+    const tab = monitorTabs(managers).find((t) => t.label === name);
+    if (!tab?.monitor)
+        return;
+    tab.monitor.targets = targets;
+    tab.monitor.contextBytes = contextBytes;
+    messageBus.emit('state', { type: 'dirty' });
+}
+// Close a persona's reporting tab (used when the last monitor feeding it goes away
+// with its owning agent tab).
+export function closeMonitorTab(managers, name) {
+    const index = managers.tab.tabs.findIndex((t) => t.view === 'monitor' && t.label === name);
+    if (index !== -1)
+        managers.tab.closeTab(index);
+}
+// Find a suggestion anywhere in the monitor feeds by id.
+export function findSuggestion(managers, id) {
+    return monitorTabs(managers)
+        .flatMap((t) => t.monitor.suggestions)
+        .find((s) => s.id === id);
+}
+// Remove a suggestion from whichever feed holds it (thumbs-down).
+export function removeSuggestion(managers, id) {
+    for (const tab of monitorTabs(managers)) {
+        const before = tab.monitor.suggestions.length;
+        tab.monitor.suggestions = tab.monitor.suggestions.filter((s) => s.id !== id);
+        if (tab.monitor.suggestions.length !== before)
+            messageBus.emit('state', { type: 'dirty' });
+    }
+}
+// Run a suggestion's command in the tab the suggestion is about (a clicked command
+// line). The suggestion stays in the feed — the history of what was suggested (and run)
+// is part of the record. Monitor tabs themselves never execute commands.
+export function runSuggestion(managers, id) {
+    const suggestion = findSuggestion(managers, id);
+    if (!suggestion?.command)
+        return;
+    managers.command.dispatchTo(suggestion.about, suggestion.command);
+}
+// Thumbs up/down on a reporting-tab suggestion. The rating is fed back to the monitor through its
+// normal batched prompt channel (queued on the owning monitor's buffer, no extra ACP round-trip),
+// so the AI learns what the user found useful. Rating a suggestion means the user is done with it,
+// so either direction removes it from the feed.
+export function rateSuggestion(monitors, managers, id, up) {
+    const suggestion = findSuggestion(managers, id);
+    if (!suggestion)
+        return;
+    const reg = [...monitors].find((r) => !r.inline && r.persona.name === suggestion.persona);
+    reg?.buffer.push({
+        tabLabel: suggestion.about,
+        entry: { input: '', output: `[user feedback] The user rated your suggestion "${suggestion.text}" as ${up ? 'helpful (thumbs up)' : 'not helpful (thumbs down)'}.` },
+    });
+    removeSuggestion(managers, id);
+}