agent-tempo 1.0.1

package/dist/tools/ensemble.js

@@ -0,0 +1,198 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DORMANT_THRESHOLD_MS = void 0;
+exports.classifyDormancy = classifyDormancy;
+exports.registerEnsembleTool = registerEnsembleTool;
+const zod_1 = require("zod");
+const os = __importStar(require("os"));
+const resolve_1 = require("../activities/resolve");
+const helpers_1 = require("./helpers");
+const duration_1 = require("../utils/duration");
+/**
+ * Default dormancy threshold (1 hour). Per #563: a `detached` player whose
+ * last activity is older than this is considered dormant. `phase === 'gone'`
+ * is dormant regardless of timestamp.
+ */
+exports.DORMANT_THRESHOLD_MS = 60 * 60 * 1000;
+/**
+ * Classify a session as `'active'` or `'dormant'` per the #563 rules.
+ *
+ * - `phase === 'gone'` → always dormant.
+ * - `phase === 'detached'` AND `lastActivityAt` older than `thresholdMs`
+ *   → dormant.
+ * - `phase === 'detached'` AND `lastActivityAt` missing → dormant. (Pre-W2
+ *   sessions don't carry the timestamp; operator intent is to declutter
+ *   the active list, so we err toward grouping these with the cruft. The
+ *   default `--dormant=show` still shows them, just in their own section.)
+ * - Otherwise → active. Includes `awaiting` (live attachment), `processing`,
+ *   `attached`, `booting`, `draining`, and the undefined-phase case (older
+ *   workflows that predate the attachment lifecycle).
+ *
+ * Pure function — injectable `now` keeps it deterministic under test.
+ *
+ * Exported for unit testing.
+ */
+function classifyDormancy(session, now, thresholdMs = exports.DORMANT_THRESHOLD_MS) {
+    if (session.phase === 'gone')
+        return 'dormant';
+    if (session.phase === 'detached') {
+        if (!session.lastActivityAt)
+            return 'dormant';
+        const lastMs = Date.parse(session.lastActivityAt);
+        if (!Number.isFinite(lastMs))
+            return 'dormant';
+        if (now - lastMs > thresholdMs)
+            return 'dormant';
+    }
+    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') {
+            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
+            }
+        }
+        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'));
+            }
+            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, helpers_1.ok)(sections.join('\n'));
+    });
+}
+/**
+ * Render one player as the multi-line block historically emitted by
+ * `ensemble`. Dormant entries append a "last seen X ago" line so operators
+ * can gauge staleness without a second tool call.
+ *
+ * Kept private — the renderer's exact text is the tool's UI surface, not a
+ * stable API; the test exercises classification + the structural split, not
+ * line-by-line formatting.
+ */
+function renderPlayerLine(p, now, isDormant) {
+    const tags = [
+        p.isYou ? '(you)' : '',
+        p.isConductor ? '(conductor)' : '',
+        p.agentType === 'copilot' ? '[copilot]' : '',
+        phaseTag(p.phase),
+    ].filter(Boolean).join(' ');
+    const nameDisplay = p.playerType
+        ? `**${p.playerId}** (${p.playerType})`
+        : `**${p.playerId}**`;
+    const lines = [
+        `${nameDisplay} ${tags}`.trim(),
+        `  Part: ${p.part}`,
+        `  Dir: ${p.workDir}`,
+        p.gitBranch ? `  Branch: ${p.gitBranch}` : '',
+        `  Host: ${p.hostname}`,
+    ];
+    if (isDormant && p.lastActivityAt) {
+        lines.push(`  Last seen: ${(0, duration_1.formatTimeAgo)(p.lastActivityAt, now)}`);
+    }
+    return lines.filter(Boolean).join('\n');
+}
+/**
+ * Option-B phase → tag mapping (see #176 PR):
+ *   booting → (pending); attached/processing/awaiting → no tag;
+ *   draining/detached → (disconnected); gone → (gone).
+ * #203: typed as AttachmentPhase (callers always have the typed phase
+ * in hand via EnsembleSessionInfo.phase); `string` lost enum discipline.
+ */
+function phaseTag(phase) {
+    if (phase === 'booting')
+        return '(pending)';
+    if (phase === 'draining' || phase === 'detached')
+        return '(disconnected)';
+    if (phase === 'gone')
+        return '(gone)';
+    return '';
+}

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

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

package/dist/tools/evaluate-gate.js

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

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

@@ -0,0 +1,13 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { WorkflowHandle, Client } from '@temporalio/client';
+import { Config } from '../config';
+/**
+ * Return type is monomorphic by design: `{ content, savedAt, savedBy } | null`.
+ * ADR 0011 §Alternatives explicitly rejected a `list: boolean` flag because
+ * the overloaded return shape (slot vs `string[]`) would force union-narrowing
+ * on every downstream consumer (TUI, dashboard, future TempoClient). Slot
+ * enumeration is reachable for operators via `temporal workflow query <id>
+ * 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;

package/dist/tools/fetch-state.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFetchStateTool = registerFetchStateTool;
+/**
+ * `fetch_state` — read a saved state slot for self or any peer in the
+ * ensemble (#334 PR-1, ADR 0011).
+ *
+ * Permissions are by-design open for reads — the architect's design §5.4
+ * mirrors `recall` / `attachment_info` ergonomics: any player in the
+ * ensemble can read any other player's saved state. Audit identity lives
+ * on the entry's `savedBy` field. Writes/clears remain owner-only by
+ * structure (no `playerId` arg on `save_state` / `clear_state`).
+ *
+ * Implementation note: peer reads go through `resolveSession()` (the
+ * codebase convention), NOT a raw `client.workflow.getHandle(...)`. This
+ * matches every other peer-targeting tool (`cue`, `attachment_info`,
+ * `recall`) and inherits their resilience to workflow-id format drift.
+ *
+ * Phase=gone behavior: Temporal continues to serve queries against
+ * completed workflows (returning the last-known query state from history).
+ * `fetch_state` therefore returns the slot's final value even after
+ * `destroy` — useful for post-mortem inspection. If the workflow has been
+ * fully GC'd or never existed, `resolveSession` returns null and the tool
+ * surfaces a "no session found" error.
+ */
+const zod_1 = require("zod");
+const resolve_1 = require("./resolve");
+const signals_1 = require("../workflows/signals");
+const helpers_1 = require("./helpers");
+const validation_1 = require("../utils/validation");
+/**
+ * Return type is monomorphic by design: `{ content, savedAt, savedBy } | null`.
+ * ADR 0011 §Alternatives explicitly rejected a `list: boolean` flag because
+ * the overloaded return shape (slot vs `string[]`) would force union-narrowing
+ * on every downstream consumer (TUI, dashboard, future TempoClient). Slot
+ * enumeration is reachable for operators via `temporal workflow query <id>
+ * 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.
+
+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}".`);
+            }
+            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})`);
+            }
+            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)}`);
+        }
+    });
+}

package/dist/tools/gates.d.ts

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

package/dist/tools/gates.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGatesTool = registerGatesTool;
+const zod_1 = require("zod");
+const helpers_1 = require("./helpers");
+const validation_1 = require("../utils/validation");
+function registerGatesTool(server, handle) {
+    (0, helpers_1.defineTool)(server, 'gates', 'List quality gates and their status. Optionally filter by task name or status. Conductor only.', {
+        task: zod_1.z.string().max(validation_1.GATE_TASK_MAX).optional().describe('Filter by specific task name'),
+        status: zod_1.z.enum(['open', 'passed', 'failed']).optional().describe('Filter by gate status'),
+    }, async (args) => {
+        const { task, status } = args;
+        try {
+            const gates = await handle.query('qualityGates');
+            let filtered = gates;
+            if (task) {
+                filtered = filtered.filter((g) => g.task === task);
+            }
+            if (status) {
+                filtered = filtered.filter((g) => g.status === status);
+            }
+            if (filtered.length === 0) {
+                return (0, helpers_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, 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/helpers.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/** Standard MCP tool result type. */
+export type ToolResult = {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+};
+/** Return a successful tool result. */
+export declare function ok(text: string): ToolResult;
+/** Return an error tool result. */
+export declare function fail(text: string): ToolResult;
+/** Extract a human-readable message from an unknown error. */
+export declare function formatError(err: unknown): string;
+/**
+ * Wrapper around McpServer.tool() that avoids TS2589 deep type instantiation
+ * errors caused by Zod 3.25 + MCP SDK type inference interaction.
+ */
+export declare function defineTool(server: McpServer, name: string, description: string, paramsSchema: Record<string, z.ZodTypeAny>, handler: (args: Record<string, any>, extra: any) => Promise<ToolResult>): void;

package/dist/tools/helpers.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ok = ok;
+exports.fail = fail;
+exports.formatError = formatError;
+exports.defineTool = defineTool;
+/** Return a successful tool result. */
+function ok(text) {
+    return { content: [{ type: 'text', text }] };
+}
+/** Return an error tool result. */
+function fail(text) {
+    return { content: [{ type: 'text', text }], isError: true };
+}
+/** Extract a human-readable message from an unknown error. */
+function formatError(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/**
+ * Wrapper around McpServer.tool() that avoids TS2589 deep type instantiation
+ * errors caused by Zod 3.25 + MCP SDK type inference interaction.
+ */
+function defineTool(server, name, description, paramsSchema, handler) {
+    server.tool(name, description, paramsSchema, handler);
+}

package/dist/tools/hosts.d.ts

@@ -0,0 +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;

package/dist/tools/hosts.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerHostsTool = registerHostsTool;
+/**
+ * `hosts` — MCP tool for surfacing daemons polling the Temporal namespace (#274).
+ *
+ * Joins two sources of truth and returns a formatted text payload:
+ *   - Temporal's own poller registry (`describeTaskQueue`), filtered to
+ *     identities parseable as `agent-tempo:<host>:<pid>:<version>` or
+ *     the legacy `<pid>@<hostname>` SDK default.
+ *   - The `hostProfiles` projection maintained by the global maestro
+ *     from daemon boot signals.
+ *
+ * Consumes the shared formatter from `src/utils/format-hosts.ts`, so
+ * CLI `agent-tempo hosts` and TUI `/hosts` produce the same text.
+ * Thin wrapper — all the logic is in `listHosts`.
+ */
+const zod_1 = require("zod");
+const helpers_1 = require("./helpers");
+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)}`);
+        }
+    });
+}

package/dist/tools/listen.d.ts

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

package/dist/tools/listen.js

@@ -0,0 +1,22 @@
+"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.');
+            }
+            // 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)}`);
+        }
+    });
+}

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

@@ -0,0 +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;