@loompad/cli 0.1.0 → 1.1.1

package/dist/core/orchestra.d.ts

@@ -0,0 +1,635 @@
+/**
+ * Orchestra — one orchestrator agent, many worker agents, in parallel.
+ *
+ * A route passes one baton down a line; a subtask fans out but never reports
+ * back. Orchestra is the missing shape: an orchestrator agent (any adapter —
+ * Claude Code, Codex, Antigravity, Grok, OpenCode) turns a goal into a task
+ * graph, Loom runs every ready task at once on whichever worker agents the
+ * plan names, each in its own thread and its own git worktree, merges the
+ * finished work into one integration branch, and hands the orchestrator the
+ * results to review — accept, follow up, spawn more, or finish.
+ *
+ * Design lineage, credited: the orchestrator/worker split, the "coordinate,
+ * never implement" orchestrator rules and the worktree-per-worker isolation
+ * follow Agent Orchestrator (github.com/Untrivial-ai/agent-orchestrator,
+ * Apache-2.0). What differs, on purpose:
+ *
+ *  - **The orchestrator never needs a shell tool.** AO's orchestrator drives a
+ *    CLI (`ao spawn`, `ao send`) from its terminal, which fails for agents that
+ *    run sandboxed or can't execute commands headless. Here it answers in a
+ *    fenced ```loom block of JSON actions that Loom parses — so ANY agent can
+ *    orchestrate, including ones with no tools at all.
+ *  - **A real task graph.** Tasks declare `dependsOn`; a task starts only when
+ *    its dependencies merged, and it branches from the integration tip so it
+ *    sees their work.
+ *  - **Mixed fleets.** Each task names its worker; three Codex tasks and two
+ *    Antigravity tasks run side by side as separate CLI sessions.
+ *
+ * Everything is observable: every step is an `orchestra` event in the project
+ * log (so the web app, the phone and the CLI all watch the same run), and each
+ * task's agent output streams into that task's own chat.
+ */
+import type { TeamPolicy } from "./team-policy.js";
+import { type GoalScope } from "./goal-lanes.js";
+import type { Adapter, AgentConfig, ChatInfo, EventKind, GitDelivery, LoomEvent } from "../types.js";
+export type OrchestraStatus = "starting" | "planning" | "running" | "reviewing" | "waiting_human" | "completed" | "failed" | "aborted" | "moved";
+export type TaskStatus = "pending" | "running" | "done" | "conflict" | "needs_input" | "failed" | "cancelled";
+/**
+ * Why a ready task isn't running yet (Loom Teams, Phase 2). "decide" needs the
+ * orchestrator (an overlap without an `overlap` decision, missing `touches`, a
+ * disallowed agent); the rest clear on their own and are re-checked.
+ */
+export interface TaskHold {
+    kind: "decide" | "wait" | "zone" | "capacity";
+    reason: string;
+    /** wait: the teammate goal this task waits on. */
+    runId?: string;
+    /** zone: the hard zone and who holds it. */
+    zone?: string;
+    holder?: string;
+    since: number;
+    checkedAt?: number;
+}
+export interface OrchestraTask {
+    id: string;
+    title: string;
+    prompt: string;
+    /** Roster agent id (or kind) that runs it. */
+    agent: string;
+    /** Adapter kind actually used. */
+    kind: string;
+    dependsOn: string[];
+    /** File globs the orchestrator declared this task will touch (D9). */
+    touches?: string[];
+    /** The orchestrator's answer to a teammate overlap (D29): wait:<goal> | narrow | proceed:<reason>. */
+    overlap?: string;
+    /** Set while the task waits on something other than its own dependencies. */
+    hold?: TaskHold;
+    status: TaskStatus;
+    /** The chat (thread) this task's output streams into. */
+    chat: string;
+    branch?: string;
+    dir?: string;
+    attempts: number;
+    /** Follow-up messages queued by the orchestrator, run after the current turn. */
+    queued: string[];
+    result?: string;
+    files?: string[];
+    error?: string;
+    costUsd?: number;
+    /** The integration branch's merge commit for this task, and the lines it changed (stacks, D59). */
+    mergeCommit?: string;
+    lines?: number;
+    startedAt?: number;
+    finishedAt?: number;
+    /** Set once the orchestrator has been shown this outcome. */
+    reported?: boolean;
+}
+export interface OrchestraRun {
+    id: string;
+    goal: string;
+    orchestrator: {
+        agent: string;
+        kind: string;
+    };
+    /** Agents the orchestrator may assign work to (roster ids). */
+    workers: string[];
+    status: OrchestraStatus;
+    /** The thread the orchestrator answers in. */
+    chat: string;
+    /**
+     * True when `chat` is a thread that already existed and will outlive the
+     * run \u2014 you orchestrated from Main and the orchestrator answered there.
+     * The difference matters after the run ends: a thread the run made belongs
+     * to it forever, and Main goes back to being Main.
+     */
+    inPlace?: boolean;
+    baseBranch: string | null;
+    baseCommit: string;
+    branch: string;
+    dir: string;
+    tasks: OrchestraTask[];
+    round: number;
+    maxRounds: number;
+    maxParallel: number;
+    summary?: string;
+    question?: string;
+    error?: string;
+    /** Set when the integration branch was merged back into the project. */
+    applied?: {
+        at: number;
+        into: string;
+        task?: string;
+    };
+    /**
+     * Plan mode: the plan is written as markdown specs under plans/<run>/ on the
+     * integration branch — PLAN.md plus one self-contained file per task — so
+     * any agent (or teammate) can read, resume or re-run it. See writePlan.
+     */
+    plan?: boolean;
+    /** What the project's git delivery policy did with the finished run. */
+    delivered?: {
+        mode: GitDelivery;
+        into?: string;
+        pushed?: string;
+        prUrl?: string;
+        at: number;
+    };
+    deliveryError?: string;
+    /** Team facts for the orchestrator's next review: predicted conflicts, drift (D33, D34). */
+    notes?: string[];
+    /** Phase 4: the goal's PR on its way to main — checks, fixes, review, landing. */
+    landing?: LandingState;
+    /** An adopted goal (D63): this run fixes a teammate's PR, starting from and pushing to its branch. */
+    from?: {
+        branch: string;
+        pr: number;
+        url: string;
+        ownerRunId?: string;
+        owner?: string;
+    };
+    /** This goal's spending cap in USD (D64), raised each time a human says continue. */
+    budgetUsd?: number;
+    /** So the 80% word is said once, not once a turn. */
+    budgetWarned?: boolean;
+    /** Phase 5: set while the goal is being handed to another machine; nothing new starts. */
+    moving?: boolean;
+    /** Where the goal went (D75). */
+    movedTo?: {
+        where: string;
+        at: number;
+    };
+    /**
+     * Set when Loom itself stopped the run (a restart or shutdown), not you:
+     * which tasks were in flight, so Resume can pick exactly those back up in
+     * the worktrees they left.
+     */
+    interrupted?: {
+        at: number;
+        tasks: string[];
+        phase: OrchestraStatus;
+    };
+    /** A race (see OrchestraStartOptions.race); applied.task names the entrant you picked. */
+    race?: boolean;
+    costUsd: number;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * A goal PR's journey to main (Loom Teams, Phase 4 — D52–D63). Kept on the
+ * run so it survives restarts and shows wherever the run does.
+ */
+export interface LandingState {
+    pr: number;
+    url: string;
+    /** "queued": Land was clicked, and another goal holds a lane this one needs (Phase 6, D82). */
+    state: "open" | "pending" | "green" | "failing" | "fixing" | "needs_human" | "queued" | "landing" | "merged" | "closed";
+    headSha?: string;
+    /** Fix attempts spent (D55: checks and high review findings share them). */
+    fixAttempts: number;
+    /** `${sha}:${check}` already rerun once (D53). */
+    reruns: string[];
+    /** Checks that failed, then passed on rerun. */
+    flaky: string[];
+    checks?: {
+        failing: string[];
+        pending: string[];
+        passing: number;
+    };
+    reviews: number;
+    reviewedSha?: string;
+    review?: {
+        state: "success" | "failure" | "skipped";
+        reviewer: string | null;
+        high: number;
+        findings: number;
+        at: number;
+        overridden?: string;
+        overriddenSha?: string;
+    };
+    /** Why it waits on a human. */
+    reason?: string;
+    /** The owner clicked Land: keep going (pushrebase-lite, auto-merge) until merged (D56). */
+    landRequested?: boolean;
+    /** One agent attempt at a conflict with fresh main (D58). */
+    conflictTried?: boolean;
+    /** A teammate holds this goal right now (D63). */
+    adoptedBy?: string;
+    /** An adopted goal, handed back to its owner. */
+    returned?: boolean;
+    /** The PR head when it started waiting on a human: it keeps waiting until that changes. */
+    needsHumanSha?: string;
+    /** The commit the PR merged as (deploy alerts, D72). */
+    mergeSha?: string;
+    /** Actions minutes the goal's branch used, recorded when it lands (§10). */
+    ciMinutes?: number;
+    /** Stacked delivery (D59): the PRs bottom-up; the last is this goal's own branch. */
+    stack?: Array<{
+        pr: number;
+        url: string;
+        branch: string;
+        base: string;
+        state?: string;
+    }>;
+    /** Land goes through the train: Loom merges it when its lanes' turn comes. */
+    train?: boolean;
+    /** The lanes it needs (path scopes from `landing.lanes`; "main" when none match). */
+    lanes?: string[];
+    /** It holds its lanes' slots right now: its turn. */
+    slot?: boolean;
+    /** The PR head this turn pushed (fresh base merged in), and when. */
+    turnSha?: string;
+    turnAt?: number;
+    updatedAt: number;
+}
+/** How much of a goal's budget may go before it says something. */
+export declare const BUDGET_WARN_AT = 0.8;
+export interface OrchestraStartOptions {
+    goal: string;
+    /** Roster id (or kind) of the orchestrator. Defaults to the host's pick. */
+    orchestrator?: string;
+    /** Roster ids (or kinds) of allowed workers. Defaults to every adapter. */
+    workers?: string[];
+    maxParallel?: number;
+    maxRounds?: number;
+    /** Write the plan as markdown specs other agents can read (plans/<run>/). */
+    plan?: boolean;
+    /** Adopt (D63): start from a teammate's PR branch and push back to it. */
+    from?: OrchestraRun["from"];
+    /** Stop this goal when it has spent this much, and say so. */
+    maxUsd?: number;
+    /**
+     * A race: every worker gets the same prompt in its own worktree, nobody
+     * plans and nothing merges — you compare what came back and pick one.
+     */
+    race?: boolean;
+    /** The paths this goal expects to touch, when the caller already knows. */
+    touches?: string[];
+    /**
+     * The thread the goal was given in. The orchestrator answers there instead
+     * of in a thread of its own, so orchestrating from Main leaves you in Main.
+     * The caller proves the chat exists; an unknown one gets a new thread.
+     */
+    chat?: string;
+}
+/** What orchestra needs from the project that owns it. */
+export interface OrchestraHost {
+    projectId: string;
+    projectName: string;
+    projectDir: string;
+    /** Adapter entries of the roster (enabled only). */
+    roster(): AgentConfig[];
+    /** Kinds installed on this machine but not on the roster, usable as workers. */
+    installedKinds(): string[];
+    /** Build a fresh adapter instance for `cfg`, working in `dir`. */
+    makeAgent(cfg: AgentConfig, dir: string): Adapter;
+    append(e: {
+        kind: EventKind;
+        agentId?: string;
+        chat?: string;
+        payload: Record<string, unknown>;
+    }): LoomEvent;
+    /** agentId pins who answers there — a task thread is its worker's. */
+    createChat(title: string, opts?: {
+        agentId?: string;
+    }): ChatInfo;
+    /** Does this thread exist? Asked before a run is told to answer in one. */
+    chatExists?(id: string): boolean;
+    /** Skills + retrieved memories for a task, or "" — the project brain (and the team's, when shared). */
+    /**
+     * The memory brief for a task. May be async: with the dense channel on
+     * (core/semantic.ts) the query has to be embedded first, which is a
+     * millisecond of real work rather than a lookup.
+     */
+    briefingFor(query: string, agentId: string, files?: string[]): string | Promise<string>;
+    /** Throws when `agentId` is over budget or quarantined. */
+    gate(agentId: string): void;
+    /** Cost/metrics bookkeeping for a worker event. */
+    observe(event: LoomEvent): void;
+    /** A reply as it's written, for the live view (never logged — see StreamDelta). */
+    stream?(f: {
+        agentId: string;
+        chat: string;
+        text: string;
+        reasoning?: boolean;
+    }): void;
+    /** The project's git delivery policy, read when a run completes. */
+    gitDelivery?(): GitDelivery;
+    /** The project's own per-goal spend cap, when it sets one (.loom/config.json). */
+    goalBudgetUsd?(): number | null;
+    /** How many goals may run at once when their paths don't collide (default 1). */
+    maxConcurrentGoals?(): number | null;
+    /** The GitHub login of the member running this daemon, when on a team (commit trailers). */
+    member?(): string | null;
+    /** The team coordinator for this project, when it's shared with a team (Phase 2). */
+    coordinator?(): OrchestraCoordinator | null;
+}
+/** What a task's admission decided. */
+export type Admission = {
+    go: true;
+    rebase?: boolean;
+    note?: string;
+} | {
+    go: false;
+    hold: TaskHold;
+};
+/**
+ * Loom Teams, Phase 2 — the team's say over when a task runs (leases, hard
+ * zones, waits, capacity, policy) and what it hears back (drift, WIP, landing).
+ * Implemented by the daemon's Team Link; absent for solo projects.
+ */
+export interface OrchestraCoordinator {
+    teamPolicy?(): Promise<TeamPolicy | null>;
+    release?(runId: string, reason: string): Promise<void>;
+    admit(run: OrchestraRun, task: OrchestraTask): Promise<Admission>;
+    onEdit?(run: OrchestraRun, task: OrchestraTask, path: string): void;
+    onTaskDone?(run: OrchestraRun, task: OrchestraTask): void;
+    onRunEnd?(run: OrchestraRun): void;
+    /** Policy cap on tasks at once for this member (D38). */
+    maxParallel?(): number | null;
+    /** The project's own per-goal cap, when it has one (.loom/config.json). */
+    goalBudgetUsd?(): number | null;
+    /** Protected branches only receive PRs (D38). */
+    isProtected?(branch: string): boolean;
+    /** Why this member can't start a goal right now (D64: over the daily budget), or null. */
+    canStart?(): string | null;
+    /** The per-goal budget in USD (D64), or null for none. */
+    goalBudgetUsd?(): number | null;
+    /** Stacked delivery for big goals (D59). */
+    stackMode?(): "auto" | "off";
+}
+export type OrchestraAction = {
+    type: "spawn";
+    id?: string;
+    title: string;
+    agent: string;
+    prompt: string;
+    dependsOn?: string[];
+    touches?: string[];
+    overlap?: string;
+} | {
+    type: "send";
+    task: string;
+    message: string;
+} | {
+    type: "cancel";
+    task: string;
+} | {
+    type: "ask";
+    question: string;
+} | {
+    type: "done";
+    summary: string;
+};
+/**
+ * Pull the actions out of an orchestrator reply.
+ *
+ * Accepts the last ```loom fence (the documented form), falling back to the
+ * last ```json fence holding an `actions` array, then to a bare object — models
+ * drift, and a plan lost to a fence label is a wasted round. Returns null when
+ * nothing parses, so the caller can ask again rather than guess.
+ */
+/**
+ * How much of an agent's turn is kept in memory, and why cutting it is delicate.
+ *
+ * The orchestrator's answer is parsed from this text, and the part that matters
+ * — the ```loom block — sits at the END of a reply whose prose can be long. The
+ * old cap kept the last 20,000 characters, which on any real plan threw away
+ * the OPENING fence while keeping the closing one. The parser then saw an
+ * unterminated block, reported that the reply had no actions, and the whole
+ * plan was silently discarded (#104). Measured on one real run: seven
+ * consecutive plans of 6, 5, 5, 5, 5, 8 and 8 tasks, every one of them parsed
+ * perfectly from the logged event and every one destroyed by the cap. The
+ * better the orchestrator planned, the more certainly its plan was binned.
+ *
+ * So two changes. The budget is large enough that no plausible reply reaches
+ * it — a turn is bounded by the model's own output limit long before this.
+ * And when it IS reached, the cut is made at the start of the last actions
+ * block rather than blindly at a character offset, so the payload can never be
+ * decapitated by the thing that is meant to be protecting memory.
+ */
+export declare const TURN_TEXT_LIMIT = 400000;
+export declare function capTurnText(text: string, limit?: number): string;
+export declare function parseOrchestraActions(text: string): OrchestraAction[] | null;
+/** The orchestrator's standing instructions, sent with its first turn. */
+export declare function orchestratorBriefing(opts: {
+    project: string;
+    goal: string;
+    workers: Array<{
+        id: string;
+        kind: string;
+        role?: string;
+    }>;
+    maxParallel: number;
+    branch: string;
+    planDir?: string;
+}): string;
+/** plans/<run>/PLAN.md — the index: goal, task table, how to use it, results. */
+export declare function renderPlanIndex(run: OrchestraRun): string;
+/** plans/<run>/<task>.md — one task, readable by any agent with no other context. */
+export declare function renderTaskFile(run: OrchestraRun, t: OrchestraTask): string;
+/** What a worker is told, alongside its task. */
+export declare function workerBriefing(opts: {
+    project: string;
+    runGoal: string;
+    task: OrchestraTask;
+    branch: string;
+    brain: string;
+    planFile?: string;
+}): string;
+/**
+ * A worker's commit, traceable to its goal, task and agent from `git log`
+ * alone (docs/teams-architecture.md §7). GitHub reads Co-Authored-By; the
+ * Loom-* trailers are for people and tools (`git log --grep 'Loom-Goal: o7x'`).
+ */
+export declare function taskCommitMessage(run: OrchestraRun, task: OrchestraTask, member: string | null): string;
+/** Where a run's plan lives inside the repo. */
+export declare function planDir(run: {
+    id: string;
+}): string;
+export declare class OrchestraEngine {
+    private host;
+    private runs;
+    private live;
+    /** A worker's or orchestrator's live instance by its id, for answering its questions. */
+    liveAgent(instanceId: string): Adapter | undefined;
+    private gitLock;
+    private turnText;
+    private orchestratorBusy;
+    constructor(host: OrchestraHost);
+    private runsDir;
+    private loadRuns;
+    private save;
+    list(): OrchestraRun[];
+    get(id: string): OrchestraRun | undefined;
+    active(): OrchestraRun | undefined;
+    /** Every goal in flight, with the paths it expects to touch. */
+    runningScopes(): GoalScope[];
+    private emit;
+    /** Resolve a name the orchestrator (or user) gave into a runnable config. */
+    resolveAgent(name: string): AgentConfig | null;
+    start(opts: OrchestraStartOptions): Promise<OrchestraRun>;
+    private workerCfgs;
+    private workersFor;
+    abort(runId: string, reason?: string): Promise<OrchestraRun>;
+    /** The human answers an orchestrator's question (or adds direction mid-run). */
+    reply(runId: string, text: string): Promise<OrchestraRun>;
+    private pendingHuman;
+    /**
+     * Put a completed goal back to work (Phase 4): a failed check, a high review
+     * finding, a conflict with fresh main. Same integration branch, same task
+     * worktrees; the orchestrator gets the problem and a fresh round budget.
+     * Whatever landed on the pushed branch meanwhile (an adopter's fix) comes in first.
+     */
+    reopen(runId: string, text: string, why: string): Promise<OrchestraRun>;
+    /**
+     * Hand a goal to another machine (Phase 5, D75): stop starting anything,
+     * let running turns finish (interrupting them after `graceMs`), commit every
+     * worktree, and push the integration and task branches to hidden refs. The
+     * returned record is what the other side needs to rebuild the run; this
+     * copy becomes "moved" and read-only.
+     */
+    moveOut(runId: string, where: string, opts?: {
+        graceMs?: number;
+    }): Promise<{
+        record: OrchestraRun;
+        refs: string[];
+    }>;
+    /**
+     * Rebuild a moved goal here (a runner taking it, or bringing it back):
+     * fetch its hidden refs, recreate the integration and task worktrees, and
+     * give the orchestrator a review turn to carry on (D75, D76).
+     */
+    importRun(record: OrchestraRun, opts?: {
+        from?: string;
+        resume?: boolean;
+    }): Promise<OrchestraRun>;
+    /** The orchestrator's standing instructions, for a fresh orchestrator session. */
+    private briefingOf;
+    /** The branch this goal's PR is on. */
+    prBranch(run: OrchestraRun): string;
+    /** Bring commits pushed to the goal's PR branch by someone else into the integration branch. */
+    pullPushed(run: OrchestraRun): Promise<void>;
+    /** Record where a goal's PR stands (the landing manager owns the transitions). */
+    setLanding(runId: string, patch: Partial<LandingState>): LandingState | undefined;
+    private goalCap;
+    /**
+     * A word before the stop.
+     *
+     * Hearing about a budget for the first time when the goal halts is a bad way
+     * to learn it exists — especially now that a queue can start goals while
+     * you're elsewhere. Said once per goal.
+     */
+    private warnNearBudget;
+    /** D64: a goal over its cap stops asking for more work until a human says continue. */
+    private overBudget;
+    /**
+     * Merge the integration branch into the project's working tree.
+     *
+     * Explicit, never automatic: the run's work lands on its own branch, and the
+     * human decides when it reaches theirs.
+     */
+    apply(runId: string, taskId?: string): Promise<{
+        merged: string;
+        into: string;
+    }>;
+    /** What one task changed on its branch since the run began — a race entrant's diff. */
+    taskDiff(runId: string, taskId: string): Promise<string>;
+    /** Remove a finished run's worktrees (the branch stays for the record). */
+    cleanup(runId: string): Promise<void>;
+    shutdown(): Promise<void>;
+    /**
+     * Carry on a run Loom stopped by restarting. The tasks that were in flight
+     * go back to pending in the worktrees they left (their work so far is
+     * there); the orchestrator — a fresh session, so it's briefed again —
+     * picks up at review when nothing was in flight.
+     */
+    resume(runId: string): Promise<OrchestraRun>;
+    /** Runs whose orchestrator restarts as a fresh session (resume) and needs its brief again. */
+    private rebrief;
+    private mustGet;
+    private stopAll;
+    private orchestratorAgent;
+    private orchestratorTurn;
+    private applyActions;
+    /** Write (or refresh) plans/<run>/ on the integration branch and commit it. */
+    private writePlan;
+    private addTask;
+    private followUp;
+    private cancelTask;
+    private admitting;
+    private recheckTimers;
+    private schedule;
+    private armRecheck;
+    /** Something the team coordinator watches changed (a lease freed, a PR merged): look again now. */
+    recheck(runId: string): void;
+    /**
+     * Stop a running task and hold it (D33: drift into someone's hard zone).
+     * It keeps its worktree and session; when the hold clears it resumes with a
+     * "continue" follow-up instead of starting over.
+     */
+    pauseTask(runId: string, taskId: string, hold: TaskHold): void;
+    /**
+     * The owner says stop waiting (D32): a `wait:` hold is released and the task
+     * proceeds alongside the other goal, with the reason on record.
+     */
+    stopWaiting(runId: string, taskId: string): OrchestraTask;
+    /** A team fact for the orchestrator's next review (D33, D34). */
+    addNote(runId: string, note: string): void;
+    /** Ask the team coordinator (if any) whether this task may start, then start it. */
+    private admitAndRun;
+    /**
+     * Bring the base branch's latest into the integration branch (D30): a task
+     * that waited for a teammate's PR must build on the merged code.
+     */
+    private syncWithBase;
+    /** When nothing can move without the orchestrator, give it a turn. */
+    private maybeReview;
+    /** The report the orchestrator reviews: every task's outcome since last time. */
+    statusReport(run: OrchestraRun): string;
+    private runTask;
+    private lastError;
+    /** `${run}/${task}` → the question a worker stopped to ask mid-turn. */
+    private workerQuestion;
+    private integrate;
+    private wire;
+    /** A finished or aborted run's per-turn scratch (reply text, errors, questions) goes with it. */
+    private forgetRun;
+    private finish;
+    /**
+     * Do what the project's git delivery policy says with a completed run:
+     * nothing, merge it in, merge and push, or push its branch and open a PR.
+     * A failure here never un-completes the run — the work is safe on its
+     * branch — it's reported, and the manual Apply is still there.
+     */
+    /**
+     * D59: where a big goal's stack is cut — tasks in the order they merged into
+     * the integration branch, sliced by size (cutStack). Null when unknowable.
+     */
+    private stackSlices;
+    /**
+     * Push one branch per slice and open a PR for each, each based on the one
+     * below; the top slice is the goal's own branch (so fixes land on it). The
+     * landing manager lands them bottom-up with the merge method.
+     */
+    private deliverStack;
+    deliver(run: OrchestraRun, mode?: GitDelivery): Promise<void>;
+}
+/** A new PR's landing record. */
+export declare function newLanding(pr: number, url: string): LandingState;
+/** The goal PR's description: the summary, the task table, the plan. */
+export declare function prBody(run: OrchestraRun, extra?: string[]): string;
+/**
+ * Verification commands a Claude orchestrator may run while reviewing.
+ *
+ * Headless Claude in acceptEdits mode can't run any shell command, so a Claude
+ * orchestrator could only read the workers' code and take their word that the
+ * tests passed (seen on a real run: "could not run node --test, approval not
+ * granted"). Codex, sandboxed, just ran them. These are the checks a reviewer
+ * runs — tests, typecheck, build, and read-only git — and nothing else.
+ */
+export declare const ORCHESTRATOR_VERIFY_TOOLS: string[];
+export declare function taskSummary(t: OrchestraTask): Record<string, unknown>;
+export declare function isTerminal(s: OrchestraStatus): boolean;
+/** Where a moved goal's branches travel: hidden refs, like WIP refs (D11, D75). */
+export declare function runRef(runId: string, name: string): string;