agent-tempo 1.2.0 → 1.3.1

package/dist/scripts/258-spotcheck.js

@@ -1,303 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * scripts/258-spotcheck.ts — automated #258 "one-delivery-then-silence" probe
- *
- * Ops tooling for the v0.26.0-beta.4 burn-in window (issue #258). Replaces
- * the manual 4-step analysis performed by tempo-researcher on 2026-04-19
- * at ~T+2h into the burn-in (dump at C:\tmp\wf-conductor-burnin.json). Run
- * this whenever you want a fresh read on whether the #249 fix is still
- * holding under real ensemble traffic.
- *
- * NOT committed. NOT production code. No tests, no docs. If this script
- * stops working because the wire protocol evolves, delete and rewrite.
- *
- * ── Usage ─────────────────────────────────────────────────────────────
- *
- *   npx ts-node --project scripts/tsconfig.json scripts/258-spotcheck.ts
- *
- *   Flags (all optional):
- *     --ensemble <name>    Override ensemble (default: $CLAUDE_TEMPO_ENSEMBLE or 'tempo-impl')
- *     --conductor <name>   Override conductor player name (default: 'conductor')
- *     --json               Emit JSON instead of the human table
- *     --save <path>        Write full report JSON to <path>
- *
- * ── Exit codes ────────────────────────────────────────────────────────
- *     0  pattern-not-detected (healthy)
- *     1  unexpected error (Temporal unreachable, workflow missing, etc.)
- *     2  pattern-recurring (hypothesis A or B) — HIGH PRIORITY
- *     3  inconclusive-too-early (< 30 min window)
- *
- * ── Assumptions ───────────────────────────────────────────────────────
- *   • Temporal server reachable via the canonical getConfig() chain
- *     (localhost:7233 default; overridable via TEMPORAL_ADDRESS,
- *     ~/.claude-tempo/config.json, or ~/.config/temporalio/temporal.yaml).
- *   • Conductor workflow ID = `claude-session-{ensemble}-conductor`
- *     (src/config.ts::conductorWorkflowId). For non-default ensembles,
- *     set CLAUDE_TEMPO_ENSEMBLE or pass --ensemble.
- *   • Reads the *current* run via handle-without-runId. If a CAN has
- *     occurred, the SDK returns the latest run — which is exactly what
- *     we want for post-CAN health.
- *   • Signal / update names are per docs/WIRE-PROTOCOL.md (stable):
- *     Signals:  'heartbeat', 'markDelivered', 'receiveMessage',
- *               'playerReport', 'setPaused', 'setPart', 'releaseHeld', ...
- *     Updates:  'claimAttachment', 'submitOutbox', ...
- *
- * ── #258 pattern definitions (from C:\tmp\spike-0d17dc0f-verdict.md) ──
- *
- *   • Hypothesis A — adapter process death:
- *       heartbeats stop mid-window, markDelivered goes silent while
- *       receiveMessage continues arriving, NO reclaim attempts.
- *
- *   • Hypothesis B — delayed fireTerminal('destroy') via reconnect loop:
- *       same silence signature, PLUS at least one claimAttachment reclaim
- *       fired after the silence started (adapter tried to recover, then
- *       a terminal-class error on the pre-check killed the poller).
- *
- *   Thresholds used here (conservative; tune if we recalibrate):
- *       – Heartbeat staleness:  > 180 s since last (3× expected 60 s cadence)
- *       – Silence skew:         receiveMessage last-ts > markDelivered last-ts + 60 s
- *       – Too-early window:     total history span < 30 min
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const client_1 = require("@temporalio/client");
-const fs_1 = require("fs");
-const config_1 = require("../src/config");
-const connection_1 = require("../src/connection");
-// ─── CLI ──────────────────────────────────────────────────────────────
-const args = process.argv.slice(2);
-function argVal(flag) {
-    const i = args.indexOf(flag);
-    return i >= 0 && i + 1 < args.length ? args[i + 1] : undefined;
-}
-const emitJson = args.includes('--json');
-const savePath = argVal('--save');
-const ensembleOverride = argVal('--ensemble');
-const conductorNameOverride = argVal('--conductor') ?? 'conductor';
-// ─── Helpers ──────────────────────────────────────────────────────────
-function tsIso(t) {
-    // Temporal SDK decodes protobuf Timestamp to { seconds: Long|number|bigint, nanos: number }.
-    // Fall back through a few shapes defensively; the SDK's Long type has .toNumber().
-    if (!t)
-        return '';
-    if (typeof t === 'string')
-        return t;
-    const rawSeconds = t.seconds;
-    let seconds;
-    if (typeof rawSeconds === 'bigint')
-        seconds = Number(rawSeconds);
-    else if (typeof rawSeconds === 'number')
-        seconds = rawSeconds;
-    else if (rawSeconds && typeof rawSeconds.toNumber === 'function')
-        seconds = rawSeconds.toNumber();
-    else
-        seconds = 0;
-    const nanos = typeof t.nanos === 'number' ? t.nanos : 0;
-    return new Date(seconds * 1000 + nanos / 1e6).toISOString();
-}
-function addStat(map, name, ts) {
-    const s = map.get(name) ?? { count: 0 };
-    s.count++;
-    if (!s.first)
-        s.first = ts;
-    s.last = ts;
-    map.set(name, s);
-}
-function isoToMs(iso) {
-    return iso ? new Date(iso).getTime() : 0;
-}
-function fmtDur(ms) {
-    const s = Math.max(0, Math.floor(ms / 1000));
-    const h = Math.floor(s / 3600);
-    const m = Math.floor((s % 3600) / 60);
-    const ss = s % 60;
-    return h ? `${h}h ${m}m ${ss}s` : `${m}m ${ss}s`;
-}
-function fmtSec(ms) {
-    return ms === null ? 'n/a' : `${(ms / 1000).toFixed(1)}s`;
-}
-// ─── Main ─────────────────────────────────────────────────────────────
-async function run() {
-    const config = (0, config_1.getConfig)();
-    const ensemble = ensembleOverride ?? config.ensemble ?? 'tempo-impl';
-    const workflowId = conductorNameOverride === 'conductor'
-        ? (0, config_1.conductorWorkflowId)(ensemble)
-        : `claude-session-${ensemble}-${conductorNameOverride}`;
-    const connection = await (0, connection_1.createTemporalConnection)(config);
-    try {
-        const client = new client_1.Client({ connection, namespace: config.temporalNamespace });
-        const handle = client.workflow.getHandle(workflowId);
-        const history = await handle.fetchHistory();
-        const events = history.events ?? [];
-        if (events.length === 0) {
-            throw new Error(`Workflow "${workflowId}" returned no events — is it running? (ensemble="${ensemble}", ns="${config.temporalNamespace}", addr="${config.temporalAddress}")`);
-        }
-        // Run identity (first event is EXECUTION_STARTED; capture its runId).
-        let runId = '(unknown)';
-        const startedAttrs = events[0].workflowExecutionStartedEventAttributes;
-        if (startedAttrs?.originalExecutionRunId)
-            runId = startedAttrs.originalExecutionRunId;
-        const signals = new Map();
-        const updates = new Map();
-        const hbTimes = [];
-        for (const e of events) {
-            const ts = tsIso(e.eventTime);
-            // Presence-of-attribute pattern — matches how src/adapters/base.ts
-            // detects CAN events. Avoids coupling to the numeric eventType enum.
-            if (e.workflowExecutionSignaledEventAttributes) {
-                const name = e.workflowExecutionSignaledEventAttributes.signalName ?? '<unknown>';
-                addStat(signals, name, ts);
-                if (name === 'heartbeat')
-                    hbTimes.push(isoToMs(ts));
-                continue;
-            }
-            if (e.workflowExecutionUpdateAcceptedEventAttributes) {
-                const req = e.workflowExecutionUpdateAcceptedEventAttributes.acceptedRequest;
-                const name = req?.input?.name ?? '<unknown>';
-                addStat(updates, name, ts);
-                continue;
-            }
-        }
-        // Window = first event -> last event
-        const windowStart = tsIso(events[0].eventTime);
-        const windowEnd = tsIso(events[events.length - 1].eventTime);
-        const windowMs = isoToMs(windowEnd) - isoToMs(windowStart);
-        // Heartbeat cadence stats
-        let minGap = null;
-        let maxGap = null;
-        let meanGap = null;
-        if (hbTimes.length >= 2) {
-            const gaps = [];
-            for (let i = 1; i < hbTimes.length; i++)
-                gaps.push(hbTimes[i] - hbTimes[i - 1]);
-            minGap = Math.min(...gaps);
-            maxGap = Math.max(...gaps);
-            meanGap = gaps.reduce((a, b) => a + b, 0) / gaps.length;
-        }
-        const nowMs = Date.now();
-        const STALE_MS = 180000; // 3× 60 s expected cadence
-        const msSinceLast = hbTimes.length ? nowMs - hbTimes[hbTimes.length - 1] : null;
-        const stalled = msSinceLast !== null && msSinceLast > STALE_MS;
-        // Silence-skew detector: markDelivered silent while receiveMessage continues.
-        const receiveLast = signals.get('receiveMessage')?.last;
-        const markLast = signals.get('markDelivered')?.last;
-        const skew = !!receiveLast &&
-            !!markLast &&
-            isoToMs(receiveLast) > isoToMs(markLast) + 60000;
-        // Reclaim-after-silence detector (hypothesis B): a claimAttachment
-        // update fired AFTER markDelivered went quiet.
-        const claimLast = updates.get('claimAttachment')?.last;
-        const reclaimAfterSilence = !!claimLast && !!markLast && isoToMs(claimLast) > isoToMs(markLast) + 60000;
-        // ── Verdict ─────────────────────────────────────────────────────────
-        const TOO_EARLY_MS = 30 * 60 * 1000;
-        let verdict;
-        let verdictReason;
-        if (windowMs < TOO_EARLY_MS) {
-            verdict = 'inconclusive-too-early';
-            verdictReason = `window ${fmtDur(windowMs)} < 30 min minimum — re-run later.`;
-        }
-        else if (stalled && skew && reclaimAfterSilence) {
-            verdict = 'pattern-recurring-hypothesis-B';
-            verdictReason = `heartbeats stale (${fmtSec(msSinceLast)}); markDelivered silent while receiveMessage continued; claimAttachment reclaim fired after silence — consistent with delayed fireTerminal('destroy').`;
-        }
-        else if (stalled && skew) {
-            verdict = 'pattern-recurring-hypothesis-A';
-            verdictReason = `heartbeats stale (${fmtSec(msSinceLast)}); markDelivered silent while receiveMessage continued; no reclaim — consistent with adapter process death.`;
-        }
-        else if (stalled) {
-            verdict = 'pattern-recurring-hypothesis-A';
-            verdictReason = `heartbeats stale (${fmtSec(msSinceLast)} > ${STALE_MS / 1000}s threshold); no inbound-vs-outbound skew detected but cadence is broken.`;
-        }
-        else {
-            verdict = 'pattern-not-detected';
-            const lastPart = msSinceLast !== null ? `last tick ${fmtSec(msSinceLast)} ago` : 'no heartbeats';
-            const maxPart = maxGap !== null ? `max gap ${fmtSec(maxGap)}` : '';
-            verdictReason = `heartbeat cadence healthy (${lastPart}${maxPart ? `, ${maxPart}` : ''}); no signal-flow anomaly.`;
-        }
-        return {
-            workflowId,
-            runId,
-            windowStart,
-            windowEnd,
-            windowMs,
-            eventCount: events.length,
-            signals: Object.fromEntries(signals),
-            updates: Object.fromEntries(updates),
-            heartbeat: {
-                count: hbTimes.length,
-                minGapMs: minGap,
-                maxGapMs: maxGap,
-                meanGapMs: meanGap,
-                staleThresholdMs: STALE_MS,
-                msSinceLast,
-                stalled,
-            },
-            verdict,
-            verdictReason,
-            capturedAt: new Date().toISOString(),
-        };
-    }
-    finally {
-        await connection.close();
-    }
-}
-function printHuman(r) {
-    const sep = '─'.repeat(74);
-    console.log(`\n${sep}`);
-    console.log(`#258 spot-check — ${r.workflowId}`);
-    console.log(sep);
-    console.log(`Run:       ${r.runId}`);
-    console.log(`Window:    ${r.windowStart}  →  ${r.windowEnd}`);
-    console.log(`           ${fmtDur(r.windowMs)}, ${r.eventCount} events`);
-    console.log(`Captured:  ${r.capturedAt}`);
-    console.log();
-    console.log('Signal counts:');
-    const sigRows = Object.entries(r.signals).sort((a, b) => b[1].count - a[1].count);
-    if (sigRows.length === 0)
-        console.log('  (none)');
-    for (const [name, s] of sigRows) {
-        console.log(`  ${name.padEnd(22)} ${String(s.count).padStart(4)}   first=${s.first}   last=${s.last}`);
-    }
-    console.log('\nAccepted-update counts:');
-    const updRows = Object.entries(r.updates).sort((a, b) => b[1].count - a[1].count);
-    if (updRows.length === 0)
-        console.log('  (none)');
-    for (const [name, s] of updRows) {
-        console.log(`  ${name.padEnd(22)} ${String(s.count).padStart(4)}   first=${s.first}   last=${s.last}`);
-    }
-    console.log('\nHeartbeat cadence:');
-    const hb = r.heartbeat;
-    console.log(`  count=${hb.count}   min=${fmtSec(hb.minGapMs)}   max=${fmtSec(hb.maxGapMs)}   mean=${fmtSec(hb.meanGapMs)}`);
-    console.log(`  since last heartbeat: ${fmtSec(hb.msSinceLast)}   stale threshold: ${hb.staleThresholdMs / 1000}s   stalled=${hb.stalled ? 'YES' : 'no'}`);
-    console.log(`\nVerdict: ${r.verdict}`);
-    console.log(`  ${r.verdictReason}`);
-    console.log();
-}
-run()
-    .then((r) => {
-    if (emitJson) {
-        console.log(JSON.stringify(r, null, 2));
-    }
-    else {
-        printHuman(r);
-    }
-    if (savePath) {
-        (0, fs_1.writeFileSync)(savePath, JSON.stringify(r, null, 2));
-        if (!emitJson)
-            console.log(`(saved report JSON to ${savePath})`);
-    }
-    switch (r.verdict) {
-        case 'pattern-not-detected':
-            process.exit(0);
-        case 'inconclusive-too-early':
-            process.exit(3);
-        default:
-            process.exit(2); // hypothesis-A or hypothesis-B — escalate
-    }
-})
-    .catch((err) => {
-    console.error('\n[258-spotcheck] error:', err instanceof Error ? err.message : err);
-    if (err instanceof Error && err.stack)
-        console.error(err.stack);
-    process.exit(1);
-});

package/dist/tools/detach.d.ts

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

package/dist/tools/detach.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerDetachTool = registerDetachTool;
-/**
- * `detach` — graceful reap of a session's adapter without destroying the workflow.
- *
- * QA B1: enqueues a `DetachOutboxEntry` on the caller's workflow outbox rather
- * than firing `requestDetachSignal` directly from tool code. The session
- * workflow's dispatch loop runs the `deliverDetach` activity on the target,
- * which signals `requestDetachSignal` with the supplied `reason` + `deadlineMs`.
- *
- * Design reference: §8.1 (three verbs), §2.4 (phase transitions).
- */
-const zod_1 = require("zod");
-const signals_1 = require("../workflows/signals");
-const helpers_1 = require("./helpers");
-const validation_1 = require("../utils/validation");
-const DEFAULT_DETACH_DEADLINE_MS = 5_000;
-function registerDetachTool(server, _client, _config, getPlayerId, handle) {
-    (0, helpers_1.defineTool)(server, 'detach', 'Gracefully detach a session\'s adapter. The session enters `draining` phase and reaps to `detached` after the deadline or when the adapter exits. The workflow survives — use `restart` to attach a new adapter, or `destroy` to terminate permanently.', {
-        playerId: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).describe('The player name to detach'),
-        deadlineMs: zod_1.z.number().min(0).max(validation_1.MAX_DETACH_DEADLINE_MS).optional().describe(`Max drain time in ms before force-detach (default ${DEFAULT_DETACH_DEADLINE_MS}, max ${validation_1.MAX_DETACH_DEADLINE_MS})`),
-    }, async (args) => {
-        const { playerId, deadlineMs = DEFAULT_DETACH_DEADLINE_MS } = args;
-        const nameError = (0, validation_1.validatePlayerName)(playerId);
-        if (nameError)
-            return (0, helpers_1.fail)(nameError);
-        if (playerId === getPlayerId()) {
-            return (0, helpers_1.fail)('Cannot detach your own session.');
-        }
-        try {
-            const entry = {
-                type: 'detach',
-                targetPlayerId: playerId,
-                reason: 'user-stop',
-                deadlineMs,
-            };
-            const entryId = await handle.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
-            return (0, helpers_1.ok)(`Detach queued for **${playerId}** (deadline: ${deadlineMs}ms; outbox: ${entryId}).`);
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to detach: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
-}

package/dist/tools/encore.d.ts

@@ -1,4 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { Client, WorkflowHandle } from '@temporalio/client';
-import type { Config } from '../config';
-export declare function registerEncoreTool(_server: McpServer, _client: Client, _config: Config, _getPlayerId: () => string, _handle: WorkflowHandle): void;

package/dist/tools/encore.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerEncoreTool = registerEncoreTool;
-/**
- * `encore` — deprecation shim (PR-D).
- *
- * The `encore` verb is retired in v0.25 per design §8.1 "three verbs" —
- * replaced by `restart`, which runs the same §8.2 algorithm (forceDetach +
- * claimAttachment + context replay + enqueueSpawn) but is not limited to
- * `stale`-only targets.
- *
- * The MCP tool remains registered so existing clients discover it via
- * ListTools but returns an `isError` pointing to the replacement. The
- * internal `case 'encore':` outbox dispatch and `performEncore` activity
- * are still live; `restart` doesn't use them, but they stay so scheduler /
- * test fixtures that enqueue encore entries keep working until v0.25.1.
- */
-const zod_1 = require("zod");
-const helpers_1 = require("./helpers");
-function registerEncoreTool(_server, _client, _config, _getPlayerId, _handle) {
-    (0, helpers_1.defineTool)(_server, 'encore', '[deprecated in v0.25] The `encore` verb is retired — use `restart` instead, which runs the same forceDetach + claim + context-replay + enqueueSpawn algorithm but is not limited to stale targets.', {
-        playerId: zod_1.z.string().describe('The player name to revive'),
-        host: zod_1.z.string().optional().describe('Target hostname (legacy)'),
-        contextMessages: zod_1.z.number().optional().describe('Number of recent messages (legacy)'),
-    }, async () => {
-        return (0, helpers_1.fail)('The `encore` tool is deprecated. Use `restart` instead.\n' +
-            '  • `restart` runs the same algorithm (forceDetach → claim → context replay → spawn)\n' +
-            '  • Not limited to `stale`-only targets — works on any non-`gone` phase\n' +
-            '  • Pair with `host=<h>` or use `migrate` for cross-host revive');
-    });
-}

package/dist/tools/pause-ensemble.d.ts

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

package/dist/tools/pause-ensemble.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerPauseEnsembleTool = registerPauseEnsembleTool;
-const config_1 = require("../config");
-const resolve_1 = require("../activities/resolve");
-const helpers_1 = require("./helpers");
-const log = (...args) => console.error('[claude-tempo:pause]', ...args);
-function registerPauseEnsembleTool(server, client, config, getPlayerId) {
-    (0, helpers_1.defineTool)(server, 'pause_ensemble', 'Pause all sessions in the ensemble — locks outbox dispatch and pauses the scheduler. Stop commands still go through. Use resume_ensemble to unpause.', {}, async () => {
-        try {
-            const results = [];
-            const errors = [];
-            // 1. Signal maestro with paused state (ground truth)
-            try {
-                const maestroId = (0, config_1.maestroWorkflowId)(config.ensemble);
-                const maestroHandle = client.workflow.getHandle(maestroId);
-                await maestroHandle.signal('maestroSetPaused', true);
-                results.push('maestro paused');
-            }
-            catch {
-                // Maestro may not be running
-            }
-            // 2. Signal all active sessions
-            const sessions = await (0, resolve_1.scanEnsembleSessions)(client, config.ensemble);
-            let sessionCount = 0;
-            for (const session of sessions) {
-                try {
-                    const sessionHandle = client.workflow.getHandle(session.workflowId);
-                    await sessionHandle.signal('setPaused', true);
-                    sessionCount++;
-                }
-                catch (err) {
-                    errors.push(`${session.playerId}: ${(0, helpers_1.formatError)(err)}`);
-                }
-            }
-            results.push(`${sessionCount} session(s) paused`);
-            // 3. Signal scheduler
-            try {
-                const schedulerId = (0, config_1.schedulerWorkflowId)(config.ensemble);
-                const schedulerHandle = client.workflow.getHandle(schedulerId);
-                await schedulerHandle.signal('setSchedulerPaused', true);
-                results.push('scheduler paused');
-            }
-            catch {
-                // Scheduler may not be running
-            }
-            const lines = [`Ensemble **${config.ensemble}** paused.`, results.join(', ')];
-            if (errors.length > 0) {
-                lines.push(`Errors:\n${errors.map((e) => `  - ${e}`).join('\n')}`);
-            }
-            log(`Paused ensemble "${config.ensemble}" by ${getPlayerId()}`);
-            return (0, helpers_1.ok)(lines.join('\n'));
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to pause ensemble: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
-}

package/dist/tools/resume-ensemble.d.ts

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

package/dist/tools/resume-ensemble.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerResumeEnsembleTool = registerResumeEnsembleTool;
-const zod_1 = require("zod");
-const config_1 = require("../config");
-const resolve_1 = require("../activities/resolve");
-const signals_1 = require("../workflows/signals");
-const helpers_1 = require("./helpers");
-const log = (...args) => console.error('[claude-tempo:resume]', ...args);
-function registerResumeEnsembleTool(server, client, config, getPlayerId) {
-    (0, helpers_1.defineTool)(server, 'resume_ensemble', '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 {
-            const results = [];
-            const errors = [];
-            // 1. Signal maestro with unpaused state (ground truth)
-            try {
-                const maestroId = (0, config_1.maestroWorkflowId)(config.ensemble);
-                const maestroHandle = client.workflow.getHandle(maestroId);
-                await maestroHandle.signal('maestroSetPaused', false);
-                results.push('maestro resumed');
-            }
-            catch {
-                // Maestro may not be running
-            }
-            // 2. Signal all active sessions — unpause, and release held ones if opted in.
-            // `releaseHeld` is idempotent on sessions that aren't holding (no heldMessage,
-            // outboxLocked: false already), so it's safe to fan out unconditionally when
-            // `release: true`. See `src/workflows/session.ts` releaseHeldSignal handler.
-            const sessions = await (0, resolve_1.scanEnsembleSessions)(client, config.ensemble);
-            let sessionCount = 0;
-            let releasedCount = 0;
-            for (const session of sessions) {
-                try {
-                    const sessionHandle = client.workflow.getHandle(session.workflowId);
-                    await sessionHandle.signal('setPaused', false);
-                    sessionCount++;
-                    if (release) {
-                        try {
-                            await sessionHandle.signal(signals_1.releaseHeldSignal);
-                            releasedCount++;
-                        }
-                        catch (err) {
-                            errors.push(`${session.playerId} release: ${(0, helpers_1.formatError)(err)}`);
-                        }
-                    }
-                }
-                catch (err) {
-                    errors.push(`${session.playerId}: ${(0, helpers_1.formatError)(err)}`);
-                }
-            }
-            results.push(`${sessionCount} session(s) resumed`);
-            if (release) {
-                results.push(`${releasedCount} session(s) signalled for release`);
-            }
-            // 3. Signal scheduler
-            try {
-                const schedulerId = (0, config_1.schedulerWorkflowId)(config.ensemble);
-                const schedulerHandle = client.workflow.getHandle(schedulerId);
-                await schedulerHandle.signal('setSchedulerPaused', false);
-                results.push('scheduler resumed');
-            }
-            catch {
-                // Scheduler may not be running
-            }
-            const lines = [`Ensemble **${config.ensemble}** resumed.`, results.join(', ')];
-            if (errors.length > 0) {
-                lines.push(`Errors:\n${errors.map((e) => `  - ${e}`).join('\n')}`);
-            }
-            log(`Resumed ensemble "${config.ensemble}" by ${getPlayerId()}${release ? ' (with release)' : ''}`);
-            return (0, helpers_1.ok)(lines.join('\n'));
-        }
-        catch (err) {
-            return (0, helpers_1.fail)(`Failed to resume ensemble: ${(0, helpers_1.formatError)(err)}`);
-        }
-    });
-}

package/dist/tools/stop.d.ts

@@ -1,4 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { Client, WorkflowHandle } from '@temporalio/client';
-import type { Config } from '../config';
-export declare function registerStopTool(_server: McpServer, _client: Client, _config: Config, _getPlayerId: () => string, _handle: WorkflowHandle): void;

package/dist/tools/stop.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerStopTool = registerStopTool;
-/**
- * `stop` — deprecation shim (PR-D).
- *
- * The `stop` verb is retired in v0.25 per design §8.1 "three verbs". Its two
- * distinct semantics are now separate tools:
- *   - graceful reap of the adapter, workflow survives → `detach`
- *   - terminal teardown of the workflow → `destroy`
- *
- * The MCP tool remains registered (so existing clients discover it via
- * ListTools) but returns an `isError` result pointing to the replacement.
- * The CLI-level `claude-tempo stop` command is unchanged — it's still useful
- * for bulk cleanup (ensemble-wide or `--all`).
- */
-const zod_1 = require("zod");
-const helpers_1 = require("./helpers");
-function registerStopTool(_server, _client, _config, _getPlayerId, _handle) {
-    (0, helpers_1.defineTool)(_server, 'stop', '[deprecated in v0.25] The `stop` verb was split into `detach` (graceful adapter reap, workflow survives) and `destroy` (terminal teardown). This tool now returns an error pointing you to the right one.', {
-        playerId: zod_1.z.string().describe('The player name to stop'),
-        force: zod_1.z.boolean().optional().describe('Legacy force flag — no longer honored'),
-    }, async () => {
-        return (0, helpers_1.fail)('The `stop` tool is deprecated. Use:\n' +
-            '  • `detach` — gracefully reap the adapter; workflow survives (use this for most cases)\n' +
-            '  • `destroy` — terminally end the workflow; abandons in-flight outbox\n' +
-            '  • `restart` — reap + claim a fresh adapter with context replay');
-    });
-}

package/dist/tui/client.d.ts

@@ -1,6 +0,0 @@
-/**
- * Re-export TempoClient from src/client/ for backward compatibility.
- * All new consumers should import from '../client' directly.
- */
-export { createTempoClient } from '../client';
-export type { TempoClient, EnsembleSummary } from '../client';

package/dist/tui/client.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTempoClient = void 0;
-/**
- * Re-export TempoClient from src/client/ for backward compatibility.
- * All new consumers should import from '../client' directly.
- */
-var client_1 = require("../client");
-Object.defineProperty(exports, "createTempoClient", { enumerable: true, get: function () { return client_1.createTempoClient; } });

package/dist/tui/components/ActivityLog.d.ts

@@ -1,16 +0,0 @@
-/**
- * Activity log — shows recent Maestro events (player joins, leaves, status changes).
- */
-import React from 'react';
-import type { MaestroEvent } from '../../types';
-export interface ActivityLogProps {
-    events: MaestroEvent[];
-    maxVisible?: number;
-}
-export declare function ActivityLog({ events, maxVisible }: ActivityLogProps): React.FunctionComponentElement<{
-    flexDirection: string;
-}> | React.CElement<{
-    flexDirection: string;
-}, React.Component<{
-    flexDirection: string;
-}, any, any>>;

package/dist/tui/components/ActivityLog.js

@@ -1,36 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActivityLog = ActivityLog;
-/**
- * Activity log — shows recent Maestro events (player joins, leaves, status changes).
- */
-const react_1 = __importDefault(require("react"));
-const ink_context_1 = require("../ink-context");
-const format_1 = require("../utils/format");
-const platform_1 = require("../utils/platform");
-function ActivityLog({ events, maxVisible = 15 }) {
-    const { Box, Text } = (0, ink_context_1.useInk)();
-    const icons = (0, platform_1.statusIcons)();
-    const visible = events.slice(-maxVisible);
-    if (visible.length === 0) {
-        return react_1.default.createElement(Box, { flexDirection: 'column' }, react_1.default.createElement(Text, { dimColor: true }, 'No events yet'));
-    }
-    return react_1.default.createElement(Box, { flexDirection: 'column' }, ...visible.map((e, i) => {
-        const time = (0, format_1.formatTime)(e.timestamp);
-        const typeLabel = (0, format_1.formatEventType)(e.type);
-        const icon = e.type === 'player_joined' ? icons.check
-            : e.type === 'player_left' ? icons.cross
-                : icons.arrow;
-        const color = e.type === 'player_joined' ? 'green'
-            : e.type === 'player_left' ? 'red'
-                : e.type === 'status_changed' ? 'yellow'
-                    : 'white';
-        const detail = e.newValue
-            ? ` ${icons.arrow} ${e.newValue}`
-            : '';
-        return react_1.default.createElement(Box, { key: `${e.timestamp}-${i}` }, react_1.default.createElement(Text, { dimColor: true }, `[${time}] `), react_1.default.createElement(Text, { color }, `${icon} `), react_1.default.createElement(Text, { bold: true }, e.playerId), react_1.default.createElement(Text, { dimColor: true }, ` ${typeLabel}`), react_1.default.createElement(Text, null, detail));
-    }));
-}