@davesheffer/hunch 1.31.0 → 1.32.0

package/dist/constitution/experiment.d.ts

@@ -0,0 +1,466 @@
+import { z } from "zod";
+import type { HunchStore } from "../store/hunchStore.js";
+import type { ExperimentPreregistration, G3RequiredExperiment } from "./g3.js";
+export declare const EXPERIMENT_ANALYSIS_SPEC: {
+    readonly implementation: "hunch-g3-experiment-report-v1";
+    readonly binary_interval: "wilson-95";
+    readonly small_cell_test: "fisher-exact-two-sided";
+    readonly reviewer_rate_interval: "seeded-nonparametric-bootstrap-4000";
+    readonly effect_sizes: readonly ["absolute-difference", "relative-risk-or-rate"];
+    readonly missingness: "all-assigned-denominators";
+};
+export declare const EXPERIMENT_ANALYSIS_HASH: string;
+export declare const Exp01CaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    block: z.ZodString;
+    created_at: z.ZodString;
+    held_out: z.ZodLiteral<true>;
+    used_for_tuning: z.ZodLiteral<false>;
+    strata: z.ZodRecord<z.ZodString, z.ZodString>;
+    prompt: z.ZodString;
+    context: z.ZodObject<{
+        decision: z.ZodString;
+        rationale: z.ZodString;
+        executable_policy: z.ZodString;
+        causal_incident: z.ZodString;
+    }, z.core.$strict>;
+    setup: z.ZodNullable<z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodArray<z.ZodString>;
+        timeout_ms: z.ZodNumber;
+        artifact: z.ZodString;
+        artifact_hash: z.ZodString;
+    }, z.core.$strict>>;
+    evaluator: z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodArray<z.ZodString>;
+        timeout_ms: z.ZodNumber;
+        artifact: z.ZodString;
+        artifact_hash: z.ZodString;
+        visibility: z.ZodLiteral<"hidden_external">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const Exp03CaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    block: z.ZodString;
+    created_at: z.ZodString;
+    held_out: z.ZodLiteral<true>;
+    used_for_tuning: z.ZodLiteral<false>;
+    strata: z.ZodRecord<z.ZodString, z.ZodString>;
+    evidence: z.ZodString;
+    required_relationship: z.ZodOptional<z.ZodString>;
+    manual_brief: z.ZodString;
+    compiler_candidate: z.ZodString;
+    proof_card: z.ZodString;
+    editable_bindings: z.ZodArray<z.ZodString>;
+    target_commitment_hash: z.ZodString;
+}, z.core.$strict>;
+export declare const ExperimentCaseBankSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    experiment: z.ZodEnum<{
+        "EXP-03": "EXP-03";
+        "EXP-01": "EXP-01";
+    }>;
+    preregistration_id: z.ZodString;
+    preregistration_hash: z.ZodString;
+    repository_root: z.ZodString;
+    base_commit: z.ZodString;
+    cases: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        block: z.ZodString;
+        created_at: z.ZodString;
+        held_out: z.ZodLiteral<true>;
+        used_for_tuning: z.ZodLiteral<false>;
+        strata: z.ZodRecord<z.ZodString, z.ZodString>;
+        prompt: z.ZodString;
+        context: z.ZodObject<{
+            decision: z.ZodString;
+            rationale: z.ZodString;
+            executable_policy: z.ZodString;
+            causal_incident: z.ZodString;
+        }, z.core.$strict>;
+        setup: z.ZodNullable<z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodArray<z.ZodString>;
+            timeout_ms: z.ZodNumber;
+            artifact: z.ZodString;
+            artifact_hash: z.ZodString;
+        }, z.core.$strict>>;
+        evaluator: z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodArray<z.ZodString>;
+            timeout_ms: z.ZodNumber;
+            artifact: z.ZodString;
+            artifact_hash: z.ZodString;
+            visibility: z.ZodLiteral<"hidden_external">;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        block: z.ZodString;
+        created_at: z.ZodString;
+        held_out: z.ZodLiteral<true>;
+        used_for_tuning: z.ZodLiteral<false>;
+        strata: z.ZodRecord<z.ZodString, z.ZodString>;
+        evidence: z.ZodString;
+        required_relationship: z.ZodOptional<z.ZodString>;
+        manual_brief: z.ZodString;
+        compiler_candidate: z.ZodString;
+        proof_card: z.ZodString;
+        editable_bindings: z.ZodArray<z.ZodString>;
+        target_commitment_hash: z.ZodString;
+    }, z.core.$strict>]>>;
+    actor: z.ZodString;
+    reason: z.ZodString;
+    data_class: z.ZodLiteral<"private">;
+    authority: z.ZodLiteral<"none">;
+    locked_at: z.ZodString;
+}, z.core.$strict>;
+export type ExperimentCaseBank = z.infer<typeof ExperimentCaseBankSchema>;
+export type Exp01Case = z.infer<typeof Exp01CaseSchema>;
+export type Exp03Case = z.infer<typeof Exp03CaseSchema>;
+export type CompileExperimentCaseBankInput = Omit<ExperimentCaseBank, "id" | "content_hash" | "data_class" | "authority" | "locked_at">;
+export declare function experimentCaseBankContentHash(bank: ExperimentCaseBank): string;
+export declare function compileExperimentCaseBank(input: CompileExperimentCaseBankInput, preregistration: ExperimentPreregistration, opts?: {
+    now?: string;
+}): ExperimentCaseBank;
+declare const AssignmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    case_id: z.ZodString;
+    arm: z.ZodString;
+    block: z.ZodString;
+    order: z.ZodNumber;
+    treatment_hash: z.ZodString;
+}, z.core.$strict>;
+export type ExperimentAssignment = z.infer<typeof AssignmentSchema>;
+export declare const ExperimentRunSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    experiment: z.ZodEnum<{
+        "EXP-03": "EXP-03";
+        "EXP-01": "EXP-01";
+    }>;
+    preregistration_id: z.ZodString;
+    preregistration_hash: z.ZodString;
+    case_bank_id: z.ZodString;
+    case_bank_hash: z.ZodString;
+    seed: z.ZodString;
+    sample_per_arm: z.ZodNumber;
+    assignment_strategy: z.ZodEnum<{
+        crossed_blocked: "crossed_blocked";
+        exclusive_blocked: "exclusive_blocked";
+    }>;
+    assignments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        case_id: z.ZodString;
+        arm: z.ZodString;
+        block: z.ZodString;
+        order: z.ZodNumber;
+        treatment_hash: z.ZodString;
+    }, z.core.$strict>>;
+    runner: z.ZodObject<{
+        implementation: z.ZodLiteral<"hunch-g3-experiment-v1">;
+        provider: z.ZodNullable<z.ZodEnum<{
+            "claude-cli": "claude-cli";
+            "codex-cli": "codex-cli";
+        }>>;
+        provider_version: z.ZodNullable<z.ZodString>;
+        model_version: z.ZodNullable<z.ZodString>;
+        max_turns: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    actor: z.ZodString;
+    reason: z.ZodString;
+    data_class: z.ZodLiteral<"private">;
+    authority: z.ZodLiteral<"none">;
+    created_at: z.ZodString;
+}, z.core.$strict>;
+export type ExperimentRun = z.infer<typeof ExperimentRunSchema>;
+export interface CompileExperimentRunInput {
+    sample_per_arm: number;
+    provider?: "claude-cli" | "codex-cli";
+    provider_version?: string;
+    model_version?: string;
+    max_turns?: number;
+    actor: string;
+    reason: string;
+}
+export declare function assignmentTreatment(bank: ExperimentCaseBank, run: ExperimentRun, assignment: ExperimentAssignment): unknown;
+export interface ExperimentReviewGuide {
+    title: string;
+    question: string;
+    action: string;
+    answer_template: string;
+    warning: string;
+    choices: Array<{
+        value: "accepted_precise" | "accepted_edited" | "rejected" | "uncompilable";
+        label: string;
+        use_when: string;
+    }>;
+}
+/** Human-facing help is deliberately outside the hash-bound treatment. It may
+ * explain the review task, but must never interpret the assigned evidence. */
+export declare function experimentReviewGuide(arm: string): ExperimentReviewGuide;
+export declare function experimentRunContentHash(run: ExperimentRun): string;
+export declare function compileExperimentRun(input: CompileExperimentRunInput, preregistration: ExperimentPreregistration, bank: ExperimentCaseBank, opts?: {
+    now?: string;
+}): ExperimentRun;
+export declare const ExperimentOutcomeSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    run_id: z.ZodString;
+    assignment_id: z.ZodString;
+    experiment: z.ZodEnum<{
+        "EXP-03": "EXP-03";
+        "EXP-01": "EXP-01";
+    }>;
+    arm: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        refused: "refused";
+        invalid_completion: "invalid_completion";
+        infrastructure_failure: "infrastructure_failure";
+        aborted: "aborted";
+    }>;
+    invocation_started: z.ZodBoolean;
+    metrics: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        valid_completion: z.ZodBoolean;
+        policy_violation: z.ZodNullable<z.ZodBoolean>;
+        task_success: z.ZodBoolean;
+        build_success: z.ZodBoolean;
+        unknown_or_error: z.ZodBoolean;
+        refusal: z.ZodBoolean;
+        turns: z.ZodNullable<z.ZodNumber>;
+        edits: z.ZodNullable<z.ZodNumber>;
+        tokens: z.ZodNullable<z.ZodNumber>;
+        latency_ms: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        decision: z.ZodEnum<{
+            rejected: "rejected";
+            abandoned: "abandoned";
+            uncompilable: "uncompilable";
+            timeout: "timeout";
+            cannot_decide: "cannot_decide";
+            accepted_precise: "accepted_precise";
+            accepted_edited: "accepted_edited";
+        }>;
+        precise: z.ZodBoolean;
+        proof_inspected: z.ZodBoolean;
+        result_hash: z.ZodNullable<z.ZodString>;
+        semantic_edit_distance: z.ZodNullable<z.ZodNumber>;
+        silent_semantic_substitution: z.ZodBoolean;
+        rejection_reason: z.ZodNullable<z.ZodString>;
+        duration_ms: z.ZodNumber;
+    }, z.core.$strict>]>>;
+    output_hash: z.ZodNullable<z.ZodString>;
+    diff_hash: z.ZodNullable<z.ZodString>;
+    evaluator_hash: z.ZodNullable<z.ZodString>;
+    error_code: z.ZodNullable<z.ZodString>;
+    incidents: z.ZodObject<{
+        confirmed_private_leak: z.ZodBoolean;
+        data_loss_or_corruption: z.ZodBoolean;
+        unsafe_evaluator_behavior: z.ZodBoolean;
+    }, z.core.$strict>;
+    recorder: z.ZodString;
+    reason: z.ZodString;
+    supersedes: z.ZodNullable<z.ZodString>;
+    data_class: z.ZodLiteral<"private">;
+    authority: z.ZodLiteral<"none">;
+    recorded_at: z.ZodString;
+}, z.core.$strict>;
+export type ExperimentOutcome = z.infer<typeof ExperimentOutcomeSchema>;
+export type CompileExperimentOutcomeInput = Omit<ExperimentOutcome, "id" | "content_hash" | "experiment" | "arm" | "data_class" | "authority" | "recorded_at">;
+export declare function experimentOutcomeContentHash(outcome: ExperimentOutcome): string;
+export declare function normalizedEditDistance(from: string, to: string): number;
+export declare function compileExperimentOutcome(input: CompileExperimentOutcomeInput, run: ExperimentRun, opts?: {
+    now?: string;
+}): ExperimentOutcome;
+export declare const EXP03_REVIEW_CHOICES: readonly ["accept", "edit", "reject", "cannot_decide"];
+export type Exp03ReviewChoice = (typeof EXP03_REVIEW_CHOICES)[number];
+export interface Exp03ReviewResponse {
+    choice: Exp03ReviewChoice;
+    /** the rule exactly as it should be recorded; required for accept/edit, blank otherwise. */
+    rule_text?: string | null;
+    /** one plain-language sentence. */
+    reason: string;
+    /** arm C only: the reviewer looked at the supporting checks before answering. */
+    inspected_supporting_checks?: boolean;
+}
+declare const CHOICE_TO_DECISION: {
+    readonly accept: "accepted_precise";
+    readonly edit: "accepted_edited";
+    readonly reject: "rejected";
+    readonly cannot_decide: "cannot_decide";
+};
+export declare function compileExp03ReviewResponse(item: Exp03Case, arm: string, response: Exp03ReviewResponse): {
+    decision: (typeof CHOICE_TO_DECISION)[Exp03ReviewChoice];
+    precise: boolean;
+    proof_inspected: boolean;
+    result: string | null;
+    silent_semantic_substitution: boolean;
+    rejection_reason: string | null;
+};
+export declare const ExperimentReviewStartSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    run_id: z.ZodString;
+    assignment_id: z.ZodString;
+    reviewer: z.ZodString;
+    treatment_hash: z.ZodString;
+    data_class: z.ZodLiteral<"private">;
+    authority: z.ZodLiteral<"none">;
+    started_at: z.ZodString;
+}, z.core.$strict>;
+export type ExperimentReviewStart = z.infer<typeof ExperimentReviewStartSchema>;
+export declare function experimentReviewStartContentHash(record: ExperimentReviewStart): string;
+export declare function compileExperimentReviewStart(run: ExperimentRun, assignment: ExperimentAssignment, reviewer: string, opts?: {
+    now?: string;
+}): ExperimentReviewStart;
+export declare const ExperimentReviewerQualificationSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    preregistration_id: z.ZodString;
+    preregistration_hash: z.ZodString;
+    reviewer: z.ZodString;
+    protocol: z.ZodLiteral<"exp03-plain-language-comprehension-v2">;
+    cases_hash: z.ZodString;
+    passed: z.ZodLiteral<true>;
+    reason: z.ZodString;
+    data_class: z.ZodLiteral<"private">;
+    authority: z.ZodLiteral<"none">;
+    recorded_at: z.ZodString;
+}, z.core.$strict>;
+export type ExperimentReviewerQualification = z.infer<typeof ExperimentReviewerQualificationSchema>;
+export type CompileExperimentReviewerQualificationInput = Pick<ExperimentReviewerQualification, "preregistration_id" | "preregistration_hash" | "reviewer" | "protocol" | "cases_hash" | "passed" | "reason">;
+export declare function experimentReviewerQualificationContentHash(record: ExperimentReviewerQualification): string;
+export declare function compileExperimentReviewerQualification(input: CompileExperimentReviewerQualificationInput, preregistration: ExperimentPreregistration, opts?: {
+    now?: string;
+}): ExperimentReviewerQualification;
+export declare const ExperimentFollowupSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    run_id: z.ZodString;
+    assignment_id: z.ZodString;
+    outcome_id: z.ZodString;
+    reviewer: z.ZodString;
+    reversed: z.ZodNullable<z.ZodBoolean>;
+    missing_reason: z.ZodNullable<z.ZodString>;
+    notes: z.ZodString;
+    supersedes: z.ZodNullable<z.ZodString>;
+    data_class: z.ZodLiteral<"private">;
+    authority: z.ZodLiteral<"none">;
+    measured_at: z.ZodString;
+}, z.core.$strict>;
+export type ExperimentFollowup = z.infer<typeof ExperimentFollowupSchema>;
+export declare function experimentFollowupContentHash(record: ExperimentFollowup): string;
+export declare function compileExperimentFollowup(input: Omit<ExperimentFollowup, "id" | "content_hash" | "run_id" | "assignment_id" | "outcome_id" | "data_class" | "authority" | "measured_at">, run: ExperimentRun, outcome: ExperimentOutcome, opts?: {
+    now?: string;
+}): ExperimentFollowup;
+export declare function currentExperimentOutcomes(records: ExperimentOutcome[]): ExperimentOutcome[];
+export declare function currentExperimentFollowups(records: ExperimentFollowup[]): ExperimentFollowup[];
+export declare const ExperimentStopSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    run_id: z.ZodString;
+    category: z.ZodEnum<{
+        confirmed_private_leak: "confirmed_private_leak";
+        data_loss_or_corruption: "data_loss_or_corruption";
+        unsafe_evaluator_behavior: "unsafe_evaluator_behavior";
+        unsafe_semantic_substitution: "unsafe_semantic_substitution";
+        provider_wide_unavailability: "provider_wide_unavailability";
+    }>;
+    actor: z.ZodString;
+    reason: z.ZodString;
+    evidence_hashes: z.ZodArray<z.ZodString>;
+    data_class: z.ZodLiteral<"private">;
+    authority: z.ZodLiteral<"none">;
+    effect: z.ZodLiteral<"irreversible_run_stop">;
+    recorded_at: z.ZodString;
+}, z.core.$strict>;
+export type ExperimentStop = z.infer<typeof ExperimentStopSchema>;
+export declare function experimentStopContentHash(record: ExperimentStop): string;
+export declare function compileExperimentStop(input: Omit<ExperimentStop, "id" | "content_hash" | "run_id" | "data_class" | "authority" | "effect" | "recorded_at">, run: ExperimentRun, opts?: {
+    now?: string;
+}): ExperimentStop;
+export interface ExperimentArmReport {
+    arm: string;
+    assigned: number;
+    terminal: number;
+    infrastructure_failures: number;
+    invalid_or_refused: number;
+    valid_completions: number;
+    violations: number | null;
+    violation_rate: number | null;
+    wilson_95: [number, number] | null;
+    accepted_precise: number | null;
+    reviewer_hours: number | null;
+    accepted_per_reviewer_hour: number | null;
+    bootstrap_95: [number, number] | null;
+    reversals: number | null;
+    followups_missing: number | null;
+    /** EXP-03 only: raw count per decision token (all tokens present, zeros kept) —
+     *  the preregistered "raw use-as-written / corrected / rejected / cannot-decide /
+     *  abandoned / timeout counts" visibility (expreg_ba6aef4ecd analysis plan). */
+    decisions: Record<string, number> | null;
+}
+export interface ExperimentReport {
+    id: string;
+    content_hash: string;
+    run_id: string;
+    preregistration_hash: string;
+    case_bank_hash: string;
+    experiment: G3RequiredExperiment;
+    analysis: typeof EXPERIMENT_ANALYSIS_SPEC & {
+        deterministic_hash: string;
+    };
+    status: "registered" | "running" | "awaiting_followup" | "completed" | "guardrail_stopped";
+    arms: ExperimentArmReport[];
+    strata: Array<{
+        key: string;
+        value: string;
+        arm: string;
+        assigned: number;
+        terminal: number;
+        valid_completions: number;
+        violations: number | null;
+        accepted_precise: number | null;
+        reviewer_ms: number | null;
+    }>;
+    assignments: number;
+    terminal: number;
+    unresolved: string[];
+    contrasts: Record<string, number | null>;
+    deviations: string[];
+    guardrails: {
+        confirmed_private_leaks: number;
+        silent_semantic_substitutions: number;
+        data_loss_or_corruption: number;
+        unsafe_evaluator_behavior: number;
+    };
+    stop_receipts: ExperimentStop[];
+    claim_allowed: false;
+    authority: "none";
+}
+export declare function buildExperimentReport(run: ExperimentRun, bank: ExperimentCaseBank, outcomes: ExperimentOutcome[], followups: ExperimentFollowup[], stops?: ExperimentStop[]): ExperimentReport;
+/** Private-only, content-addressed experiment execution ledger. */
+export declare class ExperimentRepository {
+    private readonly store;
+    constructor(store: HunchStore);
+    private requirePrivate;
+    private load;
+    private put;
+    listCaseBanks(): ExperimentCaseBank[];
+    putCaseBank(bank: ExperimentCaseBank): ExperimentCaseBank;
+    listRuns(): ExperimentRun[];
+    putRun(run: ExperimentRun): ExperimentRun;
+    listOutcomes(): ExperimentOutcome[];
+    putOutcome(outcome: ExperimentOutcome): ExperimentOutcome;
+    listReviewStarts(): ExperimentReviewStart[];
+    putReviewStart(record: ExperimentReviewStart): ExperimentReviewStart;
+    listReviewerQualifications(): ExperimentReviewerQualification[];
+    putReviewerQualification(record: ExperimentReviewerQualification): ExperimentReviewerQualification;
+    listFollowups(): ExperimentFollowup[];
+    putFollowup(record: ExperimentFollowup): ExperimentFollowup;
+    listStops(): ExperimentStop[];
+    putStop(record: ExperimentStop): ExperimentStop;
+}
+export {};

package/dist/constitution/experimentRunner.d.ts

@@ -0,0 +1,7 @@
+import { ExperimentRepository, type ExperimentAssignment, type ExperimentCaseBank, type ExperimentOutcome, type ExperimentRun } from "./experiment.js";
+export interface Exp01ExecutionOptions {
+    timeoutMs?: number;
+    now?: string;
+}
+export declare function subscriptionCliVersion(provider: "claude-cli" | "codex-cli"): string;
+export declare function executeExp01Assignment(repository: ExperimentRepository, run: ExperimentRun, bank: ExperimentCaseBank, assignment: ExperimentAssignment, opts?: Exp01ExecutionOptions): ExperimentOutcome;

package/dist/constitution/g2.d.ts

@@ -0,0 +1,209 @@
+import { z } from "zod";
+import type { Runbook } from "../core/types.js";
+import type { HunchStore } from "../store/hunchStore.js";
+export declare const G2_RUNBOOK_CATEGORIES: readonly ["evaluator_error", "false_positive", "private_leak", "stale_policy", "provider_outage", "corrupt_graph", "adapter_break"];
+export type G2RunbookCategory = (typeof G2_RUNBOOK_CATEGORIES)[number];
+export declare const G2PlanSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    gate: z.ZodLiteral<"G2">;
+    policy_ids: z.ZodArray<z.ZodString>;
+    runbooks: z.ZodObject<{
+        evaluator_error: z.ZodString;
+        false_positive: z.ZodString;
+        private_leak: z.ZodString;
+        stale_policy: z.ZodString;
+        provider_outage: z.ZodString;
+        corrupt_graph: z.ZodString;
+        adapter_break: z.ZodString;
+    }, z.core.$strict>;
+    min_shadow_applicable: z.ZodNumber;
+    actor: z.ZodString;
+    reason: z.ZodString;
+    supersedes: z.ZodNullable<z.ZodString>;
+    data_class: z.ZodLiteral<"private">;
+    authority: z.ZodLiteral<"none">;
+    created_at: z.ZodString;
+}, z.core.$strict>;
+export type G2Plan = z.infer<typeof G2PlanSchema>;
+export interface CompileG2PlanInput {
+    policy_ids: string[];
+    runbooks: Record<G2RunbookCategory, string>;
+    min_shadow_applicable?: number;
+    actor: string;
+    reason: string;
+    supersedes?: string | null;
+}
+export declare function g2PlanContentHash(plan: G2Plan): string;
+export declare function compileG2Plan(input: CompileG2PlanInput, opts?: {
+    now?: string;
+}): G2Plan;
+export declare const RunbookRehearsalSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    runbook_id: z.ZodString;
+    runbook_hash: z.ZodString;
+    result: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+    }>;
+    actor: z.ZodString;
+    evidence_hashes: z.ZodArray<z.ZodString>;
+    notes: z.ZodString;
+    supersedes: z.ZodNullable<z.ZodString>;
+    data_class: z.ZodLiteral<"private">;
+    authority: z.ZodLiteral<"none">;
+    created_at: z.ZodString;
+}, z.core.$strict>;
+export type RunbookRehearsal = z.infer<typeof RunbookRehearsalSchema>;
+export interface CompileRunbookRehearsalInput {
+    runbook_id: string;
+    runbook_hash: string;
+    result: "passed" | "failed";
+    actor: string;
+    evidence_hashes: string[];
+    notes: string;
+    supersedes?: string | null;
+}
+export declare function runbookRehearsalContentHash(receipt: RunbookRehearsal): string;
+export declare function compileRunbookRehearsal(input: CompileRunbookRehearsalInput, opts?: {
+    now?: string;
+}): RunbookRehearsal;
+export declare function currentAppendOnly<T extends {
+    id: string;
+    supersedes: string | null;
+}>(records: T[], label: string, identity: (record: T) => string, singleCurrent?: boolean): T[];
+export declare function currentG2Plans(records: G2Plan[]): G2Plan[];
+export declare function currentRunbookRehearsals(records: RunbookRehearsal[]): RunbookRehearsal[];
+export interface G2PolicyEvidence {
+    policy_id: string;
+    complete: boolean;
+    proof_id: string | null;
+    corpus_id: string | null;
+    shadow_applicable: number;
+    shadow_violations: number;
+    shadow_unclassified: number;
+    confirmed_precision: number | null;
+    reasons: string[];
+}
+export interface G2RunbookEvidence {
+    category: G2RunbookCategory;
+    runbook_id: string;
+    runbook_hash: string | null;
+    rehearsal_id: string | null;
+    passed: boolean;
+    reasons: string[];
+}
+export interface G2Inventory {
+    private_policies: number;
+    public_policies: number;
+    private_proofs: number;
+    private_corpora: number;
+    private_shadow_evaluations: number;
+    private_shadow_dispositions: number;
+    private_runbooks: number;
+    public_runbooks: number;
+    private_plans: number;
+    private_rehearsals: number;
+}
+export interface G2ReadinessReport {
+    id: string;
+    content_hash: string;
+    gate: "G2";
+    manifest: G2Plan | null;
+    policy_evidence: G2PolicyEvidence[];
+    runbook_evidence: G2RunbookEvidence[];
+    active_blocking_policy_ids: string[];
+    blockers: string[];
+    inventory?: G2Inventory;
+    recommendation: "not_ready" | "eligible_for_human_g2_signoff";
+    authority: "none";
+    g2_passed: false;
+}
+export interface G2ShadowSweepReport {
+    id: string;
+    content_hash: string;
+    plan_id: string | null;
+    selected: number;
+    recorded: string[];
+    existing: string[];
+    failures: Array<{
+        policy_id: string;
+        error: string;
+    }>;
+    skipped_reason: string | null;
+    authority: "none";
+    effects: "shadow_only";
+}
+export interface G2ShadowBackfillReport {
+    id: string;
+    content_hash: string;
+    plan_id: string | null;
+    max_commits: number;
+    commits: string[];
+    selected: number;
+    attempted: number;
+    recorded: string[];
+    existing: string[];
+    ineligible: Array<{
+        policy_id: string;
+        commit: string;
+        reason: string;
+    }>;
+    preflight_failures: Array<{
+        policy_id: string;
+        commit: string;
+        error: string;
+    }>;
+    skipped_reason: string | null;
+    authority: "none";
+    effects: "shadow_only";
+    writes: "atomic_after_preflight" | "none";
+}
+export interface G2ShadowQueueItem {
+    policy_id: string;
+    shadow_id: string;
+    proof_id: string;
+    policy_hash: string;
+    evaluation_hash: string;
+    observed_at: string;
+    result: "violated";
+    explanation: string;
+    matches: Array<{
+        file: string;
+        line?: number;
+        symbol?: string;
+        relation_path?: string[];
+    }>;
+}
+export interface G2ShadowQueue {
+    id: string;
+    content_hash: string;
+    plan_id: string | null;
+    total_unclassified: number;
+    unresolved_unknown_error: number;
+    limit: number;
+    items: G2ShadowQueueItem[];
+    has_more: boolean;
+    authority: "none";
+}
+export interface ScoreG2ReadinessInput {
+    manifest: G2Plan | null;
+    policy_evidence: G2PolicyEvidence[];
+    runbook_evidence: G2RunbookEvidence[];
+    active_blocking_policy_ids: string[];
+    inventory?: G2Inventory;
+}
+export declare function scoreG2Readiness(input: ScoreG2ReadinessInput): G2ReadinessReport;
+export declare function loadPrivateRecords<T>(dir: string | undefined, prefix: string, parse: (value: unknown) => T, label: string): T[];
+/** Private-only append-only storage for the human-selected G2 packet and runbook drills. */
+export declare class G2EvidenceRepository {
+    private readonly store;
+    constructor(store: HunchStore);
+    listPlans(): G2Plan[];
+    currentPlan(): G2Plan | null;
+    putPlan(plan: G2Plan): G2Plan;
+    listRehearsals(): RunbookRehearsal[];
+    putRehearsal(receipt: RunbookRehearsal): RunbookRehearsal;
+}
+export declare function runbookContentHash(runbook: Runbook): string;