agent-tempo 1.2.0 → 1.4.0

package/dist/tools/release.d.ts

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

package/dist/tools/release.js

@@ -1,98 +1,103 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerReleaseTool = registerReleaseTool;
+exports.buildReleaseTool = buildReleaseTool;
 const zod_1 = require("zod");
 const resolve_1 = require("../activities/resolve");
 const signals_1 = require("../workflows/signals");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 const validation_1 = require("../utils/validation");
-function registerReleaseTool(server, client, config, getPlayerId, handle) {
-    (0, helpers_1.defineTool)(server, 'release', 'Release held player sessions — unlocks their outboxes and delivers deferred task messages. Without a player name, releases all held sessions.', {
-        player: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional()
-            .describe('Name of a specific held player to release. Omit to release all held players.'),
-    }, async (args) => {
-        const { player } = args;
-        if (player) {
-            const nameError = (0, validation_1.validatePlayerName)(player);
-            if (nameError)
-                return (0, helpers_1.fail)(nameError);
-        }
-        try {
+function buildReleaseTool(client, config, getPlayerId, handle) {
+    return {
+        name: 'release',
+        description: 'Release held player sessions — unlocks their outboxes and delivers deferred task messages. Without a player name, releases all held sessions.',
+        params: {
+            player: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional()
+                .describe('Name of a specific held player to release. Omit to release all held players.'),
+        },
+        handler: async (args) => {
+            const { player } = args;
             if (player) {
-                // Release a specific player
-                const sessions = await (0, resolve_1.scanEnsembleSessions)(client, config.ensemble);
-                const target = sessions.find((s) => s.playerId === player);
-                if (!target) {
-                    return (0, helpers_1.fail)(`No session found with name "${player}".`);
-                }
-                // Check if the session's outbox is actually locked
-                const targetHandle = client.workflow.getHandle(target.workflowId);
-                let isLocked = false;
-                try {
-                    isLocked = await targetHandle.query(signals_1.outboxLockedQuery);
-                }
-                catch {
-                    // Query may fail for old workflows without the handler — not held
-                }
-                if (!isLocked) {
-                    return (0, helpers_1.fail)(`Session "${player}" is not held (outbox not locked). Only held sessions can be released.`);
-                }
-                const entry = {
-                    type: 'release',
-                    targetPlayerId: player,
-                };
-                const entryId = await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
-                return (0, helpers_1.ok)(`Release request submitted for **${player}**. Task assignment will be delivered shortly. (outbox: ${entryId})`);
+                const nameError = (0, validation_1.validatePlayerName)(player);
+                if (nameError)
+                    return (0, descriptor_1.fail)(nameError);
             }
-            else {
-                // Release all held players — scan ensemble and check outboxLocked on each
-                const sessions = await (0, resolve_1.scanEnsembleSessions)(client, config.ensemble);
-                const heldSessions = [];
-                for (const session of sessions) {
-                    // Skip self and conductors (conductor outbox is never locked)
-                    if (session.playerId === getPlayerId())
-                        continue;
+            try {
+                if (player) {
+                    // Release a specific player
+                    const sessions = await (0, resolve_1.scanEnsembleSessions)(client, config.ensemble);
+                    const target = sessions.find((s) => s.playerId === player);
+                    if (!target) {
+                        return (0, descriptor_1.fail)(`No session found with name "${player}".`);
+                    }
+                    // Check if the session's outbox is actually locked
+                    const targetHandle = client.workflow.getHandle(target.workflowId);
+                    let isLocked = false;
                     try {
-                        const sessionHandle = client.workflow.getHandle(session.workflowId);
-                        const isLocked = await sessionHandle.query(signals_1.outboxLockedQuery);
-                        if (isLocked) {
-                            heldSessions.push(session);
-                        }
+                        isLocked = await targetHandle.query(signals_1.outboxLockedQuery);
                     }
                     catch {
-                        // Skip sessions where query fails (old workflows, terminated, etc.)
+                        // Query may fail for old workflows without the handler — not held
                     }
+                    if (!isLocked) {
+                        return (0, descriptor_1.fail)(`Session "${player}" is not held (outbox not locked). Only held sessions can be released.`);
+                    }
+                    const entry = {
+                        type: 'release',
+                        targetPlayerId: player,
+                    };
+                    const entryId = await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
+                    return (0, descriptor_1.ok)(`Release request submitted for **${player}**. Task assignment will be delivered shortly. (outbox: ${entryId})`);
                 }
-                if (heldSessions.length === 0) {
-                    return (0, helpers_1.ok)('No held sessions found. Nothing to release.');
-                }
-                const released = [];
-                const errors = [];
-                for (const session of heldSessions) {
-                    try {
-                        const entry = {
-                            type: 'release',
-                            targetPlayerId: session.playerId,
-                        };
-                        await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
-                        released.push(session.playerId);
+                else {
+                    // Release all held players — scan ensemble and check outboxLocked on each
+                    const sessions = await (0, resolve_1.scanEnsembleSessions)(client, config.ensemble);
+                    const heldSessions = [];
+                    for (const session of sessions) {
+                        // Skip self and conductors (conductor outbox is never locked)
+                        if (session.playerId === getPlayerId())
+                            continue;
+                        try {
+                            const sessionHandle = client.workflow.getHandle(session.workflowId);
+                            const isLocked = await sessionHandle.query(signals_1.outboxLockedQuery);
+                            if (isLocked) {
+                                heldSessions.push(session);
+                            }
+                        }
+                        catch {
+                            // Skip sessions where query fails (old workflows, terminated, etc.)
+                        }
                     }
-                    catch (err) {
-                        errors.push(`${session.playerId}: ${(0, helpers_1.formatError)(err)}`);
+                    if (heldSessions.length === 0) {
+                        return (0, descriptor_1.ok)('No held sessions found. Nothing to release.');
                     }
+                    const released = [];
+                    const errors = [];
+                    for (const session of heldSessions) {
+                        try {
+                            const entry = {
+                                type: 'release',
+                                targetPlayerId: session.playerId,
+                            };
+                            await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
+                            released.push(session.playerId);
+                        }
+                        catch (err) {
+                            errors.push(`${session.playerId}: ${(0, descriptor_1.formatError)(err)}`);
+                        }
+                    }
+                    const lines = [];
+                    if (released.length > 0) {
+                        lines.push(`Released ${released.length} player(s): ${released.join(', ')}`);
+                    }
+                    if (errors.length > 0) {
+                        lines.push(`Errors:\n${errors.map((e) => `  - ${e}`).join('\n')}`);
+                    }
+                    return (0, descriptor_1.ok)(lines.join('\n'));
                 }
-                const lines = [];
-                if (released.length > 0) {
-                    lines.push(`Released ${released.length} player(s): ${released.join(', ')}`);
-                }
-                if (errors.length > 0) {
-                    lines.push(`Errors:\n${errors.map((e) => `  - ${e}`).join('\n')}`);
-                }
-                return (0, helpers_1.ok)(lines.join('\n'));
             }
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to release: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to release: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

package/dist/tools/report.d.ts

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

package/dist/tools/report.js

@@ -1,29 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerReportTool = registerReportTool;
+exports.buildReportTool = buildReportTool;
 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 registerReportTool(server, handle) {
-    (0, helpers_1.defineTool)(server, 'report', 'Send an update to the conductor. Use this to report task completion, blockers, or questions. No-op if no conductor is running.', {
-        text: zod_1.z.string().max(validation_1.MESSAGE_MAX).describe('The report content'),
-        type: zod_1.z.enum(['result', 'blocker', 'question', 'update']).optional()
-            .describe('Type of report: "result" (default, task done), "blocker" (stuck), "question" (need input), "update" (progress update, still working)'),
-    }, async (args) => {
-        const text = args.text;
-        const type = (args.type ?? 'result');
-        try {
-            const entry = {
-                type: 'report',
-                text,
-                reportType: type,
-            };
-            const entryId = await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
-            return (0, helpers_1.ok)(`Report sent to conductor: [${type}] ${text} (outbox: ${entryId})`);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to send report: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+function buildReportTool(handle) {
+    return {
+        name: 'report',
+        description: 'Send an update to the conductor. Use this to report task completion, blockers, or questions. No-op if no conductor is running.',
+        params: {
+            text: zod_1.z.string().max(validation_1.MESSAGE_MAX).describe('The report content'),
+            type: zod_1.z.enum(['result', 'blocker', 'question', 'update']).optional()
+                .describe('Type of report: "result" (default, task done), "blocker" (stuck), "question" (need input), "update" (progress update, still working)'),
+        },
+        handler: async (args) => {
+            const text = args.text;
+            const type = (args.type ?? 'result');
+            try {
+                const entry = {
+                    type: 'report',
+                    text,
+                    reportType: type,
+                };
+                const entryId = await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
+                return (0, descriptor_1.ok)(`Report sent to conductor: [${type}] ${text} (outbox: ${entryId})`);
+            }
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to send report: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

package/dist/tools/reset.d.ts

@@ -0,0 +1,3 @@
+import { WorkflowHandle } from '@temporalio/client';
+import { type TempoToolDescriptor } from './descriptor';
+export declare function buildResetTool(handle: WorkflowHandle, getPlayerId: () => string): TempoToolDescriptor;

package/dist/tools/reset.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildResetTool = buildResetTool;
+/**
+ * `reset` — clean-wipe a player's conversation context (D14). Enqueues a
+ * `ResetOutboxEntry` on the caller's outbox; the dispatch loop runs
+ * `deliverReset` on the target, setting a `pendingReset` flag the target's Pi
+ * extension polls + acts on (Pi `newSession()` — fresh context, no replay).
+ *
+ * D14 ruling: reset = CLEAN-WIPE only (always `fresh: true`). For a context
+ * wipe that RE-SEEDS from saved state, use `restart` with `loadFromState`
+ * instead — that is a different path. Reset is an operator/conductor control op
+ * and does NOT route through the MD-G tool gate.
+ */
+const zod_1 = require("zod");
+const signals_1 = require("../workflows/signals");
+const descriptor_1 = require("./descriptor");
+const validation_1 = require("../utils/validation");
+function buildResetTool(handle, getPlayerId) {
+    return {
+        name: 'reset',
+        description: "Clean-wipe a player's conversation context — the target starts a FRESH " +
+            "session (no transcript replay). Use this to clear a player that's stuck " +
+            'or off-track. For a context wipe that RE-SEEDS from saved state, use ' +
+            '`restart` with `loadFromState` instead.',
+        params: {
+            playerId: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).describe('The player whose context to clean-wipe'),
+            reason: zod_1.z.string().max(500).optional().describe('Optional reason — surfaced to the wiped session and recorded for audit'),
+        },
+        handler: async (args) => {
+            const { playerId, reason } = args;
+            const nameError = (0, validation_1.validatePlayerName)(playerId);
+            if (nameError)
+                return (0, descriptor_1.fail)(nameError);
+            try {
+                const entry = {
+                    type: 'reset',
+                    targetPlayerId: playerId,
+                    invokerPlayerId: getPlayerId(),
+                    fresh: true, // D14: reset = clean-wipe only.
+                    ...(reason !== undefined ? { reason } : {}),
+                };
+                const entryId = await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
+                return (0, descriptor_1.ok)(`Reset (clean-wipe) queued for **${playerId}**. (outbox: ${entryId})`);
+            }
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to reset: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
+}

package/dist/tools/restart.d.ts

@@ -1,6 +1,6 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Client, WorkflowHandle } from '@temporalio/client';
 import { Config } from '../config';
+import { type TempoToolDescriptor } from './descriptor';
 export interface RestartToolArgs {
     playerId: string;
     host?: string;
@@ -32,4 +32,4 @@ export declare function enforceYesStealGuard(client: Client, ensemble: string, p
     force?: boolean;
     confirmStealFromHost?: string;
 }, localHostname?: string): Promise<string | null>;
-export declare function registerRestartTool(server: McpServer, client: Client, config: Config, getPlayerId: () => string, handle: WorkflowHandle): void;
+export declare function buildRestartTool(client: Client, config: Config, getPlayerId: () => string, handle: WorkflowHandle): TempoToolDescriptor;

package/dist/tools/restart.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceYesStealGuard = enforceYesStealGuard;
-exports.registerRestartTool = registerRestartTool;
+exports.buildRestartTool = buildRestartTool;
 /**
  * `restart` — reap the current attachment, claim a fresh one, spawn a new adapter.
  *
@@ -35,7 +35,7 @@ const zod_1 = require("zod");
 const os_1 = require("os");
 const signals_1 = require("../workflows/signals");
 const resolve_1 = require("./resolve");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 const validation_1 = require("../utils/validation");
 const DEFAULT_CONTEXT_MESSAGES = 10;
 /**
@@ -84,48 +84,53 @@ async function enforceYesStealGuard(client, ensemble, playerId, args, localHostn
     }
     return null;
 }
-function registerRestartTool(server, client, config, getPlayerId, handle) {
-    (0, helpers_1.defineTool)(server, 'restart', 'Restart a session — reap the current attachment (gracefully, or with force=true), claim a fresh attachment, spawn a new adapter, and optionally replay recent context. Replaces `encore`, `recruit --force`, and `stop`-then-`recruit`. Pass `host` to restart on a different machine; when `force=true` AND the target is currently on a different host, pass `confirmStealFromHost` matching that hostname (design §16.5). Pass `loadFromState` to seed the restarted session from a saved-state slot (#334) instead of (or alongside) transcript replay.', {
-        playerId: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).describe('The player name to restart'),
-        host: zod_1.z.string().optional().describe('Target host for the new attachment (defaults to the session\'s preferredHost or last-known hostname). When set, the spawn is routed to the per-host task queue `agent-tempo-{host}`.'),
-        fresh: zod_1.z.boolean().optional().describe('Skip context replay — spawn a clean slate (default false)'),
-        force: zod_1.z.boolean().optional().describe('Steal a live attachment via forceDetach (default false; graceful detach is tried first regardless)'),
-        contextMessages: zod_1.z.number().min(0).max(validation_1.RESTART_CONTEXT_MESSAGES_MAX).optional().describe(`Number of recent messages to include in context (default ${DEFAULT_CONTEXT_MESSAGES}, max ${validation_1.RESTART_CONTEXT_MESSAGES_MAX})`),
-        confirmStealFromHost: zod_1.z.string().optional().describe('Required when `force=true` and the target\'s current attachment is on a different host. Must match the hostname currently holding the attachment (design §16.5 Option B).'),
-        // #334 PR-2 — saved-state seed integration.
-        loadFromState: zod_1.z.union([
-            zod_1.z.boolean(),
-            zod_1.z.string().regex(validation_1.PLAYER_STATE_KEY_REGEX).max(validation_1.PLAYER_STATE_KEY_MAX),
-        ]).optional().describe(`Seed the restarted session with a saved-state slot. \`true\` resolves to the default key "${validation_1.PLAYER_STATE_DEFAULT_KEY}"; a string names a specific slot. By default, transcript replay is suppressed when this is set — pass \`transcript: 'replay'\` to stack both. Falls back to transcript replay if the slot is empty.`),
-        transcript: zod_1.z.enum(['suppress', 'replay']).optional().describe('When `loadFromState` is set, controls transcript-replay interaction: `suppress` (default) seeds only the saved state; `replay` seeds the saved state and then replays the recent transcript on top of it. Ignored when `loadFromState` is absent.'),
-    }, async (args) => {
-        const input = args;
-        const nameError = (0, validation_1.validatePlayerName)(input.playerId);
-        if (nameError)
-            return (0, helpers_1.fail)(nameError);
-        // Client-side --yes-steal guard (§16.5). Cross-host force-restart
-        // requires an explicit confirmStealFromHost matching the current holder.
-        const guardError = await enforceYesStealGuard(client, config.ensemble, input.playerId, input);
-        if (guardError)
-            return (0, helpers_1.fail)(guardError);
-        try {
-            const entry = {
-                type: 'restart',
-                targetPlayerId: input.playerId,
-                invokerPlayerId: getPlayerId(),
-                ...(input.host !== undefined ? { host: input.host } : {}),
-                ...(input.fresh !== undefined ? { fresh: input.fresh } : {}),
-                ...(input.force !== undefined ? { force: input.force } : {}),
-                ...(input.contextMessages !== undefined ? { contextMessages: input.contextMessages } : {}),
-                ...(input.loadFromState !== undefined ? { loadFromState: input.loadFromState } : {}),
-                ...(input.transcript !== undefined ? { transcript: input.transcript } : {}),
-            };
-            const entryId = await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
-            return (0, helpers_1.ok)(`Restart queued for **${input.playerId}**${input.host ? ` on ${input.host}` : ''}` +
-                `${input.fresh ? ' (fresh)' : ''}${input.force ? ' (force)' : ''}. (outbox: ${entryId})`);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to restart: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+function buildRestartTool(client, config, getPlayerId, handle) {
+    return {
+        name: 'restart',
+        description: 'Restart a session — reap the current attachment (gracefully, or with force=true), claim a fresh attachment, spawn a new adapter, and optionally replay recent context. Replaces `encore`, `recruit --force`, and `stop`-then-`recruit`. Pass `host` to restart on a different machine; when `force=true` AND the target is currently on a different host, pass `confirmStealFromHost` matching that hostname (design §16.5). Pass `loadFromState` to seed the restarted session from a saved-state slot (#334) instead of (or alongside) transcript replay.',
+        params: {
+            playerId: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).describe('The player name to restart'),
+            host: zod_1.z.string().optional().describe('Target host for the new attachment (defaults to the session\'s preferredHost or last-known hostname). When set, the spawn is routed to the per-host task queue `agent-tempo-{host}`.'),
+            fresh: zod_1.z.boolean().optional().describe('Skip context replay — spawn a clean slate (default false)'),
+            force: zod_1.z.boolean().optional().describe('Steal a live attachment via forceDetach (default false; graceful detach is tried first regardless)'),
+            contextMessages: zod_1.z.number().min(0).max(validation_1.RESTART_CONTEXT_MESSAGES_MAX).optional().describe(`Number of recent messages to include in context (default ${DEFAULT_CONTEXT_MESSAGES}, max ${validation_1.RESTART_CONTEXT_MESSAGES_MAX})`),
+            confirmStealFromHost: zod_1.z.string().optional().describe('Required when `force=true` and the target\'s current attachment is on a different host. Must match the hostname currently holding the attachment (design §16.5 Option B).'),
+            // #334 PR-2 — saved-state seed integration.
+            loadFromState: zod_1.z.union([
+                zod_1.z.boolean(),
+                zod_1.z.string().regex(validation_1.PLAYER_STATE_KEY_REGEX).max(validation_1.PLAYER_STATE_KEY_MAX),
+            ]).optional().describe(`Seed the restarted session with a saved-state slot. \`true\` resolves to the default key "${validation_1.PLAYER_STATE_DEFAULT_KEY}"; a string names a specific slot. By default, transcript replay is suppressed when this is set — pass \`transcript: 'replay'\` to stack both. Falls back to transcript replay if the slot is empty.`),
+            transcript: zod_1.z.enum(['suppress', 'replay']).optional().describe('When `loadFromState` is set, controls transcript-replay interaction: `suppress` (default) seeds only the saved state; `replay` seeds the saved state and then replays the recent transcript on top of it. Ignored when `loadFromState` is absent.'),
+        },
+        handler: async (args) => {
+            const input = args;
+            const nameError = (0, validation_1.validatePlayerName)(input.playerId);
+            if (nameError)
+                return (0, descriptor_1.fail)(nameError);
+            // Client-side --yes-steal guard (§16.5). Cross-host force-restart
+            // requires an explicit confirmStealFromHost matching the current holder.
+            const guardError = await enforceYesStealGuard(client, config.ensemble, input.playerId, input);
+            if (guardError)
+                return (0, descriptor_1.fail)(guardError);
+            try {
+                const entry = {
+                    type: 'restart',
+                    targetPlayerId: input.playerId,
+                    invokerPlayerId: getPlayerId(),
+                    ...(input.host !== undefined ? { host: input.host } : {}),
+                    ...(input.fresh !== undefined ? { fresh: input.fresh } : {}),
+                    ...(input.force !== undefined ? { force: input.force } : {}),
+                    ...(input.contextMessages !== undefined ? { contextMessages: input.contextMessages } : {}),
+                    ...(input.loadFromState !== undefined ? { loadFromState: input.loadFromState } : {}),
+                    ...(input.transcript !== undefined ? { transcript: input.transcript } : {}),
+                };
+                const entryId = await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
+                return (0, descriptor_1.ok)(`Restart queued for **${input.playerId}**${input.host ? ` on ${input.host}` : ''}` +
+                    `${input.fresh ? ' (fresh)' : ''}${input.force ? ' (force)' : ''}. (outbox: ${entryId})`);
+            }
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to restart: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

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