agent-tempo 1.0.1

package/dist/tools/load-lineup.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLoadLineupTool = registerLoadLineupTool;
+const zod_1 = require("zod");
+const croner_1 = require("croner");
+const client_1 = require("@temporalio/client");
+const config_1 = require("../config");
+const agent_types_1 = require("../ensemble/agent-types");
+const loader_1 = require("../ensemble/loader");
+const resolve_1 = require("./resolve");
+const resolve_2 = require("../activities/resolve");
+const signals_1 = require("../workflows/signals");
+const duration_1 = require("../utils/duration");
+const safe_path_1 = require("../utils/safe-path");
+const helpers_1 = require("./helpers");
+const validation_1 = require("../utils/validation");
+const constants_1 = require("../constants");
+const log = (...args) => console.error('[agent-tempo:load-lineup]', ...args);
+function registerLoadLineupTool(server, client, config, getPlayerId, ownAgentType = 'claude', handle, setPlayerId, isConductor) {
+    (0, helpers_1.defineTool)(server, 'load_lineup', 'Load an ensemble lineup — recruits players and creates schedules.', {
+        name: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional().describe('Name of a lineup — resolves saved lineups, then shipped examples (e.g. "tempo-dev-team")'),
+        path: zod_1.z.string().max(validation_1.PATH_MAX).optional().describe('Explicit file path to a lineup YAML file'),
+        hold: zod_1.z.boolean().optional().describe('When true, spawn players in "warm hold": processes start and attach but their outbox is locked, so they receive a standby message and defer their initial task until `release` is called.'),
+        initialStartup: zod_1.z.boolean().optional().describe('Issue #172: when true, the lineup was loaded as part of initial ensemble startup (`up --lineup` / `conduct --lineup`). Conductor instructions are stored as pending context and combined with the user\'s first message instead of firing immediately. Also recruits players with `hold: true`. Defaults to false — conductor-invoked mid-work `load_lineup` keeps the legacy behavior.'),
+    }, async (args) => {
+        const lineupName = args.name;
+        const lineupPath = args.path;
+        const initialStartup = args.initialStartup === true;
+        // Initial-startup always implies warm-hold — players should wait for
+        // the conductor to decompose the user's first message before starting.
+        const hold = args.hold === true || initialStartup;
+        if (!lineupName && !lineupPath) {
+            return (0, helpers_1.fail)('Provide either `name` (saved lineup) or `path` (file path). Exactly one is required.');
+        }
+        if (lineupName && lineupPath) {
+            return (0, helpers_1.fail)('Provide either `name` or `path`, not both.');
+        }
+        try {
+            // Resolve the file path: saved → shipped examples → direct file path
+            let filePath;
+            if (lineupPath) {
+                // User-provided path — validate against allowed roots
+                filePath = (0, safe_path_1.safeLineupPath)(lineupPath, process.cwd());
+            }
+            else {
+                const resolution = (0, loader_1.resolveLineupPath)(lineupName);
+                filePath = resolution.path;
+                // Only validate user-facing paths (saved lineups, file paths).
+                // Shipped examples are package-controlled and may live outside
+                // allowed roots when globally installed.
+                if (resolution.source !== 'shipped') {
+                    filePath = (0, safe_path_1.safeLineupPath)(filePath, process.cwd());
+                }
+            }
+            const lineup = (0, agent_types_1.loadAndResolveLineup)(filePath);
+            const recruited = [];
+            const failed = [];
+            const conductorActions = [];
+            // Issue #172 follow-up: on `initialStartup`, fire the `from: 'system'`
+            // directive BEFORE any lineup instructions. Earlier messages weigh
+            // more heavily with the LLM — putting the "call resume_ensemble +
+            // release FIRST" framing at the top of the conductor's inbox reduces
+            // the chance the model skims past it and goes straight to broadcast.
+            // Runs independently of whether the lineup has a `conductor:` section
+            // (e.g. players-only lineups still need the banner + directive).
+            if (initialStartup && isConductor && handle) {
+                try {
+                    const playerCount = lineup.players.length;
+                    await handle.signal('receiveMessage', {
+                        from: 'system',
+                        text: (0, constants_1.ensembleReadyDirective)(lineup.name, playerCount),
+                        responseRequested: false,
+                    });
+                    conductorActions.push('startup banner + directive delivered');
+                }
+                catch (err) {
+                    failed.push(`conductor startup banner: ${err}`);
+                }
+            }
+            // Apply conductor section if present and this session is the conductor
+            if (lineup.conductor && isConductor && handle) {
+                // Apply conductor name
+                if (lineup.conductor.name && lineup.conductor.name !== getPlayerId()) {
+                    try {
+                        // Check if the name is already taken
+                        const existing = await (0, resolve_1.resolveSession)(client, config.ensemble, lineup.conductor.name);
+                        if (existing && existing.workflowId !== handle.workflowId) {
+                            failed.push(`conductor name "${lineup.conductor.name}": already taken by another session`);
+                        }
+                        else {
+                            await handle.signal('setName', lineup.conductor.name);
+                            if (setPlayerId)
+                                setPlayerId(lineup.conductor.name);
+                            conductorActions.push(`name → ${lineup.conductor.name}`);
+                            log(`Conductor name set to "${lineup.conductor.name}"`);
+                        }
+                    }
+                    catch (err) {
+                        failed.push(`conductor name: ${err}`);
+                    }
+                }
+                // Apply conductor type (update metadata)
+                if (lineup.conductor.type) {
+                    try {
+                        const typeInfo = (0, agent_types_1.resolveAgentType)(lineup.conductor.type);
+                        if (typeInfo) {
+                            await handle.signal('updateMetadata', {
+                                playerType: typeInfo.name,
+                                playerTypeDescription: typeInfo.description || '',
+                            });
+                            conductorActions.push(`type → ${typeInfo.name}`);
+                            log(`Conductor type set to "${typeInfo.name}"`);
+                        }
+                        else {
+                            failed.push(`conductor type "${lineup.conductor.type}": agent type not found`);
+                        }
+                    }
+                    catch (err) {
+                        failed.push(`conductor type: ${err}`);
+                    }
+                }
+                // Send conductor instructions.
+                // Issue #172 (v0.26 simplification): on the initial-startup path,
+                // signal the lineup instructions as a `receiveMessage` immediately
+                // — the ensemble-wide pause (below) stops any downstream dispatch,
+                // and the banner+directive signal (also below) tells the LLM to
+                // wait silently until the user speaks and then call
+                // `resume_ensemble` first. Legacy mid-work path also signals
+                // immediately — no branching required.
+                if (lineup.conductor.instructions) {
+                    try {
+                        await handle.signal('receiveMessage', {
+                            from: 'lineup',
+                            text: lineup.conductor.instructions,
+                            responseRequested: false,
+                        });
+                        conductorActions.push(initialStartup ? 'instructions seeded (initial startup)' : 'instructions delivered');
+                        log('Conductor instructions delivered');
+                    }
+                    catch (err) {
+                        failed.push(`conductor instructions: ${err}`);
+                    }
+                }
+            }
+            // Legacy hold-mode standby (conductor-invoked mid-work with hold: true).
+            // Runs ONLY on the non-initial-startup path — initialStartup handling
+            // happens earlier above, ordered before the lineup instructions.
+            if (!initialStartup && hold && isConductor && handle) {
+                try {
+                    await handle.signal('receiveMessage', {
+                        from: 'system',
+                        text: 'Ensemble is loading in hold mode — players are connecting but on standby. Wait for instructions from the user or maestro before directing the ensemble. When ready, use the `release` tool to deliver task assignments to all held players.',
+                        responseRequested: false,
+                    });
+                    conductorActions.push('hold mode standby');
+                }
+                catch (err) {
+                    failed.push(`conductor hold message: ${err}`);
+                }
+            }
+            // Recruit players via outbox — no polling needed
+            for (const player of lineup.players) {
+                const playerName = player.name;
+                const workDir = player.workDir || process.cwd();
+                const agentType = player.agent === 'copilot' ? 'copilot' : 'claude';
+                const isCustomAgent = player.agent && player.agent !== 'default' && player.agent !== 'copilot';
+                const systemPrompt = player._agentDefinition ? undefined : (isCustomAgent ? player.agent : undefined);
+                const agentDefinition = player._agentDefinition;
+                const agentDefinitionPath = player._agentDefinitionPath;
+                // Skip if already active — send instructions via cue instead
+                const existing = await (0, resolve_1.resolveSession)(client, config.ensemble, playerName);
+                if (existing) {
+                    log(`Player "${playerName}" already active — skipping recruit`);
+                    recruited.push(`${playerName} (already active)`);
+                    if (player.instructions && handle) {
+                        try {
+                            const cueEntry = {
+                                type: 'cue',
+                                targetPlayerId: playerName,
+                                message: player.instructions,
+                            };
+                            await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [cueEntry] });
+                        }
+                        catch (err) {
+                            log(`Failed to send instructions to already-active player "${playerName}":`, err);
+                        }
+                    }
+                    continue;
+                }
+                // Submit recruit via outbox — pre-creates workflow with pending status
+                if (!handle) {
+                    failed.push(`${playerName}: load_lineup requires a workflow handle to recruit`);
+                    continue;
+                }
+                try {
+                    // Resolve full agent type info (description, nativeResolvable) if available
+                    const resolvedType = agentDefinition ? (0, agent_types_1.resolveAgentType)(agentDefinition) : null;
+                    const entry = {
+                        type: 'recruit',
+                        targetName: playerName,
+                        workDir,
+                        isConductor: false,
+                        initialMessage: player.instructions,
+                        agent: agentType,
+                        systemPrompt: agentDefinition ? undefined : systemPrompt,
+                        agentDefinition: resolvedType?.name || agentDefinition,
+                        agentDefinitionPath: resolvedType?.path || agentDefinitionPath,
+                        agentDefinitionDescription: resolvedType?.description,
+                        nativeResolvable: resolvedType?.nativeResolvable,
+                        allowedTools: player.allowedTools,
+                        claudeBin: config.claudeBin,
+                        ...(hold ? { held: true } : {}),
+                    };
+                    await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
+                    recruited.push(playerName);
+                    log(`Recruit request submitted for "${playerName}" in ${workDir}`);
+                }
+                catch (err) {
+                    failed.push(`${playerName}: recruit failed — ${err}`);
+                }
+            }
+            // Create schedules
+            const schedulesCreated = [];
+            const scheduleWarnings = [];
+            if (lineup.schedules && lineup.schedules.length > 0) {
+                // Build valid target set from lineup player names + special values
+                const validTargets = new Set(lineup.players.map((p) => p.name));
+                validTargets.add('conductor');
+                validTargets.add('all');
+                for (const sched of lineup.schedules) {
+                    try {
+                        // Validate schedule target against known player names
+                        if (!validTargets.has(sched.target)) {
+                            scheduleWarnings.push(`schedule "${sched.name}": target "${sched.target}" does not match any player in this lineup (known: ${[...validTargets].join(', ')})`);
+                        }
+                        const now = Date.now();
+                        let nextFireAt;
+                        let interval;
+                        let cronExpression;
+                        let timezone;
+                        if (sched.at) {
+                            nextFireAt = Date.parse(sched.at);
+                            // Support at + every: use `at` as the initial fire time, `every` as the interval
+                            if (sched.every) {
+                                const ms = (0, duration_1.parseDuration)(sched.every);
+                                if (!ms)
+                                    throw new Error(`Invalid interval: ${sched.every}`);
+                                interval = ms;
+                            }
+                        }
+                        else if (sched.delay) {
+                            const ms = (0, duration_1.parseDuration)(sched.delay);
+                            if (!ms)
+                                throw new Error(`Invalid delay: ${sched.delay}`);
+                            nextFireAt = now + ms;
+                        }
+                        else if (sched.every) {
+                            const ms = (0, duration_1.parseDuration)(sched.every);
+                            if (!ms)
+                                throw new Error(`Invalid interval: ${sched.every}`);
+                            nextFireAt = now + ms;
+                            interval = ms;
+                        }
+                        else if (sched.cron) {
+                            cronExpression = sched.cron;
+                            timezone = sched.timezone || 'UTC';
+                            const job = new croner_1.Cron(cronExpression, { timezone });
+                            const next = job.nextRun();
+                            if (!next)
+                                throw new Error(`Cron expression "${sched.cron}" has no upcoming fire time`);
+                            nextFireAt = next.getTime();
+                        }
+                        else {
+                            throw new Error('No timing specified');
+                        }
+                        const type = sched.cron ? 'cron' : (sched.every || interval) ? 'interval' : 'once';
+                        const scheduleEntry = {
+                            name: sched.name,
+                            message: sched.message,
+                            target: sched.target,
+                            type,
+                            nextFireAt: new Date(nextFireAt).toISOString(),
+                            interval,
+                            cronExpression,
+                            timezone,
+                            until: sched.until,
+                            remainingCount: sched.count,
+                            firedCount: 0,
+                            createdBy: getPlayerId(),
+                        };
+                        const wfId = (0, config_1.schedulerWorkflowId)(config.ensemble);
+                        try {
+                            const handle = client.workflow.getHandle(wfId);
+                            await handle.describe();
+                            await handle.signal('addSchedule', scheduleEntry);
+                        }
+                        catch {
+                            await client.workflow.start('agentSchedulerWorkflow', {
+                                workflowId: wfId,
+                                taskQueue: config.taskQueue,
+                                args: [{ ensemble: config.ensemble, entries: [scheduleEntry] }],
+                                workflowIdConflictPolicy: client_1.WorkflowIdConflictPolicy.USE_EXISTING,
+                                searchAttributes: {
+                                    AgentTempoEnsemble: [config.ensemble],
+                                },
+                            });
+                        }
+                        schedulesCreated.push(sched.name);
+                    }
+                    catch (err) {
+                        failed.push(`schedule "${sched.name}": ${err}`);
+                    }
+                }
+            }
+            // Issue #172: on the initial-startup path, pause the whole ensemble
+            // so scheduler fires, maestro nudges, and per-session outbox dispatch
+            // are all halted while we wait for the user's first message. The
+            // conductor's `receiveMessageSignal` handler combines lineup context +
+            // user text and the combined prompt instructs Claude Code to call
+            // `resume_ensemble` BEFORE any other action. Inlines the three signals
+            // that `pause_ensemble` fires so we don't depend on the tool impl.
+            if (initialStartup && isConductor && handle) {
+                try {
+                    const maestroId = (0, config_1.maestroWorkflowId)(config.ensemble);
+                    await client.workflow.getHandle(maestroId).signal('maestroSetPaused', true);
+                }
+                catch {
+                    // Maestro may not be running yet — fine, it will start paused once spawned.
+                }
+                try {
+                    const schedulerId = (0, config_1.schedulerWorkflowId)(config.ensemble);
+                    await client.workflow.getHandle(schedulerId).signal('setSchedulerPaused', true);
+                }
+                catch {
+                    // Scheduler may not exist yet if no schedules are defined — ignore.
+                }
+                try {
+                    const sessions = await (0, resolve_2.scanEnsembleSessions)(client, config.ensemble);
+                    for (const session of sessions) {
+                        try {
+                            await client.workflow.getHandle(session.workflowId).signal('setPaused', true);
+                        }
+                        catch {
+                            // Individual session may have just terminated — skip.
+                        }
+                    }
+                    conductorActions.push('ensemble paused (awaiting first user message)');
+                }
+                catch (err) {
+                    failed.push(`pause ensemble: ${(0, helpers_1.formatError)(err)}`);
+                }
+            }
+            // Build summary
+            const lines = [`Loaded lineup **${lineup.name}**.`];
+            if (conductorActions.length > 0) {
+                lines.push(`Conductor: ${conductorActions.join(', ')}`);
+            }
+            if (recruited.length > 0) {
+                if (hold) {
+                    lines.push(`Held: ${recruited.join(', ')} — ${recruited.length} player(s) held. Use \`release\` to start them.`);
+                }
+                else {
+                    lines.push(`Recruited: ${recruited.join(', ')}`);
+                }
+            }
+            if (schedulesCreated.length > 0) {
+                lines.push(`Schedules created: ${schedulesCreated.join(', ')}`);
+            }
+            if (scheduleWarnings.length > 0) {
+                lines.push(`⚠ Schedule target warnings:\n${scheduleWarnings.map(w => `  - ${w}`).join('\n')}`);
+            }
+            if (failed.length > 0) {
+                lines.push(`Failures:\n${failed.map(f => `  - ${f}`).join('\n')}`);
+            }
+            return (0, helpers_1.ok)(lines.join('\n'));
+        }
+        catch (err) {
+            return (0, helpers_1.fail)(`Failed to load lineup: ${(0, helpers_1.formatError)(err)}`);
+        }
+    });
+}

package/dist/tools/migrate.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Client, WorkflowHandle } from '@temporalio/client';
+import { Config } from '../config';
+export declare function registerMigrateTool(server: McpServer, client: Client, config: Config, getPlayerId: () => string, handle: WorkflowHandle): void;

package/dist/tools/migrate.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMigrateTool = registerMigrateTool;
+/**
+ * `migrate` — sugar for `restart --host=<h>` per design §9.6.
+ *
+ * Identical semantics to `restart` with the `host` argument required. Separate
+ * verb for UX clarity: "migrate to host X" vs "restart this session". Both
+ * names route through the same `RestartOutboxEntry` outbox path so the §8.2
+ * algorithm is implemented once in `deliverRestart` (QA B3).
+ *
+ * PR-F wires the `confirmStealFromHost` guard (design §16.5 Option B) via the
+ * shared `enforceYesStealGuard` helper from `restart.ts`. When the caller passes
+ * `force: true` AND the target's current attachment is on a different host,
+ * `confirmStealFromHost` must name that hostname exactly.
+ */
+const zod_1 = require("zod");
+const signals_1 = require("../workflows/signals");
+const helpers_1 = require("./helpers");
+const restart_1 = require("./restart");
+const validation_1 = require("../utils/validation");
+function registerMigrateTool(server, client, config, getPlayerId, handle) {
+    (0, helpers_1.defineTool)(server, 'migrate', 'Migrate a session to a different host — sugar for `restart` with a required `host`. Reaps the current attachment, claims fresh on the target host, spawns a new adapter. Cross-host routing (per-host task queues) is honored automatically. When `force=true` AND the target is currently on a different host, `confirmStealFromHost` must match that hostname (design §16.5).', {
+        playerId: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).describe('The player name to migrate'),
+        host: zod_1.z.string().min(1).describe('Target hostname — required'),
+        fresh: zod_1.z.boolean().optional().describe('Skip context replay (default false)'),
+        force: zod_1.z.boolean().optional().describe('Steal a live attachment via forceDetach (default false)'),
+        contextMessages: zod_1.z.number().min(0).max(validation_1.RESTART_CONTEXT_MESSAGES_MAX).optional().describe('Number of recent messages to include in context (default 10)'),
+        confirmStealFromHost: zod_1.z.string().optional().describe('Required when `force=true` and the target\'s current attachment is on a different host (design §16.5 Option B).'),
+    }, async (args) => {
+        const input = args;
+        const nameError = (0, validation_1.validatePlayerName)(input.playerId);
+        if (nameError)
+            return (0, helpers_1.fail)(nameError);
+        if (!input.host || !input.host.trim()) {
+            return (0, helpers_1.fail)('`host` is required for migrate. Use `restart` (without host) to restart on the session\'s current host.');
+        }
+        // Shared cross-host guard with `restart` — same rules, same copy-paste
+        // error messages (§16.5).
+        const guardError = await (0, restart_1.enforceYesStealGuard)(client, config.ensemble, input.playerId, input);
+        if (guardError)
+            return (0, helpers_1.fail)(guardError);
+        try {
+            const entry = {
+                type: 'restart',
+                targetPlayerId: input.playerId,
+                invokerPlayerId: getPlayerId(),
+                host: input.host,
+                ...(input.fresh !== undefined ? { fresh: input.fresh } : {}),
+                ...(input.force !== undefined ? { force: input.force } : {}),
+                ...(input.contextMessages !== undefined ? { contextMessages: input.contextMessages } : {}),
+            };
+            const entryId = await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
+            return (0, helpers_1.ok)(`Migrate queued for **${input.playerId}** → ${input.host}. (outbox: ${entryId})`);
+        }
+        catch (err) {
+            return (0, helpers_1.fail)(`Failed to migrate: ${(0, helpers_1.formatError)(err)}`);
+        }
+    });
+}

package/dist/tools/pause-ensemble.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Client } from '@temporalio/client';
+import { Config } from '../config';
+export declare function registerPauseEnsembleTool(server: McpServer, client: Client, config: Config, getPlayerId: () => string): void;

package/dist/tools/pause-ensemble.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPauseEnsembleTool = registerPauseEnsembleTool;
+const config_1 = require("../config");
+const resolve_1 = require("../activities/resolve");
+const helpers_1 = require("./helpers");
+const log = (...args) => console.error('[claude-tempo:pause]', ...args);
+function registerPauseEnsembleTool(server, client, config, getPlayerId) {
+    (0, helpers_1.defineTool)(server, 'pause_ensemble', 'Pause all sessions in the ensemble — locks outbox dispatch and pauses the scheduler. Stop commands still go through. Use resume_ensemble to unpause.', {}, async () => {
+        try {
+            const results = [];
+            const errors = [];
+            // 1. Signal maestro with paused state (ground truth)
+            try {
+                const maestroId = (0, config_1.maestroWorkflowId)(config.ensemble);
+                const maestroHandle = client.workflow.getHandle(maestroId);
+                await maestroHandle.signal('maestroSetPaused', true);
+                results.push('maestro paused');
+            }
+            catch {
+                // Maestro may not be running
+            }
+            // 2. Signal all active sessions
+            const sessions = await (0, resolve_1.scanEnsembleSessions)(client, config.ensemble);
+            let sessionCount = 0;
+            for (const session of sessions) {
+                try {
+                    const sessionHandle = client.workflow.getHandle(session.workflowId);
+                    await sessionHandle.signal('setPaused', true);
+                    sessionCount++;
+                }
+                catch (err) {
+                    errors.push(`${session.playerId}: ${(0, helpers_1.formatError)(err)}`);
+                }
+            }
+            results.push(`${sessionCount} session(s) paused`);
+            // 3. Signal scheduler
+            try {
+                const schedulerId = (0, config_1.schedulerWorkflowId)(config.ensemble);
+                const schedulerHandle = client.workflow.getHandle(schedulerId);
+                await schedulerHandle.signal('setSchedulerPaused', true);
+                results.push('scheduler paused');
+            }
+            catch {
+                // Scheduler may not be running
+            }
+            const lines = [`Ensemble **${config.ensemble}** paused.`, results.join(', ')];
+            if (errors.length > 0) {
+                lines.push(`Errors:\n${errors.map((e) => `  - ${e}`).join('\n')}`);
+            }
+            log(`Paused ensemble "${config.ensemble}" by ${getPlayerId()}`);
+            return (0, helpers_1.ok)(lines.join('\n'));
+        }
+        catch (err) {
+            return (0, helpers_1.fail)(`Failed to pause ensemble: ${(0, helpers_1.formatError)(err)}`);
+        }
+    });
+}

package/dist/tools/pause.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Client } from '@temporalio/client';
+import { Config } from '../config';
+export declare function registerPauseTool(server: McpServer, client: Client, config: Config, getPlayerId: () => string): void;

package/dist/tools/pause.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPauseTool = registerPauseTool;
+const signals_1 = require("../workflows/signals");
+const helpers_1 = require("./helpers");
+const ensemble_ops_1 = require("../utils/ensemble-ops");
+const log = (...args) => console.error('[agent-tempo:pause]', ...args);
+function registerPauseTool(server, client, config, getPlayerId) {
+    (0, helpers_1.defineTool)(server, 'pause', 'Pause all sessions in the ensemble — locks outbox dispatch and pauses the scheduler. Stop commands still go through. Use `play` to unpause.', {}, async () => {
+        try {
+            const [toggle, sessions] = await Promise.all([
+                (0, ensemble_ops_1.pauseMaestroAndScheduler)(client, config.ensemble),
+                (0, ensemble_ops_1.signalAllSessions)(client, config.ensemble, signals_1.setPausedSignal.name, true),
+            ]);
+            const bits = [
+                `Ensemble **${config.ensemble}** paused.`,
+                `${sessions.sent} session(s) paused`,
+            ];
+            if (toggle.maestro)
+                bits.push('maestro paused');
+            if (toggle.scheduler)
+                bits.push('scheduler paused');
+            if (sessions.failed > 0) {
+                const errs = sessions.perSession
+                    .filter((p) => p.outcome === 'failed')
+                    .map((p) => `  - ${p.playerId}: ${'error' in p ? p.error : ''}`);
+                bits.push(`Errors:\n${errs.join('\n')}`);
+            }
+            log(`Paused ensemble "${config.ensemble}" by ${getPlayerId()}`);
+            return (0, helpers_1.ok)(bits.join('\n'));
+        }
+        catch (err) {
+            return (0, helpers_1.fail)(`Failed to pause ensemble: ${(0, helpers_1.formatError)(err)}`);
+        }
+    });
+}

package/dist/tools/play.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Client } from '@temporalio/client';
+import { Config } from '../config';
+export declare function registerPlayTool(server: McpServer, client: Client, config: Config, getPlayerId: () => string): void;

package/dist/tools/play.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPlayTool = registerPlayTool;
+const zod_1 = require("zod");
+const signals_1 = require("../workflows/signals");
+const helpers_1 = require("./helpers");
+const ensemble_ops_1 = require("../utils/ensemble-ops");
+const log = (...args) => console.error('[agent-tempo:play]', ...args);
+function registerPlayTool(server, client, config, getPlayerId) {
+    (0, helpers_1.defineTool)(server, 'play', 'Resume all paused sessions in the ensemble — unlocks outbox dispatch and resumes the scheduler. Buffered outbox entries will be dispatched. Pass `release: true` to also release any held sessions (deliver deferred task messages and unlock their outboxes) in the same call.', {
+        release: zod_1.z.boolean().optional().describe('Also release any held sessions (deliver deferred task messages and unlock outboxes). Safe to call when no sessions are held — it is a no-op on those. Default: false.'),
+    }, async (args) => {
+        const release = args.release === true;
+        try {
+            // Unpause everything in parallel: maestro + scheduler + every session.
+            const [toggle, sessions] = await Promise.all([
+                (0, ensemble_ops_1.unpauseMaestroAndScheduler)(client, config.ensemble),
+                (0, ensemble_ops_1.signalAllSessions)(client, config.ensemble, signals_1.setPausedSignal.name, false),
+            ]);
+            // `releaseHeld` is idempotent — safe to fan out to everyone. Keep it
+            // AFTER the unpause so sessions aren't releasing while paused.
+            let releasedCount = 0;
+            const releaseErrors = [];
+            if (release) {
+                const released = await (0, ensemble_ops_1.signalAllSessions)(client, config.ensemble, 
+                // typed constant → `'releaseHeld'` string name, matches the session handler
+                signals_1.releaseHeldSignal.name, undefined);
+                releasedCount = released.sent;
+                for (const p of released.perSession) {
+                    if (p.outcome === 'failed')
+                        releaseErrors.push(`${p.playerId} release: ${'error' in p ? p.error : ''}`);
+                }
+            }
+            const bits = [
+                `Ensemble **${config.ensemble}** resumed.`,
+                `${sessions.sent} session(s) resumed`,
+            ];
+            if (release)
+                bits.push(`${releasedCount} session(s) signalled for release`);
+            if (toggle.maestro)
+                bits.push('maestro resumed');
+            if (toggle.scheduler)
+                bits.push('scheduler resumed');
+            const failedUnpause = sessions.perSession
+                .filter((p) => p.outcome === 'failed')
+                .map((p) => `  - ${p.playerId}: ${'error' in p ? p.error : ''}`);
+            const allErrors = [...failedUnpause, ...releaseErrors.map((e) => `  - ${e}`)];
+            if (allErrors.length > 0)
+                bits.push(`Errors:\n${allErrors.join('\n')}`);
+            log(`Resumed ensemble "${config.ensemble}" by ${getPlayerId()}${release ? ' (with release)' : ''}`);
+            return (0, helpers_1.ok)(bits.join('\n'));
+        }
+        catch (err) {
+            return (0, helpers_1.fail)(`Failed to resume ensemble: ${(0, helpers_1.formatError)(err)}`);
+        }
+    });
+}

package/dist/tools/quality-gate.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { WorkflowHandle } from '@temporalio/client';
+export declare function registerQualityGateTool(server: McpServer, handle: WorkflowHandle, getPlayerId: () => string): void;

package/dist/tools/quality-gate.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerQualityGateTool = registerQualityGateTool;
+const zod_1 = require("zod");
+const helpers_1 = require("./helpers");
+const validation_1 = require("../utils/validation");
+function registerQualityGateTool(server, handle, getPlayerId) {
+    (0, helpers_1.defineTool)(server, 'quality_gate', 'Define or replace a quality gate for a task. Each gate has a list of criteria that must pass before the task is considered complete. Conductor only.', {
+        task: zod_1.z.string().max(validation_1.GATE_TASK_MAX).describe('Unique task name for this gate (e.g. "pr-review", "deploy-staging")'),
+        criteria: zod_1.z.array(zod_1.z.string().max(validation_1.GATE_CRITERION_TEXT_MAX)).min(1).max(validation_1.GATE_CRITERIA_MAX).describe('List of criteria that must be evaluated (e.g. ["Tests pass", "No lint errors", "Code reviewed"])'),
+    }, async (args) => {
+        const { task, criteria } = args;
+        try {
+            await handle.signal('setQualityGate', {
+                task,
+                criteria,
+                createdBy: getPlayerId(),
+            });
+            const lines = criteria.map((c, i) => `  ${i}. [ ] ${c}`);
+            return (0, helpers_1.ok)(`Quality gate **${task}** set with ${criteria.length} criteria:\n${lines.join('\n')}`);
+        }
+        catch (err) {
+            return (0, helpers_1.fail)(`Failed to set quality gate: ${(0, helpers_1.formatError)(err)}`);
+        }
+    });
+}