claude-tempo 0.5.0 → 0.6.0

package/README.md

@@ -94,7 +94,7 @@ claude-tempo <command> [options]
 | `up [ensemble]` | First-time setup: start Temporal, configure MCP, launch conductor |
 | `down` | Stop Temporal, terminate sessions, remove MCP config |
 | `server` | Start the Temporal dev server and register search attributes |
-| `conduct [ensemble]` | Start a conductor session (one per ensemble) |
+| `conduct [ensemble]` | Start a conductor session (one per ensemble). Use `--resume` or `--replace` if one exists. |
 | `start [ensemble]` | Start a player session |
 | `status [ensemble]` | Show active sessions and Temporal health |
 | `config` | Configure Temporal connection settings (interactive or `set`/`show`) |
@@ -115,6 +115,8 @@ claude-tempo <command> [options]
 --skip-preflight              Skip preflight checks (start/conduct)
 -d, --dir <path>              Target directory (default: cwd)
 --background                  Run Temporal in background (server only)
+--resume                      Resume an existing conductor session (conduct only)
+--replace                     Stop existing conductor and start fresh (conduct only)
 ```
 
 ### `claude-tempo up`
@@ -173,6 +175,9 @@ Ensemble: myband
   bob
     Working on the dashboard
     /Users/me/projects/app  feat/ui  my-machine.local
+
+  1 active schedule
+  deploy-watch → ops | every 1h | next: 3:00:00 PM
 ```
 
 ### `claude-tempo preflight`
@@ -201,9 +206,43 @@ These tools are available inside Claude Code sessions connected to claude-tempo:
 | `set_name` | Set a human-readable name for this session. |
 | `set_part` | Describe what you're working on. Visible to others via `ensemble`. |
 | `listen` | Manually check for pending messages. |
-| `recruit` | Spawn a new Claude Code session in a directory. Opens a new terminal window. |
+| `recruit` | Spawn a new Claude Code session in a directory. Can recruit a conductor with `conductor: true`. |
 | `report` | Send updates to the conductor. No-op if no conductor exists. |
 | `terminate` | Terminate a player session by name. |
+| `schedule` | Create a one-shot or recurring schedule to cue a player. |
+| `unschedule` | Cancel a named schedule. |
+| `schedules` | List all active schedules. |
+
+## Scheduling
+
+Players can set up schedules to send messages on timers — useful for periodic checks, reminders, and recurring coordination.
+
+Three tools are available:
+- **`schedule`** — Create a named schedule (one-shot or recurring)
+- **`unschedule`** — Remove a schedule by name
+- **`schedules`** — List all active schedules
+
+### Examples
+
+Tell your session things like:
+
+- *"Schedule a check every hour called 'deploy-watch' — cue ops to check deployment status"*
+- *"Remind me in 30 minutes to review PR #42"*
+- *"Every 5 minutes for the next hour, ping frontend to check their progress"*
+- *"Set up a daily standup reminder at 9am UTC for the conductor"*
+- *"Cancel the deploy-watch schedule"*
+- *"Show me all active schedules"*
+
+Schedules support one-shot delays, fixed times, and recurring intervals with optional bounds (max count or end time).
+
+### How it works
+
+- Scheduled messages arrive with a `[scheduled: name]` prefix so recipients can distinguish them from direct cues
+- The `from` field is set to the schedule creator, so replies go to the right person
+- If the target player is gone when a schedule fires, the creator is notified so they can re-recruit if needed. Falls back to notifying the conductor if the creator is also unavailable
+- Messages include `isScheduled` metadata for dashboard integrations
+- `claude-tempo status` shows active schedules alongside sessions
+- A single durable scheduler workflow per ensemble manages all schedules using Temporal timers
 
 ## Conductors
 
@@ -274,11 +313,12 @@ Inside a session, try:
 
 Sessions start with a random 8-character hex ID. Set a name at launch with `-n` or use `set_name` inside a session.
 
-- Names are stored as Temporal search attributes (`ClaudeTempoPlayerId`)
+- Names are stored in workflow metadata and discoverable via metadata queries. Search attributes are also set for Temporal UI visibility.
 - Other players use names to send messages via `cue`
 - `recruit` automatically tells new sessions to set their name
 - Names must be unique within an ensemble
 - Names must contain only letters, numbers, hyphens, and underscores
+- The name "conductor" is reserved for conductor sessions
 
 ### Terminal support
 

package/dist/activities/schedule-fire.d.ts

@@ -0,0 +1,21 @@
+import { Client } from '@temporalio/client';
+export interface FireScheduleInput {
+    ensemble: string;
+    scheduleName: string;
+    message: string;
+    target: string;
+    createdBy: string;
+}
+export interface FireScheduleResult {
+    success: boolean;
+    error?: string;
+}
+/** Activity interface — used by proxyActivities in the scheduler workflow. */
+export interface ScheduleActivities {
+    fireSchedule(input: FireScheduleInput): Promise<FireScheduleResult>;
+}
+/**
+ * Create the schedule-fire activity bound to a Temporal client.
+ * The returned object is registered with the worker as activities.
+ */
+export declare function createScheduleActivities(client: Client): ScheduleActivities;

package/dist/activities/schedule-fire.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScheduleActivities = createScheduleActivities;
+/**
+ * Create the schedule-fire activity bound to a Temporal client.
+ * The returned object is registered with the worker as activities.
+ */
+function createScheduleActivities(client) {
+    return {
+        async fireSchedule(input) {
+            const { ensemble, scheduleName, message, target, createdBy } = input;
+            try {
+                // Resolve target player by querying running session workflows
+                const handle = await resolveSession(client, ensemble, target);
+                if (!handle) {
+                    // Notify the creator (or conductor as fallback) about the failure
+                    await notifyFailure(client, ensemble, createdBy, scheduleName, target, `Player "${target}" not found — session may have been terminated.`);
+                    return { success: false, error: `No active session found for "${target}"` };
+                }
+                // Send cue signal with from set to the original creator's name
+                const text = `[scheduled: ${scheduleName}] ${message}`;
+                await handle.signal('receiveMessage', {
+                    from: createdBy,
+                    text,
+                    isScheduled: true,
+                    scheduleName,
+                });
+                return { success: true };
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                return { success: false, error: errorMsg };
+            }
+        },
+    };
+}
+/**
+ * Notify the schedule creator (or conductor as fallback) that delivery failed.
+ * This lets the creator's AI session decide whether to re-recruit the target.
+ */
+async function notifyFailure(client, ensemble, createdBy, scheduleName, target, reason) {
+    const failureText = `[scheduled: ${scheduleName}] Delivery to "${target}" failed — ${reason}`;
+    // Try the creator first
+    const creatorHandle = await resolveSession(client, ensemble, createdBy);
+    if (creatorHandle) {
+        try {
+            await creatorHandle.signal('receiveMessage', {
+                from: 'scheduler',
+                text: failureText,
+                isScheduled: true,
+                scheduleName,
+            });
+            return;
+        }
+        catch {
+            // creator signal failed, fall through to conductor
+        }
+    }
+    // Fallback: notify the conductor
+    try {
+        const conductorId = `claude-session-${ensemble}-conductor`;
+        const conductorHandle = client.workflow.getHandle(conductorId);
+        await conductorHandle.signal('receiveMessage', {
+            from: 'scheduler',
+            text: failureText,
+            isScheduled: true,
+            scheduleName,
+        });
+    }
+    catch {
+        // Nobody available to notify — logged by the workflow
+    }
+}
+/**
+ * Resolve a session by player name — mirrors src/tools/resolve.ts logic.
+ * We duplicate here because activities run in Node.js and need their own copy.
+ */
+async function resolveSession(client, ensemble, playerName) {
+    const query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"`;
+    for await (const wf of client.workflow.list({ query })) {
+        try {
+            const handle = client.workflow.getHandle(wf.workflowId);
+            const metadata = await handle.query('getMetadata');
+            if (metadata.ensemble === ensemble && metadata.playerId === playerName) {
+                return handle;
+            }
+        }
+        catch {
+            // Workflow may have just completed — skip
+        }
+    }
+    return null;
+}

package/dist/cli/commands.js

@@ -55,6 +55,15 @@ const mcp_1 = require("./mcp");
 const out = __importStar(require("./output"));
 /** Package root is two levels up from dist/cli/ */
 const PACKAGE_ROOT = (0, path_1.resolve)(__dirname, '..', '..');
+function formatDurationMs(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`;
+}
 async function start(opts) {
     const config = (0, config_1.getConfig)(opts);
     const workDir = opts.dir || process.cwd();
@@ -221,8 +230,27 @@ async function status(opts) {
             // workflow may have closed between list and query
         }
     }
+    // Query scheduler workflows for active schedules
+    const schedulesByEnsemble = new Map();
+    const schedulerQuery = 'WorkflowType = "claudeSchedulerWorkflow" AND ExecutionStatus = "Running"';
+    for await (const wf of client.workflow.list({ query: schedulerQuery })) {
+        try {
+            const handle = client.workflow.getHandle(wf.workflowId);
+            const entries = await handle.query('getSchedules');
+            if (entries.length > 0) {
+                // Extract ensemble from workflow ID: claude-scheduler-{ensemble}
+                const ensemble = wf.workflowId.replace('claude-scheduler-', '');
+                if (opts.ensemble && ensemble !== opts.ensemble)
+                    continue;
+                schedulesByEnsemble.set(ensemble, entries);
+            }
+        }
+        catch {
+            // scheduler may have just completed
+        }
+    }
     await connection.close();
-    if (sessions.length === 0) {
+    if (sessions.length === 0 && schedulesByEnsemble.size === 0) {
         out.log(opts.ensemble
             ? `No active sessions in ensemble "${opts.ensemble}".`
             : 'No active sessions found.');
@@ -256,6 +284,23 @@ async function status(opts) {
             if (details)
                 out.log(`    ${out.dim(details)}`);
         }
+        // Show schedules for this ensemble
+        const ensembleSchedules = schedulesByEnsemble.get(ensemble);
+        if (ensembleSchedules && ensembleSchedules.length > 0) {
+            console.log();
+            out.log(`  ${out.dim(`${ensembleSchedules.length} active schedule${ensembleSchedules.length !== 1 ? 's' : ''}`)}`);
+            for (const sched of ensembleSchedules) {
+                const recur = sched.interval
+                    ? `every ${formatDurationMs(sched.interval)}`
+                    : 'one-shot';
+                const next = new Date(sched.nextFireAt).toLocaleTimeString();
+                const bounds = [];
+                if (sched.remainingCount != null)
+                    bounds.push(`${sched.firedCount}/${sched.firedCount + sched.remainingCount} fired`);
+                const boundsStr = bounds.length ? ` (${bounds.join(', ')})` : '';
+                out.log(`  ${out.bold(sched.name)} → ${sched.target} | ${recur}${boundsStr} | next: ${next}`);
+            }
+        }
     }
     console.log();
 }

package/dist/config.d.ts

@@ -89,3 +89,5 @@ export declare function getConfigWithSources(overrides?: CliOverrides): ConfigWi
 export declare function sessionWorkflowId(ensemble: string, playerId: string): string;
 /** Build a workflow ID for a conductor: claude-session-{ensemble}-conductor */
 export declare function conductorWorkflowId(ensemble: string): string;
+/** Build a workflow ID for the scheduler: claude-scheduler-{ensemble} */
+export declare function schedulerWorkflowId(ensemble: string): string;

package/dist/config.js

@@ -9,6 +9,7 @@ exports.getConfig = getConfig;
 exports.getConfigWithSources = getConfigWithSources;
 exports.sessionWorkflowId = sessionWorkflowId;
 exports.conductorWorkflowId = conductorWorkflowId;
+exports.schedulerWorkflowId = schedulerWorkflowId;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const os_1 = require("os");
@@ -246,3 +247,7 @@ function sessionWorkflowId(ensemble, playerId) {
 function conductorWorkflowId(ensemble) {
     return `claude-session-${ensemble}-conductor`;
 }
+/** Build a workflow ID for the scheduler: claude-scheduler-{ensemble} */
+function schedulerWorkflowId(ensemble) {
+    return `claude-scheduler-${ensemble}`;
+}

package/dist/server.js

@@ -52,6 +52,9 @@ const recruit_1 = require("./tools/recruit");
 const report_1 = require("./tools/report");
 const terminate_1 = require("./tools/terminate");
 const set_name_1 = require("./tools/set-name");
+const schedule_1 = require("./tools/schedule");
+const unschedule_1 = require("./tools/unschedule");
+const schedules_1 = require("./tools/schedules");
 const channel_1 = require("./channel");
 const log = (...args) => console.error('[claude-tempo]', ...args);
 function getGitInfo(workDir) {
@@ -160,11 +163,13 @@ async function main() {
         }
     }
     // Create MCP server
+    const hasRequestedName = Boolean(requestedName && requestedName !== 'conductor');
     const serverInstructions = `You are part of the "${config.ensemble}" ensemble of Claude Code sessions coordinated via Temporal. ` +
-        `Your temporary player ID is "${playerId}". ` +
-        `IMPORTANT: If you receive a message instructing you to call \`set_name\`, do so immediately before anything else. ` +
+        `Your player name is "${playerId}". ` +
+        (hasRequestedName
+            ? `This name was assigned at startup — do NOT call \`set_name\` unless explicitly asked to rename. `
+            : `IMPORTANT: If you receive a message instructing you to call \`set_name\`, do so immediately before anything else. Use \`set_name\` to give yourself a human-readable name. `) +
         `When you receive a message from another session, treat it like a coworker asking for help — respond promptly, then resume your work. ` +
-        `Use \`set_name\` to give yourself a human-readable name. ` +
         `Use \`ensemble\` to see who else is active. ` +
         `Use \`cue\` to reply directly to the player who messaged you, or to ask others for help. ` +
         `Use \`recruit\` if you need a session in a directory where none exists. ` +
@@ -187,6 +192,9 @@ async function main() {
     (0, recruit_1.registerRecruitTool)(mcpServer, client, config, getPlayerId, isBridgeMode ? 'copilot' : 'claude');
     (0, report_1.registerReportTool)(mcpServer, client, config, getPlayerId);
     (0, terminate_1.registerTerminateTool)(mcpServer, client, config, getPlayerId);
+    (0, schedule_1.registerScheduleTool)(mcpServer, client, config, getPlayerId);
+    (0, unschedule_1.registerUnscheduleTool)(mcpServer, client, config);
+    (0, schedules_1.registerSchedulesTool)(mcpServer, client, config);
     const MAESTRO_ACK = '\n\n[IMPORTANT: This message is from a human (Maestro). Immediately cue the sender back with a brief acknowledgment and your planned next step before doing the work.]';
     // Start message poller — push messages into Claude Code via channel notifications.
     // Skip when running under the Copilot bridge: the bridge has its own poller that

package/dist/tools/recruit.js

@@ -140,20 +140,11 @@ function registerRecruitTool(server, client, config, getPlayerId, ownAgentType =
                 };
             }
             const newHandle = client.workflow.getHandle(newWorkflowId);
-            // For copilot agent, the bridge handles set_name automatically.
-            // For claude agent, send a message instructing it to set its name.
-            if (agent === 'claude') {
-                const nameInstruction = `You have been recruited as "${name}". Call set_name("${name}") immediately.`;
-                const fullMessage = initialMessage
-                    ? `${nameInstruction}\n\nThen: ${initialMessage}`
-                    : nameInstruction;
-                await newHandle.signal('receiveMessage', {
-                    from: getPlayerId(),
-                    text: fullMessage,
-                });
-            }
-            else if (initialMessage) {
-                // For copilot, just send the initial task (name is set by the bridge)
+            // Name is already set via CLAUDE_TEMPO_PLAYER_NAME env var at startup,
+            // so we only need to send the initial task message if provided.
+            // (Previously we sent a set_name instruction here, but that was redundant
+            // and could cause confusion if the LLM renamed itself incorrectly.)
+            if (initialMessage) {
                 await newHandle.signal('receiveMessage', {
                     from: getPlayerId(),
                     text: initialMessage,

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

package/dist/tools/schedule.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerScheduleTool = registerScheduleTool;
+const zod_1 = require("zod");
+const client_1 = require("@temporalio/client");
+const config_1 = require("../config");
+const helpers_1 = require("./helpers");
+const log = (...args) => console.error('[claude-tempo:schedule]', ...args);
+/** Parse a duration string like "30s", "10m", "2h", "1d" into milliseconds. */
+function parseDuration(dur) {
+    const match = dur.match(/^(\d+(?:\.\d+)?)\s*(s|m|h|d)$/i);
+    if (!match)
+        return null;
+    const value = parseFloat(match[1]);
+    switch (match[2].toLowerCase()) {
+        case 's': return value * 1000;
+        case 'm': return value * 60_000;
+        case 'h': return value * 3_600_000;
+        case 'd': return value * 86_400_000;
+        default: return null;
+    }
+}
+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, or on a recurring interval.', {
+        name: zod_1.z.string().describe('Unique name for this schedule'),
+        message: zod_1.z.string().describe('The message to deliver'),
+        target: zod_1.z.string().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")'),
+        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, until, count } = args;
+        let target = args.target;
+        // Resolve "self" to the current player name
+        if (target === 'self') {
+            target = getPlayerId();
+        }
+        // Validate exactly one timing option
+        const timingCount = [at, delay, every].filter(Boolean).length;
+        if (timingCount !== 1) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: 'Provide exactly one timing option: `at`, `delay`, or `every`.',
+                    }],
+                isError: true,
+            };
+        }
+        const now = Date.now();
+        let nextFireAt;
+        let interval;
+        if (at) {
+            const ts = Date.parse(at);
+            if (isNaN(ts)) {
+                return {
+                    content: [{ type: 'text', text: `Invalid ISO datetime for "at": ${at}` }],
+                    isError: true,
+                };
+            }
+            nextFireAt = ts;
+        }
+        else if (delay) {
+            const ms = parseDuration(delay);
+            if (ms === null) {
+                return {
+                    content: [{ type: 'text', text: `Invalid duration for "delay": ${delay}. Use e.g. "30s", "10m", "2h", "1d".` }],
+                    isError: true,
+                };
+            }
+            nextFireAt = now + ms;
+        }
+        else {
+            // every (recurring)
+            const ms = parseDuration(every);
+            if (ms === null || ms < 10_000) {
+                return {
+                    content: [{ type: 'text', text: `Invalid or too-short interval for "every": ${every}. Minimum is 10s.` }],
+                    isError: true,
+                };
+            }
+            nextFireAt = now + ms;
+            interval = ms;
+        }
+        // Parse optional until
+        let untilMs;
+        if (until) {
+            const ts = Date.parse(until);
+            if (isNaN(ts)) {
+                return {
+                    content: [{ type: 'text', text: `Invalid ISO datetime for "until": ${until}` }],
+                    isError: true,
+                };
+            }
+            untilMs = ts;
+        }
+        const type = every ? 'interval' : 'once';
+        const scheduleEntry = {
+            name,
+            message,
+            target,
+            type,
+            nextFireAt: new Date(nextFireAt).toISOString(),
+            interval,
+            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('claudeSchedulerWorkflow', {
+                    workflowId: wfId,
+                    taskQueue: config.taskQueue,
+                    args: [{ ensemble: config.ensemble, entries: [scheduleEntry] }],
+                    workflowIdConflictPolicy: client_1.WorkflowIdConflictPolicy.USE_EXISTING,
+                    searchAttributes: {
+                        ClaudeTempoEnsemble: [config.ensemble],
+                    },
+                });
+                log(`Started scheduler workflow ${wfId}`);
+            }
+            const fireDate = new Date(nextFireAt).toISOString();
+            const recur = interval ? ` (repeating every ${every})` : ' (one-shot)';
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Schedule **${name}** created. Next fire: ${fireDate}${recur}. Target: ${target}.`,
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Failed to create schedule: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+}

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,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSchedulesTool = registerSchedulesTool;
+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 {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: 'No scheduler running — no schedules exist yet.',
+                        }],
+                };
+            }
+            if (schedules.length === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: 'No active schedules.',
+                        }],
+                };
+            }
+            const lines = schedules.map((s) => {
+                const next = s.nextFireAt; // already ISO string
+                const recur = 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 {
+                content: [{
+                        type: 'text',
+                        text: lines.join('\n'),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Failed to query schedules: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+}

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,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUnscheduleTool = registerUnscheduleTool;
+const zod_1 = require("zod");
+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);
+            await handle.signal('removeSchedule', name);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Schedule **${name}** removed.`,
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Failed to remove schedule: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/types.d.ts

@@ -57,3 +57,25 @@ export interface HistoryEntry {
     timestamp: string;
     data: Command | PlayerReport;
 }
+export interface ScheduleEntry {
+    /** Unique name for this schedule (used as key for add/replace/remove). */
+    name: string;
+    /** The message text to deliver when the schedule fires. */
+    message: string;
+    /** Target player name to deliver the cue to. */
+    target: string;
+    /** Player name of whoever created this schedule. */
+    createdBy: string;
+    /** ISO timestamp of the next fire time. */
+    nextFireAt: string;
+    /** Interval in milliseconds for repeating schedules. */
+    interval?: number;
+    /** ISO timestamp after which the schedule should be removed. */
+    until?: string;
+    /** Number of remaining fires (decremented each fire, removed at 0). */
+    remainingCount?: number;
+    /** Total number of times this schedule has fired. */
+    firedCount: number;
+    /** Schedule type for display purposes. */
+    type: 'once' | 'interval';
+}