/**
 * audit → the ONE read-vs-run decision. `audit` is a Lighthouse-style LOCAL
 * report: a deterministic READ by default — safe + identical on every OS, nothing
 * executes — NOT a CI step (CI uses `vigiles lint`, the deterministic gate). The
 * executing checks (safety battery, live MCP resolution, skill-firing trigger-rate)
 * run ONLY when there's a human to consent: at a TTY `audit` ASKS once (and
 * remembers in `.vigilesrc.json` `audit.measure`); headless (an agent / `--json` /
 * `--no-interactive` / a pipe) it stays a read + a one-line nudge — never hangs,
 * never silently executes. There is deliberately NO execution flag: automation
 * tests the harness through the `vigiles` testing API + skills (the layered tiers),
 * not through the report verb. The IO (prompt / run / remember) lives in the CLI;
 * this is the pure decision + helpers.
 */
/** Why the executing checks were skipped (drives the "not run" nudge). */
export type ExecuteSkipReason = "nothing" | "headless" | "remembered-no";
/**
 * What `audit` should do about the EXECUTING checks (battery + live MCP +
 * trigger-rate), as ONE bundle:
 * - `run`  — run them now (a remembered yes).
 * - `ask`  — interactive human + something to run + no sticky choice: ask once,
 *            then remember.
 * - `skip` — stay a deterministic read; the `reason` drives a one-line nudge.
 */
export type ExecuteDecision = {
    readonly kind: "run";
} | {
    readonly kind: "ask";
} | {
    readonly kind: "skip";
    readonly reason: ExecuteSkipReason;
};
export interface ExecuteEnv {
    /** Is there ANY executable surface — runnable hooks, an own-repo MCP server, or
     *  a model-invocable skill? Nothing to run → never ask, never nudge. */
    readonly hasExecutable: boolean;
    /** Both stdin AND stdout are a terminal (a human who can answer + wait). */
    readonly isTTY: boolean;
    /** `--json` — machine output; stays a read even at a TTY (never prompt). */
    readonly json: boolean;
    /** `--no-interactive` / `--yes` — explicit agent/CI mode (never prompt). */
    readonly noInteractive: boolean;
    /** Sticky remembered choice from `.vigilesrc.json` (`audit.measure`), or undefined. */
    readonly remembered?: boolean;
}
/**
 * Decide what `audit` does with the executing checks. Total + pure; the first
 * matching rule wins. There is NO execution flag — `audit` is a local report, so
 * the executing checks need a human to consent:
 *  1. nothing executable → skip "nothing" (a clean read; no nudge)
 *  2. headless (`--json` / `--no-interactive` / non-TTY — an agent, a pipe, CI) →
 *     skip "headless" (no one to ask; automation uses the `vigiles` testing API)
 *  3. sticky no → skip "remembered-no"
 *  4. sticky yes → run
 *  5. interactive human, no sticky choice → ask (then remember)
 */
export declare function decideExecute(o: ExecuteEnv): ExecuteDecision;
/**
 * The one-line "executing checks not run" nudge for a skipped read (the
 * no-silent-skips corollary). Returns null for `nothing` (nothing to run — not a
 * gap). There is no flag to point at — `audit` runs them only interactively, and
 * automation uses the `vigiles` testing API.
 */
export declare function formatExecuteSkip(reason: ExecuteSkipReason): string | null;
/**
 * A starter `--prompts` file (the real `TriggerPromptSet` shape: bare skill name
 * → `{ prompts, irrelevant }`). One entry per triggerable skill, with TODO
 * placeholders the user replaces with real requests.
 */
export declare function scaffoldTriggerPrompts(skillNames: readonly string[]): string;
//# sourceMappingURL=scan-trigger-suggest.d.ts.map