agent-tempo 1.3.1 → 1.4.1

package/dist/tools/ensemble.js

@@ -35,11 +35,11 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DORMANT_THRESHOLD_MS = void 0;
 exports.classifyDormancy = classifyDormancy;
-exports.registerEnsembleTool = registerEnsembleTool;
+exports.buildEnsembleTool = buildEnsembleTool;
 const zod_1 = require("zod");
 const os = __importStar(require("os"));
 const resolve_1 = require("../activities/resolve");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 const duration_1 = require("../utils/duration");
 /**
  * Default dormancy threshold (1 hour). Per #563: a `detached` player whose
@@ -79,75 +79,80 @@ function classifyDormancy(session, now, thresholdMs = exports.DORMANT_THRESHOLD_
     }
     return 'active';
 }
-function registerEnsembleTool(server, client, config, getPlayerId, ownWorkflowId) {
-    (0, helpers_1.defineTool)(server, 'ensemble', `Discover active Claude Code sessions in the "${config.ensemble}" ensemble. Returns player IDs, descriptions, and metadata. NOTE: returns tempo-registered players only — does NOT include Claude Code Agent-tool sub-agents (spawned via the Agent tool / subagent_type). Those are ephemeral and process-local; call TaskList separately to enumerate them. Tempo players are addressable via cue; Agent-tool sub-agents are not.`, {
-        scope: zod_1.z.string().optional().describe('Filter scope: "machine" (same hostname), "repo" (same git root), "all" (default). All scopes are within the current ensemble.'),
-        // #563: dormancy filter. Default `show` preserves the pre-#563 listing
-        // (everything visible) but groups gone/long-detached players into a
-        // separate "Dormant" section. `hide` suppresses dormant entries
-        // entirely; `show-only` is the inverse, useful for cleanup workflows.
-        dormant: zod_1.z.enum(['show', 'hide', 'show-only']).optional().describe('Dormancy filter: "show" (default — group dormant in a separate section), "hide" (suppress dormant entries), "show-only" (only show dormant). A player is dormant when phase=gone, or phase=detached with no activity in the last hour.'),
-    }, async (args) => {
-        const scope = (args.scope ?? 'all');
-        const dormantFilter = (args.dormant ?? 'show');
-        let sessions;
-        try {
-            sessions = await (0, resolve_1.scanEnsembleSessions)(client, config.ensemble);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Error listing workflows: ${(0, helpers_1.formatError)(err)}`);
-        }
-        // Apply scope filters
-        let ownGitRoot;
-        if (scope === 'repo') {
+function buildEnsembleTool(client, config, getPlayerId, ownWorkflowId) {
+    return {
+        name: 'ensemble',
+        description: `Discover active Claude Code sessions in the "${config.ensemble}" ensemble. Returns player IDs, descriptions, and metadata. NOTE: returns tempo-registered players only — does NOT include Claude Code Agent-tool sub-agents (spawned via the Agent tool / subagent_type). Those are ephemeral and process-local; call TaskList separately to enumerate them. Tempo players are addressable via cue; Agent-tool sub-agents are not.`,
+        params: {
+            scope: zod_1.z.string().optional().describe('Filter scope: "machine" (same hostname), "repo" (same git root), "all" (default). All scopes are within the current ensemble.'),
+            // #563: dormancy filter. Default `show` preserves the pre-#563 listing
+            // (everything visible) but groups gone/long-detached players into a
+            // separate "Dormant" section. `hide` suppresses dormant entries
+            // entirely; `show-only` is the inverse, useful for cleanup workflows.
+            dormant: zod_1.z.enum(['show', 'hide', 'show-only']).optional().describe('Dormancy filter: "show" (default — group dormant in a separate section), "hide" (suppress dormant entries), "show-only" (only show dormant). A player is dormant when phase=gone, or phase=detached with no activity in the last hour.'),
+        },
+        handler: async (args) => {
+            const scope = (args.scope ?? 'all');
+            const dormantFilter = (args.dormant ?? 'show');
+            let sessions;
             try {
-                const ownHandle = client.workflow.getHandle(ownWorkflowId);
-                const ownMeta = await ownHandle.query('getMetadata');
-                ownGitRoot = ownMeta.gitRoot;
+                sessions = await (0, resolve_1.scanEnsembleSessions)(client, config.ensemble);
             }
-            catch {
-                // Can't determine own git root — skip repo filtering
+            catch (err) {
+                return (0, descriptor_1.fail)(`Error listing workflows: ${(0, descriptor_1.formatError)(err)}`);
             }
-        }
-        const scoped = sessions.filter((s) => {
-            if (scope === 'machine' && s.hostname !== os.hostname())
-                return false;
-            if (scope === 'repo' && ownGitRoot && s.gitRoot !== ownGitRoot)
-                return false;
-            return true;
-        });
-        const now = Date.now();
-        const enriched = scoped.map((s) => ({
-            ...s,
-            isYou: s.playerId === getPlayerId(),
-            dormancy: classifyDormancy(s, now),
-        }));
-        const active = enriched.filter((p) => p.dormancy === 'active');
-        const dormant = enriched.filter((p) => p.dormancy === 'dormant');
-        if (active.length === 0 && dormant.length === 0) {
-            return (0, helpers_1.ok)('No active sessions found.');
-        }
-        // #563 summary line — surface both counts so operators can see what's
-        // being hidden behind the dormant filter without re-running.
-        const summary = `**${config.ensemble}**: ${active.length} active, ${dormant.length} dormant`;
-        const sections = [summary];
-        const showActive = dormantFilter !== 'show-only';
-        const showDormant = dormantFilter !== 'hide';
-        if (showActive) {
-            if (active.length > 0) {
-                sections.push(`\n=== Active (${active.length}) ===\n`);
-                sections.push(active.map((p) => renderPlayerLine(p, now, false)).join('\n\n'));
+            // Apply scope filters
+            let ownGitRoot;
+            if (scope === 'repo') {
+                try {
+                    const ownHandle = client.workflow.getHandle(ownWorkflowId);
+                    const ownMeta = await ownHandle.query('getMetadata');
+                    ownGitRoot = ownMeta.gitRoot;
+                }
+                catch {
+                    // Can't determine own git root — skip repo filtering
+                }
             }
-            else {
-                sections.push('\n=== Active (0) ===\n(none)');
+            const scoped = sessions.filter((s) => {
+                if (scope === 'machine' && s.hostname !== os.hostname())
+                    return false;
+                if (scope === 'repo' && ownGitRoot && s.gitRoot !== ownGitRoot)
+                    return false;
+                return true;
+            });
+            const now = Date.now();
+            const enriched = scoped.map((s) => ({
+                ...s,
+                isYou: s.playerId === getPlayerId(),
+                dormancy: classifyDormancy(s, now),
+            }));
+            const active = enriched.filter((p) => p.dormancy === 'active');
+            const dormant = enriched.filter((p) => p.dormancy === 'dormant');
+            if (active.length === 0 && dormant.length === 0) {
+                return (0, descriptor_1.ok)('No active sessions found.');
             }
-        }
-        if (showDormant && dormant.length > 0) {
-            sections.push(`\n=== Dormant (${dormant.length}) — last seen >1h ago or gone ===\n`);
-            sections.push(dormant.map((p) => renderPlayerLine(p, now, true)).join('\n\n'));
-        }
-        return (0, helpers_1.ok)(sections.join('\n'));
-    });
+            // #563 summary line — surface both counts so operators can see what's
+            // being hidden behind the dormant filter without re-running.
+            const summary = `**${config.ensemble}**: ${active.length} active, ${dormant.length} dormant`;
+            const sections = [summary];
+            const showActive = dormantFilter !== 'show-only';
+            const showDormant = dormantFilter !== 'hide';
+            if (showActive) {
+                if (active.length > 0) {
+                    sections.push(`\n=== Active (${active.length}) ===\n`);
+                    sections.push(active.map((p) => renderPlayerLine(p, now, false)).join('\n\n'));
+                }
+                else {
+                    sections.push('\n=== Active (0) ===\n(none)');
+                }
+            }
+            if (showDormant && dormant.length > 0) {
+                sections.push(`\n=== Dormant (${dormant.length}) — last seen >1h ago or gone ===\n`);
+                sections.push(dormant.map((p) => renderPlayerLine(p, now, true)).join('\n\n'));
+            }
+            return (0, descriptor_1.ok)(sections.join('\n'));
+        },
+    };
 }
 /**
  * Render one player as the multi-line block historically emitted by

package/dist/tools/evaluate-gate.d.ts

@@ -1,3 +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;
+import { type TempoToolDescriptor } from './descriptor';
+export declare function buildEvaluateGateTool(handle: WorkflowHandle, getPlayerId: () => string): TempoToolDescriptor;

package/dist/tools/evaluate-gate.js

@@ -1,32 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerEvaluateGateTool = registerEvaluateGateTool;
+exports.buildEvaluateGateTool = buildEvaluateGateTool;
 const zod_1 = require("zod");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
+const signals_1 = require("../workflows/signals");
 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 (0, helpers_1.ok)(`Evaluated ${evaluations.length} criteria on gate **${task}**:\n${summary}`);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to evaluate gate: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+function buildEvaluateGateTool(handle, getPlayerId) {
+    return {
+        name: 'evaluate_gate',
+        description: 'Mark one or more criteria on a quality gate as passed or failed. Conductor only.',
+        params: {
+            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'),
+        },
+        handler: async (args) => {
+            const { task, evaluations } = args;
+            try {
+                await handle.signal(signals_1.evaluateGateCriteriaSignal, {
+                    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 (0, descriptor_1.ok)(`Evaluated ${evaluations.length} criteria on gate **${task}**:\n${summary}`);
+            }
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to evaluate gate: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

package/dist/tools/fetch-state.d.ts

@@ -1,6 +1,6 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { WorkflowHandle, Client } from '@temporalio/client';
 import { Config } from '../config';
+import { type TempoToolDescriptor } from './descriptor';
 /**
  * Return type is monomorphic by design: `{ content, savedAt, savedBy } | null`.
  * ADR 0011 §Alternatives explicitly rejected a `list: boolean` flag because
@@ -10,4 +10,4 @@ import { Config } from '../config';
  * playerStateKeys`; v2 can graduate a dedicated `list_state` MCP tool if
  * telemetry shows real demand.
  */
-export declare function registerFetchStateTool(server: McpServer, client: Client, config: Config, handle: WorkflowHandle, getPlayerId: () => string): void;
+export declare function buildFetchStateTool(client: Client, config: Config, handle: WorkflowHandle, getPlayerId: () => string): TempoToolDescriptor;

package/dist/tools/fetch-state.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerFetchStateTool = registerFetchStateTool;
+exports.buildFetchStateTool = buildFetchStateTool;
 /**
  * `fetch_state` — read a saved state slot for self or any peer in the
  * ensemble (#334 PR-1, ADR 0011).
@@ -26,7 +26,7 @@ exports.registerFetchStateTool = registerFetchStateTool;
 const zod_1 = require("zod");
 const resolve_1 = require("./resolve");
 const signals_1 = require("../workflows/signals");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 const validation_1 = require("../utils/validation");
 /**
  * Return type is monomorphic by design: `{ content, savedAt, savedBy } | null`.
@@ -37,42 +37,47 @@ const validation_1 = require("../utils/validation");
  * playerStateKeys`; v2 can graduate a dedicated `list_state` MCP tool if
  * telemetry shows real demand.
  */
-function registerFetchStateTool(server, client, config, handle, getPlayerId) {
-    (0, helpers_1.defineTool)(server, 'fetch_state', `Read a saved-state slot for yourself or a peer. Defaults to your own "${validation_1.PLAYER_STATE_DEFAULT_KEY}" slot.
+function buildFetchStateTool(client, config, handle, getPlayerId) {
+    return {
+        name: 'fetch_state',
+        description: `Read a saved-state slot for yourself or a peer. Defaults to your own "${validation_1.PLAYER_STATE_DEFAULT_KEY}" slot.
 
-Pass \`playerId\` to read a peer's slot (any player in the ensemble can read any other player's state — audit identity is recorded on each slot via \`savedBy\`). Returns a "(no state saved …)" message when the slot is empty.`, {
-        key: zod_1.z.string().regex(validation_1.PLAYER_STATE_KEY_REGEX).max(validation_1.PLAYER_STATE_KEY_MAX).optional().describe(`Slot name (default "${validation_1.PLAYER_STATE_DEFAULT_KEY}").`),
-        playerId: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional().describe('Target player name (default: self).'),
-    }, async (args) => {
-        const { key, playerId } = args;
-        const targetId = playerId ?? getPlayerId();
-        // Validate any explicit playerId — `getPlayerId()` is trusted (set by
-        // the MCP server) and skips this check.
-        if (playerId !== undefined) {
-            const nameError = (0, validation_1.validatePlayerName)(playerId);
-            if (nameError)
-                return (0, helpers_1.fail)(nameError);
-        }
-        try {
-            // Self-targeted reads use the cached own-session handle directly;
-            // peer reads go through `resolveSession` (the codebase convention,
-            // not a raw `client.workflow.getHandle`) so workflow-id format
-            // changes only need to be tracked in one place.
-            const targetHandle = targetId === getPlayerId()
-                ? handle
-                : await (0, resolve_1.resolveSession)(client, config.ensemble, targetId);
-            if (!targetHandle) {
-                return (0, helpers_1.fail)(`No session found with name "${targetId}".`);
+Pass \`playerId\` to read a peer's slot (any player in the ensemble can read any other player's state — audit identity is recorded on each slot via \`savedBy\`). Returns a "(no state saved …)" message when the slot is empty.`,
+        params: {
+            key: zod_1.z.string().regex(validation_1.PLAYER_STATE_KEY_REGEX).max(validation_1.PLAYER_STATE_KEY_MAX).optional().describe(`Slot name (default "${validation_1.PLAYER_STATE_DEFAULT_KEY}").`),
+            playerId: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional().describe('Target player name (default: self).'),
+        },
+        handler: async (args) => {
+            const { key, playerId } = args;
+            const targetId = playerId ?? getPlayerId();
+            // Validate any explicit playerId — `getPlayerId()` is trusted (set by
+            // the MCP server) and skips this check.
+            if (playerId !== undefined) {
+                const nameError = (0, validation_1.validatePlayerName)(playerId);
+                if (nameError)
+                    return (0, descriptor_1.fail)(nameError);
             }
-            const slotKey = key ?? validation_1.PLAYER_STATE_DEFAULT_KEY;
-            const result = await targetHandle.query(signals_1.playerStateQuery, { key: slotKey });
-            if (!result) {
-                return (0, helpers_1.ok)(`(no state saved at slot "${slotKey}" for ${targetId})`);
+            try {
+                // Self-targeted reads use the cached own-session handle directly;
+                // peer reads go through `resolveSession` (the codebase convention,
+                // not a raw `client.workflow.getHandle`) so workflow-id format
+                // changes only need to be tracked in one place.
+                const targetHandle = targetId === getPlayerId()
+                    ? handle
+                    : await (0, resolve_1.resolveSession)(client, config.ensemble, targetId);
+                if (!targetHandle) {
+                    return (0, descriptor_1.fail)(`No session found with name "${targetId}".`);
+                }
+                const slotKey = key ?? validation_1.PLAYER_STATE_DEFAULT_KEY;
+                const result = await targetHandle.query(signals_1.playerStateQuery, { key: slotKey });
+                if (!result) {
+                    return (0, descriptor_1.ok)(`(no state saved at slot "${slotKey}" for ${targetId})`);
+                }
+                return (0, descriptor_1.ok)(`Slot **"${slotKey}"** — saved by **${result.savedBy}** at ${result.savedAt}\n\n${result.content}`);
             }
-            return (0, helpers_1.ok)(`Slot **"${slotKey}"** — saved by **${result.savedBy}** at ${result.savedAt}\n\n${result.content}`);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to fetch state: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to fetch state: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

package/dist/tools/gates.d.ts

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

package/dist/tools/gates.js

@@ -1,41 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerGatesTool = registerGatesTool;
+exports.buildGatesTool = buildGatesTool;
 const zod_1 = require("zod");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 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);
+function buildGatesTool(handle) {
+    return {
+        name: 'gates',
+        description: 'List quality gates and their status. Optionally filter by task name or status. Conductor only.',
+        params: {
+            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'),
+        },
+        handler: 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 (0, descriptor_1.ok)('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 (0, descriptor_1.ok)(`${filtered.length} quality gate${filtered.length === 1 ? '' : 's'}:\n\n${lines.join('\n\n')}`);
             }
-            if (filtered.length === 0) {
-                return (0, helpers_1.ok)('No quality gates found matching the filter.');
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to query gates: ${(0, descriptor_1.formatError)(err)}`);
             }
-            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 (0, helpers_1.ok)(`${filtered.length} quality gate${filtered.length === 1 ? '' : 's'}:\n\n${lines.join('\n\n')}`);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to query gates: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+        },
+    };
 }

package/dist/tools/hosts.d.ts

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

package/dist/tools/hosts.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerHostsTool = registerHostsTool;
+exports.buildHostsTool = buildHostsTool;
 /**
  * `hosts` — MCP tool for surfacing daemons polling the Temporal namespace (#274).
  *
@@ -16,25 +16,30 @@ exports.registerHostsTool = registerHostsTool;
  * Thin wrapper — all the logic is in `listHosts`.
  */
 const zod_1 = require("zod");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 const hosts_1 = require("../utils/hosts");
 const format_hosts_1 = require("../utils/format-hosts");
-function registerHostsTool(server, client, config) {
-    (0, helpers_1.defineTool)(server, 'hosts', 'Show all daemons polling this Temporal namespace, with their advertised capabilities. Returns liveness (live/stale), recruit-readiness, and each daemon\'s profile (default agent, available player types, platform) when it signaled one at boot. Read-only diagnostic.', {
-        includeStale: zod_1.z.boolean().optional().describe('Include hosts not seen in the last minute (default: false).'),
-        force: zod_1.z.boolean().optional().describe('Bypass the 3-second result cache (default: false).'),
-    }, async (args) => {
-        const { includeStale, force } = args;
-        try {
-            const hosts = await (0, hosts_1.listHosts)(client, {
-                force: Boolean(force),
-                namespace: config.temporalNamespace,
-                taskQueue: config.taskQueue,
-            });
-            return (0, helpers_1.ok)((0, format_hosts_1.formatHostList)(hosts, { includeStale: Boolean(includeStale) }));
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to list hosts: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+function buildHostsTool(client, config) {
+    return {
+        name: 'hosts',
+        description: 'Show all daemons polling this Temporal namespace, with their advertised capabilities. Returns liveness (live/stale), recruit-readiness, and each daemon\'s profile (default agent, available player types, platform) when it signaled one at boot. Read-only diagnostic.',
+        params: {
+            includeStale: zod_1.z.boolean().optional().describe('Include hosts not seen in the last minute (default: false).'),
+            force: zod_1.z.boolean().optional().describe('Bypass the 3-second result cache (default: false).'),
+        },
+        handler: async (args) => {
+            const { includeStale, force } = args;
+            try {
+                const hosts = await (0, hosts_1.listHosts)(client, {
+                    force: Boolean(force),
+                    namespace: config.temporalNamespace,
+                    taskQueue: config.taskQueue,
+                });
+                return (0, descriptor_1.ok)((0, format_hosts_1.formatHostList)(hosts, { includeStale: Boolean(includeStale) }));
+            }
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to list hosts: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

package/dist/tools/listen.d.ts

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

package/dist/tools/listen.js

@@ -1,22 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerListenTool = registerListenTool;
-const helpers_1 = require("./helpers");
-function registerListenTool(server, handle) {
-    (0, helpers_1.defineTool)(server, 'listen', 'Check for pending messages from other sessions. Use this if you want to manually check for new messages.', {}, async () => {
-        try {
-            const messages = await handle.query('pendingMessages');
-            if (messages.length === 0) {
-                return (0, helpers_1.ok)('No pending messages.');
+exports.buildListenTool = buildListenTool;
+const descriptor_1 = require("./descriptor");
+function buildListenTool(handle) {
+    return {
+        name: 'listen',
+        description: 'Check for pending messages from other sessions. Use this if you want to manually check for new messages.',
+        params: {},
+        handler: async () => {
+            try {
+                const messages = await handle.query('pendingMessages');
+                if (messages.length === 0) {
+                    return (0, descriptor_1.ok)('No pending messages.');
+                }
+                // Mark messages as delivered
+                const ids = messages.map((m) => m.id);
+                await handle.signal('markDelivered', ids);
+                const lines = messages.map((m) => `**${m.from}** (${m.timestamp}):\n${m.text}`);
+                return (0, descriptor_1.ok)(lines.join('\n\n'));
             }
-            // Mark messages as delivered
-            const ids = messages.map((m) => m.id);
-            await handle.signal('markDelivered', ids);
-            const lines = messages.map((m) => `**${m.from}** (${m.timestamp}):\n${m.text}`);
-            return (0, helpers_1.ok)(lines.join('\n\n'));
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to check messages: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to check messages: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

package/dist/tools/load-lineup.d.ts

@@ -1,5 +1,5 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Client, WorkflowHandle } from '@temporalio/client';
 import { Config } from '../config';
 import { AgentType } from '../types';
-export declare function registerLoadLineupTool(server: McpServer, client: Client, config: Config, getPlayerId: () => string, ownAgentType?: AgentType, handle?: WorkflowHandle, setPlayerId?: (id: string) => void, isConductor?: boolean): void;
+import { type TempoToolDescriptor } from './descriptor';
+export declare function buildLoadLineupTool(client: Client, config: Config, getPlayerId: () => string, ownAgentType?: AgentType, handle?: WorkflowHandle, setPlayerId?: (id: string) => void, isConductor?: boolean): TempoToolDescriptor;