/**
 * Scenario → CampaignNode mapping (TH-9; DES-CAMPAIGN-001 §8).
 *
 * `POST /campaigns` accepts a batch of SCENARIOS (the qe-campaign vocabulary: garden's
 * campaign-recon rungs, or any caller's batch of checks) and this module maps them onto the
 * engine's `CampaignDef` — nodes, `on_success`/`on_terminal` edges, and one composed
 * single-phase workflow per deterministic scenario. Pure data-in/data-out: no engine handle,
 * no I/O, so every rule below is unit-testable without spawning a Core.
 *
 * ## The two scenario shapes, and where the work actually lives
 *
 *  - **`tool` (deterministic)** — the scenario is a spec FILE (garden's runner spec, a script,
 *    any argv-runnable check) and the node's workflow is one Tool-executor phase running that
 *    argv verbatim: no council, no LLM, near-zero cost. The engine's Tool path (`run_tool_cmd`)
 *    spawns the command directly.
 *  - **`agent` (exploratory / authoring)** — a governed agent run over a problem statement;
 *    seats are spent only where judgment is the work (test-R9).
 *
 * ## The 1022-byte rule (load-bearing, enforced here)
 *
 * PTY worker prompts longer than 1022 bytes are SILENTLY DISCARDED by the canonical line
 * discipline — the worker waits on input that never arrives and the unit burns its full
 * timeout (the S8 campaign finding; memory: "PTY canonical line limit"). The mapping
 * therefore refuses, loudly and per-token, anything that smells like a scenario BODY inlined
 * where a FILE PATH belongs: every Tool argv token and every agent problem statement must be
 * a single line of at most {@link MAX_INLINE_BYTES} bytes. The fix is always the same and the
 * error says it: persist the content as a file and pass its path.
 */
import type { CampaignDef, CampaignScenario, LaunchCampaignBody, WorkflowDef } from '../core/types.js';
/**
 * Byte ceiling for a single inline string handed to a node (a Tool argv token, an agent
 * problem). 1022 is the PTY canonical-line limit — the longest line a worker's stdin
 * accepts before the kernel silently discards it. Tool argv does not itself traverse a PTY,
 * but the ceiling is enforced uniformly because the failure it guards against is the same
 * SHAPE either way: scenario bodies belong in files, and a token this long is a body.
 */
export declare const MAX_INLINE_BYTES = 1022;
/** Composed node workflows carry this prefix — the adapter keeps them OUT of the workflow
 *  catalog (`listWorkflows`) while still persisting them to the overlay dir so a fresh-process
 *  `resumeCampaign` can re-dispatch pending nodes by workflow id. */
export declare const CAMPAIGN_WORKFLOW_PREFIX = "campaign-";
/** The engine's preset-name cap (wicked-core `preset::validate_name`): a node's preset is named by it. */
export declare const MAX_PRESET_NAME = 64;
/**
 * The composed workflow id for one deterministic scenario node: `campaign-<campaign>-<scenario>`, or
 * when that would pass the engine's 64-char preset-name cap (X-MIG M11 arms node workflows as
 * presets; codex r1 on crew A), `campaign-<16 hex of sha256(campaign NUL scenario)>`. Deterministic,
 * and never equal to a composed name (that one always holds a `-` after the prefix; hex has none).
 */
export declare function scenarioWorkflowId(campaignId: string, scenarioId: string): string;
/** A built campaign: the engine def plus the per-node Tool workflows the adapter must arm
 *  (hot-register + overlay-persist) BEFORE the def launches. */
/** The engine's `CampaignDef.denial_gate` (wicked-core ≥ 0.7.27; DES-L1 PR-1D). Typed HERE until
 *  wicked-crew-api-types carries `CampaignDef.denial_gate?` / `LaunchCampaignBody.denialGate?`
 *  (0.39.0) — the engine's serde reads it today; `engineCampaignDef` spreads the def verbatim. */
export type CampaignDenialGate = 'hold' | 'auto_reject';
export type EngineCampaignDef = CampaignDef & {
    denial_gate?: CampaignDenialGate;
};
export type LaunchCampaignBodyWithDenialGate = LaunchCampaignBody & {
    denialGate?: CampaignDenialGate;
};
export interface BuiltCampaign {
    def: EngineCampaignDef;
    workflows: WorkflowDef[];
}
/** A resolved repo the fan targets — `id` rides `run_spec.repo_ref`, `name` labels titles. */
export interface FanRepo {
    id: string;
    name: string;
}
/** The fanned scenario list plus the node-id order the route's `runIds` answer follows. */
export interface FannedScenarios {
    scenarios: CampaignScenario[];
    /**
     * Node ids in the PINNED `runIds` order: repo-major over the fanned scenarios (repos in the
     * caller's resolved order, scenarios in input order within each repo), then the scenarios
     * that pinned their own `repoRef` (never fanned — an explicit per-scenario pin wins over the
     * launch-level scope) in input order. Empty exactly when `repos` was empty (legacy launch).
     */
    runOrder: string[];
}
/**
 * Fan a scenario batch across the launch's resolved repos (multiscope `projectId`/`repoRefs`).
 *
 *  - `repos` empty ⇒ the batch is returned untouched (`runOrder: []`) — the legacy launch.
 *  - one repo ⇒ no copies: scenarios without their own `repoRef` are assigned it, ids
 *    unchanged (a single-codebase launch must look exactly like today's per-scenario spelling).
 *  - several repos ⇒ each unpinned scenario becomes one copy per repo (`<id>--r<n>`, titled
 *    `<label> [<repo name>]`), with dep edges rewritten to stay INSIDE a repo lane: a dep on a
 *    fanned sibling follows the lane, a dep on a pinned scenario points at its single node,
 *    and a pinned scenario depending on a fanned one waits for EVERY lane's copy.
 *
 * Throws a plain `Error` (the route answers 400 with the message) when a fanned id would break
 * the {@link MAX_SCENARIO_ID} cap or collide with an id the caller already used.
 */
export declare function fanScenarios(scenarios: CampaignScenario[], repos: FanRepo[]): FannedScenarios;
/** The intake gate every recon sibling pauses at (engine serde shape of `HumanConfirm::Before(1)`):
 *  pause before unit 1 — the plan is on the table, nothing has run. The same posture as the
 *  studio composer's shipped default (`before:1` on the launch wire). */
export declare const RECON_INTAKE_GATE: {
    readonly before: 1;
};
/** The `LaunchRunInput.humanConfirm` wire token for the same gate — the per-run fan path
 *  (single repo / unscoped / no campaign bindings) must pause at the identical seam. */
export declare const RECON_INTAKE_GATE_TOKEN = "before:1";
export interface ReconCampaignInput {
    /** Campaign id = the shared recon label (`recon-<ts36>-<hex8>` — {@link SAFE_ID}-safe by
     *  construction, and what `TestingReconResponse.campaign` already carries). */
    id: string;
    /** The operator's brief, VERBATIM — each sibling node's Run decomposes exactly this, the same
     *  text the per-run fan passed to `launchRun`. Deliberately NOT held to the 1022-byte inline
     *  rule: that rule stops scenario BODIES being smuggled into argv/label slots, whereas this IS
     *  the run's problem statement — the same field a plain `POST /runs` launch carries uncapped. */
    problem: string;
    /** The resolved fan targets, in the caller's resolved order (≥ 2 — a smaller scope stays on
     *  the per-run path so the single-repo/unscoped recon keeps today's shape). */
    repos: FanRepo[];
    /** The parsed council roster every sibling convenes. */
    clis: unknown[];
    /** `true` = the caller EXPLICITLY asked for an unattended fan (`ungated: true` on the wire —
     *  never a silent default): nodes carry no gate. `false` = the intake gate per sibling. */
    ungated: boolean;
}
/** A built recon fan: the engine def plus the attempt-0 node run ids in repo order — the
 *  `runIds` the route answers with (`{campaign}:{node}:a0`, the engine's documented scheme). */
export interface ReconCampaign {
    def: CampaignDef;
    runIds: string[];
}
/**
 * Build the recon fan-out's `CampaignDef`: one AGENT node per resolved repo — no edges (siblings
 * are independent, exactly as the per-run fan launched them), `continue_independent` (one honest
 * failure never cancels the others), and `max_concurrency` = the fan width capped at 64 (the
 * per-run fan launched everything at once; the campaign must not silently serialize it, but an
 * unbounded fan must not exhaust the host either). Each node's
 * run_spec carries the caller's brief, the shared roster, its repo, and — unless the caller
 * explicitly said `ungated` — the {@link RECON_INTAKE_GATE}.
 *
 * Throws a plain `Error` (the route's 500 — the inputs are daemon-resolved, not caller text)
 * when called with fewer than 2 repos or a label that breaks the campaign-id rule.
 */
export declare function buildReconCampaign(input: ReconCampaignInput): ReconCampaign;
/**
 * Map a `POST /campaigns` body onto the engine's `CampaignDef` + the per-node workflows to arm.
 *
 * Throws a plain `Error` (the route answers 400 with the message) on: a malformed campaign or
 * scenario id, a duplicate scenario id, a scenario with neither/both of `tool`/`agent`, an
 * empty argv, an inline-rule break ({@link assertInline}), an unknown/self/duplicate dep, or an
 * `agent.workflow` that is itself a composed campaign workflow. Cycles are LEFT to the engine's
 * own launch validation — one authority for graph shape, and its reject arrives before anything
 * persists.
 *
 * `defaultClis` is the parsed council roster used for every node that does not carry its own —
 * Tool nodes never convene it (the phase bypasses the council), agent nodes do.
 */
export declare function buildCampaign(body: LaunchCampaignBodyWithDenialGate, defaultClis: unknown[]): BuiltCampaign;
//# sourceMappingURL=plan.d.ts.map