/**
 * Post-hoc delivery (crew#393): run the SAME hardened deliver script the deliver phase runs
 * (`core/deliver.ts`, crew#293/#317) against a completed run's existing worktree — the recovery
 * path for a run whose reviewable work was left stranded (completed, repo-scoped, no PR).
 *
 * ONE script, two entry points. The deliver PHASE is `bash -lc <script>` spawned by the engine's
 * `run_tool_cmd` inside the run worktree; this module is the daemon spawning the identical
 * invocation itself, because a post-hoc lift has no phase to ride. Everything the script
 * hardened — commit the run's work, refuse the default branch, rebase onto origin's default
 * branch with a LOUD abort on conflict, never force, push, `gh pr create` with output and status
 * captured separately, success re-derived from a real PR URL — is therefore hardened here too,
 * by construction rather than by copy.
 *
 * The exit status + merged output travel back verbatim: the ROUTE decides what they mean
 * (non-zero ⇒ a loud 4xx carrying the script's own words; zero ⇒ the PR URL is re-extracted
 * crew-side via `prUrlFrom`, the same grep the script itself ends with).
 */
import { type DeliverScriptOptions } from '../core/deliver.js';
/** What one spawn of the deliver script produced: its exit status and merged output. */
export interface DeliverScriptResult {
    /** 0 = the script itself reported a delivery; anything else is the script's loud refusal. */
    status: number;
    /** stdout + stderr, chronological (the script folds stderr into stdout itself: `exec 2>&1`). */
    output: string;
    /** True when the SCRIPT never ran to its own verdict — a spawn failure (ENOENT) or the
     *  timeout kill. The route answers 500 (infra fault, retryable), never the refusal 409. */
    spawnFailure?: boolean;
}
/** The exec seam the deliver route runs the script through — injectable so route tests can
 *  point HOME/PATH at a fixture (a stub `gh`, a temp home) without touching the daemon env.
 *  `opts` is the script's PR/commit text context (crew#524): the run id, the facts the route
 *  already holds for the fallback text, and this daemon's own origin for the run-record fetch. */
export type DeliverExec = (workdir: string, intent?: string, opts?: DeliverScriptOptions) => Promise<DeliverScriptResult>;
/** A worktree stood back up from a run's `wicked/<id>` branch, plus its teardown (crew#418). */
export interface ReprovisionedWorktree {
    /** The path to deliver in — a throwaway checkout of `wicked/<runId>`. */
    workdir: string;
    /** Remove the throwaway worktree; the `wicked/<runId>` branch (the record) survives. */
    cleanup: () => Promise<void>;
}
/** The reprovision seam (crew#418) — injectable so route tests never shell out to git. Resolves
 *  to a throwaway worktree checked out on the run's branch, or `null` when the branch is gone. */
export type WorktreeReprovisioner = (repoRoot: string, runId: string) => Promise<ReprovisionedWorktree | null>;
/**
 * Stand a run's committed work back up from its `wicked/<runId>` branch (crew#418).
 *
 * The engine REAPS a failed-deliver run's worktree once the deliver phase has committed the work
 * (a clean tree; `git worktree remove` succeeds even with the branch ahead) — the work then lives
 * ONLY on the `wicked/<runId>` branch, which the reap never deletes ("the checkout is scaffolding,
 * the branch is the record"). A post-hoc lift therefore has no worktree to run in; this checks the
 * branch out at a THROWAWAY path so the hardened deliver script can commit-nothing / rebase / push
 * it. The path's basename is deliberately NOT the run id, so the script's branch derivation falls
 * back to `git branch --show-current` — which the checkout puts on `wicked/<runId>` — instead of
 * `wicked/<basename>`. Never touches the engine's recorded worktree path, so it cannot race the
 * engine's own worktree bookkeeping.
 *
 * Resolves `null` when the branch does not exist (nothing to reprovision) — the caller then
 * answers the same "nothing to deliver" refusal as a truly empty run.
 */
export declare const gitReprovisionWorktree: WorktreeReprovisioner;
/** A post-hoc lift talks to a real remote; 5 minutes is generous, hanging forever is not. */
export declare const DELIVER_SCRIPT_TIMEOUT_MS: number;
/**
 * The production {@link DeliverExec}: `bash -lc <script>` in the run's worktree — the exact
 * invocation core's `run_tool_cmd` uses for the deliver phase (login shell, so the operator's
 * PATH — where `gh` lives — is loaded). `opts` is the PR/commit text context (crew#524). `env`
 * overlays the daemon's own environment; tests use it to substitute HOME (whose `.bash_profile`
 * prepends a stub `gh`), production passes none.
 */
export declare function runDeliverScript(workdir: string, intent?: string, opts?: DeliverScriptOptions, env?: Record<string, string>): Promise<DeliverScriptResult>;
//# sourceMappingURL=post-hoc-deliver.d.ts.map