agent-tempo 1.2.0 → 1.4.0

package/dist/tools/load-lineup.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerLoadLineupTool = registerLoadLineupTool;
+exports.buildLoadLineupTool = buildLoadLineupTool;
 const zod_1 = require("zod");
 const croner_1 = require("croner");
 const client_1 = require("@temporalio/client");
@@ -12,370 +12,375 @@ 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 descriptor_1 = require("./descriptor");
 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());
+function buildLoadLineupTool(client, config, getPlayerId, ownAgentType = 'claude', handle, setPlayerId, isConductor) {
+    return {
+        name: 'load_lineup',
+        description: 'Load an ensemble lineup — recruits players and creates schedules.',
+        params: {
+            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.'),
+        },
+        handler: 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, descriptor_1.fail)('Provide either `name` (saved lineup) or `path` (file path). Exactly one is required.');
             }
-            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());
-                }
+            if (lineupName && lineupPath) {
+                return (0, descriptor_1.fail)('Provide either `name` or `path`, not both.');
             }
-            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');
+            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());
                 }
-                catch (err) {
-                    failed.push(`conductor startup banner: ${err}`);
+                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());
+                    }
                 }
-            }
-            // 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()) {
+                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 {
-                        // 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}"`);
-                        }
+                        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 name: ${err}`);
+                        failed.push(`conductor startup banner: ${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}"`);
+                // 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}"`);
+                            }
                         }
-                        else {
-                            failed.push(`conductor type "${lineup.conductor.type}": agent type not found`);
+                        catch (err) {
+                            failed.push(`conductor name: ${err}`);
                         }
                     }
-                    catch (err) {
-                        failed.push(`conductor type: ${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}`);
+                        }
                     }
                 }
-                // 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) {
+                // 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: 'lineup',
-                            text: lineup.conductor.instructions,
+                            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(initialStartup ? 'instructions seeded (initial startup)' : 'instructions delivered');
-                        log('Conductor instructions delivered');
+                        conductorActions.push('hold mode standby');
                     }
                     catch (err) {
-                        failed.push(`conductor instructions: ${err}`);
+                        failed.push(`conductor hold message: ${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);
+                // 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;
                     }
-                    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) {
+                        // 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);
                         }
-                        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 (err) {
+                            failed.push(`schedule "${sched.name}": ${err}`);
                         }
-                        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],
-                                },
-                            });
+                    }
+                }
+                // 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.
+                            }
                         }
-                        schedulesCreated.push(sched.name);
+                        conductorActions.push('ensemble paused (awaiting first user message)');
                     }
                     catch (err) {
-                        failed.push(`schedule "${sched.name}": ${err}`);
+                        failed.push(`pause ensemble: ${(0, descriptor_1.formatError)(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.
+                // Build summary
+                const lines = [`Loaded lineup **${lineup.name}**.`];
+                if (conductorActions.length > 0) {
+                    lines.push(`Conductor: ${conductorActions.join(', ')}`);
                 }
-                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.
-                        }
+                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(', ')}`);
                     }
-                    conductorActions.push('ensemble paused (awaiting first user message)');
                 }
-                catch (err) {
-                    failed.push(`pause ensemble: ${(0, helpers_1.formatError)(err)}`);
+                if (schedulesCreated.length > 0) {
+                    lines.push(`Schedules created: ${schedulesCreated.join(', ')}`);
                 }
-            }
-            // 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.`);
+                if (scheduleWarnings.length > 0) {
+                    lines.push(`⚠ Schedule target warnings:\n${scheduleWarnings.map(w => `  - ${w}`).join('\n')}`);
                 }
-                else {
-                    lines.push(`Recruited: ${recruited.join(', ')}`);
+                if (failed.length > 0) {
+                    lines.push(`Failures:\n${failed.map(f => `  - ${f}`).join('\n')}`);
                 }
+                return (0, descriptor_1.ok)(lines.join('\n'));
             }
-            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')}`);
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to load lineup: ${(0, descriptor_1.formatError)(err)}`);
             }
-            return (0, helpers_1.ok)(lines.join('\n'));
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to load lineup: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+        },
+    };
 }