claude-tempo 0.11.1 → 0.13.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
 
@@ -61,6 +62,9 @@ src/
 │   ├── schedule.ts    # Create one-shot or recurring schedules
 │   ├── unschedule.ts  # Cancel a named schedule
 │   ├── schedules.ts   # List active schedules
+│   ├── quality-gate.ts # Define quality gates for tasks (conductor only)
+│   ├── evaluate-gate.ts # Mark gate criteria as passed/failed (conductor only)
+│   ├── gates.ts       # List quality gates and their status (conductor only)
 │   └── helpers.ts     # Zod/MCP tool registration wrapper
 ├── utils/
 │   └── validation.ts  # Shared validation constants (name/message/path limits, encore defaults) and helpers
@@ -111,10 +115,11 @@ 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.
+- **Quality Gate**: A named checklist of criteria a conductor tracks to verify a task is complete. Created via `quality_gate` (conductor only), evaluated via `evaluate_gate`, and listed via `gates`. Each criterion has a `pending` → `passed` | `failed` status; the gate's aggregate status is derived automatically (all passed → `passed`, any failed → `failed`, else `open`). Gates are stored in the conductor workflow and survive `continueAsNew`.
 - **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.
 
 ## Dashboard

package/README.md

@@ -133,6 +133,9 @@ These tools are available inside Claude Code sessions connected to claude-tempo:
 | `broadcast` | Send a message to all active players. Optional `type` filter limits to a specific player type. |
 | `encore` | Revive a stale player session — restarts the process and reconnects to the existing workflow with context restored. |
 | `recall` | Read your own message history. Shows received messages by default; pass `includeSent: true` for the full timeline. |
+| `quality_gate` | Define or replace a quality gate for a task — a named checklist of criteria that must pass. Conductor only. |
+| `evaluate_gate` | Mark one or more criteria on a quality gate as passed or failed. Conductor only. |
+| `gates` | List quality gates and their status. Filter by task name or status (`open`, `passed`, `failed`). Conductor only. |
 
 ## Scheduling
 
@@ -150,11 +153,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
 
@@ -165,6 +177,24 @@ Schedules support one-shot delays, fixed times, and recurring intervals with opt
 - `claude-tempo status` shows active schedules alongside sessions
 - A single durable scheduler workflow per ensemble manages all schedules using Temporal timers
 
+## Quality Gates
+
+Conductors can define named checklists of criteria to verify task completion. Three conductor-only tools are available: `quality_gate` (create or replace a gate), `evaluate_gate` (mark criteria as passed or failed), and `gates` (list all gates with optional filters).
+
+### Examples
+
+Tell your conductor things like:
+
+- *"Set a quality gate 'pr-ready' with criteria: tests pass, no lint errors, code reviewed"*
+- *"Mark criteria 0 and 1 on 'pr-ready' as passed"*
+- *"Show me all open quality gates"*
+- *"Check whether 'deploy-staging' has passed"*
+
+### How it works
+
+- Gate status is derived from criteria: all passed → `passed`; any failed → `failed`; otherwise `open`
+- Gates survive `continueAsNew` for the conductor workflow's lifetime
+
 ## Ensemble Lineups
 
 Define reusable ensemble configurations as YAML files. A lineup specifies which players to recruit, what instructions to give them, what schedules to create, and optionally which custom agent files to use.
@@ -241,7 +271,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 +287,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/server.js

@@ -64,6 +64,9 @@ const who_am_i_1 = require("./tools/who-am-i");
 const broadcast_1 = require("./tools/broadcast");
 const recall_1 = require("./tools/recall");
 const encore_1 = require("./tools/encore");
+const quality_gate_1 = require("./tools/quality-gate");
+const evaluate_gate_1 = require("./tools/evaluate-gate");
+const gates_1 = require("./tools/gates");
 const channel_1 = require("./channel");
 const agent_types_2 = require("./ensemble/agent-types");
 const log = (...args) => console.error('[claude-tempo]', ...args);
@@ -279,6 +282,12 @@ async function main() {
     (0, broadcast_1.registerBroadcastTool)(mcpServer, client, config, getPlayerId, handle);
     (0, recall_1.registerRecallTool)(mcpServer, handle, getPlayerId);
     (0, encore_1.registerEncoreTool)(mcpServer, client, config, getPlayerId, handle);
+    // Conductor-only tools
+    if (isConductor) {
+        (0, quality_gate_1.registerQualityGateTool)(mcpServer, handle, getPlayerId);
+        (0, evaluate_gate_1.registerEvaluateGateTool)(mcpServer, handle, getPlayerId);
+        (0, gates_1.registerGatesTool)(mcpServer, handle);
+    }
     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/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/evaluate-gate.d.ts

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

package/dist/tools/evaluate-gate.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEvaluateGateTool = registerEvaluateGateTool;
+const zod_1 = require("zod");
+const helpers_1 = require("./helpers");
+const validation_1 = require("../utils/validation");
+function registerEvaluateGateTool(server, handle, getPlayerId) {
+    (0, helpers_1.defineTool)(server, 'evaluate_gate', 'Mark one or more criteria on a quality gate as passed or failed. Conductor only.', {
+        task: zod_1.z.string().max(validation_1.GATE_TASK_MAX).describe('The task name of the gate to evaluate'),
+        evaluations: zod_1.z.array(zod_1.z.object({
+            index: zod_1.z.number().int().min(0).describe('Zero-based index of the criterion'),
+            status: zod_1.z.enum(['passed', 'failed']).describe('Whether this criterion passed or failed'),
+            notes: zod_1.z.string().max(validation_1.GATE_NOTES_MAX).optional().describe('Optional notes explaining the evaluation'),
+        })).min(1).describe('List of criterion evaluations'),
+    }, async (args) => {
+        const { task, evaluations } = args;
+        try {
+            await handle.signal('evaluateGateCriteria', {
+                task,
+                evaluations,
+                evaluatedBy: getPlayerId(),
+            });
+            const summary = evaluations
+                .map((ev) => `  ${ev.index}: ${ev.status === 'passed' ? '\u2705' : '\u274c'} ${ev.status}${ev.notes ? ` — ${ev.notes}` : ''}`)
+                .join('\n');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Evaluated ${evaluations.length} criteria on gate **${task}**:\n${summary}`,
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Failed to evaluate gate: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/gates.d.ts

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

package/dist/tools/gates.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGatesTool = registerGatesTool;
+const zod_1 = require("zod");
+const helpers_1 = require("./helpers");
+const validation_1 = require("../utils/validation");
+function registerGatesTool(server, handle) {
+    (0, helpers_1.defineTool)(server, 'gates', 'List quality gates and their status. Optionally filter by task name or status. Conductor only.', {
+        task: zod_1.z.string().max(validation_1.GATE_TASK_MAX).optional().describe('Filter by specific task name'),
+        status: zod_1.z.enum(['open', 'passed', 'failed']).optional().describe('Filter by gate status'),
+    }, async (args) => {
+        const { task, status } = args;
+        try {
+            const gates = await handle.query('qualityGates');
+            let filtered = gates;
+            if (task) {
+                filtered = filtered.filter((g) => g.task === task);
+            }
+            if (status) {
+                filtered = filtered.filter((g) => g.status === status);
+            }
+            if (filtered.length === 0) {
+                return {
+                    content: [{ type: 'text', text: 'No quality gates found matching the filter.' }],
+                };
+            }
+            const lines = filtered.map((g) => {
+                const icon = g.status === 'passed' ? '\u2705' : g.status === 'failed' ? '\u274c' : '\u23f3';
+                const criteriaLines = g.criteria.map((c, i) => {
+                    const cIcon = c.status === 'passed' ? '\u2705' : c.status === 'failed' ? '\u274c' : '\u2b1c';
+                    const evaluator = c.evaluatedBy ? ` (by ${c.evaluatedBy})` : '';
+                    const notes = c.notes ? ` — ${c.notes}` : '';
+                    return `    ${i}. ${cIcon} ${c.text}${evaluator}${notes}`;
+                });
+                return `${icon} **${g.task}** [${g.status}] (by ${g.createdBy}, ${g.createdAt})\n${criteriaLines.join('\n')}`;
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: `${filtered.length} quality gate${filtered.length === 1 ? '' : 's'}:\n\n${lines.join('\n\n')}`,
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Failed to query gates: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+}

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/quality-gate.d.ts

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

package/dist/tools/quality-gate.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerQualityGateTool = registerQualityGateTool;
+const zod_1 = require("zod");
+const helpers_1 = require("./helpers");
+const validation_1 = require("../utils/validation");
+function registerQualityGateTool(server, handle, getPlayerId) {
+    (0, helpers_1.defineTool)(server, 'quality_gate', 'Define or replace a quality gate for a task. Each gate has a list of criteria that must pass before the task is considered complete. Conductor only.', {
+        task: zod_1.z.string().max(validation_1.GATE_TASK_MAX).describe('Unique task name for this gate (e.g. "pr-review", "deploy-staging")'),
+        criteria: zod_1.z.array(zod_1.z.string().max(validation_1.GATE_CRITERION_TEXT_MAX)).min(1).max(validation_1.GATE_CRITERIA_MAX).describe('List of criteria that must be evaluated (e.g. ["Tests pass", "No lint errors", "Code reviewed"])'),
+    }, async (args) => {
+        const { task, criteria } = args;
+        try {
+            await handle.signal('setQualityGate', {
+                task,
+                criteria,
+                createdBy: getPlayerId(),
+            });
+            const lines = criteria.map((c, i) => `  ${i}. [ ] ${c}`);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Quality gate **${task}** set with ${criteria.length} criteria:\n${lines.join('\n')}`,
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Failed to set quality gate: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+}

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 {