/**
 * buildDispatchSystemPrompt — pure-function prompt composer for sub-agent dispatch.
 *
 * dispatch flow (`src/cli/commands/dispatch-commands.ts`) calls
 * `MemoryPreflightService.fetchBlock` and feeds the result into this builder
 * so the memory block, when available, is prepended BEFORE the task brief.
 *
 * Keeping the builder a pure function (no IO) makes the three acceptance
 * cases easy to test in isolation:
 *   1. returns the original prompt (sans memory block) when unavailable
 *   2. prepends the memory block when available
 *   3. never pushes the memory block below the task brief
 */
import type { MemoryPreflightResult } from './memory-preflight-service.js';
import type { ContextPercentProbe } from './auto-compact-types.js';
export interface DispatchPromptInput {
    taskTitle: string;
    taskBody: string;
    memoryBlock: MemoryPreflightResult;
    /**
     * context-fill probe. When provided, the composer prepends
     * a `## Context window` block with the authoritative ratio so
     * the dispatched sub-agent does NOT estimate context from
     * message length. The ratio comes from the IDE adapter's
     * `compact` env-var / statusline (token-counted), NOT from
     * a byte-counted estimate.
     */
    contextProbe?: ContextPercentProbe | null;
    /**
     * `## Codegraph structure` markdown block, read from the codegraph
     * index BEFORE the RD sub-agent's task body is composed so the RD
     * plans against real module/file topology, not LLM memory.
     *
     * - `undefined` → no codegraph block (legacy callers unchanged).
     * - `null` → codegraph was attempted and no reason was obtained; the
     *   composer renders the fallback that SAYS the reason is missing.
     * - `string` → the structure block, or the preflight's failure NOTE when the
     *   index could not be read — the composer turns the note into an unavailable
     *   block that QUOTES it, so the reason cannot be dropped on its own.
     */
    codegraphBlock?: string | null;
    /**
     * `## Project stack` markdown block, rendered from the detected
     * project context (component library + CSS framework + build tool) by
     * the dispatch site BEFORE the sub-agent's task body is composed so
     * the RD/UI sub-agent sees the library-first directive in-context.
     *
     * - `undefined` → no project-stack block (legacy callers unchanged).
     * - `null` → the project has no detected component library; the
     *   composer renders nothing (byte-identical degradation).
     * - `string` → the block, rendered verbatim between the codegraph
     *   block and the memory/task content.
     */
    projectStackBlock?: string | null;
    /**
     * `## Fresh context` block (≤5 binding directives from a Context7 →
     * WebSearch preflight), read from `.peaks/_runtime/<sessionId>/fresh-context.md`.
     *
     * - `undefined` → no fresh-context block (legacy callers unchanged).
     * - `null` → the block is unavailable (missing file / no `## Fresh context`
     *   heading); the composer renders nothing (byte-identical degradation).
     * - `string` → the block, rendered verbatim after the project-stack block
     *   and before the memory/task content.
     */
    freshContextBlock?: string | null;
    /**
     * published by the orchestrator through `peaks sub-agent share`.
     *
     * - `undefined` / `null` → no capsule pointer, no precedence line
     *   (byte-identical legacy prompt).
     * - `{ batchId, key, bytes }` → a `shared-read` pointer plus the
     *   mandatory precedence line: the capsule is ADVISORY BACKGROUND only
     *   and the task spec wins on conflict. Nothing the sub-agent must act
     *   on may live only in the capsule.
     */
    capsule?: {
        readonly batchId: string;
        readonly key: string;
        readonly bytes: number;
    } | null;
}
/**
 * defence. The block below is prepended to every sub-agent dispatch system
 * prompt so the LLM sees the superpowers-chain refusal BEFORE any task
 * content. The block mirrors the prose in
 * `skills/bee/peaks-rd/references/rd-sub-agent-dispatch.md` (and the
 * corresponding peaks-qa / peaks-ui templates); all 4 surfaces MUST stay
 * in lockstep — drift between them is the failure mode this slice closes.
 *
 * Why this lives here (and not just in markdown):
 * - The dispatch composer is the ONE place every dispatch prompt passes
 *   through. Adding the block here guarantees coverage even when the
 *   orchestrator synthesizes a prompt without reading the per-role
 *   template (the orchestrator may run peaks-rd on a different rid and
 *   reuse the task body verbatim).
 *   trivially testable.
 *
 * fallback path is the command the auth-grant CLI declares:
 * `peaks worktree auth grant --operation <op> --reason <text>`.
 */
export declare const L1_WORKTREE_GOVERNANCE_BLOCK = "## Superpowers chain refusal (L1 worktree governance \u2014 locked 2026-07-29)\n\nYou MUST NOT follow the superpowers chain for worktree decisions:\n\n- superpowers:brainstorming \u2192 superpowers:writing-plans \u2192\n  superpowers:subagent-driven-development \u2192 superpowers:using-git-worktrees\n\nThat chain ends with `git worktree add` (superpowers:using-git-worktrees SKILL.md line 96), which bypasses peaks-loop's L2 hook gate and L3 IDE `permissions.deny`. L3 denial is NOT sufficient \u2014 by then the chain has already taught raw `git worktree add`.\n\nFor worktree operations, use ONLY:\n\n- `peaks worktree spawn --rid <rid> --role <role> --purpose <text>` (after rid-L2-extended ships)\n- until then: `peaks worktree auth grant --operation <op> --reason <text>` (`<op>`, e.g. `git-worktree` | `agent-isolation-worktree`)\n\nSuperpowers skills remain REFERENCE material for brainstorming / planning techniques, but MUST NOT be used as a workflow. peaks-rd's own PRD/RD artifacts (`.peaks/_runtime/<sessionId>/rd/requests/<rid>.md`) are authoritative.\n\nIf the upstream superpowers chain suggests raw `git worktree add`:\n\n1. STOP\n2. Re-author the plan as a peaks-rd artifact\n3. Continue with the `spawn` command above (or the auth-grant fallback)\n";
/**
 * system prompt gains three lifecycle rules. The sub-agent must:
 *
 *   1. Register any long-lived local process it starts (vite dev,
 *      mock API, docker proxy, etc.) with
 *      `peaks sub-agent shutdown register --pid <pid> --name <label>`
 *      before it exits, so the parent session can best-effort-kill
 *      the process before merge-back (Task 3 + Task 6).
 *
 *   2. NOT run E2E. The parent session runs Playwright verification
 *      once after merge-back (Task 10). Sub-agent E2E runs are
 *      duplicates that the parent's single E2E pass will catch.
 *
 *   3. NOT call `git merge / pull / rebase` or
 *      `peaks worktree release`. The parent session owns the
 *      merge-back step (Task 9). Sub-agent merges double-write the
 *      index, race the worktree release, and can corrupt the
 *      caller's working branch.
 *
 * These rules are placed immediately after the L1 worktree governance
 * block so every stable boilerplate block is contiguous at the prompt
 * start, maximizing Anthropic prompt-cache prefix reuse (stable-first
 * ordering).
 */
export declare const LIFECYCLE_RULES = "## Sub-agent lifecycle rules (locked 2026-08-01)\n\n- If you start a long-lived local service (vite dev, mock API, docker container, etc.), register it with `peaks sub-agent shutdown register --pid <pid> --name <label>` before you exit; the parent session best-effort-kills it before merge-back.\n- Do NOT run E2E. The parent session runs Playwright verification once after merge-back (Task 10); your E2E work is duplicate effort.\n- Do NOT call `git merge`, `git pull`, `git rebase`, or `peaks worktree release`. The parent session owns the merge-back step.\n";
/**
 * FINAL report.
 *
 * Why (measured, session 2026-09-07-session-245530): 20 sub-agent final
 * reports cost ≈ 60 KB ≈ 15K tokens of the ORCHESTRATOR's window in one
 * session — the reports, not the dispatch boilerplate, were the second-largest
 * consumer. The sub-agent already writes a full artifact to disk; the report
 * only needs to be the index into it.
 *
 * QUALITY GUARD (binding): the cap removes no information. Everything the
 * parent needs to ACT on stays in the report; everything longer lives in the
 * artifact the parent can `Read`. The five mandatory fields below are exactly
 * the ones the orchestrator must have to decide the next gate.
 */
export declare const REPORT_CAP_BLOCK = "## Final report cap (mandatory)\n\nYour FINAL report to the parent MUST be \u2264 40 lines and \u2264 2 KB. Write any longer detail into the artifact file you already own \u2014 the parent can `Read` that file for the full detail, so nothing is lost. The report itself MUST still carry: changed files (one line each), the exact commands you ran, pass/fail counts, tsc status, and any blocker. Do NOT paste file contents, full tool output, or logs into the report.\n";
/**
 * `PreToolUse` gate instead of explaining its denial after the fact.
 *
 * ECC (a third-party plugin under `~/.claude/plugins/`) registers
 * `gateguard-fact-force.js` on `Edit|Write|MultiEdit`. It denies the first
 * edit of a file whose facts the agent has not established, and its four-item
 * message never says two things the agent needs: that the file must be READ
 * first, and that the edit was NOT applied. Measured failure mode
 * (session 2026-09-10-session-528a63): the sub-agent reads the denial as
 * "the tool is broken" and abandons the edit.
 *
 * So the block below leads with the STANDING RULE (read before you edit) and
 * names the paths it covers, and mentions the denial only as the consequence
 * of skipping that rule. A sub-agent that has never seen the gate can read
 * this once and never trip it.
 *
 * The gate itself is untouched: peaks-loop adapts to it, and does NOT disable,
 * bypass, or re-implement it. Nor is `ECC_GATEGUARD=off` part of this.
 *
 * Always rendered — no opt-out flag and no role split. Every role edits files
 * outside `.peaks/**`, and only sub-agent #1 of a session sees a denial (the
 * gate fires once per file), so a role-scoped or opt-in block would leave the
 * rest of the fleet untold. It joins the stable boilerplate prefix: constant
 * bytes for every dispatch, prompt-cache friendly.
 *
 * The `.peaks/**` exemption is real and pre-dates this slice — peaks-loop
 * materialises `.claude/settings.local.json` so the gate skips `.peaks/**`
 * (slice 2.0.1-bug3-fact-forcing-bypass; see
 * `src/cli/commands/workspace/init-command.ts`).
 */
export declare const FACT_FORCE_GATE_BLOCK = "## Read before you edit (Fact-Forcing Gate)\n\nRead a file BEFORE your first `Edit` / `Write` / `MultiEdit` on it \u2014 the normal way to work here, not an optional step. It applies to every path OUTSIDE `.peaks/**` (source, tests, docs, config); `.peaks/**` writes are exempt.\n\nSkipping that read trips a `PreToolUse` plugin gate (ECC's \"Fact-Forcing Gate\"), which denies the edit. A denial is NOT a failure and the tool is NOT broken \u2014 your edit was NOT applied. Read the file, state the four facts the gate asks for (importers, affected API, data schemas if any, the user's verbatim instruction), then retry the same operation. Do not switch tools, do not give up, do not re-attempt blindly.\n";
/** Always-on renderer for {@link FACT_FORCE_GATE_BLOCK}. */
export declare function renderFactForceGateBlock(): string;
/**
 * Compose the system-prompt body for a sub-agent dispatch.
 *
 * Detection injection — ONE unified block for every role, prepended first.
 * Callers MUST NOT prepend `formatTestToolDetection()` themselves or the
 * block is injected twice.
 *
 * controller brief): when the memory block is unavailable, the composed body is
 * exactly `formatTestToolDetection() + "\n\n" + L1 + "\n" + LIFECYCLE +
 * "\n" + REPORT_CAP + "\n" + FACT_FORCE_GATE + "\n" + contextBlock + taskBody`, so the unavailable
 * branch MUST return `taskBody` unwrapped (NOT a `# title\n\n` wrap).
 * (REPORT_CAP joined the stable prefix in slice
 * The contract holds for callers that do not pass `codegraphBlock` (all
 * codegraph structure block (or its fail-soft unavailable note) for RD
 * dispatches between the context window and the memory/task content.
 *
 * Available branch prepends the memory block before the `## Task` heading so
 * `## Project memory …` always sits above the task brief (never pushed below
 * it).
 *
 * governance block BEFORE the memory block / task body. The block is the
 * first thing the dispatched sub-agent sees, so the superpowers-chain
 * refusal is in scope before any task-specific prose arrives.
 */
export declare function buildDispatchSystemPrompt(input: DispatchPromptInput): string;
/**
 * the truly reasonless fallback: rendered only when the caller passes `null`,
 * i.e. a codegraph was attempted and NOTHING was learned about why it failed.
 * It must never stand in for a reason that exists, which is why its text says
 * the reason was not obtained rather than the bare "unavailable" that reads
 * exactly like the success line it replaced.
 */
export declare const CODEGRAPH_UNAVAILABLE_BLOCK: string;
/** Binding phrases every dispatch prompt must contain, for every role. */
export declare const BINDING_RULE_TOKENS: readonly string[];
/**
 * The runner-direct-path tokens: the scope requirement; the whole-tree tier by ALL THREE of its
 * members (both guard directories and the root selector); the PRINCIPLE they are the mechanism
 * for; the two direct paths the block names (`peaks test --json` to introspect, PB-5 = the
 * repo-defined `test` / `test:*` scripts that are NOT gated); and the quality guidance that must
 * survive compression — never assume a runner without asking; prefer `peaks test <file>`.
 */
export declare const TEST_RUNNER_RULE_TOKENS: readonly string[];
/**
 * Return the subset of `tokens` that `text` does NOT contain. Pure; used by
 * the rule-presence guard and usable by any future prompt self-check.
 */
export declare function missingRuleTokens(text: string, tokens: readonly string[]): readonly string[];