agent-tempo 1.0.1

package/dist/ensemble/agent-types.d.ts

@@ -0,0 +1,23 @@
+import { AgentTypeInfo } from '../types';
+import { EnsembleLineup } from './schema';
+/**
+ * Parse YAML frontmatter from a markdown file.
+ * Expects `---` delimiters wrapping YAML at the top of the file.
+ */
+export declare function parseFrontmatter(filePath: string): Record<string, any>;
+/**
+ * List all available agent types across the three-tier lookup.
+ * Deduplicates by name: project > user > shipped.
+ */
+export declare function listAgentTypes(cwd?: string): AgentTypeInfo[];
+/**
+ * Resolve a single agent type by name across the three-tier lookup.
+ * Returns the first match (project > user > shipped) or null.
+ */
+export declare function resolveAgentType(name: string, cwd?: string): AgentTypeInfo | null;
+/**
+ * Load and resolve a lineup, validating and resolving `type` fields on each player.
+ * Players without `type` pass through unchanged.
+ * Throws if a referenced type is not found.
+ */
+export declare function loadAndResolveLineup(filePath: string, cwd?: string): EnsembleLineup;

package/dist/ensemble/agent-types.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFrontmatter = parseFrontmatter;
+exports.listAgentTypes = listAgentTypes;
+exports.resolveAgentType = resolveAgentType;
+exports.loadAndResolveLineup = loadAndResolveLineup;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const yaml_1 = require("yaml");
+const loader_1 = require("./loader");
+/**
+ * Parse YAML frontmatter from a markdown file.
+ * Expects `---` delimiters wrapping YAML at the top of the file.
+ */
+function parseFrontmatter(filePath) {
+    const content = (0, fs_1.readFileSync)(filePath, 'utf8');
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return {};
+    try {
+        return (0, yaml_1.parse)(match[1]) ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Resolve the shipped examples/agents directory relative to package root. */
+function shippedAgentsDir() {
+    // Walk up from __dirname until we find examples/agents/ or package.json
+    let dir = __dirname;
+    for (let i = 0; i < 5; i++) {
+        const candidate = (0, path_1.join)(dir, 'examples', 'agents');
+        if ((0, fs_1.existsSync)(candidate))
+            return candidate;
+        const parent = (0, path_1.resolve)(dir, '..');
+        if (parent === dir)
+            break; // filesystem root
+        dir = parent;
+    }
+    // Fallback: two levels up (src/ensemble → package root or dist/ensemble → package root)
+    return (0, path_1.join)((0, path_1.resolve)(__dirname, '..', '..'), 'examples', 'agents');
+}
+function agentDirs(cwd) {
+    return [
+        { dir: (0, path_1.join)(cwd || process.cwd(), '.claude', 'agents'), source: 'project', nativeResolvable: true },
+        { dir: (0, path_1.join)((0, os_1.homedir)(), '.claude', 'agents'), source: 'user', nativeResolvable: true },
+        { dir: shippedAgentsDir(), source: 'shipped', nativeResolvable: false },
+    ];
+}
+/**
+ * List all available agent types across the three-tier lookup.
+ * Deduplicates by name: project > user > shipped.
+ */
+function listAgentTypes(cwd) {
+    const seen = new Map();
+    for (const { dir, source, nativeResolvable } of agentDirs(cwd)) {
+        if (!(0, fs_1.existsSync)(dir))
+            continue;
+        let files;
+        try {
+            files = (0, fs_1.readdirSync)(dir).filter(f => f.endsWith('.md'));
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            const filePath = (0, path_1.join)(dir, file);
+            const fm = parseFrontmatter(filePath);
+            const name = fm.name || file.replace(/\.md$/, '');
+            // Higher-priority sources are scanned first — skip if already seen
+            if (seen.has(name))
+                continue;
+            seen.set(name, {
+                name,
+                description: fm.description,
+                source,
+                path: filePath,
+                nativeResolvable,
+                ...(Array.isArray(fm.allowedTools) ? { allowedTools: fm.allowedTools.map(String) } : {}),
+            });
+        }
+    }
+    return Array.from(seen.values());
+}
+/**
+ * Resolve a single agent type by name across the three-tier lookup.
+ * Returns the first match (project > user > shipped) or null.
+ */
+function resolveAgentType(name, cwd) {
+    for (const { dir, source, nativeResolvable } of agentDirs(cwd)) {
+        const filePath = (0, path_1.join)(dir, `${name}.md`);
+        if (!(0, fs_1.existsSync)(filePath))
+            continue;
+        const fm = parseFrontmatter(filePath);
+        return {
+            name: fm.name || name,
+            description: fm.description,
+            source,
+            path: filePath,
+            nativeResolvable,
+            ...(Array.isArray(fm.allowedTools) ? { allowedTools: fm.allowedTools.map(String) } : {}),
+        };
+    }
+    return null;
+}
+/**
+ * Load and resolve a lineup, validating and resolving `type` fields on each player.
+ * Players without `type` pass through unchanged.
+ * Throws if a referenced type is not found.
+ */
+function loadAndResolveLineup(filePath, cwd) {
+    const lineup = (0, loader_1.loadLineup)(filePath);
+    for (const player of lineup.players) {
+        if (!player.type)
+            continue;
+        const info = resolveAgentType(player.type, cwd);
+        if (!info) {
+            const available = listAgentTypes(cwd).map(t => t.name);
+            throw new Error(`Unknown agent type "${player.type}" for player "${player.name}". ` +
+                `Available types: ${available.length ? available.join(', ') : '(none)'}`);
+        }
+        player._agentDefinition = info.name;
+        player._agentDefinitionPath = info.path;
+        // Type's allowedTools is the security authority — overrides lineup-level setting
+        // Empty array means "not specified" (no restriction), so don't override
+        if (info.allowedTools && info.allowedTools.length > 0) {
+            player.allowedTools = info.allowedTools;
+        }
+    }
+    return lineup;
+}

package/dist/ensemble/loader.d.ts

@@ -0,0 +1,14 @@
+import { EnsembleLineup } from './schema';
+export interface LineupResolution {
+    path: string;
+    source: 'saved' | 'shipped' | 'file';
+}
+/**
+ * Resolve a lineup name or file path to an absolute file path.
+ * Resolution order: saved lineups → shipped examples → direct file path → error.
+ */
+export declare function resolveLineupPath(nameOrPath: string): LineupResolution;
+/**
+ * Load and validate an ensemble lineup from a YAML file.
+ */
+export declare function loadLineup(filePath: string): EnsembleLineup;

package/dist/ensemble/loader.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLineupPath = resolveLineupPath;
+exports.loadLineup = loadLineup;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const yaml_1 = require("yaml");
+const config_1 = require("../config");
+/** Walk up from a directory to find the nearest package.json. */
+function findPackageRoot(dir) {
+    if ((0, fs_1.existsSync)((0, path_1.join)(dir, 'package.json')))
+        return dir;
+    const parent = (0, path_1.resolve)(dir, '..');
+    return parent === dir ? dir : findPackageRoot(parent);
+}
+/** Package root — works from both dist/ (production) and dist-test/ (tests). */
+const PACKAGE_ROOT = findPackageRoot((0, path_1.resolve)(__dirname));
+/**
+ * Resolve a lineup name or file path to an absolute file path.
+ * Resolution order: saved lineups → shipped examples → direct file path → error.
+ */
+function resolveLineupPath(nameOrPath) {
+    // 1. Saved lineups (~/.agent-tempo/ensembles/)
+    const ensemblesDir = (0, path_1.join)(config_1.AGENT_TEMPO_HOME, 'ensembles');
+    const savedYaml = (0, path_1.join)(ensemblesDir, `${nameOrPath}.yaml`);
+    const savedYml = (0, path_1.join)(ensemblesDir, `${nameOrPath}.yml`);
+    if ((0, fs_1.existsSync)(savedYaml))
+        return { path: savedYaml, source: 'saved' };
+    if ((0, fs_1.existsSync)(savedYml))
+        return { path: savedYml, source: 'saved' };
+    // 2. Shipped examples (<package-root>/examples/ensembles/)
+    const shippedYaml = (0, path_1.join)(PACKAGE_ROOT, 'examples', 'ensembles', `${nameOrPath}.yaml`);
+    const shippedYml = (0, path_1.join)(PACKAGE_ROOT, 'examples', 'ensembles', `${nameOrPath}.yml`);
+    if ((0, fs_1.existsSync)(shippedYaml))
+        return { path: shippedYaml, source: 'shipped' };
+    if ((0, fs_1.existsSync)(shippedYml))
+        return { path: shippedYml, source: 'shipped' };
+    // 3. Direct file path
+    const resolved = (0, path_1.resolve)(nameOrPath);
+    if ((0, fs_1.existsSync)(resolved))
+        return { path: resolved, source: 'file' };
+    // 4. Error with suggestions
+    const suggestions = [];
+    const saved = (0, fs_1.existsSync)(ensemblesDir) ? (0, fs_1.readdirSync)(ensemblesDir).filter(f => f.endsWith('.yaml') || f.endsWith('.yml')).map(f => f.replace(/\.ya?ml$/, '')) : [];
+    if (saved.length)
+        suggestions.push(`Saved: ${saved.join(', ')}`);
+    const shippedDir = (0, path_1.join)(PACKAGE_ROOT, 'examples', 'ensembles');
+    if ((0, fs_1.existsSync)(shippedDir)) {
+        const shipped = (0, fs_1.readdirSync)(shippedDir).filter(f => f.endsWith('.yaml') || f.endsWith('.yml')).map(f => f.replace(/\.ya?ml$/, ''));
+        if (shipped.length)
+            suggestions.push(`Shipped: ${shipped.join(', ')}`);
+    }
+    const msg = `Lineup "${nameOrPath}" not found as saved lineup, shipped example, or file path.`;
+    throw new Error(suggestions.length ? `${msg}\n  ${suggestions.join('\n  ')}` : msg);
+}
+/**
+ * Load and validate an ensemble lineup from a YAML file.
+ */
+function loadLineup(filePath) {
+    const raw = (0, fs_1.readFileSync)(filePath, 'utf8');
+    const doc = (0, yaml_1.parse)(raw);
+    if (!doc || typeof doc !== 'object') {
+        throw new Error(`Invalid lineup: file does not contain a YAML object`);
+    }
+    // Required: name
+    if (typeof doc.name !== 'string' || !doc.name) {
+        throw new Error(`Invalid lineup: "name" is required and must be a non-empty string`);
+    }
+    // Every ensemble must define exactly one conductor — the default chat
+    // target and anchor for the maestro's `getEnsembleChat`.
+    const remediation = `Add a conductor block with 'name:' (default "conductor") and 'agent:' (default from AGENT_TEMPO_DEFAULT_AGENT config).`;
+    if (doc.conductor == null) {
+        throw new Error(`lineup "${doc.name}" is missing a conductor; every ensemble must define exactly one conductor. ${remediation}`);
+    }
+    if (typeof doc.conductor !== 'object' || Array.isArray(doc.conductor)) {
+        throw new Error(`lineup "${doc.name}" has a malformed conductor (expected a mapping, got ${Array.isArray(doc.conductor) ? 'array' : typeof doc.conductor}). ${remediation}`);
+    }
+    // Required: players array
+    if (!Array.isArray(doc.players)) {
+        throw new Error(`Invalid lineup: "players" must be an array`);
+    }
+    for (let i = 0; i < doc.players.length; i++) {
+        const p = doc.players[i];
+        if (typeof p.name !== 'string' || !p.name) {
+            throw new Error(`Invalid lineup: players[${i}].name is required`);
+        }
+        if (!/^[a-zA-Z0-9_-]+$/.test(p.name)) {
+            throw new Error(`Invalid lineup: players[${i}].name "${p.name}" contains invalid characters`);
+        }
+    }
+    // Validate schedules if present
+    if (doc.schedules != null) {
+        if (!Array.isArray(doc.schedules)) {
+            throw new Error(`Invalid lineup: "schedules" must be an array`);
+        }
+        for (let i = 0; i < doc.schedules.length; i++) {
+            const s = doc.schedules[i];
+            if (typeof s.name !== 'string' || !s.name) {
+                throw new Error(`Invalid lineup: schedules[${i}].name is required`);
+            }
+            if (typeof s.message !== 'string' || !s.message) {
+                throw new Error(`Invalid lineup: schedules[${i}].message is required`);
+            }
+            if (typeof s.target !== 'string' || !s.target) {
+                throw new Error(`Invalid lineup: schedules[${i}].target is required`);
+            }
+            if (!s.at && !s.delay && !s.every && !s.cron) {
+                throw new Error(`Invalid lineup: schedules[${i}] must have at least one of: at, delay, every, cron`);
+            }
+        }
+    }
+    // Validate conductor name if present
+    if (doc.conductor?.name != null) {
+        if (typeof doc.conductor.name !== 'string' || !doc.conductor.name) {
+            throw new Error(`Invalid lineup: conductor.name must be a non-empty string`);
+        }
+        if (!/^[a-zA-Z0-9_-]+$/.test(doc.conductor.name)) {
+            throw new Error(`Invalid lineup: conductor.name "${doc.conductor.name}" contains invalid characters`);
+        }
+    }
+    return {
+        name: doc.name,
+        description: doc.description,
+        conductor: doc.conductor,
+        players: doc.players.map((p) => ({
+            name: p.name,
+            ...(p.type != null && { type: p.type }),
+            ...(p.workDir != null && { workDir: p.workDir }),
+            ...(p.agent != null && { agent: p.agent }),
+            ...(p.instructions != null && { instructions: p.instructions }),
+            ...(Array.isArray(p.allowedTools) && { allowedTools: p.allowedTools.map(String) }),
+            // PR-3 mock fields. Pass through verbatim — schema validation is
+            // shape-only here; runtime rejection lives in `recruit.ts` (gates the
+            // dev-mode `agent: "mock"` requirement) and the spawn layer.
+            ...(p.mockMode != null && { mockMode: p.mockMode }),
+            ...(p.mockScenario != null && { mockScenario: p.mockScenario }),
+        })),
+        schedules: doc.schedules,
+    };
+}

package/dist/ensemble/saver.d.ts

@@ -0,0 +1,49 @@
+import { Client } from '@temporalio/client';
+/**
+ * Save the current live ensemble state to a YAML lineup file.
+ * Queries all running sessions and active schedules from Temporal.
+ */
+export declare function saveLineup(client: Client, ensemble: string, filePath?: string, name?: string): Promise<string>;
+/**
+ * List all saved ensemble lineups in ~/.agent-tempo/ensembles/.
+ */
+export declare function listLineups(): Array<{
+    name: string;
+    path: string;
+}>;
+/**
+ * Read a saved lineup by name from ~/.agent-tempo/ensembles/.
+ */
+export declare function readSavedLineup(name: string): string | null;
+/**
+ * Lineup catalog entry — each row in `listAllLineups()` output. Used by
+ * the TUI's CreateEnsembleWizard, the dashboard's `/v1/lineups`
+ * endpoint, and the `agent-tempo up --lineup` resolver.
+ *
+ * `players` and `description` come from a YAML parse — best-effort: a
+ * malformed lineup file silently degrades to `players: 0` /
+ * `description: undefined` rather than skipping the row entirely. The
+ * row stays clickable so the picker can still surface it; downstream
+ * `loadLineup()` runs strict validation at use time.
+ *
+ * `path` is the absolute on-disk path. Local callers use it to seed
+ * the resolver; HTTP catchments must NOT serve this field over the
+ * wire (privacy contract — strip in the route handler).
+ */
+export interface LineupCatalogEntry {
+    name: string;
+    description?: string;
+    players: number;
+    source: 'saved' | 'shipped';
+    path: string;
+}
+/**
+ * List all available lineups — saved (`~/.agent-tempo/ensembles/`)
+ * plus shipped (`<package-root>/examples/ensembles/`). Saved takes
+ * precedence over shipped when names collide.
+ *
+ * Each row carries `description` + `players` count so pickers can
+ * render rich rows without re-parsing the YAML themselves. Parse
+ * failures are tolerated (zero count, no description).
+ */
+export declare function listAllLineups(): LineupCatalogEntry[];

package/dist/ensemble/saver.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveLineup = saveLineup;
+exports.listLineups = listLineups;
+exports.readSavedLineup = readSavedLineup;
+exports.listAllLineups = listAllLineups;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const yaml_1 = require("yaml");
+const config_1 = require("../config");
+const loader_1 = require("./loader");
+const ENSEMBLES_DIR = (0, path_1.join)(config_1.AGENT_TEMPO_HOME, 'ensembles');
+function ensemblesDir() {
+    (0, fs_1.mkdirSync)(ENSEMBLES_DIR, { recursive: true });
+    return ENSEMBLES_DIR;
+}
+/**
+ * Save the current live ensemble state to a YAML lineup file.
+ * Queries all running sessions and active schedules from Temporal.
+ */
+async function saveLineup(client, ensemble, filePath, name) {
+    const outputPath = filePath || (0, path_1.join)(ensemblesDir(), `${name || ensemble}.yaml`);
+    // Query all running session workflows
+    const query = 'WorkflowType = "agentSessionWorkflow" AND ExecutionStatus = "Running"';
+    const players = [];
+    let conductor;
+    for await (const wf of client.workflow.list({ query })) {
+        try {
+            const handle = client.workflow.getHandle(wf.workflowId);
+            const [metadata, part] = await Promise.all([
+                handle.query('getMetadata').catch(() => ({})),
+                handle.query('getPart').catch(() => ''),
+            ]);
+            const meta = metadata;
+            if (meta.ensemble !== ensemble)
+                continue;
+            const isConductor = meta.isConductor || false;
+            const agentType = meta.agentType || 'claude';
+            const workDir = meta.workDir || undefined;
+            if (isConductor) {
+                const conductorName = meta.playerId || undefined;
+                conductor = {
+                    // Only save name if it's not the default 'conductor'
+                    ...(conductorName && conductorName !== 'conductor' ? { name: conductorName } : {}),
+                    agent: agentType === 'copilot' ? 'copilot' : undefined,
+                };
+            }
+            else {
+                const name = meta.playerId || wf.workflowId.split('-').pop() || 'unknown';
+                const playerType = meta.playerType || undefined;
+                players.push({
+                    name,
+                    type: playerType,
+                    workDir,
+                    agent: agentType === 'copilot' ? 'copilot' : undefined,
+                });
+            }
+        }
+        catch {
+            // workflow may have closed between list and query
+        }
+    }
+    // Query active schedules
+    const schedules = [];
+    try {
+        const schedulerWfId = (0, config_1.schedulerWorkflowId)(ensemble);
+        const handle = client.workflow.getHandle(schedulerWfId);
+        const entries = await handle.query('getSchedules');
+        for (const entry of entries) {
+            const sched = {
+                name: entry.name,
+                message: entry.message,
+                target: entry.target,
+            };
+            if (entry.cronExpression) {
+                sched.cron = entry.cronExpression;
+                if (entry.timezone)
+                    sched.timezone = entry.timezone;
+            }
+            else if (entry.interval) {
+                sched.every = formatDurationMs(entry.interval);
+            }
+            if (entry.until) {
+                sched.until = entry.until;
+            }
+            if (entry.remainingCount != null) {
+                sched.count = entry.remainingCount;
+            }
+            schedules.push(sched);
+        }
+    }
+    catch {
+        // No scheduler running or no schedules
+    }
+    // An empty `{}` satisfies the schema when no conductor session is live;
+    // downstream consumers apply the field-level defaults.
+    const lineup = {
+        name: ensemble,
+        conductor: conductor ?? {},
+        players,
+        ...(schedules.length > 0 ? { schedules } : {}),
+    };
+    // Ensure parent directory exists
+    const parentDir = outputPath.substring(0, outputPath.lastIndexOf('/') >= 0 ? outputPath.lastIndexOf('/') : outputPath.lastIndexOf('\\'));
+    if (parentDir)
+        (0, fs_1.mkdirSync)(parentDir, { recursive: true });
+    (0, fs_1.writeFileSync)(outputPath, (0, yaml_1.stringify)(lineup));
+    return outputPath;
+}
+/**
+ * List all saved ensemble lineups in ~/.agent-tempo/ensembles/.
+ */
+function listLineups() {
+    const dir = ensemblesDir();
+    if (!(0, fs_1.existsSync)(dir))
+        return [];
+    return (0, fs_1.readdirSync)(dir)
+        .filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))
+        .map(f => ({
+        name: f.replace(/\.ya?ml$/, ''),
+        path: (0, path_1.join)(dir, f),
+    }));
+}
+/**
+ * Read a saved lineup by name from ~/.agent-tempo/ensembles/.
+ */
+function readSavedLineup(name) {
+    const dir = ensemblesDir();
+    for (const ext of ['.yaml', '.yml']) {
+        const path = (0, path_1.join)(dir, name + ext);
+        if ((0, fs_1.existsSync)(path))
+            return (0, fs_1.readFileSync)(path, 'utf8');
+    }
+    return null;
+}
+/**
+ * Find the package root by walking up from a directory.
+ */
+function findPackageRoot(dir) {
+    if ((0, fs_1.existsSync)((0, path_1.join)(dir, 'package.json')))
+        return dir;
+    const parent = (0, path_1.resolve)(dir, '..');
+    return parent === dir ? dir : findPackageRoot(parent);
+}
+/**
+ * List all available lineups — saved (`~/.agent-tempo/ensembles/`)
+ * plus shipped (`<package-root>/examples/ensembles/`). Saved takes
+ * precedence over shipped when names collide.
+ *
+ * Each row carries `description` + `players` count so pickers can
+ * render rich rows without re-parsing the YAML themselves. Parse
+ * failures are tolerated (zero count, no description).
+ */
+function listAllLineups() {
+    const seen = new Map();
+    const append = (name, path, source) => {
+        if (seen.has(name))
+            return;
+        let description;
+        let players = 0;
+        try {
+            const lineup = (0, loader_1.loadLineup)(path);
+            description = lineup.description;
+            players = lineup.players.length;
+        }
+        catch {
+            // Malformed YAML — keep the row but with zero count.
+        }
+        seen.set(name, {
+            name,
+            ...(description !== undefined && { description }),
+            players,
+            source,
+            path,
+        });
+    };
+    // Saved (higher priority).
+    for (const l of listLineups())
+        append(l.name, l.path, 'saved');
+    // Shipped fallback.
+    const pkgRoot = findPackageRoot((0, path_1.resolve)(__dirname));
+    const shippedDir = (0, path_1.join)(pkgRoot, 'examples', 'ensembles');
+    if ((0, fs_1.existsSync)(shippedDir)) {
+        for (const f of (0, fs_1.readdirSync)(shippedDir)) {
+            if (!f.endsWith('.yaml') && !f.endsWith('.yml'))
+                continue;
+            const name = f.replace(/\.ya?ml$/, '');
+            append(name, (0, path_1.join)(shippedDir, f), 'shipped');
+        }
+    }
+    return Array.from(seen.values());
+}
+function formatDurationMs(ms) {
+    if (ms >= 86_400_000 && ms % 86_400_000 === 0)
+        return `${ms / 86_400_000}d`;
+    if (ms >= 3_600_000 && ms % 3_600_000 === 0)
+        return `${ms / 3_600_000}h`;
+    if (ms >= 60_000 && ms % 60_000 === 0)
+        return `${ms / 60_000}m`;
+    return `${ms / 1000}s`;
+}

package/dist/ensemble/schema.d.ts

@@ -0,0 +1,71 @@
+import type { MockMode } from '../types';
+export interface EnsembleLineup {
+    name: string;
+    description?: string;
+    /**
+     * Every ensemble defines exactly one conductor — the default chat target,
+     * the home for system messages, and the anchor for `getEnsembleChat`.
+     * Inner fields remain optional: unset `name` defaults to `"conductor"` and
+     * unset `agent` falls back to `AGENT_TEMPO_DEFAULT_AGENT`.
+     */
+    conductor: {
+        name?: string;
+        type?: string;
+        /** "default", "copilot", "mock" (dev mode only), or path to agent .md file. */
+        agent?: string;
+        instructions?: string;
+        /**
+         * Mock-adapter mode — only consulted when `agent: "mock"`. Mirrors the
+         * same field on players. Defaults to `echo` when omitted.
+         */
+        mockMode?: MockMode;
+        /**
+         * Scenario reference for `agent: "mock"` + `mockMode: "scripted"`.
+         * Bare name (resolved against shipped `scenarios/`), absolute path,
+         * or relative path.
+         */
+        mockScenario?: string;
+    };
+    players: Array<{
+        name: string;
+        type?: string;
+        workDir?: string;
+        /**
+         * "default", "copilot", path to agent .md file, or "mock" (dev-mode
+         * only — ADR 0014 §4 / PR-2). Mock players are headless subprocesses
+         * with no terminal window, suitable for autonomous validation
+         * harnesses (e.g. the `tempo-mock-jam` lineup).
+         */
+        agent?: string;
+        instructions?: string;
+        allowedTools?: string[];
+        /**
+         * Mock-adapter mode (only consulted when `agent: "mock"`). One of
+         * `echo` / `scripted` / `silent` / `chaos`. ADR 0014 §4.2. Defaults
+         * to `echo` when omitted. PR-3 added `silent` + `chaos`.
+         */
+        mockMode?: MockMode;
+        /**
+         * Scenario reference for `agent: "mock"` + `mockMode: "scripted"` —
+         * bare name (resolved against shipped `scenarios/`), absolute path,
+         * or relative path. CLI `--scenario` flag overrides this when set.
+         */
+        mockScenario?: string;
+        /** Transient: resolved agent definition name (set by loadAndResolveLineup). */
+        _agentDefinition?: string;
+        /** Transient: resolved absolute path to .md file (set by loadAndResolveLineup). */
+        _agentDefinitionPath?: string;
+    }>;
+    schedules?: Array<{
+        name: string;
+        message: string;
+        target: string;
+        at?: string;
+        delay?: string;
+        every?: string;
+        cron?: string;
+        timezone?: string;
+        until?: string;
+        count?: number;
+    }>;
+}

package/dist/ensemble/schema.js

@@ -0,0 +1,3 @@
+"use strict";
+// Ensemble lineup types — defines the structure of a saved/loaded ensemble configuration.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/git-info.d.ts

@@ -0,0 +1,4 @@
+export declare function getGitInfo(workDir: string): {
+    gitRoot?: string;
+    gitBranch?: string;
+};

package/dist/git-info.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitInfo = getGitInfo;
+const child_process_1 = require("child_process");
+function getGitInfo(workDir) {
+    try {
+        const gitRoot = (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+            cwd: workDir,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        }).trim();
+        let gitBranch;
+        try {
+            gitBranch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+                cwd: workDir,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+        }
+        catch {
+            // not on a branch
+        }
+        return { gitRoot, gitBranch };
+    }
+    catch {
+        return {};
+    }
+}