agent-tempo 1.2.0 → 1.4.0

package/dist/tools/restore.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerRestoreTool = registerRestoreTool;
+exports.buildRestoreTool = buildRestoreTool;
 /**
  * `restore` — ensemble-wide revive (#287).
  *
@@ -28,80 +28,85 @@ const os_1 = require("os");
 const zod_1 = require("zod");
 const orphans_1 = require("../reconcile/orphans");
 const signals_1 = require("../workflows/signals");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 const ensemble_ops_1 = require("../utils/ensemble-ops");
 const log = (...args) => console.error('[agent-tempo:restore]', ...args);
-function registerRestoreTool(server, client, config, getPlayerId) {
-    (0, helpers_1.defineTool)(server, 'restore', 'Revive the ensemble after `shutdown`: reattach orphaned sessions and unpause the maestro + scheduler. Defaults to scanning the local host; pass `hostname` to target a remote machine in distributed setups (per-host task queues). Does NOT spawn a conductor terminal — use the CLI for that.', {
-        // #306 follow-up: cross-host restore. The default (omitted) preserves
-        // the original behavior — scan the local daemon's host. When supplied,
-        // we route the orphan-visibility query against the named host's
-        // `AgentTempoAttachedHost`/`AgentTempoHostname` search attributes,
-        // so an operator on host A can revive sessions parked on host B.
-        // Surfaced from my own #306 review (regression risk #2): "MCP
-        // restore hard-codes hostname: osHostname() — won't see orphans on
-        // other hosts in distributed setups."
-        hostname: zod_1.z.string().min(1).max(253).optional().describe('Target host whose orphans should be restored. Defaults to the local OS hostname. Use this when the conductor / TUI is on a different machine than the workers that owned the parked sessions.'),
-    }, async (args) => {
-        const { hostname: explicitHostname } = args;
-        const targetHostname = explicitHostname ?? (0, os_1.hostname)();
-        try {
-            let summary;
+function buildRestoreTool(client, config, getPlayerId) {
+    return {
+        name: 'restore',
+        description: 'Revive the ensemble after `shutdown`: reattach orphaned sessions and unpause the maestro + scheduler. Defaults to scanning the local host; pass `hostname` to target a remote machine in distributed setups (per-host task queues). Does NOT spawn a conductor terminal — use the CLI for that.',
+        params: {
+            // #306 follow-up: cross-host restore. The default (omitted) preserves
+            // the original behavior — scan the local daemon's host. When supplied,
+            // we route the orphan-visibility query against the named host's
+            // `AgentTempoAttachedHost`/`AgentTempoHostname` search attributes,
+            // so an operator on host A can revive sessions parked on host B.
+            // Surfaced from my own #306 review (regression risk #2): "MCP
+            // restore hard-codes hostname: osHostname() — won't see orphans on
+            // other hosts in distributed setups."
+            hostname: zod_1.z.string().min(1).max(253).optional().describe('Target host whose orphans should be restored. Defaults to the local OS hostname. Use this when the conductor / TUI is on a different machine than the workers that owned the parked sessions.'),
+        },
+        handler: async (args) => {
+            const { hostname: explicitHostname } = args;
+            const targetHostname = explicitHostname ?? (0, os_1.hostname)();
             try {
-                summary = await (0, orphans_1.restoreOrphansOnce)(client, {
-                    hostname: targetHostname,
-                    invokerPlayerId: getPlayerId(),
-                    policy: 'auto',
-                    // #306: narrow to detached-only so a live attached/processing
-                    // session is never flagged as an orphan by user-invoked
-                    // `/restore`. Daemon reconcile-on-boot + CLI `up --resume`
-                    // keep the broad live-phase default (no PID memory after
-                    // crash → must treat every live phase as presumed orphan).
-                    phases: ['detached'],
-                }, log);
+                let summary;
+                try {
+                    summary = await (0, orphans_1.restoreOrphansOnce)(client, {
+                        hostname: targetHostname,
+                        invokerPlayerId: getPlayerId(),
+                        policy: 'auto',
+                        // #306: narrow to detached-only so a live attached/processing
+                        // session is never flagged as an orphan by user-invoked
+                        // `/restore`. Daemon reconcile-on-boot + CLI `up --resume`
+                        // keep the broad live-phase default (no PID memory after
+                        // crash → must treat every live phase as presumed orphan).
+                        phases: ['detached'],
+                    }, log);
+                }
+                catch (err) {
+                    return (0, descriptor_1.fail)(`Failed to scan for orphans: ${(0, descriptor_1.formatError)(err)}`);
+                }
+                // Maestro/scheduler hub unpause + per-session `setPaused=false`
+                // fan-out run in parallel — independent calls and a slow session
+                // shouldn't gate the hub toggle (or vice-versa).
+                const [toggle, sessions] = await Promise.all([
+                    (0, ensemble_ops_1.unpauseMaestroAndScheduler)(client, config.ensemble),
+                    (0, ensemble_ops_1.signalAllSessions)(client, config.ensemble, signals_1.setPausedSignal.name, false),
+                ]);
+                const hostSuffix = explicitHostname !== undefined
+                    ? ` (host: ${explicitHostname})`
+                    : '';
+                const lines = [
+                    `Ensemble **${config.ensemble}** restored${hostSuffix}.`,
+                    `${summary.reattached} reattached, ${summary.skipped} skipped, ${summary.failed} failed`,
+                ];
+                if (summary.details.length > 0) {
+                    lines.push(...summary.details.map((d) => `  - ${d.playerId} (${d.ensemble}): ${(0, orphans_1.formatRestoreOutcome)(d.outcome)}`));
+                }
+                if (sessions.sent > 0) {
+                    lines.push(`${sessions.sent} session(s) resumed`);
+                }
+                const unpausedBits = [];
+                if (toggle.maestro)
+                    unpausedBits.push('maestro');
+                if (toggle.scheduler)
+                    unpausedBits.push('scheduler');
+                if (unpausedBits.length > 0)
+                    lines.push(`Unpaused: ${unpausedBits.join(', ')}`);
+                if (sessions.failed > 0) {
+                    const errs = sessions.perSession
+                        .filter((p) => p.outcome === 'failed')
+                        .map((p) => `  - ${p.playerId}: ${'error' in p ? p.error : ''}`);
+                    lines.push(`Errors:\n${errs.join('\n')}`);
+                }
+                log(`Restore by ${getPlayerId()} in "${config.ensemble}" on host "${targetHostname}": ` +
+                    `${summary.reattached}/${summary.skipped}/${summary.failed}`);
+                return (0, descriptor_1.ok)(lines.join('\n'));
             }
             catch (err) {
-                return (0, helpers_1.fail)(`Failed to scan for orphans: ${(0, helpers_1.formatError)(err)}`);
+                return (0, descriptor_1.fail)(`Failed to restore ensemble: ${(0, descriptor_1.formatError)(err)}`);
             }
-            // Maestro/scheduler hub unpause + per-session `setPaused=false`
-            // fan-out run in parallel — independent calls and a slow session
-            // shouldn't gate the hub toggle (or vice-versa).
-            const [toggle, sessions] = await Promise.all([
-                (0, ensemble_ops_1.unpauseMaestroAndScheduler)(client, config.ensemble),
-                (0, ensemble_ops_1.signalAllSessions)(client, config.ensemble, signals_1.setPausedSignal.name, false),
-            ]);
-            const hostSuffix = explicitHostname !== undefined
-                ? ` (host: ${explicitHostname})`
-                : '';
-            const lines = [
-                `Ensemble **${config.ensemble}** restored${hostSuffix}.`,
-                `${summary.reattached} reattached, ${summary.skipped} skipped, ${summary.failed} failed`,
-            ];
-            if (summary.details.length > 0) {
-                lines.push(...summary.details.map((d) => `  - ${d.playerId} (${d.ensemble}): ${(0, orphans_1.formatRestoreOutcome)(d.outcome)}`));
-            }
-            if (sessions.sent > 0) {
-                lines.push(`${sessions.sent} session(s) resumed`);
-            }
-            const unpausedBits = [];
-            if (toggle.maestro)
-                unpausedBits.push('maestro');
-            if (toggle.scheduler)
-                unpausedBits.push('scheduler');
-            if (unpausedBits.length > 0)
-                lines.push(`Unpaused: ${unpausedBits.join(', ')}`);
-            if (sessions.failed > 0) {
-                const errs = sessions.perSession
-                    .filter((p) => p.outcome === 'failed')
-                    .map((p) => `  - ${p.playerId}: ${'error' in p ? p.error : ''}`);
-                lines.push(`Errors:\n${errs.join('\n')}`);
-            }
-            log(`Restore by ${getPlayerId()} in "${config.ensemble}" on host "${targetHostname}": ` +
-                `${summary.reattached}/${summary.skipped}/${summary.failed}`);
-            return (0, helpers_1.ok)(lines.join('\n'));
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to restore ensemble: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+        },
+    };
 }

package/dist/tools/save-lineup.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 registerSaveLineupTool(server: McpServer, client: Client, config: Config, getPlayerId: () => string, isConductor: boolean): void;
+import { type TempoToolDescriptor } from './descriptor';
+export declare function buildSaveLineupTool(client: Client, config: Config, getPlayerId: () => string, isConductor: boolean): TempoToolDescriptor;

package/dist/tools/save-lineup.js

@@ -1,36 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerSaveLineupTool = registerSaveLineupTool;
+exports.buildSaveLineupTool = buildSaveLineupTool;
 const zod_1 = require("zod");
 const saver_1 = require("../ensemble/saver");
 const safe_path_1 = require("../utils/safe-path");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 const validation_1 = require("../utils/validation");
 const log = (...args) => console.error('[agent-tempo:save-lineup]', ...args);
-function registerSaveLineupTool(server, client, config, getPlayerId, isConductor) {
-    (0, helpers_1.defineTool)(server, 'save_lineup', 'Save the current ensemble state as a YAML lineup. Only available to the conductor.', {
-        name: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional().describe('Lineup name (defaults to ensemble name)'),
-        path: zod_1.z.string().max(validation_1.PATH_MAX).optional().describe('Explicit file path to save to'),
-    }, async (args) => {
-        if (!isConductor) {
-            return (0, helpers_1.fail)('Only the conductor can save ensemble lineups.');
-        }
-        const lineupName = args.name;
-        const filePath = args.path;
-        try {
-            // Validate user-supplied path if provided
-            let validatedPath = filePath;
-            if (validatedPath) {
-                validatedPath = (0, safe_path_1.safeLineupPath)(validatedPath, process.cwd());
+function buildSaveLineupTool(client, config, getPlayerId, isConductor) {
+    return {
+        name: 'save_lineup',
+        description: 'Save the current ensemble state as a YAML lineup. Only available to the conductor.',
+        params: {
+            name: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional().describe('Lineup name (defaults to ensemble name)'),
+            path: zod_1.z.string().max(validation_1.PATH_MAX).optional().describe('Explicit file path to save to'),
+        },
+        handler: async (args) => {
+            if (!isConductor) {
+                return (0, descriptor_1.fail)('Only the conductor can save ensemble lineups.');
             }
-            // Pass lineupName as optional name override for the output filename.
-            // If no name or path is provided, saveLineup defaults to ensemble name.
-            const outputPath = await (0, saver_1.saveLineup)(client, config.ensemble, validatedPath, lineupName);
-            log(`Saved lineup to ${outputPath}`);
-            return (0, helpers_1.ok)(`Ensemble lineup saved to **${outputPath}**.`);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to save ensemble: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+            const lineupName = args.name;
+            const filePath = args.path;
+            try {
+                // Validate user-supplied path if provided
+                let validatedPath = filePath;
+                if (validatedPath) {
+                    validatedPath = (0, safe_path_1.safeLineupPath)(validatedPath, process.cwd());
+                }
+                // Pass lineupName as optional name override for the output filename.
+                // If no name or path is provided, saveLineup defaults to ensemble name.
+                const outputPath = await (0, saver_1.saveLineup)(client, config.ensemble, validatedPath, lineupName);
+                log(`Saved lineup to ${outputPath}`);
+                return (0, descriptor_1.ok)(`Ensemble lineup saved to **${outputPath}**.`);
+            }
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to save ensemble: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

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

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

package/dist/tools/save-state.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerSaveStateTool = registerSaveStateTool;
+exports.buildSaveStateTool = buildSaveStateTool;
 /**
  * `save_state` — write a curated artifact to one of the calling player's
  * saveable-state slots (#334 PR-1, ADR 0011).
@@ -16,42 +16,47 @@ exports.registerSaveStateTool = registerSaveStateTool;
  */
 const zod_1 = require("zod");
 const signals_1 = require("../workflows/signals");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 const validation_1 = require("../utils/validation");
-function registerSaveStateTool(server, handle, getPlayerId) {
-    (0, helpers_1.defineTool)(server, 'save_state', `Save curated state for yourself into a named slot — a peer can later read it via \`fetch_state\`, and a future restart can seed itself from this artifact instead of replaying the transcript.
-
-Recommended structure (markdown, not enforced):
-
-  ## Current task
-  ...
-  ## Findings
-  ...
-  ## Next steps
-  ...
-  ## Open questions
-  ...
-
-Limits: ${validation_1.PLAYER_STATE_CONTENT_MAX} bytes per slot, max ${validation_1.PLAYER_STATE_SLOTS_MAX} slots per player. Slot key defaults to "${validation_1.PLAYER_STATE_DEFAULT_KEY}". When all ${validation_1.PLAYER_STATE_SLOTS_MAX} slots are full, saving a new key fails with \`PlayerStateSlotsFull\` — call \`clear_state\` to free a slot.`, {
-        content: zod_1.z.string().min(1).max(validation_1.PLAYER_STATE_CONTENT_MAX).describe(`The state content — markdown encouraged, opaque to the system. Max ${validation_1.PLAYER_STATE_CONTENT_MAX} bytes (UTF-8).`),
-        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}"). Alphanumeric + underscore + hyphen, max ${validation_1.PLAYER_STATE_KEY_MAX} chars.`),
-    }, async (args) => {
-        const { content, key } = args;
-        const slotKey = key ?? validation_1.PLAYER_STATE_DEFAULT_KEY;
-        const savedBy = getPlayerId();
-        try {
-            const result = await handle.executeUpdate(signals_1.savePlayerStateUpdate, {
-                args: [{ key: slotKey, content, savedBy }],
-            });
-            return (0, helpers_1.ok)(`Saved to slot **"${slotKey}"** at ${result.savedAt}.`);
-        }
-        catch (err) {
-            // The workflow validator surfaces structured ApplicationFailure errors
-            // (`PlayerStateSlotsFull`, `PlayerStateContentTooLarge`,
-            // `PlayerStateInvalidKey`). The `formatError` message preserves the
-            // workflow-supplied text so the LLM sees the existing-keys list and
-            // can pick which slot to clear.
-            return (0, helpers_1.fail)(`Failed to save state: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+function buildSaveStateTool(handle, getPlayerId) {
+    return {
+        name: 'save_state',
+        description: `Save curated state for yourself into a named slot — a peer can later read it via \`fetch_state\`, and a future restart can seed itself from this artifact instead of replaying the transcript.
+
+Recommended structure (markdown, not enforced):
+
+  ## Current task
+  ...
+  ## Findings
+  ...
+  ## Next steps
+  ...
+  ## Open questions
+  ...
+
+Limits: ${validation_1.PLAYER_STATE_CONTENT_MAX} bytes per slot, max ${validation_1.PLAYER_STATE_SLOTS_MAX} slots per player. Slot key defaults to "${validation_1.PLAYER_STATE_DEFAULT_KEY}". When all ${validation_1.PLAYER_STATE_SLOTS_MAX} slots are full, saving a new key fails with \`PlayerStateSlotsFull\` — call \`clear_state\` to free a slot.`,
+        params: {
+            content: zod_1.z.string().min(1).max(validation_1.PLAYER_STATE_CONTENT_MAX).describe(`The state content — markdown encouraged, opaque to the system. Max ${validation_1.PLAYER_STATE_CONTENT_MAX} bytes (UTF-8).`),
+            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}"). Alphanumeric + underscore + hyphen, max ${validation_1.PLAYER_STATE_KEY_MAX} chars.`),
+        },
+        handler: async (args) => {
+            const { content, key } = args;
+            const slotKey = key ?? validation_1.PLAYER_STATE_DEFAULT_KEY;
+            const savedBy = getPlayerId();
+            try {
+                const result = await handle.executeUpdate(signals_1.savePlayerStateUpdate, {
+                    args: [{ key: slotKey, content, savedBy }],
+                });
+                return (0, descriptor_1.ok)(`Saved to slot **"${slotKey}"** at ${result.savedAt}.`);
+            }
+            catch (err) {
+                // The workflow validator surfaces structured ApplicationFailure errors
+                // (`PlayerStateSlotsFull`, `PlayerStateContentTooLarge`,
+                // `PlayerStateInvalidKey`). The `formatError` message preserves the
+                // workflow-supplied text so the LLM sees the existing-keys list and
+                // can pick which slot to clear.
+                return (0, descriptor_1.fail)(`Failed to save state: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

package/dist/tools/schedule.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 registerScheduleTool(server: McpServer, client: Client, config: Config, getPlayerId: () => string): void;
+import { type TempoToolDescriptor } from './descriptor';
+export declare function buildScheduleTool(client: Client, config: Config, getPlayerId: () => string): TempoToolDescriptor;