janissary 0.5.0

package/dist/open-file-manager.js

@@ -0,0 +1,100 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { openerForExtension } from './openers/index.js';
+import { didOsOpen } from './openers/os-open.js';
+import { openInEditor } from './openers/editor.js';
+import { parseOpen, isGlobPattern } from './commands/open.js';
+import { expandUserPath } from './paths.js';
+import { webOpener } from './openers/page.js';
+import { SHELL_NAME } from './shell-manager.js';
+import { TabManager } from './tab/manager.js';
+export class OpenFileManager {
+    managers;
+    constructor(managers) {
+        this.managers = managers;
+    }
+    run(command, label) {
+        const parsed = parseOpen(command);
+        if ('error' in parsed) {
+            this.managers.tab.append(label, { input: command, output: parsed.error });
+            return;
+        }
+        const cwd = this.managers.tab.cwdOf(label) ?? process.cwd();
+        const context = this.buildContext(command, label);
+        const target = expandUserPath(parsed.target, { root: this.managers.tab.launchDir });
+        if (parsed.web) {
+            void (parsed.external ? webOpener.external(target, context) : webOpener.inline(target, context));
+            return;
+        }
+        if (isGlobPattern(target)) {
+            const matches = this.expandGlob(target, cwd);
+            if (matches.length === 0) {
+                this.managers.tab.append(label, { input: command, output: `open: ${target}: no matching files` });
+                return;
+            }
+            const files = matches.slice(0, TabManager.OPEN_MAX_FILES);
+            if (matches.length > files.length) {
+                this.managers.tab.append(label, { input: command, output: `Opening the first ${files.length} of ${matches.length} matching files.` });
+            }
+            for (const file of files)
+                this.openOne(command, label, file, parsed.external, context);
+            return;
+        }
+        const file = path.isAbsolute(target) ? target : path.resolve(cwd, target);
+        this.openOne(command, label, file, parsed.external, context);
+    }
+    // The `edit <file>` command: resolve the target like `open` does, but bypass the opener
+    // registry and hand the file straight to the editor — this is how markdown and extensionless
+    // files (Makefile, .gitignore) get edited.
+    edit(command, target, label, line) {
+        const cwd = this.managers.tab.cwdOf(label) ?? process.cwd();
+        const expanded = expandUserPath(target, { root: this.managers.tab.launchDir });
+        const file = path.isAbsolute(expanded) ? expanded : path.resolve(cwd, expanded);
+        openInEditor(file, this.buildContext(command, label), line);
+    }
+    buildContext(command, label) {
+        return {
+            note: (text) => this.managers.tab.append(label, { input: command, output: text }),
+            openImageTab: (image) => this.managers.tab.openImageTab(image),
+            openMarkdownTab: (view) => this.managers.tab.openMarkdownTab(view),
+            openEditorTab: (view) => this.managers.tab.openEditorTab(view),
+            openPageTab: (view) => this.managers.tab.openPageTab(view),
+            registerFile: (absPath) => this.managers.tab.registerFile(absPath),
+            openExternally: (absPath) => didOsOpen(absPath),
+        };
+    }
+    openOne(command, label, file, external, context) {
+        if (!existsSync(file)) {
+            this.managers.tab.append(label, { input: command, output: `open: ${file}: no such file` });
+            return;
+        }
+        const opener = openerForExtension(path.extname(file));
+        if (!opener) {
+            this.managers.tab.append(label, { input: command, output: `No opener for "${path.extname(file) || '(none)'}" files.` });
+            return;
+        }
+        void (external ? opener.external(file, context) : opener.inline(file, context));
+    }
+    expandGlob(pattern, cwd) {
+        let stdout;
+        try {
+            const res = spawnSync(SHELL_NAME, ['-c', String.raw `for f in ${pattern}; do printf '%s\n' "$f"; done`], {
+                cwd, encoding: 'utf8', timeout: 5000,
+            });
+            stdout = res.stdout ?? '';
+        }
+        catch {
+            return [];
+        }
+        const files = stdout.split('\n').map((s) => s.trim()).filter(Boolean)
+            .map((p) => (path.isAbsolute(p) ? p : path.resolve(cwd, p)))
+            .filter((p) => { try {
+            return statSync(p).isFile();
+        }
+        catch {
+            return false;
+        } });
+        return [...new Set(files)].toSorted((a, b) => a.localeCompare(b));
+    }
+}

package/dist/openers/editor.js

@@ -0,0 +1,41 @@
+import { statSync } from 'node:fs';
+import path from 'node:path';
+import { humanSize } from './size.js';
+import { openInDefaultViewer } from './external-viewer.js';
+// Refuse to open files above this size: the editor holds the whole buffer in memory and a
+// multi-megabyte file is almost certainly not something to hand-edit in-app.
+export const EDITOR_MAX_BYTES = 2 * 1024 * 1024;
+// Common plain-text extensions the editor claims for `open`. Markdown is deliberately absent —
+// `open foo.md` keeps the rendered view; `edit foo.md` forces the editor.
+const EXTENSIONS = [
+    '.txt', '.text', '.log',
+    '.json', '.yaml', '.yml', '.toml', '.ini', '.conf', '.cfg', '.env',
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.py', '.rb', '.go', '.rs', '.c', '.h', '.cpp', '.hpp', '.java',
+    '.sh', '.bash', '.zsh',
+    '.css', '.html', '.xml', '.sql', '.csv',
+];
+// Shared inline handler: also the entry point for the `edit` command, which bypasses the opener
+// registry so any file (markdown, extensionless) can be edited.
+export function openInEditor(file, context, line) {
+    const name = path.basename(file);
+    let bytes;
+    try {
+        bytes = statSync(file).size;
+    }
+    catch {
+        bytes = undefined;
+    }
+    if (bytes !== undefined && bytes > EDITOR_MAX_BYTES) {
+        context.note(`edit: ${name} is ${humanSize(bytes)} — too large to edit in-app (limit ${humanSize(EDITOR_MAX_BYTES)}).`);
+        return;
+    }
+    const size = bytes === undefined ? 'unknown' : humanSize(bytes);
+    context.openEditorTab({ name, path: file, size, url: context.registerFile(file), line });
+}
+export const opener = {
+    name: 'editor',
+    extensions: EXTENSIONS,
+    external: openInDefaultViewer,
+    inline: (file, context) => { openInEditor(file, context); },
+};

package/dist/openers/external-viewer.js

@@ -0,0 +1,11 @@
+import path from 'node:path';
+// Hand a file to the OS's default viewer (via `context.openExternally`), noting success or the
+// fallback path in the originating tab's transcript. Shared by openers with no specialized
+// external-viewer messaging of their own.
+export function openInDefaultViewer(file, context) {
+    const name = path.basename(file);
+    if (context.openExternally(file))
+        context.note(`Opening ${name} in your default viewer…`);
+    else
+        context.note(`No viewer available. The file is at ${file}`);
+}

package/dist/openers/image.js

@@ -0,0 +1,27 @@
+import { statSync } from 'node:fs';
+import path from 'node:path';
+import { humanSize } from './size.js';
+// The first opener: handles common raster and vector image types. `external` hands the image to the
+// OS image viewer; `inline` mounts an image tab showing the file's metadata and the image itself.
+export const opener = {
+    name: 'image',
+    extensions: ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg', '.avif', '.ico'],
+    external: (file, context) => {
+        const name = path.basename(file);
+        if (context.openExternally(file))
+            context.note(`Opening ${name} in your image viewer…`);
+        else
+            context.note(`No image viewer available. The file is at ${file}`);
+    },
+    inline: (file, context) => {
+        const name = path.basename(file);
+        let size;
+        try {
+            size = humanSize(statSync(file).size);
+        }
+        catch {
+            size = 'unknown';
+        }
+        context.openImageTab({ name, path: file, size, url: context.registerFile(file) });
+    },
+};

package/dist/openers/index.js

@@ -0,0 +1,16 @@
+import { opener as image } from './image.js';
+import { opener as markdown } from './markdown.js';
+import { opener as editor } from './editor.js';
+// The opener registry. The `open` dispatcher walks this list in order and picks the first opener
+// whose `extensions` include the target file's extension. Supporting a new file type is additive:
+// add one opener module and one entry here — the dispatcher is never touched.
+export const openers = [
+    image,
+    markdown,
+    editor,
+];
+// Find the opener registered for a file extension (lowercased, dot-prefixed), or undefined.
+export function openerForExtension(extension) {
+    const lowerExtension = extension.toLowerCase();
+    return openers.find((o) => o.extensions.includes(lowerExtension));
+}

package/dist/openers/markdown.js

@@ -0,0 +1,20 @@
+import { statSync } from 'node:fs';
+import path from 'node:path';
+import { humanSize } from './size.js';
+import { openInDefaultViewer } from './external-viewer.js';
+export const opener = {
+    name: 'markdown',
+    extensions: ['.md', '.markdown'],
+    external: openInDefaultViewer,
+    inline: (file, context) => {
+        const name = path.basename(file);
+        let size;
+        try {
+            size = humanSize(statSync(file).size);
+        }
+        catch {
+            size = 'unknown';
+        }
+        context.openMarkdownTab({ name, path: file, size, url: context.registerFile(file) });
+    },
+};

package/dist/openers/os-open.js

@@ -0,0 +1,24 @@
+import { spawn } from 'node:child_process';
+// Hand a file to the operating system's default application, launched detached so it never blocks
+// the app's event loop (the same pattern as `browser shot` in src/browser.ts). Spawn errors are
+// swallowed — a missing opener must not crash the app. Returns false on a platform with no known
+// opener so the caller can fall back to reporting the path.
+export function didOsOpen(path) {
+    const command = process.platform === 'darwin' ? 'open'
+        : process.platform === 'win32' ? 'start'
+            : process.platform === 'linux' ? 'xdg-open'
+                : undefined;
+    if (!command)
+        return false;
+    // `start` is a cmd.exe builtin; the empty title arg avoids it consuming a quoted path as the title.
+    const arguments_ = command === 'start' ? ['', path] : [path];
+    try {
+        const child = spawn(command, arguments_, { stdio: 'ignore', detached: true, shell: command === 'start' });
+        child.on('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/openers/page.js

@@ -0,0 +1,51 @@
+export function normalizeWebUrl(target) {
+    let raw = target.trim();
+    if (!raw)
+        return { error: 'empty URL' };
+    // Reject non-http/https schemes explicitly (e.g. javascript:, file:, ftp:).
+    if (/^[a-z][a-z\d+\-.]*:/i.test(raw) && !/^https?:/i.test(raw)) {
+        return { error: `unsupported scheme in "${raw}"` };
+    }
+    // Bare target (no scheme) — default to https.
+    if (!/^https?:/i.test(raw))
+        raw = `https://${raw}`;
+    try {
+        const parsed = new URL(raw);
+        return { url: parsed.href };
+    }
+    catch {
+        return { error: `invalid URL "${target}"` };
+    }
+}
+// Strip leading "www." and reduce to the registrable domain (last 2 labels, or 3 when the
+// second-level label is a well-known short SLD: co, com, org, net, gov, ac, edu).
+export function rootDomain(hostname) {
+    const clean = hostname.replace(/^www\./i, '');
+    const labels = clean.split('.');
+    if (labels.length <= 2)
+        return clean;
+    const SHORT_SLDS = new Set(['co', 'com', 'org', 'net', 'gov', 'ac', 'edu']);
+    const second = labels.at(-2) ?? '';
+    const keep = SHORT_SLDS.has(second) ? 3 : 2;
+    return labels.slice(-keep).join('.');
+}
+export const webOpener = {
+    name: 'page',
+    inline: (target, context) => {
+        const n = normalizeWebUrl(target);
+        if ('error' in n) {
+            context.note(`open: invalid URL "${target}"`);
+            return;
+        }
+        context.openPageTab({ url: n.url, domain: rootDomain(new URL(n.url).hostname) });
+    },
+    external: (target, context) => {
+        const n = normalizeWebUrl(target);
+        if ('error' in n) {
+            context.note(`open: invalid URL "${target}"`);
+            return;
+        }
+        const domain = rootDomain(new URL(n.url).hostname);
+        context.note(context.openExternally(n.url) ? `Opening ${domain} in your browser…` : `No browser available. The address is ${n.url}`);
+    },
+};

package/dist/openers/size.js

@@ -0,0 +1,13 @@
+// Render a byte count as a compact human-readable size (e.g. "1.4 MB", "812 B").
+export function humanSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ['KB', 'MB', 'GB', 'TB'];
+    let value = bytes / 1024;
+    let index = 0;
+    while (value >= 1024 && index < units.length - 1) {
+        value /= 1024;
+        index++;
+    }
+    return `${value.toFixed(value >= 10 ? 0 : 1)} ${units[index]}`;
+}

package/dist/openers/types.js

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

package/dist/page/sync.js

@@ -0,0 +1,10 @@
+// Cache a page tab's currently visible text as transient snapshot state on the tab, relayed by the
+// bundled extension's content script. `url` is the tab's `page.url`, matched the same way
+// `syncEditorBuffer` resolves its tab — this never touches the filesystem or is sent to any client,
+// it only writes the in-memory `pageSnapshot`. An unresolvable `url` (e.g. a tab closed mid-relay)
+// is a no-op, never an error.
+export function syncPageSnapshot(managers, url, text) {
+    const tab = managers.tab.tabs.find((t) => t.page?.url === url);
+    if (tab)
+        tab.pageSnapshot = { text, capturedAt: Date.now() };
+}

package/dist/paths.js

@@ -0,0 +1,45 @@
+import { homedir } from 'node:os';
+import path from 'node:path';
+// Expand a user-authored path by replacing `~` with the home directory and `$root` with the
+// project root. Only the path start is expanded — `~` and `$root` appearing mid-path are left
+// as-is. This is the inverse of `abbreviatePath()`.
+export function expandUserPath(input, context) {
+    const { root } = context;
+    if (input === '$root' || input === '$root/')
+        return root;
+    if (input.startsWith('$root/'))
+        return root + input.slice(5);
+    const home = context.home ?? homedir();
+    if (input === '~')
+        return home;
+    if (input.startsWith('~/'))
+        return home + input.slice(1);
+    return input;
+}
+// Abbreviate an absolute path for display in the transcript. The launch (root) directory reads as
+// `$root`, and the application's hidden state directory inside it (`.janissary`) folds into the root
+// too — its `.janissary` segment is elided so its contents read directly under `$root` (e.g. a
+// workspace clone at `<root>/.janissary/workspace/<name>` shows as `$root/workspace/<name>`). A path
+// elsewhere under home reads as `~`. The longest matching prefix wins. Returns the path unchanged
+// when none applies. Display-only — callers keep the real path.
+export function abbreviatePath(p, context) {
+    const { root } = context;
+    const state = path.join(root, '.janissary');
+    // State directory inside the root (longest, checked first).
+    if (p === state)
+        return '$root/';
+    if (p.startsWith(state + path.sep))
+        return '$root' + p.slice(state.length);
+    // The root directory itself and anything under it.
+    if (p === root)
+        return '$root/';
+    if (p.startsWith(root + path.sep))
+        return '$root' + p.slice(root.length);
+    // Elsewhere under home.
+    const home = context.home ?? homedir();
+    if (p === home)
+        return '~';
+    if (p.startsWith(home + path.sep))
+        return '~' + p.slice(home.length);
+    return p;
+}

package/dist/persona-parsing.js

@@ -0,0 +1,49 @@
+// The only tools a persona may opt into (see `[//]: # tools:` config line). Every other tool stays
+// denied; a persona that declares none is fully tool-less (today's behavior).
+export const SUPPORTED_PERSONA_TOOLS = ['web_search', 'web_fetch'];
+const COMMENT_PREFIX = '[//]: # ';
+// Whether a line is the optional `[//]: # tools: …` config comment (case-insensitive label).
+export function isPersonaToolsLine(line) {
+    if (!line.startsWith(COMMENT_PREFIX))
+        return false;
+    return line.slice(COMMENT_PREFIX.length).trimStart().toLowerCase().startsWith('tools:');
+}
+// Parse a `[//]: # tools: a, b` line into a de-duplicated, lowercased tool list. Entries are
+// validated against SUPPORTED_PERSONA_TOOLS; an unknown tool throws (fail loud, like a bad
+// directive), so a persona never looks enabled when it isn't. An empty list is allowed.
+export function parsePersonaTools(name, line) {
+    const content = line.slice(COMMENT_PREFIX.length).trimStart();
+    const afterLabel = content.slice(content.indexOf(':') + 1);
+    const entries = afterLabel.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
+    const result = [];
+    for (const entry of entries) {
+        if (!SUPPORTED_PERSONA_TOOLS.includes(entry)) {
+            throw new Error(`Persona "${name}" requests unknown tool "${entry}" (supported: ${SUPPORTED_PERSONA_TOOLS.join(', ')}).`);
+        }
+        if (!result.includes(entry))
+            result.push(entry);
+    }
+    return result;
+}
+export function parseDirective(name, line) {
+    const prefix = '[//]: # ';
+    if (!line.startsWith(prefix)) {
+        throw new Error(`Persona "${name}" has no harness directive. First line must be: [//]: # <harness>:<model>:<variant>.`);
+    }
+    const spec = line.slice(prefix.length).trim();
+    const first = spec.indexOf(':');
+    const last = spec.lastIndexOf(':');
+    if (first === -1 || first === last) {
+        throw new Error(`Persona "${name}" has a malformed harness directive. Expected: [//]: # <harness>:<model>:<variant>.`);
+    }
+    const harness = spec.slice(0, first);
+    if (harness !== 'opencode' && harness !== 'claude') {
+        throw new Error(`Unknown harness "${harness}" in persona "${name}" (expected opencode or claude).`);
+    }
+    const model = spec.slice(first + 1, last).trim();
+    const variant = spec.slice(last + 1).trim();
+    if (!model || !variant) {
+        throw new Error(`Persona "${name}" has a malformed harness directive. Expected: [//]: # <harness>:<model>:<variant>.`);
+    }
+    return { harness, model, variant };
+}

package/dist/personas.js

@@ -0,0 +1,44 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+// AI monitor personas: markdown files in `ai/personas/`. The filename (without `.md`)
+// is the persona name used on the `monitor` command line. The first line is a required
+// harness directive; the rest of the file is the monitoring session's startup prompt.
+import { parseDirective, isPersonaToolsLine, parsePersonaTools } from './persona-parsing.js';
+export { parseDirective } from './persona-parsing.js';
+const PERSONAS_DIR = path.join('ai', 'personas');
+function personasDir(root) {
+    return path.join(root, PERSONAS_DIR);
+}
+// Read and parse `ai/personas/<name>.md` under `root` (the app's working directory).
+// Throws on a missing file or a missing/malformed/unknown-harness directive.
+export function loadPersona(name, root = process.cwd()) {
+    const file = path.join(personasDir(root), `${name}.md`);
+    let raw;
+    try {
+        raw = readFileSync(file, 'utf8');
+    }
+    catch {
+        throw new Error(`No persona "${name}" (looked in ${path.join(PERSONAS_DIR, `${name}.md`)}).`);
+    }
+    const lines = raw.split('\n');
+    const harness = parseDirective(name, (lines[0] ?? '').trim());
+    // An optional second `[//]: #` comment line lists the persona's tools; anything else (a blank
+    // line, an ordinary comment, or prose) starts the body, so existing personas are unaffected.
+    const secondLine = (lines[1] ?? '').trim();
+    const hasTools = isPersonaToolsLine(secondLine);
+    const tools = hasTools ? parsePersonaTools(name, secondLine) : [];
+    const body = lines.slice(hasTools ? 2 : 1).join('\n').trim();
+    return { name, harness, body, tools };
+}
+// Persona names available for the `monitor` command (used by completion and errors).
+export function listPersonas(root = process.cwd()) {
+    try {
+        return readdirSync(personasDir(root))
+            .filter((f) => f.endsWith('.md'))
+            .map((f) => f.slice(0, -3))
+            .toSorted((a, b) => a.localeCompare(b));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/profile/agent-opener.js

@@ -0,0 +1,154 @@
+import { distinctColor, makeTab } from '../tab/index.js';
+import { HARNESS_COMMANDS } from '../harness/index.js';
+import { isKnownModel } from '../harness/models.js';
+import { parseScheduleCommand } from '../schedule/index.js';
+import { startProfileMonitors } from './monitors.js';
+import { openProfileFiles } from './files.js';
+import { openProfileNotifications } from './notifications.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.`;
+    }
+    // Mirror `parseHarnessCommand`: -y is claude-only and requires a workspace (auto-approval is
+    // only allowed in a sandboxed clone). Report and skip rather than open unsafely.
+    if (entry.autoApprove && entry.harness !== 'claude')
+        return 'autoApprove (-y) is only supported for the claude harness';
+    if (entry.autoApprove && !entry.workspace)
+        return 'autoApprove (-y) requires workspace (-w)';
+    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) => 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);
+    // Profile-level file navigator(s) open next, rooted at the first newly opened tab by default, so
+    // their tabs are part of the list by the time monitor targets are resolved below.
+    const firstNewLabel = opened.length > 0 ? managers.tab.tabs[firstNew]?.label : undefined;
+    openProfileFiles(name, managers, firstNewLabel, notes);
+    // Profile-level notifications tab opens next, docked per the profile's `_notifications.json`.
+    openProfileNotifications(name, managers, notes);
+    // Profile-level monitors start after every entry is open, owned by the issuing tab, so their
+    // targets (e.g. `group:1`) can resolve against the now-complete tab list.
+    startProfileMonitors(name, managers, issuingLabel, notes);
+    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/files.js

@@ -0,0 +1,17 @@
+import { loadProfileFiles } from '../profiles.js';
+// Open each profile-level file-tree tab (from the profile's `_files.json`) once every entry is
+// open, rooted at `defaultLabel` (the profile's first newly opened tab) unless the entry names its
+// own `in` target. `defaultLabel` is undefined when the profile opened nothing, in which case an
+// entry with no `in` has nothing to root itself at and is skipped with a note.
+export function openProfileFiles(profileName, managers, defaultLabel, notes) {
+    for (const entry of loadProfileFiles(profileName)) {
+        const label = entry.in ?? defaultLabel;
+        if (label === undefined) {
+            notes.push('File navigator: no tab to root it at.');
+            continue;
+        }
+        const clauses = [entry.in ? `in ${entry.in}` : '', entry.dock ? `on ${entry.dock}` : ''].filter(Boolean).join(' ');
+        managers.fileTree.open(`files ${clauses}`.trim(), label);
+        notes.push(`Opened file navigator${entry.dock ? ` (docked ${entry.dock})` : ''}.`);
+    }
+}