claude-tempo 0.7.0 → 0.9.0

package/CLAUDE.md

@@ -21,19 +21,23 @@ src/
 ├── workflows/
 │   ├── session.ts     # claude-session workflow
 │   └── signals.ts     # Signal/query type definitions
+├── activities/
+│   ├── outbox.ts      # Outbox delivery activities (cue, report, stop, recruit)
+│   └── schedule-fire.ts # Schedule fire activity
 ├── tools/
 │   ├── ensemble.ts    # Discover active sessions
-│   ├── cue.ts         # Send message to peer
+│   ├── cue.ts         # Send message to peer (via outbox)
 │   ├── set-name.ts    # Set session name
 │   ├── set-part.ts    # Update own summary
 │   ├── resolve.ts     # Search-attribute session lookup
 │   ├── listen.ts      # Manual message check
-│   ├── recruit.ts     # Spawn new session
-│   ├── report.ts      # Report to conductor
-│   ├── terminate.ts   # Terminate a session
+│   ├── recruit.ts     # Spawn new session (via outbox)
+│   ├── report.ts      # Report to conductor (via outbox)
+│   ├── stop.ts        # Stop a session (via outbox)
 │   └── helpers.ts     # Zod/MCP tool registration wrapper
 ├── types.ts           # Shared type definitions
 ├── channel.ts         # Claude channel notification helper
+├── git-info.ts        # Git repository detection helper
 └── config.ts          # Env var handling
 ```
 
@@ -59,6 +63,10 @@ npm test
 > **Important**: Always run `npm run build` after changing workflow code (`src/workflows/`).
 > The build pre-bundles workflows into `workflow-bundle.js` so all workers use identical code.
 
+> **Dual workers**: Each session runs two Temporal workers — a shared `claude-tempo` queue
+> (workflows + delivery activities) and a per-host `claude-tempo-{hostname}` queue (spawn activities only).
+> Both are created via `createWorkers()` in `src/worker.ts`.
+
 ## Key Concepts
 
 - **Player**: A Claude Code session registered as a Temporal workflow
@@ -66,8 +74,11 @@ npm test
 - **Ensemble**: The set of all active players, namespaced by `CLAUDE_TEMPO_ENSEMBLE`
 - **Cue**: A message sent to a player by name via Temporal signal
 - **Part**: A player's description of what it's working on
-- **Recruit**: Spawning a new Claude Code session as a player
+- **Recruit**: Spawning a new Claude Code session as a player. The workflow is pre-created with the initial message before the process spawns, ensuring reliable delivery.
 - **set_name**: Players start with a random hex ID; `set_name` updates the `ClaudeTempoPlayerId` search attribute to a human-readable name
+- **Session status**: Each session has a status (`pending` → `active` → `stale`) tracked via `ClaudeTempoStatus` search attribute. Pre-created workflows start as `pending`, transition to `active` when the process connects, and become `stale` if messages go undelivered for 3+ minutes.
+- **Outbox**: Outbound requests (cue, report, stop, recruit) go through the session's own workflow outbox instead of directly signaling other workflows. The workflow's dispatch loop processes entries via activities, decoupling tools from cross-workflow signaling.
+- **Per-host task queues**: Each host runs a `claude-tempo-{hostname}` activity worker for local-only operations (e.g., `spawnProcess`). This enables cross-machine recruiting — the `recruit` tool accepts an optional `host` parameter to route the spawn to a remote machine's task queue.
 
 ## Dashboard
 

package/README.md

@@ -1,6 +1,13 @@
-# claude-tempo
-
-Multi-session [Claude Code](https://claude.ai/code) coordination via [Temporal](https://temporal.io).
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="assets/logo-dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="assets/logo-light.svg">
+    <img alt="claude-tempo" src="assets/logo-light.svg" height="140">
+  </picture>
+</p>
+<p align="center">
+  Multi-session <a href="https://claude.ai/code">Claude Code</a> coordination via <a href="https://temporal.io">Temporal</a>.
+</p>
 
 Multiple Claude Code sessions discover each other, exchange messages in real time, and coordinate work — across machines, not just localhost.
 
@@ -174,7 +181,7 @@ Ensemble: myband
     Building the REST endpoints
     /Users/me/projects/app  feat/api  my-machine.local
 
-  bob
+  bob (pending)
     Working on the dashboard
     /Users/me/projects/app  feat/ui  my-machine.local
 
@@ -210,7 +217,7 @@ These tools are available inside Claude Code sessions connected to claude-tempo:
 | `listen` | Manually check for pending messages. |
 | `recruit` | Spawn a new Claude Code session in a directory. Can recruit a conductor with `conductor: true`. |
 | `report` | Send updates to the conductor. No-op if no conductor exists. |
-| `terminate` | Terminate a player session by name. |
+| `stop` | Stop a player session by name. |
 | `schedule` | Create a one-shot or recurring schedule to cue a player. |
 | `unschedule` | Cancel a named schedule. |
 | `schedules` | List all active schedules. |
@@ -398,6 +405,23 @@ Sessions start with a random 8-character hex ID. Set a name at launch with `-n`
 - Names must contain only letters, numbers, hyphens, and underscores
 - The name "conductor" is reserved for conductor sessions
 
+### Session status lifecycle
+
+Each session has a status that tracks its connection state:
+
+| Status | Meaning |
+|--------|---------|
+| `pending` | Workflow created by `recruit`, but the Claude Code process hasn't connected yet |
+| `active` | Session is running and responsive |
+| `stale` | Messages have gone undelivered for 3+ minutes — the session is likely disconnected |
+
+Status transitions:
+- **`pending` → `active`** — when the spawned session connects and sends its `updateMetadata` signal
+- **`active` → `stale`** — when undelivered messages exceed the stale threshold (3 minutes)
+- Any status → **terminated** — on graceful shutdown or `stop`
+
+`claude-tempo status` shows `(pending)` and `(stale)` indicators next to player names. The `ClaudeTempoStatus` search attribute is also set, so you can filter sessions by status in the Temporal UI (e.g., `ClaudeTempoStatus = "stale"`).
+
 ### Terminal support
 
 `recruit` and the CLI detect your terminal automatically:
@@ -409,10 +433,13 @@ Sessions start with a random 8-character hex ID. Set a name at launch with `-n`
 | Terminal.app | ✓ | — | — |
 | gnome-terminal | — | ✓ | — |
 | konsole / xterm | — | ✓ | — |
+| Windows Terminal | — | — | ✓ (tabs) |
 | cmd.exe / PowerShell | — | — | ✓ |
 
 macOS terminals preserve the full shell environment (fish, zsh, bash) including node version managers (fnm, nvm).
 
+Windows Terminal is detected automatically via the `WT_SESSION` environment variable. When running inside Windows Terminal, recruited sessions open as new tabs (with the player name as the tab title) instead of separate cmd.exe windows.
+
 ## Configuration
 
 Run `claude-tempo config` to save Temporal connection settings so you don't need flags or env vars every time:

package/assets/icon-dark.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none">
+  <!-- Ultra-minimal metronome icon: triangle + pendulum (dark mode) -->
+  <!-- Metronome body — single-stroke triangle -->
+  <path d="M32 8 L14 54 L50 54 Z" stroke="#FAF3EE" stroke-width="3" fill="none" stroke-linejoin="round"/>
+  <!-- Pendulum arm (angled right) -->
+  <line x1="32" y1="46" x2="44" y2="14" stroke="#E07A5F" stroke-width="3" stroke-linecap="round"/>
+  <!-- Pivot dot -->
+  <circle cx="32" cy="46" r="3" fill="#E07A5F"/>
+</svg>

package/assets/icon.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none">
+  <!-- Ultra-minimal metronome icon: triangle + pendulum -->
+  <!-- Metronome body — single-stroke triangle -->
+  <path d="M32 8 L14 54 L50 54 Z" stroke="#1B2838" stroke-width="3" fill="none" stroke-linejoin="round"/>
+  <!-- Pendulum arm (angled right) -->
+  <line x1="32" y1="46" x2="44" y2="14" stroke="#E07A5F" stroke-width="3" stroke-linecap="round"/>
+  <!-- Pivot dot -->
+  <circle cx="32" cy="46" r="3" fill="#E07A5F"/>
+</svg>

package/assets/logo-dark.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 140" fill="none">
+  <!-- Ultra-minimal metronome: triangle outline + pendulum line (dark mode) -->
+  <!-- Metronome body — single-stroke triangle -->
+  <path d="M160 18 L122 100 L198 100 Z" stroke="#FAF3EE" stroke-width="3" fill="none" stroke-linejoin="round"/>
+  <!-- Pendulum arm (angled right ~18deg) -->
+  <line x1="160" y1="88" x2="182" y2="24" stroke="#E07A5F" stroke-width="3" stroke-linecap="round"/>
+  <!-- Pivot dot -->
+  <circle cx="160" cy="88" r="3.5" fill="#E07A5F"/>
+  <!-- Text -->
+  <text x="160" y="132" text-anchor="middle" font-family="'JetBrains Mono','SF Mono','Consolas',monospace" font-size="18" font-weight="600" fill="#FAF3EE" letter-spacing="-0.5">claude-tempo</text>
+</svg>

package/assets/logo-light.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 140" fill="none">
+  <!-- Ultra-minimal metronome: triangle outline + pendulum line -->
+  <!-- Metronome body — single-stroke triangle -->
+  <path d="M160 18 L122 100 L198 100 Z" stroke="#1B2838" stroke-width="3" fill="none" stroke-linejoin="round"/>
+  <!-- Pendulum arm (angled right ~18deg) -->
+  <line x1="160" y1="88" x2="182" y2="24" stroke="#E07A5F" stroke-width="3" stroke-linecap="round"/>
+  <!-- Pivot dot -->
+  <circle cx="160" cy="88" r="3.5" fill="#E07A5F"/>
+  <!-- Text -->
+  <text x="160" y="132" text-anchor="middle" font-family="'JetBrains Mono','SF Mono','Consolas',monospace" font-size="18" font-weight="600" fill="#1B2838" letter-spacing="-0.5">claude-tempo</text>
+</svg>

package/dist/activities/outbox.d.ts

@@ -0,0 +1,60 @@
+import { Client } from '@temporalio/client';
+import { Config } from '../config';
+import { AgentType } from '../types';
+export interface DeliverCueInput {
+    ensemble: string;
+    fromPlayerId: string;
+    targetPlayerId: string;
+    message: string;
+}
+export interface DeliverReportInput {
+    ensemble: string;
+    fromPlayerId: string;
+    text: string;
+    reportType: 'result' | 'blocker' | 'question';
+}
+export interface TerminateSessionInput {
+    ensemble: string;
+    targetPlayerId: string;
+    terminatedBy: string;
+}
+export interface StartRecruitedSessionInput {
+    ensemble: string;
+    targetName: string;
+    workDir: string;
+    isConductor: boolean;
+    initialMessage?: string;
+    fromPlayerId: string;
+    agent: AgentType;
+    systemPrompt?: string;
+    taskQueue: string;
+}
+export interface SpawnProcessInput {
+    targetName: string;
+    workDir: string;
+    isConductor: boolean;
+    agent: AgentType;
+    systemPrompt?: string;
+    ensemble: string;
+    temporalAddress: string;
+    temporalNamespace: string;
+    temporalApiKey?: string;
+    temporalTlsCertPath?: string;
+    temporalTlsKeyPath?: string;
+}
+export interface OutboxActivityResult {
+    success: boolean;
+    error?: string;
+}
+export interface OutboxActivities {
+    deliverCue(input: DeliverCueInput): Promise<OutboxActivityResult>;
+    deliverReport(input: DeliverReportInput): Promise<OutboxActivityResult>;
+    terminateSession(input: TerminateSessionInput): Promise<OutboxActivityResult>;
+    startRecruitedSession(input: StartRecruitedSessionInput): Promise<OutboxActivityResult>;
+    spawnProcess(input: SpawnProcessInput): Promise<OutboxActivityResult>;
+}
+/**
+ * Create outbox delivery activities bound to a Temporal client and config.
+ * The returned object is registered with the worker as activities.
+ */
+export declare function createOutboxActivities(client: Client, config: Config): OutboxActivities;

package/dist/activities/outbox.js

@@ -0,0 +1,203 @@
+"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.createOutboxActivities = createOutboxActivities;
+const client_1 = require("@temporalio/client");
+const activity_1 = require("@temporalio/activity");
+const os = __importStar(require("os"));
+const config_1 = require("../config");
+const git_info_1 = require("../git-info");
+const spawn_1 = require("../spawn");
+const config_2 = require("../config");
+const log = (...args) => console.error('[claude-tempo:outbox]', ...args);
+// ── Helper: resolve session by player name ──
+async function resolveSession(client, ensemble, playerName) {
+    const query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"`;
+    for await (const wf of client.workflow.list({ query })) {
+        try {
+            const handle = client.workflow.getHandle(wf.workflowId);
+            const metadata = await handle.query('getMetadata');
+            if (metadata.ensemble === ensemble && metadata.playerId === playerName) {
+                return handle;
+            }
+        }
+        catch {
+            // Workflow may have just completed — skip
+        }
+    }
+    return null;
+}
+/**
+ * Create outbox delivery activities bound to a Temporal client and config.
+ * The returned object is registered with the worker as activities.
+ */
+function createOutboxActivities(client, config) {
+    return {
+        async deliverCue(input) {
+            const { ensemble, fromPlayerId, targetPlayerId, message } = input;
+            const handle = await resolveSession(client, ensemble, targetPlayerId);
+            if (!handle) {
+                throw activity_1.ApplicationFailure.nonRetryable(`No active session found for "${targetPlayerId}"`);
+            }
+            await handle.signal('receiveMessage', { from: fromPlayerId, text: message });
+            return { success: true };
+        },
+        async deliverReport(input) {
+            const { ensemble, fromPlayerId, text, reportType } = input;
+            const conductorId = (0, config_1.conductorWorkflowId)(ensemble);
+            const handle = client.workflow.getHandle(conductorId);
+            await handle.signal('playerReport', { playerId: fromPlayerId, text, type: reportType });
+            return { success: true };
+        },
+        async terminateSession(input) {
+            const { ensemble, targetPlayerId, terminatedBy } = input;
+            const handle = await resolveSession(client, ensemble, targetPlayerId);
+            if (!handle) {
+                throw activity_1.ApplicationFailure.nonRetryable(`No active session found for "${targetPlayerId}"`);
+            }
+            // Signal target to mark as terminated
+            await handle.signal('updateMetadata', { status: 'terminated', terminatedBy });
+            // Notify conductor about the termination (best effort)
+            try {
+                const conductorId = (0, config_1.conductorWorkflowId)(ensemble);
+                const conductorHandle = client.workflow.getHandle(conductorId);
+                await conductorHandle.signal('receiveMessage', {
+                    from: 'system',
+                    text: `Session "${targetPlayerId}" was terminated by ${terminatedBy}.`,
+                });
+            }
+            catch {
+                // Conductor may not exist — that's fine
+            }
+            return { success: true };
+        },
+        async startRecruitedSession(input) {
+            const { ensemble, targetName, workDir, isConductor, initialMessage, fromPlayerId, agent, systemPrompt, taskQueue } = input;
+            try {
+                const workflowId = isConductor
+                    ? (0, config_1.conductorWorkflowId)(ensemble)
+                    : (0, config_1.sessionWorkflowId)(ensemble, targetName);
+                const { gitRoot, gitBranch } = (0, git_info_1.getGitInfo)(workDir);
+                const sessionInput = {
+                    metadata: {
+                        playerId: targetName,
+                        ensemble,
+                        hostname: os.hostname(),
+                        workDir,
+                        gitRoot,
+                        gitBranch,
+                        isConductor,
+                        agentType: agent,
+                        status: 'pending',
+                    },
+                    autoSummary: `Session in ${require('path').basename(workDir)}`,
+                    disableStaleDetection: true,
+                    ...(initialMessage ? {
+                        messages: [{
+                                id: require('crypto').randomUUID(),
+                                from: fromPlayerId,
+                                text: initialMessage,
+                                timestamp: new Date().toISOString(),
+                                delivered: false,
+                            }],
+                    } : {}),
+                };
+                await client.workflow.start('claudeSessionWorkflow', {
+                    workflowId,
+                    taskQueue,
+                    args: [sessionInput],
+                    workflowIdConflictPolicy: client_1.WorkflowIdConflictPolicy.USE_EXISTING,
+                    searchAttributes: {
+                        ...(gitRoot ? { ClaudeTempoGitRoot: [gitRoot] } : {}),
+                        ClaudeTempoHostname: [os.hostname()],
+                        ClaudeTempoEnsemble: [ensemble],
+                        ClaudeTempoPlayerId: [targetName],
+                    },
+                });
+                log(`Pre-created workflow ${workflowId} for recruit "${targetName}"`);
+                return { success: true };
+            }
+            catch (err) {
+                throw activity_1.ApplicationFailure.nonRetryable(`Failed to start recruited session "${targetName}": ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        async spawnProcess(input) {
+            const { targetName, workDir, isConductor, agent, systemPrompt, ensemble, temporalAddress, temporalNamespace, temporalApiKey, temporalTlsCertPath, temporalTlsKeyPath } = input;
+            try {
+                if (agent === 'copilot') {
+                    const { pid } = (0, spawn_1.spawnCopilotBridge)({
+                        name: targetName,
+                        ensemble,
+                        temporalAddress,
+                        temporalNamespace,
+                        temporalApiKey,
+                        temporalTlsCertPath,
+                        temporalTlsKeyPath,
+                        isConductor,
+                        workDir,
+                    });
+                    log(`Spawned copilot-bridge (pid ${pid}) in ${workDir} as "${targetName}"`);
+                }
+                else {
+                    const spawnArgs = [
+                        '--dangerously-skip-permissions',
+                        '--dangerously-load-development-channels', 'server:claude-tempo',
+                        '-n', targetName,
+                        ...(systemPrompt ? ['--system-prompt', systemPrompt] : []),
+                    ];
+                    const envVars = {
+                        [config_2.ENV.ENSEMBLE]: ensemble,
+                        [config_2.ENV.CONDUCTOR]: isConductor ? 'true' : '',
+                        [config_2.ENV.PLAYER_NAME]: targetName,
+                        [config_2.ENV.TEMPORAL_ADDRESS]: temporalAddress,
+                        [config_2.ENV.TEMPORAL_NAMESPACE]: temporalNamespace,
+                    };
+                    if (temporalApiKey)
+                        envVars[config_2.ENV.TEMPORAL_API_KEY] = temporalApiKey;
+                    if (temporalTlsCertPath)
+                        envVars[config_2.ENV.TEMPORAL_TLS_CERT_PATH] = temporalTlsCertPath;
+                    if (temporalTlsKeyPath)
+                        envVars[config_2.ENV.TEMPORAL_TLS_KEY_PATH] = temporalTlsKeyPath;
+                    const { pid } = (0, spawn_1.spawnInTerminal)(spawnArgs, workDir, envVars);
+                    log(`Spawned claude process (pid ${pid}) in ${workDir} as "${targetName}"`);
+                }
+                return { success: true };
+            }
+            catch (err) {
+                throw activity_1.ApplicationFailure.nonRetryable(`Failed to spawn process for "${targetName}": ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+    };
+}

package/dist/cli/commands.js

@@ -97,7 +97,7 @@ async function start(opts) {
                 if (opts.replace) {
                     out.log(`Stopping existing conductor for ensemble "${opts.ensemble}"...`);
                     try {
-                        await handle.signal(signals_1.shutdownSignal);
+                        await handle.signal(signals_1.updateMetadataSignal, { status: 'terminated' });
                         // Wait briefly for graceful shutdown
                         for (let i = 0; i < 10; i++) {
                             await new Promise(r => setTimeout(r, 500));
@@ -228,6 +228,7 @@ async function status(opts) {
                 host: meta.hostname || '',
                 conductor: meta.isConductor || false,
                 agentType: meta.agentType || 'claude',
+                status: meta.status || 'active',
             });
         }
         catch {
@@ -280,8 +281,11 @@ async function status(opts) {
         for (const s of members) {
             const role = s.conductor ? out.yellow(' (conductor)') : '';
             const agent = s.agentType === 'copilot' ? out.dim(' [copilot]') : '';
+            const statusLabel = s.status === 'stale' ? out.yellow(' (stale)')
+                : s.status === 'pending' ? out.dim(' (pending)')
+                    : '';
             const name = out.bold(s.name);
-            out.log(`  ${name}${role}${agent}`);
+            out.log(`  ${name}${role}${statusLabel}${agent}`);
             if (s.part)
                 out.log(`    ${out.dim(s.part)}`);
             const details = [s.workDir, s.branch, s.host].filter(Boolean).join('  ');
@@ -382,6 +386,7 @@ const SEARCH_ATTRIBUTES = [
     { name: 'ClaudeTempoGitRoot', type: 'Keyword' },
     { name: 'ClaudeTempoEnsemble', type: 'Keyword' },
     { name: 'ClaudeTempoPlayerId', type: 'Keyword' },
+    { name: 'ClaudeTempoStatus', type: 'Keyword' },
 ];
 function isTemporalReachable(config) {
     return (0, connection_1.createTemporalConnection)(config)
@@ -926,7 +931,7 @@ async function stop(opts) {
                         continue;
                     }
                 }
-                await handle.signal(signals_1.shutdownSignal);
+                await handle.signal(signals_1.updateMetadataSignal, { status: 'terminated' });
                 stopped++;
                 out.log(`  ${out.dim('stopped')} ${wf.workflowId}`);
             }
@@ -986,9 +991,9 @@ async function stopByName(client, name, config, ensemble) {
                 // No conductor or conductor not running — fine
             }
         }
-        // Send shutdown signal (graceful)
+        // Send termination status update (graceful)
         try {
-            await handle.signal(signals_1.shutdownSignal);
+            await handle.signal(signals_1.updateMetadataSignal, { status: 'terminated' });
             out.success(`Stopped "${name}"`);
         }
         catch {

package/dist/config.d.ts

@@ -85,6 +85,8 @@ export interface ConfigWithSources {
  * Used by `claude-tempo config show` to help users debug.
  */
 export declare function getConfigWithSources(overrides?: CliOverrides): ConfigWithSources;
+/** Build a per-host task queue name for cross-machine activities: {taskQueue}-{hostname} */
+export declare function hostTaskQueue(taskQueue: string, hostname: string): string;
 /** Build a workflow ID for a player session: claude-session-{ensemble}-{playerId} */
 export declare function sessionWorkflowId(ensemble: string, playerId: string): string;
 /** Build a workflow ID for a conductor: claude-session-{ensemble}-conductor */

package/dist/config.js

@@ -7,6 +7,7 @@ exports.loadTemporalCliConfig = loadTemporalCliConfig;
 exports.parseTemporalYaml = parseTemporalYaml;
 exports.getConfig = getConfig;
 exports.getConfigWithSources = getConfigWithSources;
+exports.hostTaskQueue = hostTaskQueue;
 exports.sessionWorkflowId = sessionWorkflowId;
 exports.conductorWorkflowId = conductorWorkflowId;
 exports.schedulerWorkflowId = schedulerWorkflowId;
@@ -239,6 +240,10 @@ function getConfigWithSources(overrides = {}) {
         },
     };
 }
+/** Build a per-host task queue name for cross-machine activities: {taskQueue}-{hostname} */
+function hostTaskQueue(taskQueue, hostname) {
+    return `${taskQueue}-${hostname}`;
+}
 /** Build a workflow ID for a player session: claude-session-{ensemble}-{playerId} */
 function sessionWorkflowId(ensemble, playerId) {
     return `claude-session-${ensemble}-${playerId}`;

package/dist/copilot-bridge.js

@@ -179,7 +179,7 @@ async function main() {
                 `- listen: Check for pending messages\n` +
                 `- recruit: Spawn a new player session\n` +
                 `- report: Report to the conductor\n` +
-                `- terminate: Terminate a session\n\n` +
+                `- stop: Stop a session\n\n` +
                 `When you receive a message from another session, treat it like a coworker asking for help — respond promptly using your MCP tools.`,
         },
         excludedTools: ['write_powershell', 'read_powershell', 'list_powershell'],
@@ -391,7 +391,7 @@ async function main() {
         polling = false;
         clearInterval(interval);
         try {
-            await handle.signal('shutdown');
+            await handle.signal('updateMetadata', { status: 'terminated', terminatedBy: 'system' });
         }
         catch {
             // workflow may already be gone

package/dist/git-info.d.ts

@@ -0,0 +1,4 @@
+export declare function getGitInfo(workDir: string): {
+    gitRoot?: string;
+    gitBranch?: string;
+};

package/dist/git-info.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitInfo = getGitInfo;
+const child_process_1 = require("child_process");
+function getGitInfo(workDir) {
+    try {
+        const gitRoot = (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+            cwd: workDir,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        let gitBranch;
+        try {
+            gitBranch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+                cwd: workDir,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+        }
+        catch {
+            // not on a branch
+        }
+        return { gitRoot, gitBranch };
+    }
+    catch {
+        return {};
+    }
+}