agent-tempo 1.0.1

package/dist/tools/schedule.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerScheduleTool = registerScheduleTool;
+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 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.`;
+                }
+            }
+            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, 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}`);
+            }
+            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".`);
+            }
+            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.`);
+            }
+            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.`);
+                }
+                nextFireAt = next.getTime();
+            }
+            catch (err) {
+                return (0, helpers_1.fail)(`Invalid cron expression "${cron}": ${(0, helpers_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}`);
+            }
+            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
+            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, 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

@@ -0,0 +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;

package/dist/tools/schedules.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSchedulesTool = registerSchedulesTool;
+const client_1 = require("@temporalio/client");
+const config_1 = require("../config");
+const helpers_1 = require("./helpers");
+function formatDuration(ms) {
+    if (ms >= 86_400_000)
+        return `${ms / 86_400_000}d`;
+    if (ms >= 3_600_000)
+        return `${ms / 3_600_000}h`;
+    if (ms >= 60_000)
+        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;
+            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.');
+                }
+                throw err;
+            }
+            if (schedules.length === 0) {
+                return (0, helpers_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, 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

@@ -0,0 +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;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSetEnsembleDescriptionTool = registerSetEnsembleDescriptionTool;
+/**
+ * `set_ensemble_description` MCP tool — #399 W1 (Q5.1).
+ *
+ * Updates the per-ensemble maestro's mission-flavor description string,
+ * surfaced on the dashboard EnsembleCard. Conductors are encouraged to
+ * keep updates milestone-flavored (~80 chars) — see
+ * `examples/agents/tempo-conductor.md`.
+ */
+const zod_1 = require("zod");
+const config_1 = require("../config");
+const maestro_signals_1 = require("../workflows/maestro-signals");
+const helpers_1 = require("./helpers");
+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.`);
+            }
+            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)}`);
+        }
+    });
+}

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

@@ -0,0 +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;

package/dist/tools/set-name.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSetNameTool = registerSetNameTool;
+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 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
+            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, 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

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

package/dist/tools/set-part.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSetPartTool = registerSetPartTool;
+const zod_1 = require("zod");
+const helpers_1 = require("./helpers");
+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)}`);
+        }
+    });
+}

package/dist/tools/shutdown.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 registerShutdownTool(server: McpServer, client: Client, config: Config, getPlayerId: () => string): void;

package/dist/tools/shutdown.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerShutdownTool = registerShutdownTool;
+/**
+ * `shutdown` — graceful ensemble-wide teardown (#287).
+ *
+ * Fan-out peer to `pause` / `play`: walks every session in the ensemble and
+ * requests a graceful detach, then pauses the scheduler + maestro so no new
+ * work fires while the adapters drain. Workflows survive — pair with
+ * `restore` to reattach, or `destroy` (ensemble-scope) for terminal teardown.
+ *
+ * The per-session fan-out uses `signalAllSessions` so every detach runs in
+ * parallel; a slow / dead session can't block peers from draining.
+ */
+const zod_1 = require("zod");
+const signals_1 = require("../workflows/signals");
+const helpers_1 = require("./helpers");
+const validation_1 = require("../utils/validation");
+const ensemble_ops_1 = require("../utils/ensemble-ops");
+const log = (...args) => console.error('[agent-tempo:shutdown]', ...args);
+function registerShutdownTool(server, client, config, getPlayerId) {
+    (0, helpers_1.defineTool)(server, 'shutdown', 'Gracefully shut down the ensemble: request detach on every session, pause the scheduler, and pause the maestro. Workflows survive in `detached` phase. Pair with `restore` to come back up, or `destroy` (no player arg) to terminate. Does not touch your own session.', {
+        deadlineMs: zod_1.z.number().min(0).max(validation_1.MAX_DETACH_DEADLINE_MS).optional().describe(`Max drain time per session before force-detach (default ${validation_1.DEFAULT_RESTART_DETACH_DEADLINE_MS}, max ${validation_1.MAX_DETACH_DEADLINE_MS}).`),
+    }, async (args) => {
+        const { deadlineMs = validation_1.DEFAULT_RESTART_DETACH_DEADLINE_MS } = args;
+        const callerId = getPlayerId();
+        try {
+            // Pause maestro + scheduler in parallel with the session fan-out —
+            // they're independent and draining adapters won't mind if the
+            // scheduler keeps firing for a few ms longer.
+            const [toggle, fanout] = await Promise.all([
+                (0, ensemble_ops_1.pauseMaestroAndScheduler)(client, config.ensemble),
+                (0, ensemble_ops_1.signalAllSessions)(client, config.ensemble, signals_1.requestDetachSignal.name, { reason: 'user-stop', deadlineMs }, { skip: (playerId) => playerId === callerId }),
+            ]);
+            const summaryLine = `${fanout.sent} detaching, ${fanout.skipped} skipped, ${fanout.failed} failed`;
+            const bits = [`Ensemble **${config.ensemble}** shutting down.`, summaryLine];
+            if (toggle.maestro)
+                bits.push('maestro paused');
+            if (toggle.scheduler)
+                bits.push('scheduler paused');
+            if (fanout.failed > 0) {
+                const errs = fanout.perSession
+                    .filter((p) => p.outcome === 'failed')
+                    .map((p) => `  - ${p.playerId}: ${'error' in p ? p.error : ''}`);
+                bits.push(`Errors:\n${errs.join('\n')}`);
+            }
+            log(`Shutdown requested by ${callerId} in "${config.ensemble}": ${summaryLine}`);
+            return (0, helpers_1.ok)(bits.join('\n'));
+        }
+        catch (err) {
+            return (0, helpers_1.fail)(`Failed to shut down ensemble: ${(0, helpers_1.formatError)(err)}`);
+        }
+    });
+}

package/dist/tools/stage.d.ts

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

package/dist/tools/stage.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStageTool = registerStageTool;
+const zod_1 = require("zod");
+const helpers_1 = require("./helpers");
+const validation_1 = require("../utils/validation");
+function registerStageTool(server, handle, getPlayerId) {
+    (0, helpers_1.defineTool)(server, 'stage', 'Create a pipeline stage tracking N players. When all players report, a completion message is auto-injected. Conductor only.', {
+        name: zod_1.z.string().max(validation_1.STAGE_NAME_MAX).describe('Unique stage name (e.g. "code-review", "testing")'),
+        players: zod_1.z.array(zod_1.z.string().regex(validation_1.PLAYER_NAME_REGEX)).min(1).max(validation_1.STAGE_PLAYERS_MAX).describe('Player names to track in this stage'),
+        failurePolicy: zod_1.z.enum(['halt', 'continue']).optional().describe('What to do when a player reports a blocker. "halt" (default) fails the stage immediately; "continue" waits for all players.'),
+    }, async (args) => {
+        const { name, players, failurePolicy } = args;
+        try {
+            await handle.signal('setStage', {
+                name,
+                players,
+                failurePolicy,
+                createdBy: getPlayerId(),
+            });
+            const playerList = players.map((p) => `  - ${p}`).join('\n');
+            return (0, helpers_1.ok)(`Stage **${name}** created tracking ${players.length} player(s) [policy: ${failurePolicy || 'halt'}]:\n${playerList}`);
+        }
+        catch (err) {
+            return (0, helpers_1.fail)(`Failed to create stage: ${(0, helpers_1.formatError)(err)}`);
+        }
+    });
+}

package/dist/tools/stages.d.ts

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

package/dist/tools/stages.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStagesTool = registerStagesTool;
+const helpers_1 = require("./helpers");
+function registerStagesTool(server, handle) {
+    (0, helpers_1.defineTool)(server, 'stages', 'List all pipeline stages and their status. Shows which players have reported, who is still waiting, and stage completion status. Conductor only.', {}, async () => {
+        try {
+            const stages = await handle.query('stages');
+            if (stages.length === 0) {
+                return (0, helpers_1.ok)('No stages defined.');
+            }
+            const lines = stages.map((s) => {
+                const statusIcon = s.status === 'complete' ? '\u2714'
+                    : s.status === 'failed' ? '\u2718'
+                        : s.status === 'cancelled' ? '\u2212'
+                            : '\u25CB';
+                const playerLines = s.players.map((p) => {
+                    const pIcon = p.status === 'reported' ? '\u2714'
+                        : p.status === 'blocked' ? '\u2718'
+                            : '\u25CB';
+                    const detail = p.reportedAt ? ` (${p.reportType})` : '';
+                    return `    ${pIcon} ${p.playerId}${detail}`;
+                });
+                return [
+                    `${statusIcon} **${s.name}** [${s.status}] (policy: ${s.failurePolicy})`,
+                    ...playerLines,
+                ].join('\n');
+            });
+            return (0, helpers_1.ok)(lines.join('\n\n'));
+        }
+        catch (err) {
+            return (0, helpers_1.fail)(`Failed to query stages: ${(0, helpers_1.formatError)(err)}`);
+        }
+    });
+}

package/dist/tools/stop.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { Client, WorkflowHandle } from '@temporalio/client';
+import type { Config } from '../config';
+export declare function registerStopTool(_server: McpServer, _client: Client, _config: Config, _getPlayerId: () => string, _handle: WorkflowHandle): void;

package/dist/tools/stop.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStopTool = registerStopTool;
+/**
+ * `stop` — deprecation shim (PR-D).
+ *
+ * The `stop` verb is retired in v0.25 per design §8.1 "three verbs". Its two
+ * distinct semantics are now separate tools:
+ *   - graceful reap of the adapter, workflow survives → `detach`
+ *   - terminal teardown of the workflow → `destroy`
+ *
+ * The MCP tool remains registered (so existing clients discover it via
+ * ListTools) but returns an `isError` result pointing to the replacement.
+ * The CLI-level `claude-tempo stop` command is unchanged — it's still useful
+ * for bulk cleanup (ensemble-wide or `--all`).
+ */
+const zod_1 = require("zod");
+const helpers_1 = require("./helpers");
+function registerStopTool(_server, _client, _config, _getPlayerId, _handle) {
+    (0, helpers_1.defineTool)(_server, 'stop', '[deprecated in v0.25] The `stop` verb was split into `detach` (graceful adapter reap, workflow survives) and `destroy` (terminal teardown). This tool now returns an error pointing you to the right one.', {
+        playerId: zod_1.z.string().describe('The player name to stop'),
+        force: zod_1.z.boolean().optional().describe('Legacy force flag — no longer honored'),
+    }, async () => {
+        return (0, helpers_1.fail)('The `stop` tool is deprecated. Use:\n' +
+            '  • `detach` — gracefully reap the adapter; workflow survives (use this for most cases)\n' +
+            '  • `destroy` — terminally end the workflow; abandons in-flight outbox\n' +
+            '  • `restart` — reap + claim a fresh adapter with context replay');
+    });
+}

package/dist/tools/unschedule.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 registerUnscheduleTool(server: McpServer, client: Client, config: Config): void;

package/dist/tools/unschedule.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUnscheduleTool = registerUnscheduleTool;
+const zod_1 = require("zod");
+const common_1 = require("@temporalio/common");
+const config_1 = require("../config");
+const helpers_1 = require("./helpers");
+function registerUnscheduleTool(server, client, config) {
+    (0, helpers_1.defineTool)(server, 'unschedule', 'Remove a named schedule. The schedule stops firing immediately.', {
+        name: zod_1.z.string().describe('Name of the schedule to remove'),
+    }, async (args) => {
+        const { name } = args;
+        try {
+            const wfId = (0, config_1.schedulerWorkflowId)(config.ensemble);
+            const handle = client.workflow.getHandle(wfId);
+            // Check if the scheduler workflow is running before signaling.
+            // Only treat WorkflowNotFoundError as "no scheduler" — other errors (network, etc.)
+            // should propagate so callers get an accurate error message.
+            try {
+                await handle.describe();
+            }
+            catch (err) {
+                if (err instanceof common_1.WorkflowNotFoundError) {
+                    return (0, helpers_1.ok)('No scheduler is running — there are no schedules to remove.');
+                }
+                throw err;
+            }
+            await handle.signal('removeSchedule', name);
+            return (0, helpers_1.ok)(`Schedule **${name}** removed.`);
+        }
+        catch (err) {
+            return (0, helpers_1.fail)(`Failed to remove schedule: ${(0, helpers_1.formatError)(err)}`);
+        }
+    });
+}

package/dist/tools/who-am-i.d.ts

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

package/dist/tools/who-am-i.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWhoAmITool = registerWhoAmITool;
+const helpers_1 = require("./helpers");
+function registerWhoAmITool(server, handle, getPlayerId) {
+    (0, helpers_1.defineTool)(server, 'who_am_i', 'Get your identity, role, and session details', {}, async () => {
+        const metadata = await handle.query('getMetadata');
+        const part = await handle.query('getPart');
+        // Attachment phase is authoritative post-#175/#176 (replaced legacy status).
+        let phase;
+        try {
+            const info = await handle.query('attachmentInfo');
+            phase = info.phase;
+        }
+        catch {
+            // Older workflows pre-dating the attachment lifecycle may not support this query.
+            phase = undefined;
+        }
+        const lines = [
+            `**Name:** ${metadata.playerId}`,
+            metadata.playerType ? `**Type:** ${metadata.playerType}` : null,
+            metadata.playerTypeDescription ? `**Description:** ${metadata.playerTypeDescription}` : null,
+            `**Ensemble:** ${metadata.ensemble}`,
+            `**Role:** ${metadata.isConductor ? 'Conductor' : 'Player'}`,
+            metadata.recruitedBy ? `**Recruited by:** ${metadata.recruitedBy}` : null,
+            `**Part:** ${part}`,
+            `**Directory:** ${metadata.workDir}`,
+            `**Host:** ${metadata.hostname}`,
+            metadata.gitBranch ? `**Branch:** ${metadata.gitBranch}` : null,
+            `**Phase:** ${phase ?? 'unknown'}`,
+        ].filter(Boolean);
+        return (0, helpers_1.ok)(lines.join('\n'));
+    });
+}

package/dist/tools/worktree.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 registerWorktreeTool(server: McpServer, client: Client, config: Config, handle: WorkflowHandle, getPlayerId: () => string): void;