/**
 * check (the tasks-vs-gates weld) — the PURE gauntlet engine fold as a finite,
 * structured command. `czap check` runs `litelaunchGauntlet` IN-PROCESS (no
 * subprocess, no terminal streaming): it binds the built-in LiteShip gates, the
 * committed assurance map, and the committed waivers, runs the authority ratchet,
 * and returns the {@link Finding}[] work-list plus the single blocking verdict.
 *
 * This is deliberately NOT the existing `gauntlet` command — that one is CLI-owned
 * terminal orchestration that spawns the 28-phase `gauntlet:full` run. `check` is
 * the fixture-qualified gate FOLD: pure, fast, and `mcpExposed` because its
 * Finding[] is exactly the structured work-list a human (CLI) or an agent (MCP)
 * should be able to read and act on without a human in the loop.
 *
 * The engine (`@czap/gauntlet`'s `node:fs` glob + the gate set) is INJECTED via
 * `context.runGauntlet`, never run here, so `@czap/command` stays free of the
 * filesystem walk and the waiver-expiry clock. The adapter owns the wall-clock
 * `now` (waiver expiry is a calendar comparison — NEVER a monotonic reading).
 *
 * @module
 */
import { Schema } from 'effect';
import type { Finding } from '@czap/gauntlet';
import { type HandledCommand } from '../registry.js';
/**
 * Structured payload returned by `check` — the WELD-2 Finding-carrying shape. The
 * `findings` ARE plain JSON-serializable {@link Finding} data (ruleId, severity,
 * level, title, detail, location?, remediation?), so they ride the
 * `CapsuleCommandResult` payload straight through the MCP dispatch's
 * `structuredContent` and the CLI receipt with no separate adapter. `blocked`
 * mirrors the engine's single blocking verdict; `ok` is its negation.
 */
export declare const CheckPayloadSchema: Schema.Struct<{
    readonly ok: Schema.Boolean;
    /** True iff a self-proven (blocking) gate emitted an error, or a waiver expired/was forbidden. */
    readonly blocked: Schema.Boolean;
    /** Number of kept findings across all gates (post-waiver, authority applied). */
    readonly findingCount: Schema.Number;
    /** The kept findings — the actionable work-list a human or agent reads. */
    readonly findings: Schema.$Array<Schema.Struct<{
        readonly ruleId: Schema.String;
        readonly severity: Schema.Union<readonly [Schema.Literal<"advisory">, Schema.Literal<"warning">, Schema.Literal<"error">]>;
        readonly level: Schema.Union<readonly [Schema.Literal<"L0">, Schema.Literal<"L1">, Schema.Literal<"L2">, Schema.Literal<"L3">, Schema.Literal<"L4">]>;
        readonly title: Schema.String;
        readonly detail: Schema.String;
        readonly location: Schema.optional<Schema.Struct<{
            readonly file: Schema.String;
            readonly line: Schema.optional<Schema.Number>;
            readonly column: Schema.optional<Schema.Number>;
        }>>;
    }>>;
}>;
/**
 * Structured payload returned by `check`. Single-source-derived for every field
 * EXCEPT `findings`, which keeps the canonical `@czap/gauntlet` `Finding` type
 * (so `remediation` — undescribable in the outputSchema's dialect — stays in the
 * type and is never narrowed away from a consumer). The `outputSchema` is derived
 * from `CheckPayloadSchema` (findings minus remediation); the type is a faithful
 * superset on exactly that one field.
 */
export type CheckPayload = Omit<Schema.Schema.Type<typeof CheckPayloadSchema>, 'findings'> & {
    readonly findings: readonly Finding[];
};
/** `check` — run the pure gauntlet gate fold in-process; emit the Finding[] work-list + verdict. */
export declare const checkCommand: HandledCommand;
//# sourceMappingURL=check.d.ts.map