@isaacriehm/cairn 0.1.0

package/dist/orchestrator/orchestrator.d.ts

@@ -0,0 +1,154 @@
+import type { InboxTaskRow, OrchestratorOptions } from "./types.js";
+/**
+ * Phase 8 orchestrator. Single-task FIFO pipeline:
+ *
+ *   inbox row → enqueue → tightening (optional) → workspace prep → run agent
+ *   → write run meta → surface phase transitions to adapters
+ *
+ * No commit, no push, no UAT, no reviewer — those are Phases 9-11+.
+ */
+export declare class Orchestrator {
+    private readonly opts;
+    private readonly queue;
+    private readonly seenInboxFiles;
+    private watcher;
+    private questionsWatcher;
+    private answeredQuestions;
+    private pollTimer;
+    private running;
+    private dispatching;
+    private stopped;
+    private adapterUnsubs;
+    /**
+     * Handle on the in-flight implementer run. Set by `dispatch` before
+     * the runImplementer call; cleared in `completeRun` (or via abort).
+     * `/halt` reads this to fire the abort controller; `/status` reads it
+     * to render running-task line.
+     */
+    private activeRun;
+    private watchdogTimer;
+    /**
+     * §3.5 plan-quota — count of consecutive runs that hit a quota error
+     * (rate_limit / overloaded). Reset on any successful agent call.
+     * After `quotaPauseThreshold` (default 3) the dispatch loop pauses
+     * and pages the operator. /unpause clears it.
+     */
+    private consecutiveQuotaErrors;
+    private dispatchPaused;
+    private dispatchPauseReason;
+    private dispatchPausedAt;
+    constructor(opts: OrchestratorOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Synchronous queue-size accessor for smoke. */
+    queueSize(): number;
+    private absorbExistingInbox;
+    private absorbInboxFile;
+    private tick;
+    private dispatch;
+    private persistSensorAttempt;
+    private persistReviewerAttempt;
+    /**
+     * Phase 14 — process a Discord-issued direction row through the
+     * decision-capture flow. Runs the Tier-1 extractor → writes a draft →
+     * fires the confirm dialog through the first-registered adapter →
+     * accepts / edits / rejects + regenerates the ledger.
+     *
+     * Independent of the task FIFO. Failures are logged and the inbox row
+     * is moved to processed/ regardless so we never replay.
+     */
+    /**
+     * Phase 16.x — agent-initiated operator question (`harness_ask_operator`
+     * MCP tool). The implementer agent writes a `<id>.q.json` under
+     * `.harness/runs/active/<run_id>/questions/`; chokidar fires this
+     * handler. We:
+     *   1. Find the active run's task channel.
+     *   2. Build a pinging dialog spec (alerts the operator on mobile).
+     *   3. requestDialog → operator answers (or times out).
+     *   4. Write `<id>.a.json` with the answer; the MCP tool's poller
+     *      picks it up and returns to the agent.
+     */
+    private absorbQuestionFile;
+    private handleDirectionRow;
+    private runBackpropStep;
+    private runUatStep;
+    private runReviewerStep;
+    private renderPrompt;
+    private surfacePhase;
+    /**
+     * Ask any adapter that supports it whether `channelId` is still
+     * reachable. Adapters that don't expose `isChannelAlive` (CLI / stub)
+     * are treated as "always alive." If multiple adapters answer, ALL
+     * must say true — any single dead vote → false (dispatching to a
+     * dead channel for one adapter would lose surfacing on that adapter).
+     */
+    private isChannelAlive;
+    /**
+     * During the implementer phase, summarize recent stream-jsonl events
+     * via Tier-0 every ~8s and patch the live status embed's `activity`
+     * field. Operator sees the agent's tool calls + text in plain
+     * English ("Reading X", "Running tsc") instead of a static
+     * "running" badge.
+     *
+     * Returns a stop fn that clears the interval. Safe to call when
+     * adapters are missing or channelId is undefined.
+     */
+    private startActivityFeed;
+    /**
+     * Start a Discord-style "typing" indicator on the task's channel for
+     * any adapter that supports it. Returns a stop fn that clears the
+     * heartbeat. Safe to call when no adapter / no channelId — returns
+     * a no-op stop fn.
+     */
+    private startTaskTyping;
+    private surfacePhaseWithBody;
+    private logRunEvent;
+    /**
+     * Watchdog tick — runs every 30s. If the active run has been silent
+     * past `stallSeconds` AND the phase is one that should be producing
+     * events, post a single remediation embed pointing the operator at
+     * `/halt` + `/status`. Operator-pending phases (`blocked`) are
+     * excluded — those wait for the human and are silent on purpose.
+     * Fires once per stall episode; resets on the next log event.
+     */
+    private checkRunWatchdog;
+    private readLogTailFormatted;
+    private readToolDigestFromEvents;
+    /**
+     * Walk the tightener's ambiguities one-at-a-time, then dispatch with
+     * the resolved spec.
+     *
+     * Per operator pivot: replace the single-blob dialog with per-question
+     * A/B/C walks. Each ambiguity dialog has up to 4 buttons (the LLM's
+     * candidate_resolutions, capped at 4) plus a final approve/ship-anyway/
+     * cancel confirm after the walk.
+     *
+     * Returns:
+     *   - { decision: "approve", resolved_spec }   → run with this spec
+     *   - { decision: "ship_anyway" }              → run with original body
+     *   - { decision: "edit"|"cancel"|"timeout" }  → fail run
+     */
+    private requestTightenerDecision;
+    private completeRun;
+    private writeMeta;
+    private adapterForSource;
+    private handleSlashRow;
+    private handleHalt;
+    private handleStatus;
+    private collectStatus;
+    private collectRecentRuns;
+    private gcAgeMs;
+    private handleQueue;
+    private handleEval;
+    private handleResume;
+    private handleOops;
+    private captureStubPatternFromOops;
+    private appendStubPattern;
+    private captureOopsLog;
+    private handleHelp;
+    private recordQuotaSignal;
+    private appendQuotaJsonl;
+    private handleUnpause;
+    private handleArchive;
+}
+export type { InboxTaskRow };