agent-tempo 1.0.1

package/dist/scripts/verify-daemon-isolation-guard.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+"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 });
+/**
+ * Manual verification script for the #157 isolation guard
+ * (`test/daemon-command-isolation.test.ts`).
+ *
+ * QA observation on PR #218: the isolation test asserts the guard PASSES on
+ * the current daemon-command module, but never empirically verifies the
+ * guard would FAIL if a forbidden import leaked in. This script plugs that
+ * gap — run it as a one-shot sanity check (e.g. before a release or after
+ * touching CLI imports) to confirm the detector's fail-side actually works.
+ *
+ * Usage:
+ *   npm run build:scripts && node dist/scripts/verify-daemon-isolation-guard.js
+ *
+ * How it works:
+ *   Spawns a child `node -e "..."` that (a) requires the compiled
+ *   daemon-command module, then (b) ALSO requires `@temporalio/client` —
+ *   simulating a hypothetical regression where daemon-command grew a
+ *   forbidden import. Runs the same require.cache scan logic as the
+ *   isolation test and asserts it DOES find `@temporalio/*` entries.
+ *
+ * The test in test/daemon-command-isolation.test.ts guards the pass path
+ * (no Temporal leaks via daemon-command's own dep chain). This script
+ * guards the detector itself — it confirms the scan would catch a leak.
+ *
+ * Exit 0 = guard-detector works correctly on a simulated regression.
+ * Exit 1 = guard-detector silently accepted a forbidden import (bug in
+ *          the detector itself, or the test's FORBIDDEN_PATTERNS array is
+ *          missing a case).
+ */
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const DAEMON_COMMAND_DIST = path.join(REPO_ROOT, 'dist', 'cli', 'daemon-command.js');
+if (!fs.existsSync(DAEMON_COMMAND_DIST)) {
+    console.error('dist/cli/daemon-command.js not found. Run `npm run build` before this script.');
+    process.exit(1);
+}
+let temporalClientPath;
+try {
+    temporalClientPath = require.resolve('@temporalio/client', { paths: [REPO_ROOT] });
+}
+catch (err) {
+    console.error('Could not resolve @temporalio/client from repo node_modules. Run `npm install` first.');
+    console.error(err && err.message);
+    process.exit(1);
+}
+const detector = `
+  // Step 1: load daemon-command (should leave require.cache clean of Temporal).
+  require(${JSON.stringify(DAEMON_COMMAND_DIST)});
+  // Step 2: simulate a regression — load @temporalio/client directly.
+  // This is what would happen if a future edit to daemon-command (or one of
+  // its deps) accidentally imported something Temporal-adjacent.
+  require(${JSON.stringify(temporalClientPath)});
+  // Step 3: run the same detector as test/daemon-command-isolation.test.ts.
+  const forbidden = [
+    /[\\\\/]@temporalio[\\\\/]/,
+    /[\\\\/]rxjs[\\\\/]/,
+    /[\\\\/]@grpc[\\\\/]/,
+    /[\\\\/]nice-grpc(?:-[^\\\\/]+)?[\\\\/]/,
+    /[\\\\/]long[\\\\/]umd[\\\\/]/,
+  ];
+  const hits = Object.keys(require.cache).filter((k) => forbidden.some((re) => re.test(k)));
+  if (hits.length > 0) {
+    console.log('Detector found ' + hits.length + ' forbidden module(s) in require.cache:');
+    for (const h of hits.slice(0, 3)) console.log('  ' + h);
+    if (hits.length > 3) console.log('  ... (' + (hits.length - 3) + ' more)');
+    process.exit(0);
+  }
+  console.error('BUG: detector did not flag any of the injected forbidden modules.');
+  process.exit(1);
+`;
+const result = (0, child_process_1.spawnSync)(process.execPath, ['-e', detector], {
+    stdio: ['ignore', 'inherit', 'inherit'],
+    cwd: REPO_ROOT,
+});
+if (result.status === 0) {
+    console.log('\nIsolation guard fail-path verified. The detector correctly flags forbidden imports.');
+    console.log('   (The isolation test in test/daemon-command-isolation.test.ts will catch a real regression.)');
+    process.exit(0);
+}
+else {
+    console.error('\nIsolation guard fail-path NOT verified.');
+    if (result.status === 1) {
+        console.error('   The detector silently accepted injected forbidden imports — regression in the detector itself,');
+        console.error('   OR the FORBIDDEN_PATTERNS array in test/daemon-command-isolation.test.ts is missing a case.');
+    }
+    else {
+        console.error(`   Child exited with status ${result.status}. See output above for the cause.`);
+    }
+    process.exit(1);
+}

package/dist/server-tools.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Shared tool-registration + instructions helpers.
+ *
+ * `src/server.ts` builds an MCP server backed by stdio and registers every
+ * tempo tool onto it. The `claude-api` adapter (#131 Phase C) builds a
+ * second MCP server backed by `InMemoryTransport` and needs the **same**
+ * tool surface registered onto it. Extracting both helpers here keeps the
+ * two callsites in lock-step — adding a new tool to one surface lights it
+ * up on the other automatically.
+ *
+ * Mirrors the dual-purpose pattern used elsewhere (e.g. `src/connection.ts`
+ * shared by daemon + adapter subprocesses): keep cross-surface knowledge
+ * in a single module rather than letting drift accumulate.
+ *
+ * Design reference: `docs/design/131-claude-api-adapter.md` §4 (in-process
+ * MCP bridge) — engineer pickup explicitly calls out a `registerAllTempoTools`
+ * helper at line ~478.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Client, WorkflowHandle } from '@temporalio/client';
+import { Config } from './config';
+import { AgentType } from './types';
+/**
+ * Identity + state context every tool registration consumes. The two
+ * surfaces (stdio MCP server in `src/server.ts`, in-process MCP server in
+ * the claude-api adapter) build the same struct from their respective
+ * boot paths and pass it to {@link registerAllTempoTools}.
+ *
+ * Note: `setPlayerId` is the rename hook used by `set_name`. The adapter
+ * passes a no-op for headless players that don't need rename support; the
+ * stdio server passes its real setter so a `set_name` call from the LLM
+ * updates the in-process identity used by subsequent tool invocations.
+ */
+export interface RegisterAllTempoToolsOpts {
+    client: Client;
+    config: Config;
+    /** Returns the current player id. Mutates over a session via `set_name`. */
+    getPlayerId: () => string;
+    /** Update the player id (drives `set_name`). Adapter callers may pass a no-op. */
+    setPlayerId: (id: string) => void;
+    /** Handle to the player's own session workflow. */
+    handle: WorkflowHandle;
+    /** Workflow id of the player's session. Forwarded to ensemble tool. */
+    workflowId: string;
+    /** Default agent for `recruit` when the caller doesn't override. */
+    ownAgentType: AgentType;
+    /** Whether this player is the ensemble's conductor (gates conductor-only tools). */
+    isConductor: boolean;
+}
+/**
+ * Register every tempo MCP tool onto `server`. Single source of truth — the
+ * stdio MCP server (`src/server.ts`) and the in-process MCP server in the
+ * claude-api adapter both call this with the same option struct. Adding a
+ * new tool here lights it up on every surface without per-callsite drift.
+ *
+ * Conductor-only tools (quality gates, worktrees, stages) are gated by
+ * `opts.isConductor` — non-conductor players don't see them on either
+ * surface.
+ */
+export declare function registerAllTempoTools(server: McpServer, opts: RegisterAllTempoToolsOpts): void;
+/**
+ * Identity + ensemble context for {@link buildServerInstructions}.
+ * Same struct shape across the two callers (stdio server + claude-api
+ * adapter); the latter appends a headless-only addendum after the shared
+ * instructions land in the cached system prompt.
+ */
+export interface BuildServerInstructionsOpts {
+    ensemble: string;
+    playerId: string;
+    playerType?: string;
+    playerTypeDescription?: string;
+    isConductor: boolean;
+    /** Whether the player's name was set at startup (vs needing a `set_name` cue). */
+    hasRequestedName: boolean;
+}
+/**
+ * Build the `instructions` string that lands in `McpServer`'s `instructions`
+ * option (or in the claude-api adapter's cached system prompt). Captures
+ * identity, role, the `set_name` first-cue contract, and the conductor /
+ * non-conductor operational rules around branch switches and worktree
+ * provisioning.
+ *
+ * Verbatim port of the inline string `src/server.ts` used to build pre-#131
+ * — extracted so the claude-api adapter (and any future MCP-server caller)
+ * can reuse the same identity framing without copy-paste drift.
+ */
+export declare function buildServerInstructions(opts: BuildServerInstructionsOpts): string;

package/dist/server-tools.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAllTempoTools = registerAllTempoTools;
+exports.buildServerInstructions = buildServerInstructions;
+const ensemble_1 = require("./tools/ensemble");
+const cue_1 = require("./tools/cue");
+const set_part_1 = require("./tools/set-part");
+const listen_1 = require("./tools/listen");
+const recruit_1 = require("./tools/recruit");
+const report_1 = require("./tools/report");
+const set_name_1 = require("./tools/set-name");
+const schedule_1 = require("./tools/schedule");
+const unschedule_1 = require("./tools/unschedule");
+const schedules_1 = require("./tools/schedules");
+const save_lineup_1 = require("./tools/save-lineup");
+const load_lineup_1 = require("./tools/load-lineup");
+const agent_types_1 = require("./tools/agent-types");
+const who_am_i_1 = require("./tools/who-am-i");
+const broadcast_1 = require("./tools/broadcast");
+const recall_1 = require("./tools/recall");
+const release_1 = require("./tools/release");
+const pause_1 = require("./tools/pause");
+const play_1 = require("./tools/play");
+const shutdown_1 = require("./tools/shutdown");
+const restore_1 = require("./tools/restore");
+const quality_gate_1 = require("./tools/quality-gate");
+const evaluate_gate_1 = require("./tools/evaluate-gate");
+const gates_1 = require("./tools/gates");
+const worktree_1 = require("./tools/worktree");
+const stage_1 = require("./tools/stage");
+const stages_1 = require("./tools/stages");
+const cancel_stage_1 = require("./tools/cancel-stage");
+const restart_1 = require("./tools/restart");
+const destroy_1 = require("./tools/destroy");
+const migrate_1 = require("./tools/migrate");
+const attachment_info_1 = require("./tools/attachment-info");
+const hosts_1 = require("./tools/hosts");
+const set_ensemble_description_1 = require("./tools/set-ensemble-description");
+// #334 PR-1 — player saveable state (save_state / fetch_state / clear_state).
+const save_state_1 = require("./tools/save-state");
+const fetch_state_1 = require("./tools/fetch-state");
+const clear_state_1 = require("./tools/clear-state");
+// #318 — ensemble-shared coat-check (put / get / list / evict).
+const coat_check_put_1 = require("./tools/coat-check-put");
+const coat_check_get_1 = require("./tools/coat-check-get");
+const coat_check_list_1 = require("./tools/coat-check-list");
+const coat_check_evict_1 = require("./tools/coat-check-evict");
+/**
+ * Register every tempo MCP tool onto `server`. Single source of truth — the
+ * stdio MCP server (`src/server.ts`) and the in-process MCP server in the
+ * claude-api adapter both call this with the same option struct. Adding a
+ * new tool here lights it up on every surface without per-callsite drift.
+ *
+ * Conductor-only tools (quality gates, worktrees, stages) are gated by
+ * `opts.isConductor` — non-conductor players don't see them on either
+ * surface.
+ */
+function registerAllTempoTools(server, opts) {
+    const { client, config, getPlayerId, setPlayerId, handle, workflowId, ownAgentType, isConductor } = opts;
+    (0, ensemble_1.registerEnsembleTool)(server, client, config, getPlayerId, workflowId);
+    (0, cue_1.registerCueTool)(server, client, config, getPlayerId, handle);
+    (0, set_part_1.registerSetPartTool)(server, handle);
+    (0, set_name_1.registerSetNameTool)(server, client, config, handle, getPlayerId, setPlayerId);
+    (0, listen_1.registerListenTool)(server, handle);
+    (0, recruit_1.registerRecruitTool)(server, client, config, getPlayerId, handle, ownAgentType);
+    (0, report_1.registerReportTool)(server, handle);
+    (0, schedule_1.registerScheduleTool)(server, client, config, getPlayerId);
+    (0, unschedule_1.registerUnscheduleTool)(server, client, config);
+    (0, schedules_1.registerSchedulesTool)(server, client, config);
+    (0, save_lineup_1.registerSaveLineupTool)(server, client, config, getPlayerId, isConductor);
+    (0, load_lineup_1.registerLoadLineupTool)(server, client, config, getPlayerId, ownAgentType, handle, setPlayerId, isConductor);
+    (0, agent_types_1.registerAgentTypesTool)(server);
+    (0, who_am_i_1.registerWhoAmITool)(server, handle, getPlayerId);
+    (0, broadcast_1.registerBroadcastTool)(server, client, config, getPlayerId, handle);
+    (0, recall_1.registerRecallTool)(server, handle, getPlayerId);
+    (0, release_1.registerReleaseTool)(server, client, config, getPlayerId, handle);
+    (0, pause_1.registerPauseTool)(server, client, config, getPlayerId);
+    (0, play_1.registerPlayTool)(server, client, config, getPlayerId);
+    (0, shutdown_1.registerShutdownTool)(server, client, config, getPlayerId);
+    (0, restore_1.registerRestoreTool)(server, client, config, getPlayerId);
+    (0, restart_1.registerRestartTool)(server, client, config, getPlayerId, handle);
+    (0, destroy_1.registerDestroyTool)(server, client, config, getPlayerId, handle);
+    (0, migrate_1.registerMigrateTool)(server, client, config, getPlayerId, handle);
+    (0, attachment_info_1.registerAttachmentInfoTool)(server, client, config);
+    (0, hosts_1.registerHostsTool)(server, client, config);
+    (0, set_ensemble_description_1.registerSetEnsembleDescriptionTool)(server, client, config);
+    // #334 PR-1 — owner-write / peer-read player saveable state.
+    (0, save_state_1.registerSaveStateTool)(server, handle, getPlayerId);
+    (0, fetch_state_1.registerFetchStateTool)(server, client, config, handle, getPlayerId);
+    (0, clear_state_1.registerClearStateTool)(server, handle);
+    // #318 — ensemble-shared coat-check (put/get/list/evict). Any player can put;
+    // any player can get/list; owner-or-conductor can evict. Audit identity is
+    // set at the tool layer via getPlayerId() — no playerId arg on any schema.
+    (0, coat_check_put_1.registerCoatCheckPutTool)(server, client, config, getPlayerId);
+    (0, coat_check_get_1.registerCoatCheckGetTool)(server, client, config, getPlayerId);
+    (0, coat_check_list_1.registerCoatCheckListTool)(server, client, config);
+    (0, coat_check_evict_1.registerCoatCheckEvictTool)(server, client, config, getPlayerId);
+    if (isConductor) {
+        (0, quality_gate_1.registerQualityGateTool)(server, handle, getPlayerId);
+        (0, evaluate_gate_1.registerEvaluateGateTool)(server, handle, getPlayerId);
+        (0, gates_1.registerGatesTool)(server, handle);
+        (0, worktree_1.registerWorktreeTool)(server, client, config, handle, getPlayerId);
+        (0, stage_1.registerStageTool)(server, handle, getPlayerId);
+        (0, stages_1.registerStagesTool)(server, handle);
+        (0, cancel_stage_1.registerCancelStageTool)(server, handle);
+    }
+}
+/**
+ * Build the `instructions` string that lands in `McpServer`'s `instructions`
+ * option (or in the claude-api adapter's cached system prompt). Captures
+ * identity, role, the `set_name` first-cue contract, and the conductor /
+ * non-conductor operational rules around branch switches and worktree
+ * provisioning.
+ *
+ * Verbatim port of the inline string `src/server.ts` used to build pre-#131
+ * — extracted so the claude-api adapter (and any future MCP-server caller)
+ * can reuse the same identity framing without copy-paste drift.
+ */
+function buildServerInstructions(opts) {
+    const { ensemble, playerId, playerType, playerTypeDescription, isConductor, hasRequestedName } = opts;
+    const playerTypeLine = playerType
+        ? `Your player type is "${playerType}"${playerTypeDescription ? ` (${playerTypeDescription})` : ''}. `
+        : '';
+    return `You are part of the "${ensemble}" ensemble of Claude Code sessions coordinated via Temporal. ` +
+        `Your player name is "${playerId}". ` +
+        playerTypeLine +
+        (hasRequestedName
+            ? `This name was assigned at startup — do NOT call \`set_name\` unless explicitly asked to rename. `
+            : `IMPORTANT: If you receive a message instructing you to call \`set_name\`, do so immediately before anything else. Use \`set_name\` to give yourself a human-readable name. `) +
+        `When you receive a message from another session, treat it like a coworker asking for help — respond promptly, then resume your work. ` +
+        `Use \`ensemble\` to see who else is active. ` +
+        `Use \`cue\` to reply directly to the player who messaged you, or to ask others for help. ` +
+        `Use \`recruit\` if you need a session in a directory where none exists. ` +
+        `Use \`report\` to notify the conductor of task completion, blockers, or questions — always report when you finish a recruited task.` +
+        `\n\nCommunication discipline:\n` +
+        `- Drafting a response in your turn is not the same as sending one. The conductor and other players cannot read your reasoning — only your \`cue\` and \`report\` tool calls cross the channel boundary. If you reach a decision, ruling, or status update, fire the appropriate tool before moving on. If you find yourself thinking "I already answered that," verify the tool was actually invoked.` +
+        (isConductor
+            ? `\n\nOperational rules:\n` +
+                `- Before assigning parallel work on different branches, provision git worktrees via the \`worktree\` tool so each player has an isolated checkout.\n` +
+                `- No player should switch branches without your approval — if a player needs a different branch, provision a worktree for them.\n` +
+                `- Before shipping, verify the branch diff scope matches the assigned task (no unrelated changes).`
+            : `\n\nPlayer rules:\n` +
+                `- Do not switch git branches without the conductor's approval. If no conductor exists, broadcast your intent to the ensemble first. Prefer using the \`worktree\` tool for branch isolation.\n` +
+                `- Silent conductor = HOLD indefinitely. Never default to act on an unanswered cue. The conductor may be coordinating other streams, making a different decision than you expected, recovering from comms issues, or awaiting human input. Idle has zero cost. Acting on assumed approval compounds cost across the ensemble. If a conductor decision genuinely blocks you and time matters, send a follow-up \`cue\` reiterating the question — silence is never greenlight.\n` +
+                `- When CI surfaces a blocker on a PR you opened (or any task you're driving), escalate to the conductor with diagnosis and proposed routing. Wait for the conductor's dispatch decision. Never \`cue\` other players directly to fix issues — bypassing the conductor invites collisions on shared branches and breaks player-load tracking.`);
+}

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};