agent-tempo 1.2.0 → 1.4.0

package/dist/tools/schedule.js

@@ -1,152 +1,157 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerScheduleTool = registerScheduleTool;
+exports.buildScheduleTool = buildScheduleTool;
 const zod_1 = require("zod");
 const croner_1 = require("croner");
 const client_1 = require("@temporalio/client");
 const config_1 = require("../config");
 const duration_1 = require("../utils/duration");
 const resolve_1 = require("./resolve");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 const validation_1 = require("../utils/validation");
 const log = (...args) => console.error('[agent-tempo:schedule]', ...args);
-function registerScheduleTool(server, client, config, getPlayerId) {
-    (0, helpers_1.defineTool)(server, 'schedule', 'Schedule a message to be sent to a player at a specific time, after a delay, on a recurring interval, or via cron expression.', {
-        name: zod_1.z.string().max(validation_1.SCHEDULE_NAME_MAX).describe('Unique name for this schedule'),
-        message: zod_1.z.string().max(validation_1.SCHEDULE_MESSAGE_MAX).describe('The message to deliver'),
-        target: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).describe('Player name to deliver to ("self" = this session)'),
-        at: zod_1.z.string().optional().describe('ISO datetime for one-shot delivery (e.g. "2026-04-03T20:00:00Z")'),
-        delay: zod_1.z.string().optional().describe('Duration until first delivery (e.g. "10m", "2h", "1d")'),
-        every: zod_1.z.string().optional().describe('Recurring interval (e.g. "5m", "1h")'),
-        cron: zod_1.z.string().max(validation_1.CRON_EXPRESSION_MAX).optional().describe('Cron expression for recurring delivery (e.g. "0 9 * * 1-5" = weekdays at 9am). Mutually exclusive with at/delay/every.'),
-        timezone: zod_1.z.string().optional().describe('IANA timezone for cron evaluation (e.g. "America/New_York"). Defaults to UTC. Only used with cron.'),
-        until: zod_1.z.string().optional().describe('ISO datetime — stop recurring after this time'),
-        count: zod_1.z.number().optional().describe('Max number of deliveries for recurring schedules'),
-    }, async (args) => {
-        const { name, message, at, delay, every, cron, timezone, until, count } = args;
-        let target = args.target;
-        // Resolve "self" to the current player name
-        if (target === 'self') {
-            target = getPlayerId();
-        }
-        // Validate target player exists (warn, don't block)
-        let targetWarning;
-        if (target !== 'all' && target !== 'conductor') {
-            try {
-                const targetHandle = await (0, resolve_1.resolveSession)(client, config.ensemble, target);
-                if (!targetHandle) {
-                    targetWarning = `Warning: player "${target}" is not currently active. The schedule will be created but may fail to deliver until the player joins.`;
+function buildScheduleTool(client, config, getPlayerId) {
+    return {
+        name: 'schedule',
+        description: 'Schedule a message to be sent to a player at a specific time, after a delay, on a recurring interval, or via cron expression.',
+        params: {
+            name: zod_1.z.string().max(validation_1.SCHEDULE_NAME_MAX).describe('Unique name for this schedule'),
+            message: zod_1.z.string().max(validation_1.SCHEDULE_MESSAGE_MAX).describe('The message to deliver'),
+            target: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).describe('Player name to deliver to ("self" = this session)'),
+            at: zod_1.z.string().optional().describe('ISO datetime for one-shot delivery (e.g. "2026-04-03T20:00:00Z")'),
+            delay: zod_1.z.string().optional().describe('Duration until first delivery (e.g. "10m", "2h", "1d")'),
+            every: zod_1.z.string().optional().describe('Recurring interval (e.g. "5m", "1h")'),
+            cron: zod_1.z.string().max(validation_1.CRON_EXPRESSION_MAX).optional().describe('Cron expression for recurring delivery (e.g. "0 9 * * 1-5" = weekdays at 9am). Mutually exclusive with at/delay/every.'),
+            timezone: zod_1.z.string().optional().describe('IANA timezone for cron evaluation (e.g. "America/New_York"). Defaults to UTC. Only used with cron.'),
+            until: zod_1.z.string().optional().describe('ISO datetime — stop recurring after this time'),
+            count: zod_1.z.number().optional().describe('Max number of deliveries for recurring schedules'),
+        },
+        handler: async (args) => {
+            const { name, message, at, delay, every, cron, timezone, until, count } = args;
+            let target = args.target;
+            // Resolve "self" to the current player name
+            if (target === 'self') {
+                target = getPlayerId();
+            }
+            // Validate target player exists (warn, don't block)
+            let targetWarning;
+            if (target !== 'all' && target !== 'conductor') {
+                try {
+                    const targetHandle = await (0, resolve_1.resolveSession)(client, config.ensemble, target);
+                    if (!targetHandle) {
+                        targetWarning = `Warning: player "${target}" is not currently active. The schedule will be created but may fail to deliver until the player joins.`;
+                    }
+                }
+                catch {
+                    // Resolution failed — don't block schedule creation
                 }
             }
-            catch {
-                // Resolution failed — don't block schedule creation
+            // Validate exactly one timing option
+            const timingCount = [at, delay, every, cron].filter(Boolean).length;
+            if (timingCount !== 1) {
+                return (0, descriptor_1.fail)('Provide exactly one timing option: `at`, `delay`, `every`, or `cron`.');
             }
-        }
-        // Validate exactly one timing option
-        const timingCount = [at, delay, every, cron].filter(Boolean).length;
-        if (timingCount !== 1) {
-            return (0, helpers_1.fail)('Provide exactly one timing option: `at`, `delay`, `every`, or `cron`.');
-        }
-        // timezone only valid with cron
-        if (timezone && !cron) {
-            return (0, helpers_1.fail)('`timezone` can only be used with `cron`.');
-        }
-        const now = Date.now();
-        let nextFireAt;
-        let interval;
-        if (at) {
-            const ts = Date.parse(at);
-            if (isNaN(ts)) {
-                return (0, helpers_1.fail)(`Invalid ISO datetime for "at": ${at}`);
+            // timezone only valid with cron
+            if (timezone && !cron) {
+                return (0, descriptor_1.fail)('`timezone` can only be used with `cron`.');
             }
-            nextFireAt = ts;
-        }
-        else if (delay) {
-            const ms = (0, duration_1.parseDuration)(delay);
-            if (ms === null) {
-                return (0, helpers_1.fail)(`Invalid duration for "delay": ${delay}. Use e.g. "30s", "10m", "2h", "1d".`);
+            const now = Date.now();
+            let nextFireAt;
+            let interval;
+            if (at) {
+                const ts = Date.parse(at);
+                if (isNaN(ts)) {
+                    return (0, descriptor_1.fail)(`Invalid ISO datetime for "at": ${at}`);
+                }
+                nextFireAt = ts;
             }
-            nextFireAt = now + ms;
-        }
-        else if (every) {
-            // every (recurring interval)
-            const ms = (0, duration_1.parseDuration)(every);
-            if (ms === null || ms < 10_000) {
-                return (0, helpers_1.fail)(`Invalid or too-short interval for "every": ${every}. Minimum is 10s.`);
+            else if (delay) {
+                const ms = (0, duration_1.parseDuration)(delay);
+                if (ms === null) {
+                    return (0, descriptor_1.fail)(`Invalid duration for "delay": ${delay}. Use e.g. "30s", "10m", "2h", "1d".`);
+                }
+                nextFireAt = now + ms;
             }
-            nextFireAt = now + ms;
-            interval = ms;
-        }
-        else {
-            // cron (recurring via cron expression)
-            try {
-                const job = new croner_1.Cron(cron, { timezone: timezone || 'UTC' });
-                const next = job.nextRun();
-                if (!next) {
-                    return (0, helpers_1.fail)(`Cron expression "${cron}" has no upcoming fire time.`);
+            else if (every) {
+                // every (recurring interval)
+                const ms = (0, duration_1.parseDuration)(every);
+                if (ms === null || ms < 10_000) {
+                    return (0, descriptor_1.fail)(`Invalid or too-short interval for "every": ${every}. Minimum is 10s.`);
                 }
-                nextFireAt = next.getTime();
+                nextFireAt = now + ms;
+                interval = ms;
             }
-            catch (err) {
-                return (0, helpers_1.fail)(`Invalid cron expression "${cron}": ${(0, helpers_1.formatError)(err)}`);
+            else {
+                // cron (recurring via cron expression)
+                try {
+                    const job = new croner_1.Cron(cron, { timezone: timezone || 'UTC' });
+                    const next = job.nextRun();
+                    if (!next) {
+                        return (0, descriptor_1.fail)(`Cron expression "${cron}" has no upcoming fire time.`);
+                    }
+                    nextFireAt = next.getTime();
+                }
+                catch (err) {
+                    return (0, descriptor_1.fail)(`Invalid cron expression "${cron}": ${(0, descriptor_1.formatError)(err)}`);
+                }
             }
-        }
-        // Parse optional until
-        let untilMs;
-        if (until) {
-            const ts = Date.parse(until);
-            if (isNaN(ts)) {
-                return (0, helpers_1.fail)(`Invalid ISO datetime for "until": ${until}`);
+            // Parse optional until
+            let untilMs;
+            if (until) {
+                const ts = Date.parse(until);
+                if (isNaN(ts)) {
+                    return (0, descriptor_1.fail)(`Invalid ISO datetime for "until": ${until}`);
+                }
+                untilMs = ts;
             }
-            untilMs = ts;
-        }
-        const type = cron ? 'cron' : every ? 'interval' : 'once';
-        const scheduleEntry = {
-            name,
-            message,
-            target,
-            type,
-            nextFireAt: new Date(nextFireAt).toISOString(),
-            interval,
-            cronExpression: cron,
-            timezone: cron ? (timezone || 'UTC') : undefined,
-            until: untilMs ? new Date(untilMs).toISOString() : undefined,
-            remainingCount: count,
-            firedCount: 0,
-            createdBy: getPlayerId(),
-        };
-        try {
-            const wfId = (0, config_1.schedulerWorkflowId)(config.ensemble);
-            // Try to signal the existing scheduler workflow
+            const type = cron ? 'cron' : every ? 'interval' : 'once';
+            const scheduleEntry = {
+                name,
+                message,
+                target,
+                type,
+                nextFireAt: new Date(nextFireAt).toISOString(),
+                interval,
+                cronExpression: cron,
+                timezone: cron ? (timezone || 'UTC') : undefined,
+                until: untilMs ? new Date(untilMs).toISOString() : undefined,
+                remainingCount: count,
+                firedCount: 0,
+                createdBy: getPlayerId(),
+            };
             try {
-                const handle = client.workflow.getHandle(wfId);
-                await handle.describe(); // throws if not running
-                await handle.signal('addSchedule', scheduleEntry);
+                const wfId = (0, config_1.schedulerWorkflowId)(config.ensemble);
+                // Try to signal the existing scheduler workflow
+                try {
+                    const handle = client.workflow.getHandle(wfId);
+                    await handle.describe(); // throws if not running
+                    await handle.signal('addSchedule', scheduleEntry);
+                }
+                catch {
+                    // Scheduler not running — start it with this schedule as seed
+                    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],
+                        },
+                    });
+                    log(`Started scheduler workflow ${wfId}`);
+                }
+                const fireDate = new Date(nextFireAt).toISOString();
+                const recur = cron
+                    ? ` (cron: ${cron}, tz: ${timezone || 'UTC'})`
+                    : interval
+                        ? ` (repeating every ${every})`
+                        : ' (one-shot)';
+                const msg = `Schedule **${name}** created. Next fire: ${fireDate}${recur}. Target: ${target}.`;
+                return (0, descriptor_1.ok)(targetWarning ? `${msg}\n\n⚠ ${targetWarning}` : msg);
             }
-            catch {
-                // Scheduler not running — start it with this schedule as seed
-                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],
-                    },
-                });
-                log(`Started scheduler workflow ${wfId}`);
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to create schedule: ${(0, descriptor_1.formatError)(err)}`);
             }
-            const fireDate = new Date(nextFireAt).toISOString();
-            const recur = cron
-                ? ` (cron: ${cron}, tz: ${timezone || 'UTC'})`
-                : interval
-                    ? ` (repeating every ${every})`
-                    : ' (one-shot)';
-            const msg = `Schedule **${name}** created. Next fire: ${fireDate}${recur}. Target: ${target}.`;
-            return (0, helpers_1.ok)(targetWarning ? `${msg}\n\n⚠ ${targetWarning}` : msg);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to create schedule: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+        },
+    };
 }

package/dist/tools/schedules.d.ts

@@ -1,4 +1,4 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Client } from '@temporalio/client';
 import { Config } from '../config';
-export declare function registerSchedulesTool(server: McpServer, client: Client, config: Config): void;
+import { type TempoToolDescriptor } from './descriptor';
+export declare function buildSchedulesTool(client: Client, config: Config): TempoToolDescriptor;

package/dist/tools/schedules.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerSchedulesTool = registerSchedulesTool;
+exports.buildSchedulesTool = buildSchedulesTool;
 const client_1 = require("@temporalio/client");
 const config_1 = require("../config");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 function formatDuration(ms) {
     if (ms >= 86_400_000)
         return `${ms / 86_400_000}d`;
@@ -13,42 +13,47 @@ function formatDuration(ms) {
         return `${ms / 60_000}m`;
     return `${ms / 1000}s`;
 }
-function registerSchedulesTool(server, client, config) {
-    (0, helpers_1.defineTool)(server, 'schedules', 'List all active schedules in this ensemble.', {}, async () => {
-        try {
-            const wfId = (0, config_1.schedulerWorkflowId)(config.ensemble);
-            const handle = client.workflow.getHandle(wfId);
-            let schedules;
+function buildSchedulesTool(client, config) {
+    return {
+        name: 'schedules',
+        description: 'List all active schedules in this ensemble.',
+        params: {},
+        handler: async () => {
             try {
-                schedules = await handle.query('getSchedules');
-            }
-            catch (err) {
-                if (err instanceof client_1.WorkflowNotFoundError) {
-                    return (0, helpers_1.ok)('No scheduler running — no schedules exist yet.');
+                const wfId = (0, config_1.schedulerWorkflowId)(config.ensemble);
+                const handle = client.workflow.getHandle(wfId);
+                let schedules;
+                try {
+                    schedules = await handle.query('getSchedules');
+                }
+                catch (err) {
+                    if (err instanceof client_1.WorkflowNotFoundError) {
+                        return (0, descriptor_1.ok)('No scheduler running — no schedules exist yet.');
+                    }
+                    throw err;
                 }
-                throw err;
+                if (schedules.length === 0) {
+                    return (0, descriptor_1.ok)('No active schedules.');
+                }
+                const lines = schedules.map((s) => {
+                    const next = s.nextFireAt; // already ISO string
+                    const recur = s.cronExpression
+                        ? `cron: ${s.cronExpression} (${s.timezone || 'UTC'})`
+                        : s.interval ? `every ${formatDuration(s.interval)}` : 'one-shot';
+                    const bounds = [];
+                    if (s.until)
+                        bounds.push(`until ${s.until}`);
+                    if (s.remainingCount != null)
+                        bounds.push(`${s.firedCount}/${s.firedCount + s.remainingCount} fired`);
+                    const boundsStr = bounds.length ? ` (${bounds.join(', ')})` : '';
+                    const msgPreview = s.message.length > 60 ? s.message.slice(0, 57) + '...' : s.message;
+                    return `• **${s.name}** → ${s.target} | ${recur}${boundsStr} | next: ${next}\n  msg: ${msgPreview}`;
+                });
+                return (0, descriptor_1.ok)(lines.join('\n'));
             }
-            if (schedules.length === 0) {
-                return (0, helpers_1.ok)('No active schedules.');
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to query schedules: ${(0, descriptor_1.formatError)(err)}`);
             }
-            const lines = schedules.map((s) => {
-                const next = s.nextFireAt; // already ISO string
-                const recur = s.cronExpression
-                    ? `cron: ${s.cronExpression} (${s.timezone || 'UTC'})`
-                    : s.interval ? `every ${formatDuration(s.interval)}` : 'one-shot';
-                const bounds = [];
-                if (s.until)
-                    bounds.push(`until ${s.until}`);
-                if (s.remainingCount != null)
-                    bounds.push(`${s.firedCount}/${s.firedCount + s.remainingCount} fired`);
-                const boundsStr = bounds.length ? ` (${bounds.join(', ')})` : '';
-                const msgPreview = s.message.length > 60 ? s.message.slice(0, 57) + '...' : s.message;
-                return `• **${s.name}** → ${s.target} | ${recur}${boundsStr} | next: ${next}\n  msg: ${msgPreview}`;
-            });
-            return (0, helpers_1.ok)(lines.join('\n'));
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to query schedules: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+        },
+    };
 }

package/dist/tools/set-ensemble-description.d.ts

@@ -1,4 +1,4 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Client } from '@temporalio/client';
 import { Config } from '../config';
-export declare function registerSetEnsembleDescriptionTool(server: McpServer, client: Client, config: Config): void;
+import { type TempoToolDescriptor } from './descriptor';
+export declare function buildSetEnsembleDescriptionTool(client: Client, config: Config): TempoToolDescriptor;

package/dist/tools/set-ensemble-description.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerSetEnsembleDescriptionTool = registerSetEnsembleDescriptionTool;
+exports.buildSetEnsembleDescriptionTool = buildSetEnsembleDescriptionTool;
 /**
  * `set_ensemble_description` MCP tool — #399 W1 (Q5.1).
  *
@@ -12,26 +12,31 @@ exports.registerSetEnsembleDescriptionTool = registerSetEnsembleDescriptionTool;
 const zod_1 = require("zod");
 const config_1 = require("../config");
 const maestro_signals_1 = require("../workflows/maestro-signals");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 const validation_1 = require("../utils/validation");
-function registerSetEnsembleDescriptionTool(server, client, config) {
-    (0, helpers_1.defineTool)(server, 'set_ensemble_description', "Update the ensemble's mission-flavor description (≤100 chars). Surfaces on the dashboard EnsembleCard. Empty string clears it. Refresh at milestone boundaries — don't update for trivial changes.", {
-        description: zod_1.z
-            .string()
-            .max(validation_1.ENSEMBLE_DESCRIPTION_MAX)
-            .describe('Short summary of what the ensemble is currently working on (≤100 chars).'),
-    }, async (args) => {
-        const { description } = args;
-        try {
-            const handle = client.workflow.getHandle((0, config_1.maestroWorkflowId)(config.ensemble));
-            await handle.signal(maestro_signals_1.setEnsembleDescriptionSignal.name, description);
-            if (description.trim().length === 0) {
-                return (0, helpers_1.ok)(`Ensemble **${config.ensemble}** description cleared.`);
+function buildSetEnsembleDescriptionTool(client, config) {
+    return {
+        name: 'set_ensemble_description',
+        description: "Update the ensemble's mission-flavor description (≤100 chars). Surfaces on the dashboard EnsembleCard. Empty string clears it. Refresh at milestone boundaries — don't update for trivial changes.",
+        params: {
+            description: zod_1.z
+                .string()
+                .max(validation_1.ENSEMBLE_DESCRIPTION_MAX)
+                .describe('Short summary of what the ensemble is currently working on (≤100 chars).'),
+        },
+        handler: async (args) => {
+            const { description } = args;
+            try {
+                const handle = client.workflow.getHandle((0, config_1.maestroWorkflowId)(config.ensemble));
+                await handle.signal(maestro_signals_1.setEnsembleDescriptionSignal.name, description);
+                if (description.trim().length === 0) {
+                    return (0, descriptor_1.ok)(`Ensemble **${config.ensemble}** description cleared.`);
+                }
+                return (0, descriptor_1.ok)(`Ensemble **${config.ensemble}** description updated: "${description}"`);
             }
-            return (0, helpers_1.ok)(`Ensemble **${config.ensemble}** description updated: "${description}"`);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to set ensemble description: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to set ensemble description: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

package/dist/tools/set-name.d.ts

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

package/dist/tools/set-name.js

@@ -1,45 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerSetNameTool = registerSetNameTool;
+exports.buildSetNameTool = buildSetNameTool;
 const zod_1 = require("zod");
 const config_1 = require("../config");
 const scheduler_signals_1 = require("../workflows/scheduler-signals");
 const resolve_1 = require("./resolve");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 const validation_1 = require("../utils/validation");
 const log = (...args) => console.error('[agent-tempo:set-name]', ...args);
-function registerSetNameTool(server, client, config, handle, getPlayerId, setPlayerId) {
-    (0, helpers_1.defineTool)(server, 'set_name', 'Set a human-readable name for this session. Visible to other players in the ensemble.', {
-        name: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).describe('The name for this session (e.g., "UX", "API", "test-runner")'),
-    }, async (args) => {
-        const { name } = args;
-        // Validate name to prevent search attribute query injection
-        const nameError = (0, validation_1.validatePlayerName)(name);
-        if (nameError) {
-            return (0, helpers_1.fail)(nameError);
-        }
-        // Check if the name is already taken
-        const existing = await (0, resolve_1.resolveSession)(client, config.ensemble, name);
-        if (existing && existing.workflowId !== handle.workflowId) {
-            return (0, helpers_1.fail)(`Name **${name}** is already taken by another session. Choose a different name.`);
-        }
-        try {
-            const oldName = getPlayerId();
-            await handle.signal('setName', name);
-            setPlayerId(name);
-            // Notify the scheduler to rewrite schedule targets from old name to new name
+function buildSetNameTool(client, config, handle, getPlayerId, setPlayerId) {
+    return {
+        name: 'set_name',
+        description: 'Set a human-readable name for this session. Visible to other players in the ensemble.',
+        params: {
+            name: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).describe('The name for this session (e.g., "UX", "API", "test-runner")'),
+        },
+        handler: async (args) => {
+            const { name } = args;
+            // Validate name to prevent search attribute query injection
+            const nameError = (0, validation_1.validatePlayerName)(name);
+            if (nameError) {
+                return (0, descriptor_1.fail)(nameError);
+            }
+            // Check if the name is already taken
+            const existing = await (0, resolve_1.resolveSession)(client, config.ensemble, name);
+            if (existing && existing.workflowId !== handle.workflowId) {
+                return (0, descriptor_1.fail)(`Name **${name}** is already taken by another session. Choose a different name.`);
+            }
             try {
-                const schedulerHandle = client.workflow.getHandle((0, config_1.schedulerWorkflowId)(config.ensemble));
-                await schedulerHandle.signal(scheduler_signals_1.updateScheduleTargetSignal, oldName, name);
+                const oldName = getPlayerId();
+                await handle.signal('setName', name);
+                setPlayerId(name);
+                // Notify the scheduler to rewrite schedule targets from old name to new name
+                try {
+                    const schedulerHandle = client.workflow.getHandle((0, config_1.schedulerWorkflowId)(config.ensemble));
+                    await schedulerHandle.signal(scheduler_signals_1.updateScheduleTargetSignal, oldName, name);
+                }
+                catch {
+                    // Scheduler may not be running — that's fine, no schedules to update
+                    log(`No scheduler to notify about rename ${oldName} → ${name}`);
+                }
+                return (0, descriptor_1.ok)(`Session name set to **${name}**. Run \`/rename ${name}\` to match your Claude Code session name.`);
             }
-            catch {
-                // Scheduler may not be running — that's fine, no schedules to update
-                log(`No scheduler to notify about rename ${oldName} → ${name}`);
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to set name: ${(0, descriptor_1.formatError)(err)}`);
             }
-            return (0, helpers_1.ok)(`Session name set to **${name}**. Run \`/rename ${name}\` to match your Claude Code session name.`);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to set name: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+        },
+    };
 }

package/dist/tools/set-part.d.ts

@@ -1,3 +1,3 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { WorkflowHandle } from '@temporalio/client';
-export declare function registerSetPartTool(server: McpServer, handle: WorkflowHandle): void;
+import { type TempoToolDescriptor } from './descriptor';
+export declare function buildSetPartTool(handle: WorkflowHandle): TempoToolDescriptor;

package/dist/tools/set-part.js

@@ -1,20 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerSetPartTool = registerSetPartTool;
+exports.buildSetPartTool = buildSetPartTool;
 const zod_1 = require("zod");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 const validation_1 = require("../utils/validation");
-function registerSetPartTool(server, handle) {
-    (0, helpers_1.defineTool)(server, 'set_part', 'Update your description of what you are currently working on. Visible to other sessions via ensemble.', {
-        part: zod_1.z.string().max(validation_1.PART_MAX).describe('A short description of your current work'),
-    }, async (args) => {
-        const { part } = args;
-        try {
-            await handle.signal('setPart', part);
-            return (0, helpers_1.ok)(`Part updated: "${part}"`);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to update part: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+function buildSetPartTool(handle) {
+    return {
+        name: 'set_part',
+        description: 'Update your description of what you are currently working on. Visible to other sessions via ensemble.',
+        params: {
+            part: zod_1.z.string().max(validation_1.PART_MAX).describe('A short description of your current work'),
+        },
+        handler: async (args) => {
+            const { part } = args;
+            try {
+                await handle.signal('setPart', part);
+                return (0, descriptor_1.ok)(`Part updated: "${part}"`);
+            }
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to update part: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

package/dist/tools/shutdown.d.ts

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