agent-tempo 1.2.0 → 1.4.0

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

package/dist/tools/migrate.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerMigrateTool = registerMigrateTool;
+exports.buildMigrateTool = buildMigrateTool;
 /**
  * `migrate` — sugar for `restart --host=<h>` per design §9.6.
  *
@@ -16,45 +16,50 @@ exports.registerMigrateTool = registerMigrateTool;
  */
 const zod_1 = require("zod");
 const signals_1 = require("../workflows/signals");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 const restart_1 = require("./restart");
 const validation_1 = require("../utils/validation");
-function registerMigrateTool(server, client, config, getPlayerId, handle) {
-    (0, helpers_1.defineTool)(server, 'migrate', 'Migrate a session to a different host — sugar for `restart` with a required `host`. Reaps the current attachment, claims fresh on the target host, spawns a new adapter. Cross-host routing (per-host task queues) is honored automatically. When `force=true` AND the target is currently on a different host, `confirmStealFromHost` must match that hostname (design §16.5).', {
-        playerId: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).describe('The player name to migrate'),
-        host: zod_1.z.string().min(1).describe('Target hostname — required'),
-        fresh: zod_1.z.boolean().optional().describe('Skip context replay (default false)'),
-        force: zod_1.z.boolean().optional().describe('Steal a live attachment via forceDetach (default false)'),
-        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 10)'),
-        confirmStealFromHost: zod_1.z.string().optional().describe('Required when `force=true` and the target\'s current attachment is on a different host (design §16.5 Option B).'),
-    }, async (args) => {
-        const input = args;
-        const nameError = (0, validation_1.validatePlayerName)(input.playerId);
-        if (nameError)
-            return (0, helpers_1.fail)(nameError);
-        if (!input.host || !input.host.trim()) {
-            return (0, helpers_1.fail)('`host` is required for migrate. Use `restart` (without host) to restart on the session\'s current host.');
-        }
-        // Shared cross-host guard with `restart` — same rules, same copy-paste
-        // error messages (§16.5).
-        const guardError = await (0, restart_1.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(),
-                host: input.host,
-                ...(input.fresh !== undefined ? { fresh: input.fresh } : {}),
-                ...(input.force !== undefined ? { force: input.force } : {}),
-                ...(input.contextMessages !== undefined ? { contextMessages: input.contextMessages } : {}),
-            };
-            const entryId = await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
-            return (0, helpers_1.ok)(`Migrate queued for **${input.playerId}** → ${input.host}. (outbox: ${entryId})`);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to migrate: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+function buildMigrateTool(client, config, getPlayerId, handle) {
+    return {
+        name: 'migrate',
+        description: 'Migrate a session to a different host — sugar for `restart` with a required `host`. Reaps the current attachment, claims fresh on the target host, spawns a new adapter. Cross-host routing (per-host task queues) is honored automatically. When `force=true` AND the target is currently on a different host, `confirmStealFromHost` must match that hostname (design §16.5).',
+        params: {
+            playerId: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).describe('The player name to migrate'),
+            host: zod_1.z.string().min(1).describe('Target hostname — required'),
+            fresh: zod_1.z.boolean().optional().describe('Skip context replay (default false)'),
+            force: zod_1.z.boolean().optional().describe('Steal a live attachment via forceDetach (default false)'),
+            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 10)'),
+            confirmStealFromHost: zod_1.z.string().optional().describe('Required when `force=true` and the target\'s current attachment is on a different host (design §16.5 Option B).'),
+        },
+        handler: async (args) => {
+            const input = args;
+            const nameError = (0, validation_1.validatePlayerName)(input.playerId);
+            if (nameError)
+                return (0, descriptor_1.fail)(nameError);
+            if (!input.host || !input.host.trim()) {
+                return (0, descriptor_1.fail)('`host` is required for migrate. Use `restart` (without host) to restart on the session\'s current host.');
+            }
+            // Shared cross-host guard with `restart` — same rules, same copy-paste
+            // error messages (§16.5).
+            const guardError = await (0, restart_1.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(),
+                    host: input.host,
+                    ...(input.fresh !== undefined ? { fresh: input.fresh } : {}),
+                    ...(input.force !== undefined ? { force: input.force } : {}),
+                    ...(input.contextMessages !== undefined ? { contextMessages: input.contextMessages } : {}),
+                };
+                const entryId = await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
+                return (0, descriptor_1.ok)(`Migrate queued for **${input.playerId}** → ${input.host}. (outbox: ${entryId})`);
+            }
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to migrate: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

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

package/dist/tools/pause.js

@@ -1,36 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerPauseTool = registerPauseTool;
+exports.buildPauseTool = buildPauseTool;
 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:pause]', ...args);
-function registerPauseTool(server, client, config, getPlayerId) {
-    (0, helpers_1.defineTool)(server, 'pause', 'Pause all sessions in the ensemble — locks outbox dispatch and pauses the scheduler. Stop commands still go through. Use `play` to unpause.', {}, async () => {
-        try {
-            const [toggle, sessions] = await Promise.all([
-                (0, ensemble_ops_1.pauseMaestroAndScheduler)(client, config.ensemble),
-                (0, ensemble_ops_1.signalAllSessions)(client, config.ensemble, signals_1.setPausedSignal.name, true),
-            ]);
-            const bits = [
-                `Ensemble **${config.ensemble}** paused.`,
-                `${sessions.sent} session(s) paused`,
-            ];
-            if (toggle.maestro)
-                bits.push('maestro paused');
-            if (toggle.scheduler)
-                bits.push('scheduler paused');
-            if (sessions.failed > 0) {
-                const errs = sessions.perSession
-                    .filter((p) => p.outcome === 'failed')
-                    .map((p) => `  - ${p.playerId}: ${'error' in p ? p.error : ''}`);
-                bits.push(`Errors:\n${errs.join('\n')}`);
+function buildPauseTool(client, config, getPlayerId) {
+    return {
+        name: 'pause',
+        description: 'Pause all sessions in the ensemble — locks outbox dispatch and pauses the scheduler. Stop commands still go through. Use `play` to unpause.',
+        params: {},
+        handler: async () => {
+            try {
+                const [toggle, sessions] = await Promise.all([
+                    (0, ensemble_ops_1.pauseMaestroAndScheduler)(client, config.ensemble),
+                    (0, ensemble_ops_1.signalAllSessions)(client, config.ensemble, signals_1.setPausedSignal.name, true),
+                ]);
+                const bits = [
+                    `Ensemble **${config.ensemble}** paused.`,
+                    `${sessions.sent} session(s) paused`,
+                ];
+                if (toggle.maestro)
+                    bits.push('maestro paused');
+                if (toggle.scheduler)
+                    bits.push('scheduler paused');
+                if (sessions.failed > 0) {
+                    const errs = sessions.perSession
+                        .filter((p) => p.outcome === 'failed')
+                        .map((p) => `  - ${p.playerId}: ${'error' in p ? p.error : ''}`);
+                    bits.push(`Errors:\n${errs.join('\n')}`);
+                }
+                log(`Paused ensemble "${config.ensemble}" by ${getPlayerId()}`);
+                return (0, descriptor_1.ok)(bits.join('\n'));
             }
-            log(`Paused ensemble "${config.ensemble}" by ${getPlayerId()}`);
-            return (0, helpers_1.ok)(bits.join('\n'));
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to pause ensemble: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to pause ensemble: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

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

package/dist/tools/play.js

@@ -1,57 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerPlayTool = registerPlayTool;
+exports.buildPlayTool = buildPlayTool;
 const zod_1 = require("zod");
 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:play]', ...args);
-function registerPlayTool(server, client, config, getPlayerId) {
-    (0, helpers_1.defineTool)(server, 'play', 'Resume all paused sessions in the ensemble — unlocks outbox dispatch and resumes the scheduler. Buffered outbox entries will be dispatched. Pass `release: true` to also release any held sessions (deliver deferred task messages and unlock their outboxes) in the same call.', {
-        release: zod_1.z.boolean().optional().describe('Also release any held sessions (deliver deferred task messages and unlock outboxes). Safe to call when no sessions are held — it is a no-op on those. Default: false.'),
-    }, async (args) => {
-        const release = args.release === true;
-        try {
-            // Unpause everything in parallel: maestro + scheduler + every session.
-            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),
-            ]);
-            // `releaseHeld` is idempotent — safe to fan out to everyone. Keep it
-            // AFTER the unpause so sessions aren't releasing while paused.
-            let releasedCount = 0;
-            const releaseErrors = [];
-            if (release) {
-                const released = await (0, ensemble_ops_1.signalAllSessions)(client, config.ensemble, 
-                // typed constant → `'releaseHeld'` string name, matches the session handler
-                signals_1.releaseHeldSignal.name, undefined);
-                releasedCount = released.sent;
-                for (const p of released.perSession) {
-                    if (p.outcome === 'failed')
-                        releaseErrors.push(`${p.playerId} release: ${'error' in p ? p.error : ''}`);
+function buildPlayTool(client, config, getPlayerId) {
+    return {
+        name: 'play',
+        description: 'Resume all paused sessions in the ensemble — unlocks outbox dispatch and resumes the scheduler. Buffered outbox entries will be dispatched. Pass `release: true` to also release any held sessions (deliver deferred task messages and unlock their outboxes) in the same call.',
+        params: {
+            release: zod_1.z.boolean().optional().describe('Also release any held sessions (deliver deferred task messages and unlock outboxes). Safe to call when no sessions are held — it is a no-op on those. Default: false.'),
+        },
+        handler: async (args) => {
+            const release = args.release === true;
+            try {
+                // Unpause everything in parallel: maestro + scheduler + every session.
+                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),
+                ]);
+                // `releaseHeld` is idempotent — safe to fan out to everyone. Keep it
+                // AFTER the unpause so sessions aren't releasing while paused.
+                let releasedCount = 0;
+                const releaseErrors = [];
+                if (release) {
+                    const released = await (0, ensemble_ops_1.signalAllSessions)(client, config.ensemble, 
+                    // typed constant → `'releaseHeld'` string name, matches the session handler
+                    signals_1.releaseHeldSignal.name, undefined);
+                    releasedCount = released.sent;
+                    for (const p of released.perSession) {
+                        if (p.outcome === 'failed')
+                            releaseErrors.push(`${p.playerId} release: ${'error' in p ? p.error : ''}`);
+                    }
                 }
+                const bits = [
+                    `Ensemble **${config.ensemble}** resumed.`,
+                    `${sessions.sent} session(s) resumed`,
+                ];
+                if (release)
+                    bits.push(`${releasedCount} session(s) signalled for release`);
+                if (toggle.maestro)
+                    bits.push('maestro resumed');
+                if (toggle.scheduler)
+                    bits.push('scheduler resumed');
+                const failedUnpause = sessions.perSession
+                    .filter((p) => p.outcome === 'failed')
+                    .map((p) => `  - ${p.playerId}: ${'error' in p ? p.error : ''}`);
+                const allErrors = [...failedUnpause, ...releaseErrors.map((e) => `  - ${e}`)];
+                if (allErrors.length > 0)
+                    bits.push(`Errors:\n${allErrors.join('\n')}`);
+                log(`Resumed ensemble "${config.ensemble}" by ${getPlayerId()}${release ? ' (with release)' : ''}`);
+                return (0, descriptor_1.ok)(bits.join('\n'));
             }
-            const bits = [
-                `Ensemble **${config.ensemble}** resumed.`,
-                `${sessions.sent} session(s) resumed`,
-            ];
-            if (release)
-                bits.push(`${releasedCount} session(s) signalled for release`);
-            if (toggle.maestro)
-                bits.push('maestro resumed');
-            if (toggle.scheduler)
-                bits.push('scheduler resumed');
-            const failedUnpause = sessions.perSession
-                .filter((p) => p.outcome === 'failed')
-                .map((p) => `  - ${p.playerId}: ${'error' in p ? p.error : ''}`);
-            const allErrors = [...failedUnpause, ...releaseErrors.map((e) => `  - ${e}`)];
-            if (allErrors.length > 0)
-                bits.push(`Errors:\n${allErrors.join('\n')}`);
-            log(`Resumed ensemble "${config.ensemble}" by ${getPlayerId()}${release ? ' (with release)' : ''}`);
-            return (0, helpers_1.ok)(bits.join('\n'));
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to resume ensemble: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to resume ensemble: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

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

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

package/dist/tools/quality-gate.js

@@ -1,26 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerQualityGateTool = registerQualityGateTool;
+exports.buildQualityGateTool = buildQualityGateTool;
 const zod_1 = require("zod");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 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 (0, helpers_1.ok)(`Quality gate **${task}** set with ${criteria.length} criteria:\n${lines.join('\n')}`);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to set quality gate: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+function buildQualityGateTool(handle, getPlayerId) {
+    return {
+        name: 'quality_gate',
+        description: '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.',
+        params: {
+            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"])'),
+        },
+        handler: async (args) => {
+            const { task, criteria } = args;
+            try {
+                await handle.signal('setQualityGate', {
+                    task,
+                    criteria,
+                    createdBy: getPlayerId(),
+                });
+                const lines = criteria.map((c, i) => `  ${i}. [ ] ${c}`);
+                return (0, descriptor_1.ok)(`Quality gate **${task}** set with ${criteria.length} criteria:\n${lines.join('\n')}`);
+            }
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to set quality gate: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

package/dist/tools/recall.d.ts

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

package/dist/tools/recall.js

@@ -1,32 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerRecallTool = registerRecallTool;
+exports.buildRecallTool = buildRecallTool;
 const zod_1 = require("zod");
-const helpers_1 = require("./helpers");
+const descriptor_1 = require("./descriptor");
 const recall_format_1 = require("../utils/recall-format");
-function registerRecallTool(server, handle, getPlayerId) {
-    (0, helpers_1.defineTool)(server, 'recall', 'Read your own message history. Shows received messages by default; use includeSent to also see outgoing messages. `offset` pages the timeline; `previewLength` truncates bodies (unset = full text).', {
-        limit: zod_1.z.number().min(1).max(100).optional().describe('Max messages to return (default 20, max 100)'),
-        offset: zod_1.z.number().int().min(0).optional().describe('Skip N messages for paging (default 0)'),
-        previewLength: zod_1.z.number().int().min(1).optional().describe('Truncate each body to N chars + "…"; omit for full text'),
-        since: zod_1.z.string().optional().describe('Only show messages at or after this ISO timestamp'),
-        from: zod_1.z.string().optional().describe('Filter received messages by sender name'),
-        includeSent: zod_1.z.boolean().optional().describe('Include sent messages in the timeline (default: false)'),
-    }, async (args) => {
-        const { limit, offset, previewLength, since, from: fromFilter, includeSent } = args;
-        // Validate `since` up-front so the formatter never sees a garbage date.
-        if (since && Number.isNaN(Date.parse(since))) {
-            return (0, helpers_1.fail)(`Invalid ISO timestamp for "since": ${since}`);
-        }
-        try {
-            const received = await handle.query('allMessages');
-            const sent = includeSent ? await handle.query('allSentMessages') : [];
-            const timeline = (0, recall_format_1.buildTimeline)(received, sent, Boolean(includeSent));
-            const rendered = (0, recall_format_1.formatRecall)(timeline, { limit, offset, previewLength, since, from: fromFilter });
-            return (0, helpers_1.ok)(rendered.text);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to recall messages: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
+function buildRecallTool(handle, getPlayerId) {
+    return {
+        name: 'recall',
+        description: 'Read your own message history. Shows received messages by default; use includeSent to also see outgoing messages. `offset` pages the timeline; `previewLength` truncates bodies (unset = full text).',
+        params: {
+            limit: zod_1.z.number().min(1).max(100).optional().describe('Max messages to return (default 20, max 100)'),
+            offset: zod_1.z.number().int().min(0).optional().describe('Skip N messages for paging (default 0)'),
+            previewLength: zod_1.z.number().int().min(1).optional().describe('Truncate each body to N chars + "…"; omit for full text'),
+            since: zod_1.z.string().optional().describe('Only show messages at or after this ISO timestamp'),
+            from: zod_1.z.string().optional().describe('Filter received messages by sender name'),
+            includeSent: zod_1.z.boolean().optional().describe('Include sent messages in the timeline (default: false)'),
+        },
+        handler: async (args) => {
+            const { limit, offset, previewLength, since, from: fromFilter, includeSent } = args;
+            // Validate `since` up-front so the formatter never sees a garbage date.
+            if (since && Number.isNaN(Date.parse(since))) {
+                return (0, descriptor_1.fail)(`Invalid ISO timestamp for "since": ${since}`);
+            }
+            try {
+                const received = await handle.query('allMessages');
+                const sent = includeSent ? await handle.query('allSentMessages') : [];
+                const timeline = (0, recall_format_1.buildTimeline)(received, sent, Boolean(includeSent));
+                const rendered = (0, recall_format_1.formatRecall)(timeline, { limit, offset, previewLength, since, from: fromFilter });
+                return (0, descriptor_1.ok)(rendered.text);
+            }
+            catch (err) {
+                return (0, descriptor_1.fail)(`Failed to recall messages: ${(0, descriptor_1.formatError)(err)}`);
+            }
+        },
+    };
 }

package/dist/tools/recruit.d.ts

@@ -1,8 +1,8 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Client, WorkflowHandle } from '@temporalio/client';
 import { Config } from '../config';
 import { AgentType } from '../types';
 import type { HostInfo } from '../types';
+import { type TempoToolDescriptor } from './descriptor';
 /**
  * #274 M15 — dep-injection surface on the recruit tool registrar.
  *
@@ -13,7 +13,7 @@ import type { HostInfo } from '../types';
 export interface RegisterRecruitToolDeps {
     listHostsFn?: (client: Client) => Promise<HostInfo[]>;
 }
-export declare function registerRecruitTool(server: McpServer, client: Client, config: Config, getPlayerId: () => string, handle: WorkflowHandle, ownAgentType?: AgentType, deps?: RegisterRecruitToolDeps): void;
+export declare function buildRecruitTool(client: Client, config: Config, getPlayerId: () => string, handle: WorkflowHandle, ownAgentType?: AgentType, deps?: RegisterRecruitToolDeps): TempoToolDescriptor;
 /**
  * Given a host liveness+profile snapshot, validate that `targetHost` is
  * (a) known, (b) recruit-ready, and (c) advertises support for