agent-tempo 1.0.1

package/dist/activities/maestro.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMaestroActivities = createMaestroActivities;
+const activity_1 = require("@temporalio/activity");
+const config_1 = require("../config");
+const types_1 = require("../types");
+const resolve_1 = require("./resolve");
+const visibility_deadline_1 = require("../utils/visibility-deadline");
+const log = (...args) => console.error('[agent-tempo:maestro]', ...args);
+/**
+ * Create the Maestro activity implementations bound to a Temporal client.
+ * Registered with the shared worker.
+ */
+function createMaestroActivities(client) {
+    return {
+        async refreshEnsembleState(ensemble) {
+            try {
+                const sessions = await (0, resolve_1.scanEnsembleSessions)(client, ensemble);
+                return sessions.map((s) => ({
+                    playerId: s.playerId,
+                    ensemble,
+                    part: s.part,
+                    hostname: s.hostname,
+                    workDir: s.workDir,
+                    gitRoot: s.gitRoot,
+                    gitBranch: s.gitBranch,
+                    isConductor: s.isConductor,
+                    agentType: s.agentType,
+                    playerType: s.playerType,
+                    phase: s.phase,
+                    // #399 W1 — forward the activity-counter pair so the maestro's
+                    // tempo bucket can diff across refreshes.
+                    activityCount: s.activityCount,
+                    lastActivityAt: s.lastActivityAt,
+                }));
+            }
+            catch (err) {
+                log('refreshEnsembleState failed:', err);
+                throw activity_1.ApplicationFailure.nonRetryable(`Failed to scan ensemble: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        async fetchConductorHistory(input) {
+            try {
+                const wfId = (0, config_1.conductorWorkflowId)(input.ensemble);
+                const handle = client.workflow.getHandle(wfId);
+                const history = await handle.query('history');
+                return { success: true, history };
+            }
+            catch (err) {
+                // ContinueAsNew transient errors and missing conductor are soft failures
+                const msg = err instanceof Error ? err.message : String(err);
+                log('fetchConductorHistory failed (soft):', msg);
+                return { success: false, history: [], error: msg };
+            }
+        },
+        async relayCommandToConductor(input) {
+            try {
+                const wfId = (0, config_1.conductorWorkflowId)(input.ensemble);
+                const handle = client.workflow.getHandle(wfId);
+                await handle.signal('command', {
+                    text: input.text,
+                    source: input.source,
+                    ...(input.replyTo ? { replyTo: input.replyTo } : {}),
+                });
+                return { success: true };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log('relayCommandToConductor failed:', msg);
+                return { success: false, error: msg };
+            }
+        },
+        async discoverEnsembles() {
+            // #336/#529 — bounded visibility iterator. On deadline, return
+            // the partial result rather than aborting; the maestro retries on
+            // its own schedule, so a truncated enumeration this tick self-heals
+            // on the next.
+            const ensembles = new Set();
+            const query = `WorkflowType = "agentSessionWorkflow" AND ExecutionStatus = "Running"`;
+            try {
+                for await (const wf of (0, visibility_deadline_1.iterateWithDeadline)(client.workflow.list({ query }), visibility_deadline_1.VISIBILITY_DEADLINES_MS.discoverEnsembles, 'discoverEnsembles')) {
+                    try {
+                        const handle = client.workflow.getHandle(wf.workflowId);
+                        const metadata = await handle.query('getMetadata');
+                        if (metadata.ensemble) {
+                            ensembles.add(metadata.ensemble);
+                        }
+                    }
+                    catch {
+                        // Workflow may have completed — skip
+                    }
+                }
+                return Array.from(ensembles).sort();
+            }
+            catch (err) {
+                if ((0, visibility_deadline_1.isVisibilityTimeout)(err)) {
+                    log(`discoverEnsembles: ${err.message} — returning partial (${ensembles.size} ensembles)`);
+                    return Array.from(ensembles).sort();
+                }
+                // Discovery failures are typically transient (network, server restart) — allow retry
+                log('discoverEnsembles failed:', err);
+                throw new Error(`Failed to discover ensembles: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        async deliverMaestroMessage(input) {
+            try {
+                const handle = await (0, resolve_1.resolveSession)(client, input.ensemble, input.to);
+                if (!handle) {
+                    return { success: false, error: `Player '${input.to}' not found in ensemble '${input.ensemble}'` };
+                }
+                await handle.signal('receiveMessage', {
+                    from: input.source,
+                    text: input.text,
+                    isMaestro: true,
+                });
+                return { success: true };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log('deliverMaestroMessage failed:', msg);
+                return { success: false, error: msg };
+            }
+        },
+        async fetchPlayerMessages(input) {
+            try {
+                const handle = await (0, resolve_1.resolveSession)(client, input.ensemble, input.playerId);
+                if (!handle) {
+                    return { success: false, messages: [], error: `Player '${input.playerId}' not found in ensemble '${input.ensemble}'` };
+                }
+                const received = await handle.query('allMessages');
+                const sent = await handle.query('allSentMessages');
+                // Merge into a single timeline sorted by timestamp
+                const merged = [
+                    ...received.map((m) => ({ ...m, direction: 'received' })),
+                    ...sent.map((m) => ({ ...m, direction: 'sent' })),
+                ];
+                merged.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+                return { success: true, messages: merged };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log('fetchPlayerMessages failed (soft):', msg);
+                return { success: false, messages: [], error: msg };
+            }
+        },
+        async fetchEnsembleChat(input) {
+            const { ensemble, knownCounts } = input;
+            const hw = knownCounts ?? types_1.ZERO_CHAT_HIGH_WATER;
+            const TRUNC = 500;
+            const truncate = (t) => t.length > TRUNC ? t.slice(0, TRUNC - 1) + '...' : t;
+            try {
+                const maestroHandle = client.workflow.getHandle((0, config_1.sessionWorkflowId)(ensemble, 'maestro'));
+                let conductorHandle = null;
+                let conductorId = '';
+                const sessions = await (0, resolve_1.scanEnsembleSessions)(client, ensemble);
+                const conductorSession = sessions.find(s => s.isConductor);
+                if (conductorSession) {
+                    conductorHandle = client.workflow.getHandle(conductorSession.workflowId);
+                    conductorId = conductorSession.playerId;
+                }
+                const [maestroRecvRes, maestroSentRes, condRecvRes, condSentRes] = await Promise.allSettled([
+                    maestroHandle.query('allMessages'),
+                    maestroHandle.query('allSentMessages'),
+                    conductorHandle ? conductorHandle.query('allMessages') : Promise.resolve([]),
+                    conductorHandle ? conductorHandle.query('allSentMessages') : Promise.resolve([]),
+                ]);
+                const maestroRecv = maestroRecvRes.status === 'fulfilled' ? maestroRecvRes.value : [];
+                const maestroSent = maestroSentRes.status === 'fulfilled' ? maestroSentRes.value : [];
+                const condRecv = condRecvRes.status === 'fulfilled' ? condRecvRes.value : [];
+                const condSent = condSentRes.status === 'fulfilled' ? condSentRes.value : [];
+                const newMessages = [];
+                // #357: each push site forwards the source's broadcastId (when
+                // present) onto the projected EnsembleChatMessage so the TUI's
+                // ConversationStream can fold fan-out deliveries into one row.
+                const maybeBroadcast = (m) => m.broadcastId !== undefined ? { broadcastId: m.broadcastId } : {};
+                for (const m of maestroRecv.slice(hw.maestroRecv)) {
+                    newMessages.push({
+                        id: m.id,
+                        from: m.from,
+                        to: 'maestro',
+                        text: m.text,
+                        timestamp: m.timestamp,
+                        role: 'maestro-in',
+                        ...maybeBroadcast(m),
+                    });
+                }
+                for (const m of maestroSent.slice(hw.maestroSent)) {
+                    newMessages.push({
+                        id: m.id,
+                        from: 'maestro',
+                        to: m.to,
+                        text: m.text,
+                        timestamp: m.timestamp,
+                        role: 'maestro-out',
+                        ...maybeBroadcast(m),
+                    });
+                }
+                for (const m of condRecv.slice(hw.conductorRecv)) {
+                    if (m.from === 'maestro' || m.isMaestro)
+                        continue; // Skip maestro<->conductor (already covered)
+                    // Conductor self-reports (e.g. `tempo-conductor` calling `report`) land in the
+                    // conductor's own `messages` array. Re-target them as inbound-to-maestro so the
+                    // chat renders "tempo-conductor → maestro" instead of a confusing self-loop.
+                    const isConductorSelfReport = m.from === conductorId;
+                    newMessages.push({
+                        id: `cond-${m.id}`,
+                        from: m.from,
+                        to: isConductorSelfReport ? 'maestro' : conductorId,
+                        text: truncate(m.text),
+                        timestamp: m.timestamp,
+                        role: isConductorSelfReport ? 'maestro-in' : 'conductor-in',
+                        ...maybeBroadcast(m),
+                    });
+                }
+                for (const m of condSent.slice(hw.conductorSent)) {
+                    if (m.to === 'maestro')
+                        continue; // Skip conductor->maestro (already covered)
+                    newMessages.push({
+                        id: `cond-${m.id}`,
+                        from: conductorId,
+                        to: m.to,
+                        text: truncate(m.text),
+                        timestamp: m.timestamp,
+                        role: 'conductor-out',
+                        ...maybeBroadcast(m),
+                    });
+                }
+                newMessages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+                return {
+                    success: true,
+                    newMessages,
+                    currentCounts: {
+                        maestroRecv: maestroRecv.length,
+                        maestroSent: maestroSent.length,
+                        conductorRecv: condRecv.length,
+                        conductorSent: condSent.length,
+                    },
+                    hasConductor: !!conductorHandle,
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log('fetchEnsembleChat failed:', msg);
+                return {
+                    success: false,
+                    newMessages: [],
+                    currentCounts: hw,
+                    hasConductor: false,
+                    error: msg,
+                };
+            }
+        },
+    };
+}

package/dist/activities/outbox.d.ts

@@ -0,0 +1,188 @@
+import { Client } from '@temporalio/client';
+import { Config } from '../config';
+import { AgentType, MockMode, DetachReason } from '../types';
+import type { ClaudeCodeHeadlessPermissionMode } from '../adapters/claude-code-headless/types';
+import { type HardTerminateInput, type HardTerminateResult } from './hard-terminate';
+export interface DeliverCueInput {
+    ensemble: string;
+    fromPlayerId: string;
+    targetPlayerId: string;
+    message: string;
+    /**
+     * #357: Stable id shared across every fan-out target of one
+     * `broadcast` invocation. Threaded through to the target's
+     * `receiveMessage` signal so the stored Message carries it for
+     * later TUI grouping. `undefined` for non-broadcast direct cues.
+     */
+    broadcastId?: string;
+    /**
+     * #318: Coat-check ticket referencing content stashed via
+     * `coat_check_put`. Threaded through to the target's `receiveMessage`
+     * signal so the stored `Message` carries it and the recipient can
+     * pull the body via `coat_check_get`. `undefined` for cues without an
+     * attachment.
+     */
+    attachmentTicket?: string;
+}
+export interface DeliverReportInput {
+    ensemble: string;
+    fromPlayerId: string;
+    text: string;
+    reportType: 'result' | 'blocker' | 'question' | 'update';
+}
+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;
+    agentDefinition?: string;
+    agentDefinitionDescription?: string;
+    allowedTools?: string[];
+    /** Custom claude binary path (from config.claudeBin). */
+    claudeBin?: string;
+    /** When true, spawn process but lock outbox and defer initial message until release (warm hold). */
+    held?: boolean;
+    /**
+     * #131 Phase C — model id for the claude-api adapter (e.g.
+     * `claude-opus-4-7`). Persisted onto `SessionMetadata.model` so restart
+     * can recover the original choice. Ignored when `agent !== 'claude-api'`.
+     */
+    model?: string;
+}
+export interface ReleasePlayerInput {
+    ensemble: string;
+    targetPlayerId: string;
+}
+export interface DeliverDetachInput {
+    ensemble: string;
+    targetPlayerId: string;
+    reason?: DetachReason;
+    deadlineMs?: number;
+}
+export interface DeliverDestroyInput {
+    ensemble: string;
+    targetPlayerId: string;
+    reason?: string;
+    terminatedBy: string;
+    notifyConductor?: boolean;
+}
+export interface DeliverRestartInput {
+    ensemble: string;
+    targetPlayerId: string;
+    invokerPlayerId: string;
+    force?: boolean;
+    host?: string;
+    fresh?: boolean;
+    contextMessages?: number;
+    /** #334 PR-2 — see {@link RestartOutboxEntry.loadFromState}. */
+    loadFromState?: boolean | string;
+    /** #334 PR-2 — see {@link RestartOutboxEntry.transcript}. */
+    transcript?: 'suppress' | 'replay';
+}
+export interface SpawnProcessInput {
+    targetName: string;
+    workDir: string;
+    isConductor: boolean;
+    agent: AgentType;
+    systemPrompt?: string;
+    ensemble: string;
+    temporalAddress: string;
+    temporalNamespace: string;
+    agentDefinition?: string;
+    agentDefinitionPath?: string;
+    nativeResolvable?: boolean;
+    /** When true, use --resume instead of -n (reconnect to existing session). */
+    resume?: boolean;
+    /** Session UUID — used for Copilot SDK sessionId and Claude Code --resume/--session-id. */
+    sessionId?: string;
+    /** Tool restrictions from the agent definition frontmatter. */
+    allowedTools?: string[];
+    /** Custom claude binary path (from config.claudeBin). */
+    claudeBin?: string;
+    /**
+     * PR-D attachment-lease handoff. When present, the workflow has already
+     * called `claimAttachment` and the child process should boot and invoke
+     * `startV2Lifecycle(workflowId, attachmentId)` to renew (rather than fresh-claim)
+     * the lease using the pre-assigned id. See design §8.2 step 5.
+     */
+    attachmentId?: string;
+    /** Pinned runId returned by `claimAttachment`; passed to the adapter for handle pinning. */
+    attachmentRunId?: string;
+    /** Resolved adapter descriptor id (e.g. 'claude-code', 'copilot'); mirrors SessionMetadata.adapterId. */
+    adapterId?: string;
+    /**
+     * Mock-adapter configuration (ADR 0014 §4.2). Only present when `agent === 'mock'`.
+     * Forwarded into the spawned subprocess as `AGENT_TEMPO_MOCK_MODE` /
+     * `AGENT_TEMPO_MOCK_SCENARIO` env vars. Chaos mode also reads
+     * `AGENT_TEMPO_MOCK_CHAOS_*` from the daemon's env (inherited via spawn).
+     */
+    mockMode?: MockMode;
+    mockScenario?: string;
+    /**
+     * #131 / #449 Phase C — model id for the headless adapters.
+     *   - `claude-api`: bare Anthropic id (e.g. `claude-opus-4-7`); forwarded
+     *     as `AGENT_TEMPO_API_MODEL`.
+     *   - `opencode`: combined provider/model (e.g. `anthropic/claude-opus-4-7`,
+     *     `openai/gpt-4o`); forwarded as `AGENT_TEMPO_OPENCODE_MODEL`.
+     * The spawn dispatcher inspects `agent` to pick the right env var. Only
+     * meaningful for those two adapters; ignored otherwise. Falls back inside
+     * the adapter to its respective env var → constants-pinned default.
+     */
+    model?: string;
+    /**
+     * #520 — claude-code-headless permission mode. Forwarded as
+     * `AGENT_TEMPO_PERMISSION_MODE` to the spawned adapter; the adapter
+     * passes it through to per-turn `claude -p --permission-mode <mode>`.
+     * Only meaningful when `agent === 'claude-code-headless'`. Mutually
+     * exclusive with {@link dangerouslySkipPermissions}. Type imported from
+     * the canonical {@link ClaudeCodeHeadlessPermissionMode} tuple.
+     */
+    permissionMode?: ClaudeCodeHeadlessPermissionMode;
+    /**
+     * #520 — claude-code-headless dangerous-skip-permissions opt-in.
+     * Forwarded as `AGENT_TEMPO_DANGEROUSLY_SKIP_PERMISSIONS=1`. Only
+     * meaningful when `agent === 'claude-code-headless'`. Mutually
+     * exclusive with {@link permissionMode}.
+     */
+    dangerouslySkipPermissions?: boolean;
+}
+export interface OutboxActivityResult {
+    success: boolean;
+    error?: string;
+}
+export interface RecruitResult extends OutboxActivityResult {
+    /** Session UUID assigned at recruit time. */
+    sessionId?: string;
+}
+export interface OutboxActivities {
+    deliverCue(input: DeliverCueInput): Promise<OutboxActivityResult>;
+    deliverReport(input: DeliverReportInput): Promise<OutboxActivityResult>;
+    terminateSession(input: TerminateSessionInput): Promise<OutboxActivityResult>;
+    startRecruitedSession(input: StartRecruitedSessionInput): Promise<RecruitResult>;
+    spawnProcess(input: SpawnProcessInput): Promise<OutboxActivityResult>;
+    releasePlayer(input: ReleasePlayerInput): Promise<OutboxActivityResult>;
+    deliverDetach(input: DeliverDetachInput): Promise<OutboxActivityResult>;
+    deliverDestroy(input: DeliverDestroyInput): Promise<OutboxActivityResult>;
+    deliverRestart(input: DeliverRestartInput): Promise<OutboxActivityResult>;
+    /**
+     * OS-level child-process-tree kill for the target session. Runs on the per-host
+     * task queue (`agent-tempo-{hostname}`) so the kill happens where the process
+     * actually lives. See `src/activities/hard-terminate.ts` and issue #159 Gap 2.
+     */
+    hardTerminateAttachment(input: HardTerminateInput): Promise<HardTerminateResult>;
+}
+/**
+ * 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;