smol-symphony 0.1.0 → 0.3.0

package/dist/orchestrator.js

@@ -1,683 +0,0 @@
-// Orchestrator (SPEC §7, §8, §14, §16). Owns the single-authority runtime state and
-// drives the poll-and-dispatch tick, retries, reconciliation, and worker exit handling.
-import { validateDispatch, WorkflowError } from './workflow.js';
-import { ADAPTERS, assertHostCredentialReadable, isKnownAdapter } from './agent/adapters.js';
-import { pickTerminalTarget } from './mcp.js';
-import { withIssue, log } from './logging.js';
-const CONTINUATION_DELAY_MS = 1_000;
-const FAILURE_BASE_MS = 10_000;
-export class Orchestrator {
-    cfg;
-    workflowDef;
-    workflowSrc;
-    tracker;
-    workspaces;
-    runner;
-    running = new Map();
-    claimed = new Set();
-    retryAttempts = new Map();
-    completed = new Set();
-    codexTotals = {
-        input_tokens: 0,
-        output_tokens: 0,
-        total_tokens: 0,
-        seconds_running: 0,
-    };
-    codexRateLimits = null;
-    tickTimer = null;
-    stopped = false;
-    refreshRequested = false;
-    // Latest dispatch validation error, if any (operator-visible).
-    lastValidationError = null;
-    // Optional callback used to propagate reloaded config to components that hold their own
-    // tracker/runner/workspace state (so prompt body, hooks, smolvm config, etc., take effect
-    // on the next dispatch — see §6.2).
-    onConfigReloaded;
-    constructor(cfg, workflowDef, workflowSrc, tracker, workspaces, runner) {
-        this.cfg = cfg;
-        this.workflowDef = workflowDef;
-        this.workflowSrc = workflowSrc;
-        this.tracker = tracker;
-        this.workspaces = workspaces;
-        this.runner = runner;
-        workflowSrc.onChange((next) => {
-            if ('error' in next) {
-                this.lastValidationError = next.error.message;
-                log.warn('workflow reload error', { error: next.error.message });
-                return;
-            }
-            this.cfg = next.config;
-            this.workflowDef = next.definition;
-            this.lastValidationError = null;
-            this.onConfigReloaded?.(next.config, next.definition);
-            log.info('runtime config reloaded', {
-                poll_interval_ms: next.config.polling.interval_ms,
-                max_concurrent_agents: next.config.agent.max_concurrent_agents,
-            });
-        });
-    }
-    /** Register a callback invoked after every successful workflow reload. */
-    setOnConfigReloaded(cb) {
-        this.onConfigReloaded = cb;
-    }
-    async start() {
-        const validation = validateDispatch(this.cfg);
-        if (validation) {
-            log.error('startup validation failed', { error: validation });
-            throw new WorkflowError('workflow_parse_error', validation);
-        }
-        // Fail fast when symphony will auto-stage credentials but the host file the
-        // adapter needs is missing. Operators who set acp.command explicitly own their
-        // own credential plumbing, so skip the check in that branch.
-        if (this.cfg.acp.command === null && isKnownAdapter(this.cfg.acp.adapter)) {
-            const profile = ADAPTERS[this.cfg.acp.adapter];
-            try {
-                await assertHostCredentialReadable(profile);
-            }
-            catch (err) {
-                log.error('startup credential check failed', { error: err.message });
-                throw new WorkflowError('missing_host_credential', err.message);
-            }
-        }
-        await this.startupTerminalCleanup();
-        this.scheduleTick(0);
-    }
-    async stop() {
-        this.stopped = true;
-        if (this.tickTimer) {
-            clearTimeout(this.tickTimer);
-            this.tickTimer = null;
-        }
-        for (const e of this.retryAttempts.values())
-            clearTimeout(e.timer_handle);
-        this.retryAttempts.clear();
-        // Signal cancel on all running entries.
-        for (const e of this.running.values())
-            e.cancel();
-        this.running.clear();
-        this.claimed.clear();
-    }
-    /** Operator trigger for an immediate poll cycle (§13.7 /refresh). */
-    triggerRefresh() {
-        if (this.refreshRequested)
-            return { queued: true, coalesced: true };
-        this.refreshRequested = true;
-        if (this.tickTimer)
-            clearTimeout(this.tickTimer);
-        this.tickTimer = setTimeout(() => void this.tick(), 0);
-        return { queued: true, coalesced: false };
-    }
-    scheduleTick(delayMs) {
-        if (this.stopped)
-            return;
-        if (this.tickTimer)
-            clearTimeout(this.tickTimer);
-        this.tickTimer = setTimeout(() => void this.tick(), delayMs);
-    }
-    async tick() {
-        if (this.stopped)
-            return;
-        this.refreshRequested = false;
-        try {
-            await this.reconcile();
-        }
-        catch (err) {
-            log.warn('reconcile error', { error: err.message });
-        }
-        const validation = validateDispatch(this.cfg);
-        if (validation) {
-            this.lastValidationError = validation;
-            log.warn('dispatch validation failed; skipping dispatch', { error: validation });
-            this.scheduleTick(this.cfg.polling.interval_ms);
-            return;
-        }
-        this.lastValidationError = null;
-        let candidates;
-        let snapshotTrackerRoot;
-        let snapshotTerminalTarget;
-        try {
-            // Atomic fetch: the tracker returns the issues AND the root/terminal_states
-            // it used during the scan. That's the snapshot we pin onto each RunningEntry,
-            // so a workflow reload that races the dispatch loop can't cause `mark_done`
-            // to operate against a different tracker config than where the issue lives.
-            const result = await this.tracker.fetchCandidateIssues();
-            candidates = result.issues;
-            snapshotTrackerRoot = result.root;
-            snapshotTerminalTarget = pickTerminalTarget(result.terminalStates);
-        }
-        catch (err) {
-            log.warn('candidate fetch failed', { error: err.message });
-            this.scheduleTick(this.cfg.polling.interval_ms);
-            return;
-        }
-        const sorted = this.sortForDispatch(candidates);
-        for (const issue of sorted) {
-            if (this.availableGlobalSlots() <= 0)
-                break;
-            if (!this.isEligible(issue))
-                continue;
-            void this.dispatchIssue(issue, null, {
-                trackerRoot: snapshotTrackerRoot,
-                terminalTarget: snapshotTerminalTarget,
-            });
-        }
-        this.scheduleTick(this.cfg.polling.interval_ms);
-    }
-    /** §8.5: stall detection + tracker state refresh for running issues. */
-    async reconcile() {
-        // Part A: stall detection.
-        if (this.cfg.acp.stall_timeout_ms > 0) {
-            const now = Date.now();
-            for (const [issueId, entry] of this.running) {
-                // Skip stall detection for issues awaiting human steering: the agent is
-                // intentionally paused while the human composes a reply, and the wait can
-                // legitimately exceed stall_timeout_ms. The cancel signal still applies
-                // (the runner's awaitSteeringReply respects it) for non-stall reasons like
-                // terminal-state transitions or operator-initiated cancels.
-                if (entry.steering_requested)
-                    continue;
-                const ref = entry.last_codex_timestamp ?? entry.started_at;
-                const elapsed = now - Date.parse(ref);
-                if (Number.isFinite(elapsed) && elapsed > this.cfg.acp.stall_timeout_ms) {
-                    log.warn('stall detected', {
-                        issue_id: issueId,
-                        issue_identifier: entry.identifier,
-                        elapsed_ms: elapsed,
-                    });
-                    this.terminateRunning(issueId, false, `stalled after ${elapsed}ms`);
-                }
-            }
-        }
-        // Part B: tracker state refresh.
-        const ids = [...this.running.keys()];
-        if (ids.length === 0)
-            return;
-        let refreshed;
-        try {
-            refreshed = await this.tracker.fetchIssueStatesByIds(ids);
-        }
-        catch (err) {
-            log.debug('state refresh failed; keep workers running', { error: err.message });
-            return;
-        }
-        const byId = new Map(refreshed.map((i) => [i.id, i]));
-        const terminal = new Set(this.cfg.tracker.terminal_states.map((s) => s.toLowerCase()));
-        const active = new Set(this.cfg.tracker.active_states.map((s) => s.toLowerCase()));
-        for (const id of ids) {
-            const fresh = byId.get(id);
-            if (!fresh) {
-                // Missing from tracker — non-active, no cleanup (§8.5 part B "neither" branch).
-                this.terminateRunning(id, false, 'tracker_state_missing');
-                continue;
-            }
-            const s = fresh.state.toLowerCase();
-            if (terminal.has(s)) {
-                this.terminateRunning(id, true, 'tracker_state_terminal');
-            }
-            else if (active.has(s)) {
-                const entry = this.running.get(id);
-                if (entry)
-                    entry.issue = fresh;
-            }
-            else {
-                this.terminateRunning(id, false, 'tracker_state_non_active');
-            }
-        }
-    }
-    terminateRunning(issueId, cleanupWorkspace, reason) {
-        const entry = this.running.get(issueId);
-        if (!entry)
-            return;
-        if (cleanupWorkspace)
-            entry.cleanup_workspace_on_exit = true;
-        entry.cancel();
-        log.info('reconciliation terminating run', {
-            issue_id: issueId,
-            issue_identifier: entry.identifier,
-            reason,
-            cleanup_workspace: cleanupWorkspace,
-        });
-    }
-    /** §8.2 candidate eligibility. */
-    isEligible(issue) {
-        return this.eligibilityReason(issue, /*ignoreOwnClaim*/ false) === null;
-    }
-    // Returns null when eligible, otherwise a short reason string. The `ignoreOwnClaim`
-    // form is used by the retry path so the issue's own claim/retry entry does not block
-    // its own redispatch.
-    eligibilityReason(issue, ignoreOwnClaim) {
-        if (!issue.id || !issue.identifier || !issue.title || !issue.state) {
-            return 'missing required issue fields';
-        }
-        const state = issue.state.toLowerCase();
-        const active = new Set(this.cfg.tracker.active_states.map((s) => s.toLowerCase()));
-        const terminal = new Set(this.cfg.tracker.terminal_states.map((s) => s.toLowerCase()));
-        if (!active.has(state) || terminal.has(state))
-            return 'state not active';
-        if (this.running.has(issue.id))
-            return 'already running';
-        if (!ignoreOwnClaim && this.claimed.has(issue.id))
-            return 'already claimed';
-        if (!this.hasPerStateSlot(issue.state))
-            return 'no per-state slot';
-        if (state === 'todo' && this.hasNonTerminalBlocker(issue))
-            return 'has non-terminal blocker';
-        return null;
-    }
-    hasNonTerminalBlocker(issue) {
-        const terminal = new Set(this.cfg.tracker.terminal_states.map((s) => s.toLowerCase()));
-        for (const b of issue.blocked_by) {
-            if (!b.state)
-                return true;
-            if (!terminal.has(b.state.toLowerCase()))
-                return true;
-        }
-        return false;
-    }
-    availableGlobalSlots() {
-        return Math.max(0, this.cfg.agent.max_concurrent_agents - this.running.size);
-    }
-    /** §8.3: per-state slot accounting using current running entries. */
-    hasPerStateSlot(stateName) {
-        const cap = this.cfg.agent.max_concurrent_agents_by_state[stateName.toLowerCase()];
-        if (!cap)
-            return this.availableGlobalSlots() > 0;
-        let inState = 0;
-        for (const e of this.running.values()) {
-            if (e.issue.state.toLowerCase() === stateName.toLowerCase())
-                inState++;
-        }
-        return inState < cap && this.availableGlobalSlots() > 0;
-    }
-    /** §8.2 sort: priority ASC (null last), then created_at ASC, then identifier. */
-    sortForDispatch(issues) {
-        return [...issues].sort((a, b) => {
-            const pa = a.priority ?? Number.POSITIVE_INFINITY;
-            const pb = b.priority ?? Number.POSITIVE_INFINITY;
-            if (pa !== pb)
-                return pa - pb;
-            const ca = a.created_at ? Date.parse(a.created_at) : Number.POSITIVE_INFINITY;
-            const cb = b.created_at ? Date.parse(b.created_at) : Number.POSITIVE_INFINITY;
-            if (Number.isFinite(ca) && Number.isFinite(cb) && ca !== cb)
-                return ca - cb;
-            return a.identifier.localeCompare(b.identifier);
-        });
-    }
-    /** §16.4 dispatch_issue */
-    async dispatchIssue(issue, attempt, snapshot) {
-        if (this.running.has(issue.id))
-            return;
-        this.claimed.add(issue.id);
-        this.retryAttempts.delete(issue.id);
-        const cancel = { cancelled: false };
-        const startedAt = new Date().toISOString();
-        const workspacePath = this.workspaces.workspacePathFor(issue.identifier);
-        // Snapshot tracker.root and the terminal target BEFORE workspace setup,
-        // before_run, or smolvm bring-up. A WORKFLOW.md reload during that window
-        // (or even between fetchCandidateIssues returning and this iteration of
-        // the dispatch loop) can mutate the live tracker config; pinning here closes
-        // that window. When the caller supplies a snapshot (the tick/retry path
-        // does — it captured at the fetch atomically), prefer those values; the
-        // optional fallback reads the live config for completeness.
-        const trackerRootAtDispatch = snapshot?.trackerRoot ?? (this.tracker.currentRoot ? this.tracker.currentRoot() : null);
-        const terminalTargetAtDispatch = snapshot?.terminalTarget ?? pickTerminalTarget(this.cfg.tracker.terminal_states);
-        const entry = {
-            issue_id: issue.id,
-            identifier: issue.identifier,
-            issue,
-            session_id: null,
-            thread_id: null,
-            turn_id: null,
-            codex_app_server_pid: null,
-            last_codex_event: null,
-            last_codex_timestamp: null,
-            last_codex_message: null,
-            codex_input_tokens: 0,
-            codex_output_tokens: 0,
-            codex_total_tokens: 0,
-            last_reported_input_tokens: 0,
-            last_reported_output_tokens: 0,
-            last_reported_total_tokens: 0,
-            turn_count: 0,
-            retry_attempt: attempt,
-            started_at: startedAt,
-            workspace_path: workspacePath,
-            cancel: () => {
-                cancel.cancelled = true;
-            },
-            recent_events: [],
-            last_error: null,
-            cleanup_workspace_on_exit: false,
-            mcp_token: null,
-            tracker_root_at_dispatch: trackerRootAtDispatch,
-            terminal_target_at_dispatch: terminalTargetAtDispatch,
-            marked_done: false,
-            steering_requested: false,
-            steering_question: null,
-            steering_context: null,
-        };
-        this.running.set(issue.id, entry);
-        const logger = withIssue({ issue_id: issue.id, issue_identifier: issue.identifier });
-        logger.info('agent attempt started', { attempt });
-        void this.runWorker(issue, attempt, entry, cancel);
-    }
-    async runWorker(issue, attempt, entry, cancelSignal) {
-        const logger = withIssue({ issue_id: issue.id, issue_identifier: issue.identifier });
-        let ok = false;
-        let reason = 'unknown';
-        try {
-            const result = await this.runner.runAttempt(issue, attempt, cancelSignal, entry);
-            ok = result.ok;
-            reason = result.reason;
-            if (result.threadId)
-                entry.thread_id = result.threadId;
-            entry.turn_count = result.turnsCompleted;
-        }
-        catch (err) {
-            ok = false;
-            reason = err.message;
-            logger.error('worker threw', { error: reason });
-        }
-        this.onWorkerExit(issue.id, ok, reason, entry);
-    }
-    /** §16.6 on_worker_exit */
-    onWorkerExit(issueId, normal, reason, entry) {
-        this.running.delete(issueId);
-        const elapsedMs = Date.now() - Date.parse(entry.started_at);
-        if (Number.isFinite(elapsedMs)) {
-            this.codexTotals.seconds_running += elapsedMs / 1000;
-        }
-        const identifier = entry.identifier;
-        const logger = withIssue({ issue_id: issueId, issue_identifier: identifier });
-        if (entry.cleanup_workspace_on_exit) {
-            // Workspace removal is deferred until the worker has fully unwound (including
-            // after_run hook execution) so we never delete the dir while the agent is still
-            // inside it.
-            this.workspaces
-                .remove(entry.identifier, this.cfg.hooks)
-                .catch((err) => logger.warn('workspace removal failed', { error: err.message }));
-        }
-        // §14.2: if the service was stopped while this worker was unwinding, do not schedule
-        // a new retry — that would leave a live timer behind even though stop() was called.
-        if (this.stopped) {
-            this.claimed.delete(issueId);
-            return;
-        }
-        if (normal) {
-            this.completed.add(issueId);
-            logger.info('worker exited (normal)', { reason });
-            this.scheduleRetry(issueId, {
-                identifier,
-                attempt: 1,
-                delayMs: CONTINUATION_DELAY_MS,
-                error: null,
-            });
-        }
-        else {
-            const nextAttempt = entry.retry_attempt !== null && entry.retry_attempt !== undefined ? entry.retry_attempt + 1 : 1;
-            const delayMs = Math.min(FAILURE_BASE_MS * Math.pow(2, nextAttempt - 1), this.cfg.agent.max_retry_backoff_ms);
-            logger.warn('worker exited (abnormal)', { reason, next_attempt: nextAttempt, delay_ms: delayMs });
-            this.scheduleRetry(issueId, {
-                identifier,
-                attempt: nextAttempt,
-                delayMs,
-                error: reason,
-            });
-        }
-    }
-    /** §8.4 retry queue. */
-    scheduleRetry(issueId, sched) {
-        if (this.stopped)
-            return;
-        const existing = this.retryAttempts.get(issueId);
-        if (existing)
-            clearTimeout(existing.timer_handle);
-        const dueAt = Date.now() + sched.delayMs;
-        const handle = setTimeout(() => void this.onRetryTimer(issueId), sched.delayMs);
-        this.retryAttempts.set(issueId, {
-            issue_id: issueId,
-            identifier: sched.identifier,
-            attempt: sched.attempt,
-            due_at_ms: dueAt,
-            timer_handle: handle,
-            error: sched.error,
-        });
-        this.claimed.add(issueId);
-    }
-    /** §16.6 on_retry_timer */
-    async onRetryTimer(issueId) {
-        if (this.stopped)
-            return;
-        const entry = this.retryAttempts.get(issueId);
-        if (!entry)
-            return;
-        this.retryAttempts.delete(issueId);
-        let candidates;
-        let snapshotTrackerRoot;
-        let snapshotTerminalTarget;
-        try {
-            const result = await this.tracker.fetchCandidateIssues();
-            candidates = result.issues;
-            snapshotTrackerRoot = result.root;
-            snapshotTerminalTarget = pickTerminalTarget(result.terminalStates);
-        }
-        catch (err) {
-            log.debug('retry poll failed', {
-                issue_id: issueId,
-                issue_identifier: entry.identifier,
-                error: err.message,
-            });
-            this.scheduleRetry(issueId, {
-                identifier: entry.identifier,
-                attempt: entry.attempt + 1,
-                delayMs: Math.min(FAILURE_BASE_MS * Math.pow(2, entry.attempt), this.cfg.agent.max_retry_backoff_ms),
-                error: 'retry poll failed',
-            });
-            return;
-        }
-        const issue = candidates.find((i) => i.id === issueId);
-        if (!issue) {
-            this.claimed.delete(issueId);
-            log.info('retry releasing claim (not in candidates)', {
-                issue_id: issueId,
-                issue_identifier: entry.identifier,
-            });
-            return;
-        }
-        // Re-apply full candidate eligibility, ignoring this issue's own claim. This catches
-        // late-breaking issues like a new non-terminal blocker on a Todo or a state change to
-        // an inactive value that slipped past the candidate filter on edge tracker shapes.
-        const reason = this.eligibilityReason(issue, true);
-        if (reason !== null) {
-            if (reason === 'no per-state slot') {
-                this.scheduleRetry(issueId, {
-                    identifier: issue.identifier,
-                    attempt: entry.attempt + 1,
-                    delayMs: Math.min(FAILURE_BASE_MS * Math.pow(2, entry.attempt), this.cfg.agent.max_retry_backoff_ms),
-                    error: 'no available orchestrator slots',
-                });
-                return;
-            }
-            // For non-slot reasons (blocker, missing fields, non-active state), the right action
-            // is to release the claim rather than spin on it.
-            this.claimed.delete(issueId);
-            log.info('retry releasing claim (ineligible)', {
-                issue_id: issueId,
-                issue_identifier: entry.identifier,
-                reason,
-            });
-            return;
-        }
-        void this.dispatchIssue(issue, entry.attempt, {
-            trackerRoot: snapshotTrackerRoot,
-            terminalTarget: snapshotTerminalTarget,
-        });
-    }
-    /** §8.6 startup terminal workspace cleanup. */
-    async startupTerminalCleanup() {
-        try {
-            const terminals = await this.tracker.fetchIssuesByStates(this.cfg.tracker.terminal_states);
-            for (const issue of terminals) {
-                try {
-                    await this.workspaces.remove(issue.identifier, this.cfg.hooks);
-                }
-                catch (err) {
-                    log.warn('terminal cleanup failed for issue', {
-                        issue_identifier: issue.identifier,
-                        error: err.message,
-                    });
-                }
-            }
-        }
-        catch (err) {
-            log.warn('startup terminal cleanup fetch failed', { error: err.message });
-        }
-    }
-    // Public hooks the runner uses to feed events back.
-    reportTokenUsage(issueId, usage) {
-        const e = this.running.get(issueId);
-        if (!e)
-            return;
-        // §13.5: prefer absolute totals; track deltas to avoid double-counting.
-        const dIn = Math.max(0, usage.input_tokens - e.last_reported_input_tokens);
-        const dOut = Math.max(0, usage.output_tokens - e.last_reported_output_tokens);
-        const dTot = Math.max(0, usage.total_tokens - e.last_reported_total_tokens);
-        e.codex_input_tokens = usage.input_tokens;
-        e.codex_output_tokens = usage.output_tokens;
-        e.codex_total_tokens = usage.total_tokens;
-        e.last_reported_input_tokens = usage.input_tokens;
-        e.last_reported_output_tokens = usage.output_tokens;
-        e.last_reported_total_tokens = usage.total_tokens;
-        this.codexTotals.input_tokens += dIn;
-        this.codexTotals.output_tokens += dOut;
-        this.codexTotals.total_tokens += dTot;
-    }
-    reportRateLimits(_issueId, snapshot) {
-        this.codexRateLimits = snapshot;
-    }
-    reportRuntimeEvent(issueId, ev) {
-        const e = this.running.get(issueId);
-        if (!e)
-            return;
-        e.last_codex_event = ev.event;
-        e.last_codex_timestamp = ev.at;
-        e.last_codex_message = ev.message;
-        e.recent_events.push(ev);
-        if (e.recent_events.length > 50)
-            e.recent_events.shift();
-    }
-    reportSessionStarted(issueId, info) {
-        const e = this.running.get(issueId);
-        if (!e)
-            return;
-        e.session_id = info.sessionId;
-        e.thread_id = info.threadId;
-        e.codex_app_server_pid = info.pid;
-    }
-    reportTurnStarted(issueId, turnNumber) {
-        const e = this.running.get(issueId);
-        if (!e)
-            return;
-        e.turn_count = turnNumber;
-    }
-    /** §13.3 snapshot. */
-    snapshot() {
-        const generatedAt = new Date().toISOString();
-        const liveExtraSeconds = [...this.running.values()]
-            .map((e) => (Date.now() - Date.parse(e.started_at)) / 1000)
-            .reduce((a, b) => a + b, 0);
-        return {
-            generated_at: generatedAt,
-            counts: { running: this.running.size, retrying: this.retryAttempts.size },
-            running: [...this.running.values()].map((e) => ({
-                issue_id: e.issue_id,
-                issue_identifier: e.identifier,
-                issue_title: e.issue.title ?? '',
-                issue_body: e.issue.description ?? '',
-                state: e.issue.state,
-                session_id: e.session_id,
-                turn_count: e.turn_count,
-                last_event: e.last_codex_event,
-                last_message: e.last_codex_message,
-                started_at: e.started_at,
-                last_event_at: e.last_codex_timestamp,
-                tokens: {
-                    input_tokens: e.codex_input_tokens,
-                    output_tokens: e.codex_output_tokens,
-                    total_tokens: e.codex_total_tokens,
-                },
-                steering_requested: e.steering_requested,
-                steering_question: e.steering_question,
-                steering_context: e.steering_context,
-                marked_done: e.marked_done,
-            })),
-            retrying: [...this.retryAttempts.values()].map((r) => ({
-                issue_id: r.issue_id,
-                issue_identifier: r.identifier,
-                attempt: r.attempt,
-                due_at: new Date(r.due_at_ms).toISOString(),
-                error: r.error,
-            })),
-            codex_totals: {
-                ...this.codexTotals,
-                seconds_running: this.codexTotals.seconds_running + liveExtraSeconds,
-            },
-            rate_limits: this.codexRateLimits,
-        };
-    }
-    /** Issue-detail view used by the HTTP /api/v1/<identifier> endpoint. */
-    detailByIdentifier(identifier) {
-        let entry = null;
-        for (const e of this.running.values()) {
-            if (e.identifier === identifier) {
-                entry = e;
-                break;
-            }
-        }
-        let retry = null;
-        for (const r of this.retryAttempts.values()) {
-            if (r.identifier === identifier) {
-                retry = r;
-                break;
-            }
-        }
-        if (!entry && !retry)
-            return null;
-        return {
-            issue_identifier: identifier,
-            issue_id: entry?.issue_id ?? retry?.issue_id ?? null,
-            status: entry ? 'running' : 'retrying',
-            workspace: entry ? { path: entry.workspace_path } : null,
-            attempts: {
-                current_retry_attempt: retry?.attempt ?? null,
-            },
-            running: entry
-                ? {
-                    session_id: entry.session_id,
-                    turn_count: entry.turn_count,
-                    state: entry.issue.state,
-                    started_at: entry.started_at,
-                    last_event: entry.last_codex_event,
-                    last_message: entry.last_codex_message,
-                    last_event_at: entry.last_codex_timestamp,
-                    tokens: {
-                        input_tokens: entry.codex_input_tokens,
-                        output_tokens: entry.codex_output_tokens,
-                        total_tokens: entry.codex_total_tokens,
-                    },
-                }
-                : null,
-            retry: retry
-                ? {
-                    attempt: retry.attempt,
-                    due_at: new Date(retry.due_at_ms).toISOString(),
-                    error: retry.error,
-                }
-                : null,
-            recent_events: entry?.recent_events ?? [],
-            last_error: entry?.last_error ?? retry?.error ?? null,
-            tracked: {},
-        };
-    }
-}
-//# sourceMappingURL=orchestrator.js.map