claude-tempo 0.11.1 → 0.12.0

package/CLAUDE.md

@@ -9,7 +9,8 @@ claude-tempo is an MCP server that enables multiple Claude Code sessions to coor
 - **Runtime**: Node.js 18+ with TypeScript
 - **MCP**: `@modelcontextprotocol/sdk` (stdio transport)
 - **Temporal**: `@temporalio/client`, `@temporalio/worker`, `@temporalio/workflow`, `@temporalio/activity`
-- **No other dependencies** — no database, no custom broker
+- **croner** — cron expression parsing and next-fire computation (used by `schedule` tool)
+- **yaml**, **zod** — lineup parsing and schema validation
 
 ## Project Structure
 
@@ -111,9 +112,9 @@ npm test
 - **Broadcast**: Fan-out variant of `cue` — sends a message to all active players in the ensemble in a single call. Optionally filtered by player type. Skips the sender, pending sessions, and (by default) stale sessions.
 - **Recall**: Queries a session's own message history from the Temporal workflow. Shows received messages by default; pass `includeSent: true` to also see sent messages. Supports `limit`, `since`, and `from` filters.
 - **Per-host task queues**: Each host runs a `claude-tempo-{hostname}` activity worker for local-only operations (e.g., `spawnProcess`). This enables cross-machine recruiting — the `recruit` tool accepts an optional `host` parameter to route the spawn to a remote machine's task queue.
-- **Player types**: Reusable agent definitions in Claude Code's standard subagent format (`.md` files with YAML frontmatter). Ensemble lineups can reference types by name via a `type` field on players. Three-tier lookup: project `.claude/agents/` → user `~/.claude/agents/` → shipped `examples/agents/`. Players know their type via workflow metadata and the `who_am_i` tool.
+- **Player types**: Reusable agent definitions in Claude Code's standard subagent format (`.md` files with YAML frontmatter). Ensemble lineups can reference types by name via a `type` field on players. Three-tier lookup: project `.claude/agents/` → user `~/.claude/agents/` → shipped `examples/agents/`. Players know their type via workflow metadata and the `who_am_i` tool. Agent type frontmatter may include an `allowedTools` array to restrict which MCP/CLI tools the spawned session can use (e.g., `allowedTools: [Read, Glob, Grep]`). When present, the type's `allowedTools` overrides any lineup-level setting and is passed to the Claude Code session via `--allowedTools`.
 - **Agent type discovery**: The `agent_types` MCP tool and `claude-tempo agent-types` CLI command let conductors discover available player types. Shipped examples (tempo-conductor, tempo-composer, tempo-soloist, tempo-tuner, tempo-critic, tempo-roadie, tempo-improv, tempo-liner) work out of the box. Ensemble lineups: tempo-big-band (full lifecycle), tempo-dev-team (feature work), tempo-review-squad (parallel review), tempo-jam-session (exploration).
-- **Schedule**: A one-shot or recurring message delivery configured via the `schedule` tool. Backed by a durable `claudeSchedulerWorkflow` — survives restarts. Supports delay, cron-style intervals, and time-bounded delivery. Managed via `schedule`, `unschedule`, and `schedules` tools.
+- **Schedule**: A one-shot or recurring message delivery configured via the `schedule` tool. Backed by a durable `claudeSchedulerWorkflow` — survives restarts. Supports delay (`delay`), fixed time (`at`), recurring interval (`every`), and cron expressions (`cron`) with optional IANA timezone (`timezone`). Cron schedules use `croner` for expression parsing and next-fire computation. Managed via `schedule`, `unschedule`, and `schedules` tools.
 - **Lineup**: A YAML file defining an ensemble configuration — which players to recruit, their types, working directories, and optional startup messages. Load via `load_lineup` to bootstrap a full ensemble in one step; save via `save_lineup` to snapshot a running ensemble's state for later reuse.
 - **Wire protocol**: All Temporal signal, query, update, and workflow names are documented in [`docs/WIRE-PROTOCOL.md`](docs/WIRE-PROTOCOL.md). These names are stable as of v0.10 — renaming or removing any is a breaking change requiring a major version bump.
 

package/README.md

@@ -150,11 +150,20 @@ 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"*
+- *"Set up a daily standup at 9am New York time, weekdays only"*
 - *"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).
+Schedules support four timing modes — all accept optional bounds (`count` max fires, `until` end time):
+
+| Mode | Parameter | Example |
+|------|-----------|---------|
+| One-shot delay | `delay` | `"10m"`, `"2h"`, `"1d"` |
+| Fixed time | `at` | `"2026-04-03T20:00:00Z"` |
+| Recurring interval | `every` | `"5m"`, `"1h"` |
+| Cron expression | `cron` + optional `timezone` | `"0 9 * * 1-5"` (weekdays 9am) |
+
+The `timezone` parameter accepts any IANA timezone (e.g. `"America/New_York"`, `"Europe/London"`). Defaults to UTC when omitted.
 
 ### How it works
 
@@ -241,7 +250,7 @@ players:
 
 ## Player Types
 
-Player types are reusable agent definitions in Claude Code's standard subagent format — `.md` files with YAML frontmatter specifying name, description, and optional model. They let you define specialized roles once and reuse them across lineups.
+Player types are reusable agent definitions in Claude Code's standard subagent format — `.md` files with YAML frontmatter specifying name, description, optional model, and optional tool restrictions. They let you define specialized roles once and reuse them across lineups.
 
 ### How player types work
 
@@ -257,6 +266,23 @@ players:
 
 When a player is recruited with a type, the agent definition is resolved and passed to the session. Players know their type via the `who_am_i` tool.
 
+### Tool restrictions (`allowedTools`)
+
+Agent type frontmatter may include an `allowedTools` array to restrict which tools the spawned session can use. When present, it is passed to the Claude Code session via `--allowedTools` and overrides any lineup-level setting.
+
+```yaml
+---
+name: tempo-reviewer
+description: Read-only code reviewer
+allowedTools:
+  - Read
+  - Glob
+  - Grep
+---
+```
+
+This is useful for security-sensitive roles (read-only reviewers, auditors) or to prevent specific players from making changes outside their scope. Sessions launched without a type, or with a type that omits `allowedTools`, receive no tool restrictions.
+
 ### Three-tier lookup
 
 Player types are resolved in order (first match wins):

package/dist/activities/outbox.d.ts

@@ -30,6 +30,7 @@ export interface StartRecruitedSessionInput {
     taskQueue: string;
     agentDefinition?: string;
     agentDefinitionDescription?: string;
+    allowedTools?: string[];
 }
 export interface SpawnProcessInput {
     targetName: string;
@@ -45,6 +46,8 @@ export interface SpawnProcessInput {
     nativeResolvable?: boolean;
     /** When true, use --resume instead of -n (reconnect to existing session). */
     resume?: boolean;
+    /** Tool restrictions from the agent definition frontmatter. */
+    allowedTools?: string[];
 }
 export interface PerformEncoreInput {
     ensemble: string;
@@ -60,6 +63,7 @@ export interface EncoreResult {
     agentDefinition?: string;
     agentDefinitionPath?: string;
     nativeResolvable?: boolean;
+    allowedTools?: string[];
     temporalAddress: string;
     temporalNamespace: string;
 }

package/dist/activities/outbox.js

@@ -145,11 +145,14 @@ function createOutboxActivities(client, config) {
             }
         },
         async spawnProcess(input) {
-            const { targetName, workDir, isConductor, agent, systemPrompt, ensemble, temporalAddress, temporalNamespace, agentDefinition, agentDefinitionPath, nativeResolvable, resume } = input;
+            const { targetName, workDir, isConductor, agent, systemPrompt, ensemble, temporalAddress, temporalNamespace, agentDefinition, agentDefinitionPath, nativeResolvable, resume, allowedTools } = input;
             // Read secrets from the worker's config closure — never from workflow state
             const { temporalApiKey, temporalTlsCertPath, temporalTlsKeyPath } = config;
             try {
                 if (agent === 'copilot') {
+                    if (allowedTools && allowedTools.length > 0) {
+                        log(`Warning: allowedTools [${allowedTools.join(', ')}] specified for copilot agent "${targetName}" — copilot bridge does not support --allowedTools, skipping`);
+                    }
                     const { pid } = (0, spawn_1.spawnCopilotBridge)({
                         name: targetName,
                         ensemble,
@@ -177,11 +180,16 @@ function createOutboxActivities(client, config) {
                     }
                     // Use --resume for encore (reconnect to existing session) or -n for new sessions
                     const nameArgs = resume ? ['--resume', targetName] : ['-n', targetName];
+                    // Build --allowedTools flag from agent definition frontmatter
+                    const allowedToolsFlags = allowedTools && allowedTools.length > 0
+                        ? ['--allowedTools', ...allowedTools]
+                        : [];
                     const spawnArgs = [
                         '--dangerously-skip-permissions',
                         '--dangerously-load-development-channels', 'server:claude-tempo',
                         ...nameArgs,
                         ...agentFlags,
+                        ...allowedToolsFlags,
                     ];
                     const envVars = {
                         [config_2.ENV.ENSEMBLE]: ensemble,
@@ -249,12 +257,14 @@ function createOutboxActivities(client, config) {
                 const playerType = metadata.playerType;
                 let agentDefinitionPath;
                 let nativeResolvable;
+                let allowedTools;
                 if (playerType) {
                     try {
                         const info = (0, agent_types_1.resolveAgentType)(playerType);
                         if (info) {
                             agentDefinitionPath = info.path;
                             nativeResolvable = info.nativeResolvable;
+                            allowedTools = info.allowedTools;
                         }
                     }
                     catch {
@@ -269,6 +279,7 @@ function createOutboxActivities(client, config) {
                     agentDefinition: playerType,
                     agentDefinitionPath,
                     nativeResolvable,
+                    allowedTools,
                     temporalAddress: config.temporalAddress,
                     temporalNamespace: config.temporalNamespace,
                 };

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

@@ -10,9 +10,14 @@ export interface FireScheduleResult {
     success: boolean;
     error?: string;
 }
+export interface ComputeNextCronInput {
+    cronExpression: string;
+    timezone?: string;
+}
 /** Activity interface — used by proxyActivities in the scheduler workflow. */
 export interface ScheduleActivities {
     fireSchedule(input: FireScheduleInput): Promise<FireScheduleResult>;
+    computeNextCronFire(input: ComputeNextCronInput): Promise<string | null>;
 }
 /**
  * Create the schedule-fire activity bound to a Temporal client.

package/dist/activities/schedule-fire.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createScheduleActivities = createScheduleActivities;
+const croner_1 = require("croner");
 const config_1 = require("../config");
 const resolve_1 = require("./resolve");
 /**
@@ -9,6 +10,11 @@ const resolve_1 = require("./resolve");
  */
 function createScheduleActivities(client) {
     return {
+        async computeNextCronFire(input) {
+            const job = new croner_1.Cron(input.cronExpression, { timezone: input.timezone || 'UTC' });
+            const next = job.nextRun();
+            return next ? next.toISOString() : null;
+        },
         async fireSchedule(input) {
             const { ensemble, scheduleName, message, target, createdBy } = input;
             try {

package/dist/ensemble/agent-types.js

@@ -77,6 +77,7 @@ function listAgentTypes(cwd) {
                 source,
                 path: filePath,
                 nativeResolvable,
+                ...(Array.isArray(fm.allowedTools) ? { allowedTools: fm.allowedTools.map(String) } : {}),
             });
         }
     }
@@ -98,6 +99,7 @@ function resolveAgentType(name, cwd) {
             source,
             path: filePath,
             nativeResolvable,
+            ...(Array.isArray(fm.allowedTools) ? { allowedTools: fm.allowedTools.map(String) } : {}),
         };
     }
     return null;
@@ -120,6 +122,11 @@ function loadAndResolveLineup(filePath, cwd) {
         }
         player._agentDefinition = info.name;
         player._agentDefinitionPath = info.path;
+        // Type's allowedTools is the security authority — overrides lineup-level setting
+        // Empty array means "not specified" (no restriction), so don't override
+        if (info.allowedTools && info.allowedTools.length > 0) {
+            player.allowedTools = info.allowedTools;
+        }
     }
     return lineup;
 }

package/dist/ensemble/loader.js

@@ -45,8 +45,8 @@ function loadLineup(filePath) {
             if (typeof s.target !== 'string' || !s.target) {
                 throw new Error(`Invalid lineup: schedules[${i}].target is required`);
             }
-            if (!s.at && !s.delay && !s.every) {
-                throw new Error(`Invalid lineup: schedules[${i}] must have at least one of: at, delay, every`);
+            if (!s.at && !s.delay && !s.every && !s.cron) {
+                throw new Error(`Invalid lineup: schedules[${i}] must have at least one of: at, delay, every, cron`);
             }
         }
     }
@@ -60,6 +60,7 @@ function loadLineup(filePath) {
             ...(p.workDir != null && { workDir: p.workDir }),
             ...(p.agent != null && { agent: p.agent }),
             ...(p.instructions != null && { instructions: p.instructions }),
+            ...(Array.isArray(p.allowedTools) && { allowedTools: p.allowedTools.map(String) }),
         })),
         schedules: doc.schedules,
     };

package/dist/ensemble/saver.js

@@ -67,7 +67,12 @@ async function saveLineup(client, ensemble, filePath, name) {
                 message: entry.message,
                 target: entry.target,
             };
-            if (entry.interval) {
+            if (entry.cronExpression) {
+                sched.cron = entry.cronExpression;
+                if (entry.timezone)
+                    sched.timezone = entry.timezone;
+            }
+            else if (entry.interval) {
                 sched.every = formatDurationMs(entry.interval);
             }
             if (entry.until) {

package/dist/ensemble/schema.d.ts

@@ -12,6 +12,7 @@ export interface EnsembleLineup {
         workDir?: string;
         agent?: string;
         instructions?: string;
+        allowedTools?: string[];
         /** Transient: resolved agent definition name (set by loadAndResolveLineup). */
         _agentDefinition?: string;
         /** Transient: resolved absolute path to .md file (set by loadAndResolveLineup). */
@@ -24,6 +25,8 @@ export interface EnsembleLineup {
         at?: string;
         delay?: string;
         every?: string;
+        cron?: string;
+        timezone?: string;
         until?: string;
         count?: number;
     }>;

package/dist/tools/agent-types.js

@@ -11,7 +11,10 @@ function registerAgentTypesTool(server) {
         }
         const lines = types.map(t => {
             const src = t.source === 'shipped' ? '(shipped)' : t.source === 'user' ? '(user)' : '(project)';
-            return `**${t.name}** ${src}\n  ${t.description || 'No description'}`;
+            const tools = t.allowedTools && t.allowedTools.length > 0
+                ? `\n  Allowed tools: ${t.allowedTools.join(', ')}`
+                : '';
+            return `**${t.name}** ${src}\n  ${t.description || 'No description'}${tools}`;
         });
         return { content: [{ type: 'text', text: lines.join('\n\n') }] };
     });

package/dist/tools/load-lineup.js

@@ -4,6 +4,7 @@ exports.registerLoadLineupTool = registerLoadLineupTool;
 const zod_1 = require("zod");
 const fs_1 = require("fs");
 const path_1 = require("path");
+const croner_1 = require("croner");
 const client_1 = require("@temporalio/client");
 const config_1 = require("../config");
 const agent_types_1 = require("../ensemble/agent-types");
@@ -143,11 +144,16 @@ function registerLoadLineupTool(server, client, config, getPlayerId, ownAgentTyp
                         else if (systemPrompt) {
                             agentFlags = ['--system-prompt', systemPrompt];
                         }
+                        // Build --allowedTools flag from agent definition or lineup
+                        const allowedToolsFlags = player.allowedTools && player.allowedTools.length > 0
+                            ? ['--allowedTools', ...player.allowedTools]
+                            : [];
                         const spawnArgs = [
                             '--dangerously-skip-permissions',
                             '--dangerously-load-development-channels', 'server:claude-tempo',
                             '-n', playerName,
                             ...agentFlags,
+                            ...allowedToolsFlags,
                         ];
                         const envVars = {
                             [config_1.ENV.ENSEMBLE]: config.ensemble,
@@ -212,8 +218,17 @@ function registerLoadLineupTool(server, client, config, getPlayerId, ownAgentTyp
                         const now = Date.now();
                         let nextFireAt;
                         let interval;
+                        let cronExpression;
+                        let timezone;
                         if (sched.at) {
                             nextFireAt = Date.parse(sched.at);
+                            // Support at + every: use `at` as the initial fire time, `every` as the interval
+                            if (sched.every) {
+                                const ms = (0, duration_1.parseDuration)(sched.every);
+                                if (!ms)
+                                    throw new Error(`Invalid interval: ${sched.every}`);
+                                interval = ms;
+                            }
                         }
                         else if (sched.delay) {
                             const ms = (0, duration_1.parseDuration)(sched.delay);
@@ -228,16 +243,28 @@ function registerLoadLineupTool(server, client, config, getPlayerId, ownAgentTyp
                             nextFireAt = now + ms;
                             interval = ms;
                         }
+                        else if (sched.cron) {
+                            cronExpression = sched.cron;
+                            timezone = sched.timezone || 'UTC';
+                            const job = new croner_1.Cron(cronExpression, { timezone });
+                            const next = job.nextRun();
+                            if (!next)
+                                throw new Error(`Cron expression "${sched.cron}" has no upcoming fire time`);
+                            nextFireAt = next.getTime();
+                        }
                         else {
                             throw new Error('No timing specified');
                         }
+                        const type = sched.cron ? 'cron' : (sched.every || interval) ? 'interval' : 'once';
                         const scheduleEntry = {
                             name: sched.name,
                             message: sched.message,
                             target: sched.target,
-                            type: sched.every ? 'interval' : 'once',
+                            type,
                             nextFireAt: new Date(nextFireAt).toISOString(),
                             interval,
+                            cronExpression,
+                            timezone,
                             until: sched.until,
                             remainingCount: sched.count,
                             firedCount: 0,

package/dist/tools/recruit.js

@@ -36,6 +36,7 @@ function registerRecruitTool(server, client, config, getPlayerId, handle, ownAge
         let agentDefinitionPath;
         let agentDefinitionDescription;
         let nativeResolvable;
+        let allowedTools;
         if (agentTypeName) {
             const info = (0, agent_types_1.resolveAgentType)(agentTypeName);
             if (!info) {
@@ -52,6 +53,7 @@ function registerRecruitTool(server, client, config, getPlayerId, handle, ownAge
             agentDefinitionPath = info.path;
             agentDefinitionDescription = info.description;
             nativeResolvable = info.nativeResolvable;
+            allowedTools = info.allowedTools;
         }
         // Validate name
         const nameError = (0, validation_1.validatePlayerName)(name);
@@ -118,6 +120,7 @@ function registerRecruitTool(server, client, config, getPlayerId, handle, ownAge
                 agentDefinitionPath,
                 agentDefinitionDescription,
                 nativeResolvable,
+                allowedTools,
             };
             const entryId = await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
             return {

package/dist/tools/schedule.js

@@ -2,6 +2,7 @@
 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");
@@ -9,29 +10,41 @@ const helpers_1 = require("./helpers");
 const validation_1 = require("../utils/validation");
 const log = (...args) => console.error('[claude-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, or on a recurring interval.', {
+    (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, until, count } = 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 exactly one timing option
-        const timingCount = [at, delay, every].filter(Boolean).length;
+        const timingCount = [at, delay, every, cron].filter(Boolean).length;
         if (timingCount !== 1) {
             return {
                 content: [{
                         type: 'text',
-                        text: 'Provide exactly one timing option: `at`, `delay`, or `every`.',
+                        text: 'Provide exactly one timing option: `at`, `delay`, `every`, or `cron`.',
+                    }],
+                isError: true,
+            };
+        }
+        // timezone only valid with cron
+        if (timezone && !cron) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: '`timezone` can only be used with `cron`.',
                     }],
                 isError: true,
             };
@@ -59,8 +72,8 @@ function registerScheduleTool(server, client, config, getPlayerId) {
             }
             nextFireAt = now + ms;
         }
-        else {
-            // every (recurring)
+        else if (every) {
+            // every (recurring interval)
             const ms = (0, duration_1.parseDuration)(every);
             if (ms === null || ms < 10_000) {
                 return {
@@ -71,6 +84,27 @@ function registerScheduleTool(server, client, config, getPlayerId) {
             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 {
+                        content: [{ type: 'text', text: `Cron expression "${cron}" has no upcoming fire time.` }],
+                        isError: true,
+                    };
+                }
+                nextFireAt = next.getTime();
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: 'text', text: `Invalid cron expression "${cron}": ${msg}` }],
+                    isError: true,
+                };
+            }
+        }
         // Parse optional until
         let untilMs;
         if (until) {
@@ -83,7 +117,7 @@ function registerScheduleTool(server, client, config, getPlayerId) {
             }
             untilMs = ts;
         }
-        const type = every ? 'interval' : 'once';
+        const type = cron ? 'cron' : every ? 'interval' : 'once';
         const scheduleEntry = {
             name,
             message,
@@ -91,6 +125,8 @@ function registerScheduleTool(server, client, config, getPlayerId) {
             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,
@@ -118,7 +154,11 @@ function registerScheduleTool(server, client, config, getPlayerId) {
                 log(`Started scheduler workflow ${wfId}`);
             }
             const fireDate = new Date(nextFireAt).toISOString();
-            const recur = interval ? ` (repeating every ${every})` : ' (one-shot)';
+            const recur = cron
+                ? ` (cron: ${cron}, tz: ${timezone || 'UTC'})`
+                : interval
+                    ? ` (repeating every ${every})`
+                    : ' (one-shot)';
             return {
                 content: [{
                         type: 'text',

package/dist/tools/schedules.js

@@ -39,7 +39,9 @@ function registerSchedulesTool(server, client, config) {
             }
             const lines = schedules.map((s) => {
                 const next = s.nextFireAt; // already ISO string
-                const recur = s.interval ? `every ${formatDuration(s.interval)}` : 'one-shot';
+                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}`);

package/dist/types.d.ts

@@ -23,6 +23,7 @@ export interface AgentTypeInfo {
     source: 'project' | 'user' | 'shipped';
     path: string;
     nativeResolvable: boolean;
+    allowedTools?: string[];
 }
 export interface SessionInput {
     metadata: SessionMetadata;
@@ -110,6 +111,8 @@ export interface RecruitOutboxEntry extends OutboxEntryBase {
     agentDefinitionDescription?: string;
     /** Whether the agent definition is in a Claude Code-resolvable location. */
     nativeResolvable?: boolean;
+    /** Tool restrictions from the agent definition frontmatter. */
+    allowedTools?: string[];
 }
 export interface ReportOutboxEntry extends OutboxEntryBase {
     type: 'report';
@@ -151,6 +154,10 @@ export interface ScheduleEntry {
     /** Total number of times this schedule has fired. */
     firedCount: number;
     /** Schedule type for display purposes. */
-    type: 'once' | 'interval';
+    type: 'once' | 'interval' | 'cron';
+    /** Cron expression string (e.g., "0 9 * * 1-5"). Stored for re-computing next fire. */
+    cronExpression?: string;
+    /** IANA timezone for cron evaluation (e.g., "America/New_York"). Defaults to UTC. */
+    timezone?: string;
 }
 export {};

package/dist/utils/validation.d.ts

@@ -20,6 +20,8 @@ export declare const PATH_MAX = 1024;
 export declare const SCHEDULE_NAME_MAX = 64;
 /** Maximum schedule message size (10KB). */
 export declare const SCHEDULE_MESSAGE_MAX = 10240;
+/** Maximum cron expression length. */
+export declare const CRON_EXPRESSION_MAX = 128;
 /** Default number of recent messages to include as context in an encore. */
 export declare const ENCORE_DEFAULT_CONTEXT_MESSAGES = 10;
 /** Maximum length for message preview truncation. */

package/dist/utils/validation.js

@@ -4,7 +4,7 @@
  * Used by MCP tool Zod schemas and config validation.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PREVIEW_MAX_LENGTH = exports.ENCORE_DEFAULT_CONTEXT_MESSAGES = exports.SCHEDULE_MESSAGE_MAX = exports.SCHEDULE_NAME_MAX = exports.PATH_MAX = exports.PART_MAX = exports.MESSAGE_MAX = exports.ENSEMBLE_NAME_REGEX = exports.PLAYER_NAME_MAX = exports.PLAYER_NAME_REGEX = void 0;
+exports.PREVIEW_MAX_LENGTH = exports.ENCORE_DEFAULT_CONTEXT_MESSAGES = exports.CRON_EXPRESSION_MAX = exports.SCHEDULE_MESSAGE_MAX = exports.SCHEDULE_NAME_MAX = exports.PATH_MAX = exports.PART_MAX = exports.MESSAGE_MAX = exports.ENSEMBLE_NAME_REGEX = exports.PLAYER_NAME_MAX = exports.PLAYER_NAME_REGEX = void 0;
 exports.shouldIncludeInBroadcast = shouldIncludeInBroadcast;
 exports.validatePlayerName = validatePlayerName;
 exports.validateEnsembleName = validateEnsembleName;
@@ -26,6 +26,8 @@ exports.PATH_MAX = 1024;
 exports.SCHEDULE_NAME_MAX = 64;
 /** Maximum schedule message size (10KB). */
 exports.SCHEDULE_MESSAGE_MAX = 10240;
+/** Maximum cron expression length. */
+exports.CRON_EXPRESSION_MAX = 128;
 /** Default number of recent messages to include as context in an encore. */
 exports.ENCORE_DEFAULT_CONTEXT_MESSAGES = 10;
 /** Maximum length for message preview truncation. */

package/dist/workflows/scheduler.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.claudeSchedulerWorkflow = claudeSchedulerWorkflow;
 const workflow_1 = require("@temporalio/workflow");
 const scheduler_signals_1 = require("./scheduler-signals");
-const { fireSchedule } = (0, workflow_1.proxyActivities)({
+const { fireSchedule, computeNextCronFire } = (0, workflow_1.proxyActivities)({
     startToCloseTimeout: '30 seconds',
     retry: { maximumAttempts: 3 },
 });
@@ -83,6 +83,18 @@ async function claudeSchedulerWorkflow(input) {
             else if (entry.type === 'interval' && entry.interval) {
                 entry.nextFireAt = new Date(Date.now() + entry.interval).toISOString();
             }
+            else if ((0, workflow_1.patched)('v0.12-cron-schedule') && entry.type === 'cron' && entry.cronExpression) {
+                const nextFire = await computeNextCronFire({
+                    cronExpression: entry.cronExpression,
+                    timezone: entry.timezone,
+                });
+                if (nextFire) {
+                    entry.nextFireAt = nextFire;
+                }
+                else {
+                    entries = entries.filter((e) => e.name !== entry.name);
+                }
+            }
         }
         // Prevent unbounded history growth
         const info = (0, workflow_1.workflowInfo)();

package/dist/workflows/session.js

@@ -258,6 +258,7 @@ async function claudeSessionWorkflow(input) {
                             taskQueue: tc?.taskQueue || 'claude-tempo',
                             agentDefinition: entry.agentDefinition,
                             agentDefinitionDescription: entry.agentDefinitionDescription,
+                            allowedTools: entry.allowedTools,
                         });
                         const targetHost = entry.targetHostname || input.metadata.hostname;
                         const spawnFn = getSpawnProxy(targetHost);
@@ -273,6 +274,7 @@ async function claudeSessionWorkflow(input) {
                             agentDefinition: entry.agentDefinition,
                             agentDefinitionPath: entry.agentDefinitionPath,
                             nativeResolvable: entry.nativeResolvable,
+                            allowedTools: entry.allowedTools,
                         });
                         break;
                     }
@@ -297,6 +299,7 @@ async function claudeSessionWorkflow(input) {
                                 agentDefinition: encoreResult.agentDefinition,
                                 agentDefinitionPath: encoreResult.agentDefinitionPath,
                                 nativeResolvable: encoreResult.nativeResolvable,
+                                allowedTools: encoreResult.allowedTools,
                                 resume: true,
                             });
                         }