@agent-finops/core 0.8.0 → 0.9.0

package/dist/actionVerification.d.ts

@@ -0,0 +1,1240 @@
+import { z } from "zod";
+export declare const WASTE_FINDING_V0_KIND: "aibill.waste_finding";
+export declare const WASTE_FINDING_V0_VERSION: "0.1.0";
+export declare const TOKEN_REDUCTION_EXPERIMENT_V0_KIND: "aibill.token_reduction_experiment";
+export declare const TOKEN_REDUCTION_EXPERIMENT_V0_VERSION: "0.1.0";
+export declare const MAX_WASTE_FINDING_EVIDENCE_REFS_V0 = 256;
+export declare const MAX_TOKEN_EXPERIMENT_SESSIONS_PER_PHASE_V0 = 256;
+export declare const wasteFindingTypeValues: readonly ["configured_not_observed", "repeated_context_read", "compaction_pressure", "high_context_relative_to_baseline", "cumulative_context_exposure"];
+export type WasteFindingType = typeof wasteFindingTypeValues[number];
+export declare const wasteCandidateActionValues: readonly ["inspect_scope", "lazy_load", "disable", "remove", "start_fresh", "reduce_repeated_reads", "trim_context"];
+export type WasteCandidateAction = typeof wasteCandidateActionValues[number];
+export declare const wasteFindingCaveatValues: readonly ["signal_not_cause", "no_cash_claim", "missing_outcome_evidence"];
+export type WasteFindingCaveat = typeof wasteFindingCaveatValues[number];
+export declare const actionVerificationEvidenceValues: readonly ["verified", "observed", "calculated", "user_declared", "modeled", "missing"];
+export declare const actionVerificationEvidenceSchema: z.ZodEnum<{
+    verified: "verified";
+    missing: "missing";
+    observed: "observed";
+    calculated: "calculated";
+    user_declared: "user_declared";
+    modeled: "modeled";
+}>;
+export type ActionVerificationEvidence = z.infer<typeof actionVerificationEvidenceSchema>;
+export declare const tokenExperimentLifecycleValues: readonly ["draft", "baseline_ready", "applied", "collecting", "complete", "rolled_back", "invalidated"];
+export type TokenExperimentLifecycle = typeof tokenExperimentLifecycleValues[number];
+export declare const tokenExperimentResultValues: readonly ["not_evaluated", "collecting", "measured_token_reduction", "no_measured_change", "regressed", "inconclusive"];
+export type TokenExperimentResult = typeof tokenExperimentResultValues[number];
+export declare const tokenExperimentExclusionReasonValues: readonly ["duplicate_session", "reused_across_phases", "intervention_not_applied", "crosses_intervention_boundary", "wrong_side_of_intervention", "missing_total_tokens", "inconsistent_total_tokens", "agent_mismatch", "provider_mismatch", "model_mismatch", "project_mismatch", "session_type_mismatch", "work_type_mismatch", "missing_work_unit", "source_version_mismatch"];
+export type TokenExperimentExclusionReason = typeof tokenExperimentExclusionReasonValues[number];
+declare const wasteFindingBodySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"aibill.waste_finding">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    generatedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    window: z.ZodObject<{
+        start: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        end: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    }, z.core.$strict>;
+    findingType: z.ZodEnum<{
+        configured_not_observed: "configured_not_observed";
+        repeated_context_read: "repeated_context_read";
+        compaction_pressure: "compaction_pressure";
+        high_context_relative_to_baseline: "high_context_relative_to_baseline";
+        cumulative_context_exposure: "cumulative_context_exposure";
+    }>;
+    objective: z.ZodObject<{
+        metric: z.ZodLiteral<"total_tokens_per_matched_session">;
+        direction: z.ZodLiteral<"reduce">;
+        guard: z.ZodLiteral<"user_declared_quality_must_hold">;
+    }, z.core.$strict>;
+    caveats: z.ZodArray<z.ZodEnum<{
+        signal_not_cause: "signal_not_cause";
+        no_cash_claim: "no_cash_claim";
+        missing_outcome_evidence: "missing_outcome_evidence";
+    }>>;
+    candidateAction: z.ZodObject<{
+        kind: z.ZodEnum<{
+            start_fresh: "start_fresh";
+            inspect_scope: "inspect_scope";
+            lazy_load: "lazy_load";
+            disable: "disable";
+            remove: "remove";
+            reduce_repeated_reads: "reduce_repeated_reads";
+            trim_context: "trim_context";
+        }>;
+        provider: z.ZodString;
+        surface: z.ZodEnum<{
+            local_agent_configuration: "local_agent_configuration";
+            session_workflow: "session_workflow";
+            provider_workload_configuration: "provider_workload_configuration";
+        }>;
+        reversible: z.ZodLiteral<true>;
+        canaryRequired: z.ZodLiteral<true>;
+        rollbackRequired: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    target: z.ZodObject<{
+        kind: z.ZodEnum<{
+            session: "session";
+            repeated_read_file: "repeated_read_file";
+            configured_item: "configured_item";
+        }>;
+        ref: z.ZodString;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        agent: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        projectRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    source: z.ZodObject<{
+        id: z.ZodString;
+        validationCoverage: z.ZodEnum<{
+            live_verified: "live_verified";
+            fixture_verified: "fixture_verified";
+            untested: "untested";
+            failed: "failed";
+        }>;
+        freshness: z.ZodEnum<{
+            fresh: "fresh";
+            stale: "stale";
+            not_checked: "not_checked";
+        }>;
+    }, z.core.$strict>;
+    metric: z.ZodObject<{
+        name: z.ZodEnum<{
+            total_tokens: "total_tokens";
+            input_context_tokens: "input_context_tokens";
+            compaction_events: "compaction_events";
+            repeated_read_events: "repeated_read_events";
+            configured_items: "configured_items";
+        }>;
+        unit: z.ZodEnum<{
+            items: "items";
+            tokens: "tokens";
+            events: "events";
+            ratio: "ratio";
+        }>;
+        value: z.ZodNullable<z.ZodNumber>;
+        sampleCount: z.ZodNumber;
+        evidence: z.ZodEnum<{
+            missing: "missing";
+            observed: "observed";
+            calculated: "calculated";
+        }>;
+    }, z.core.$strict>;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    causalStatus: z.ZodLiteral<"unproven">;
+    actionability: z.ZodLiteral<"inspect_only">;
+    approvalRequired: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type WasteFindingV0DraftInput = z.input<typeof wasteFindingBodySchema>;
+declare const wasteFindingObjectSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"aibill.waste_finding">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    generatedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    window: z.ZodObject<{
+        start: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        end: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    }, z.core.$strict>;
+    findingType: z.ZodEnum<{
+        configured_not_observed: "configured_not_observed";
+        repeated_context_read: "repeated_context_read";
+        compaction_pressure: "compaction_pressure";
+        high_context_relative_to_baseline: "high_context_relative_to_baseline";
+        cumulative_context_exposure: "cumulative_context_exposure";
+    }>;
+    objective: z.ZodObject<{
+        metric: z.ZodLiteral<"total_tokens_per_matched_session">;
+        direction: z.ZodLiteral<"reduce">;
+        guard: z.ZodLiteral<"user_declared_quality_must_hold">;
+    }, z.core.$strict>;
+    caveats: z.ZodArray<z.ZodEnum<{
+        signal_not_cause: "signal_not_cause";
+        no_cash_claim: "no_cash_claim";
+        missing_outcome_evidence: "missing_outcome_evidence";
+    }>>;
+    candidateAction: z.ZodObject<{
+        kind: z.ZodEnum<{
+            start_fresh: "start_fresh";
+            inspect_scope: "inspect_scope";
+            lazy_load: "lazy_load";
+            disable: "disable";
+            remove: "remove";
+            reduce_repeated_reads: "reduce_repeated_reads";
+            trim_context: "trim_context";
+        }>;
+        provider: z.ZodString;
+        surface: z.ZodEnum<{
+            local_agent_configuration: "local_agent_configuration";
+            session_workflow: "session_workflow";
+            provider_workload_configuration: "provider_workload_configuration";
+        }>;
+        reversible: z.ZodLiteral<true>;
+        canaryRequired: z.ZodLiteral<true>;
+        rollbackRequired: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    target: z.ZodObject<{
+        kind: z.ZodEnum<{
+            session: "session";
+            repeated_read_file: "repeated_read_file";
+            configured_item: "configured_item";
+        }>;
+        ref: z.ZodString;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        agent: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        projectRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    source: z.ZodObject<{
+        id: z.ZodString;
+        validationCoverage: z.ZodEnum<{
+            live_verified: "live_verified";
+            fixture_verified: "fixture_verified";
+            untested: "untested";
+            failed: "failed";
+        }>;
+        freshness: z.ZodEnum<{
+            fresh: "fresh";
+            stale: "stale";
+            not_checked: "not_checked";
+        }>;
+    }, z.core.$strict>;
+    metric: z.ZodObject<{
+        name: z.ZodEnum<{
+            total_tokens: "total_tokens";
+            input_context_tokens: "input_context_tokens";
+            compaction_events: "compaction_events";
+            repeated_read_events: "repeated_read_events";
+            configured_items: "configured_items";
+        }>;
+        unit: z.ZodEnum<{
+            items: "items";
+            tokens: "tokens";
+            events: "events";
+            ratio: "ratio";
+        }>;
+        value: z.ZodNullable<z.ZodNumber>;
+        sampleCount: z.ZodNumber;
+        evidence: z.ZodEnum<{
+            missing: "missing";
+            observed: "observed";
+            calculated: "calculated";
+        }>;
+    }, z.core.$strict>;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    causalStatus: z.ZodLiteral<"unproven">;
+    actionability: z.ZodLiteral<"inspect_only">;
+    approvalRequired: z.ZodLiteral<true>;
+    id: z.ZodString;
+    candidateKey: z.ZodString;
+}, z.core.$strict>;
+export type WasteFindingV0 = z.infer<typeof wasteFindingObjectSchema>;
+declare const tokenSessionSchema: z.ZodObject<{
+    sessionRef: z.ZodString;
+    startedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    endedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    agent: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    projectRef: z.ZodOptional<z.ZodString>;
+    sessionType: z.ZodEnum<{
+        subagent: "subagent";
+        unknown: "unknown";
+        parent: "parent";
+    }>;
+    workTypeRef: z.ZodOptional<z.ZodString>;
+    workUnitRef: z.ZodOptional<z.ZodString>;
+    workUnitEvidence: z.ZodOptional<z.ZodEnum<{
+        verified: "verified";
+        observed: "observed";
+        user_declared: "user_declared";
+    }>>;
+    sourceVersionRef: z.ZodOptional<z.ZodString>;
+    sourceValidationCoverage: z.ZodEnum<{
+        live_verified: "live_verified";
+        fixture_verified: "fixture_verified";
+        untested: "untested";
+        failed: "failed";
+    }>;
+    tokens: z.ZodObject<{
+        uncachedInputTokens: z.ZodNullable<z.ZodNumber>;
+        cacheReadTokens: z.ZodNullable<z.ZodNumber>;
+        cacheWriteTokens: z.ZodNullable<z.ZodNumber>;
+        toolTokens: z.ZodNullable<z.ZodNumber>;
+        outputTokens: z.ZodNullable<z.ZodNumber>;
+        thoughtTokens: z.ZodNullable<z.ZodNumber>;
+        calculatedTotalTokens: z.ZodNullable<z.ZodNumber>;
+        reportedTotalTokens: z.ZodNullable<z.ZodNumber>;
+        componentEvidence: z.ZodObject<{
+            uncachedInputTokens: z.ZodEnum<{
+                observed: "observed";
+                not_separately_reported: "not_separately_reported";
+            }>;
+            cacheReadTokens: z.ZodEnum<{
+                observed: "observed";
+                not_separately_reported: "not_separately_reported";
+            }>;
+            cacheWriteTokens: z.ZodEnum<{
+                observed: "observed";
+                not_separately_reported: "not_separately_reported";
+                partial: "partial";
+            }>;
+            toolTokens: z.ZodEnum<{
+                observed: "observed";
+                not_separately_reported: "not_separately_reported";
+            }>;
+            outputTokens: z.ZodEnum<{
+                observed: "observed";
+                not_separately_reported: "not_separately_reported";
+            }>;
+            thoughtTokens: z.ZodEnum<{
+                observed: "observed";
+                not_separately_reported: "not_separately_reported";
+            }>;
+            calculatedTotalTokens: z.ZodEnum<{
+                missing: "missing";
+                calculated_complete: "calculated_complete";
+                calculated_partial: "calculated_partial";
+            }>;
+            reportedTotalTokens: z.ZodEnum<{
+                provider_reported: "provider_reported";
+                not_reported: "not_reported";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    quality: z.ZodObject<{
+        status: z.ZodEnum<{
+            missing: "missing";
+            failed: "failed";
+            passed: "passed";
+        }>;
+        evidence: z.ZodEnum<{
+            verified: "verified";
+            missing: "missing";
+            observed: "observed";
+            user_declared: "user_declared";
+        }>;
+        evidenceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TokenExperimentSessionV0 = z.infer<typeof tokenSessionSchema>;
+export type TokenExperimentSessionV0Input = z.input<typeof tokenSessionSchema>;
+declare const experimentBodySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"aibill.token_reduction_experiment">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    createdAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    finding: z.ZodObject<{
+        kind: z.ZodLiteral<"aibill.waste_finding">;
+        schemaVersion: z.ZodLiteral<"0.1.0">;
+        generatedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        window: z.ZodObject<{
+            start: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            end: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        }, z.core.$strict>;
+        findingType: z.ZodEnum<{
+            configured_not_observed: "configured_not_observed";
+            repeated_context_read: "repeated_context_read";
+            compaction_pressure: "compaction_pressure";
+            high_context_relative_to_baseline: "high_context_relative_to_baseline";
+            cumulative_context_exposure: "cumulative_context_exposure";
+        }>;
+        objective: z.ZodObject<{
+            metric: z.ZodLiteral<"total_tokens_per_matched_session">;
+            direction: z.ZodLiteral<"reduce">;
+            guard: z.ZodLiteral<"user_declared_quality_must_hold">;
+        }, z.core.$strict>;
+        caveats: z.ZodArray<z.ZodEnum<{
+            signal_not_cause: "signal_not_cause";
+            no_cash_claim: "no_cash_claim";
+            missing_outcome_evidence: "missing_outcome_evidence";
+        }>>;
+        candidateAction: z.ZodObject<{
+            kind: z.ZodEnum<{
+                start_fresh: "start_fresh";
+                inspect_scope: "inspect_scope";
+                lazy_load: "lazy_load";
+                disable: "disable";
+                remove: "remove";
+                reduce_repeated_reads: "reduce_repeated_reads";
+                trim_context: "trim_context";
+            }>;
+            provider: z.ZodString;
+            surface: z.ZodEnum<{
+                local_agent_configuration: "local_agent_configuration";
+                session_workflow: "session_workflow";
+                provider_workload_configuration: "provider_workload_configuration";
+            }>;
+            reversible: z.ZodLiteral<true>;
+            canaryRequired: z.ZodLiteral<true>;
+            rollbackRequired: z.ZodLiteral<true>;
+        }, z.core.$strict>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                session: "session";
+                repeated_read_file: "repeated_read_file";
+                configured_item: "configured_item";
+            }>;
+            ref: z.ZodString;
+        }, z.core.$strict>;
+        scope: z.ZodObject<{
+            agent: z.ZodString;
+            provider: z.ZodString;
+            model: z.ZodOptional<z.ZodString>;
+            projectRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        source: z.ZodObject<{
+            id: z.ZodString;
+            validationCoverage: z.ZodEnum<{
+                live_verified: "live_verified";
+                fixture_verified: "fixture_verified";
+                untested: "untested";
+                failed: "failed";
+            }>;
+            freshness: z.ZodEnum<{
+                fresh: "fresh";
+                stale: "stale";
+                not_checked: "not_checked";
+            }>;
+        }, z.core.$strict>;
+        metric: z.ZodObject<{
+            name: z.ZodEnum<{
+                total_tokens: "total_tokens";
+                input_context_tokens: "input_context_tokens";
+                compaction_events: "compaction_events";
+                repeated_read_events: "repeated_read_events";
+                configured_items: "configured_items";
+            }>;
+            unit: z.ZodEnum<{
+                items: "items";
+                tokens: "tokens";
+                events: "events";
+                ratio: "ratio";
+            }>;
+            value: z.ZodNullable<z.ZodNumber>;
+            sampleCount: z.ZodNumber;
+            evidence: z.ZodEnum<{
+                missing: "missing";
+                observed: "observed";
+                calculated: "calculated";
+            }>;
+        }, z.core.$strict>;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+        causalStatus: z.ZodLiteral<"unproven">;
+        actionability: z.ZodLiteral<"inspect_only">;
+        approvalRequired: z.ZodLiteral<true>;
+        id: z.ZodString;
+        candidateKey: z.ZodString;
+    }, z.core.$strict>;
+    cohort: z.ZodObject<{
+        agent: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodString;
+        projectRef: z.ZodString;
+        sessionType: z.ZodEnum<{
+            subagent: "subagent";
+            parent: "parent";
+        }>;
+        workTypeRef: z.ZodString;
+        workTypeEvidence: z.ZodEnum<{
+            verified: "verified";
+            observed: "observed";
+            user_declared: "user_declared";
+        }>;
+        sourceVersionRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    matchingPolicy: z.ZodObject<{
+        basis: z.ZodEnum<{
+            session_cohort: "session_cohort";
+            accepted_work_unit: "accepted_work_unit";
+        }>;
+        minimumBaselineSessions: z.ZodDefault<z.ZodNumber>;
+        minimumPostSessions: z.ZodDefault<z.ZodNumber>;
+        requireExactSourceVersion: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>;
+    qualityGuard: z.ZodObject<{
+        required: z.ZodLiteral<true>;
+        minimumEvidence: z.ZodEnum<{
+            verified: "verified";
+            observed: "observed";
+            user_declared: "user_declared";
+        }>;
+        rollbackOnRegression: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    baselineSessions: z.ZodArray<z.ZodObject<{
+        sessionRef: z.ZodString;
+        startedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        endedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        agent: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodString;
+        projectRef: z.ZodOptional<z.ZodString>;
+        sessionType: z.ZodEnum<{
+            subagent: "subagent";
+            unknown: "unknown";
+            parent: "parent";
+        }>;
+        workTypeRef: z.ZodOptional<z.ZodString>;
+        workUnitRef: z.ZodOptional<z.ZodString>;
+        workUnitEvidence: z.ZodOptional<z.ZodEnum<{
+            verified: "verified";
+            observed: "observed";
+            user_declared: "user_declared";
+        }>>;
+        sourceVersionRef: z.ZodOptional<z.ZodString>;
+        sourceValidationCoverage: z.ZodEnum<{
+            live_verified: "live_verified";
+            fixture_verified: "fixture_verified";
+            untested: "untested";
+            failed: "failed";
+        }>;
+        tokens: z.ZodObject<{
+            uncachedInputTokens: z.ZodNullable<z.ZodNumber>;
+            cacheReadTokens: z.ZodNullable<z.ZodNumber>;
+            cacheWriteTokens: z.ZodNullable<z.ZodNumber>;
+            toolTokens: z.ZodNullable<z.ZodNumber>;
+            outputTokens: z.ZodNullable<z.ZodNumber>;
+            thoughtTokens: z.ZodNullable<z.ZodNumber>;
+            calculatedTotalTokens: z.ZodNullable<z.ZodNumber>;
+            reportedTotalTokens: z.ZodNullable<z.ZodNumber>;
+            componentEvidence: z.ZodObject<{
+                uncachedInputTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                cacheReadTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                cacheWriteTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                    partial: "partial";
+                }>;
+                toolTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                outputTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                thoughtTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                calculatedTotalTokens: z.ZodEnum<{
+                    missing: "missing";
+                    calculated_complete: "calculated_complete";
+                    calculated_partial: "calculated_partial";
+                }>;
+                reportedTotalTokens: z.ZodEnum<{
+                    provider_reported: "provider_reported";
+                    not_reported: "not_reported";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        quality: z.ZodObject<{
+            status: z.ZodEnum<{
+                missing: "missing";
+                failed: "failed";
+                passed: "passed";
+            }>;
+            evidence: z.ZodEnum<{
+                verified: "verified";
+                missing: "missing";
+                observed: "observed";
+                user_declared: "user_declared";
+            }>;
+            evidenceRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    intervention: z.ZodObject<{
+        approval: z.ZodObject<{
+            status: z.ZodEnum<{
+                pending: "pending";
+                explicit: "explicit";
+            }>;
+            evidence: z.ZodEnum<{
+                verified: "verified";
+                missing: "missing";
+                user_declared: "user_declared";
+            }>;
+            approvedAt: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            approvalRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        appliedAt: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        changeRef: z.ZodOptional<z.ZodString>;
+        rollbackRef: z.ZodOptional<z.ZodString>;
+        canary: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                missing: "missing";
+                failed: "failed";
+                passed: "passed";
+            }>;
+            evidence: z.ZodEnum<{
+                verified: "verified";
+                missing: "missing";
+                observed: "observed";
+                user_declared: "user_declared";
+            }>;
+            evidenceRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        rolledBackAt: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    }, z.core.$strict>;
+    postSessions: z.ZodArray<z.ZodObject<{
+        sessionRef: z.ZodString;
+        startedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        endedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        agent: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodString;
+        projectRef: z.ZodOptional<z.ZodString>;
+        sessionType: z.ZodEnum<{
+            subagent: "subagent";
+            unknown: "unknown";
+            parent: "parent";
+        }>;
+        workTypeRef: z.ZodOptional<z.ZodString>;
+        workUnitRef: z.ZodOptional<z.ZodString>;
+        workUnitEvidence: z.ZodOptional<z.ZodEnum<{
+            verified: "verified";
+            observed: "observed";
+            user_declared: "user_declared";
+        }>>;
+        sourceVersionRef: z.ZodOptional<z.ZodString>;
+        sourceValidationCoverage: z.ZodEnum<{
+            live_verified: "live_verified";
+            fixture_verified: "fixture_verified";
+            untested: "untested";
+            failed: "failed";
+        }>;
+        tokens: z.ZodObject<{
+            uncachedInputTokens: z.ZodNullable<z.ZodNumber>;
+            cacheReadTokens: z.ZodNullable<z.ZodNumber>;
+            cacheWriteTokens: z.ZodNullable<z.ZodNumber>;
+            toolTokens: z.ZodNullable<z.ZodNumber>;
+            outputTokens: z.ZodNullable<z.ZodNumber>;
+            thoughtTokens: z.ZodNullable<z.ZodNumber>;
+            calculatedTotalTokens: z.ZodNullable<z.ZodNumber>;
+            reportedTotalTokens: z.ZodNullable<z.ZodNumber>;
+            componentEvidence: z.ZodObject<{
+                uncachedInputTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                cacheReadTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                cacheWriteTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                    partial: "partial";
+                }>;
+                toolTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                outputTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                thoughtTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                calculatedTotalTokens: z.ZodEnum<{
+                    missing: "missing";
+                    calculated_complete: "calculated_complete";
+                    calculated_partial: "calculated_partial";
+                }>;
+                reportedTotalTokens: z.ZodEnum<{
+                    provider_reported: "provider_reported";
+                    not_reported: "not_reported";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        quality: z.ZodObject<{
+            status: z.ZodEnum<{
+                missing: "missing";
+                failed: "failed";
+                passed: "passed";
+            }>;
+            evidence: z.ZodEnum<{
+                verified: "verified";
+                missing: "missing";
+                observed: "observed";
+                user_declared: "user_declared";
+            }>;
+            evidenceRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    invalidation: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodEnum<{
+            manual: "manual";
+            scope_changed: "scope_changed";
+            source_semantics_changed: "source_semantics_changed";
+            concurrent_change: "concurrent_change";
+        }>;
+        invalidatedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TokenReductionExperimentV0DraftInput = z.input<typeof experimentBodySchema>;
+declare const evaluationSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        collecting: "collecting";
+        not_evaluated: "not_evaluated";
+        measured_token_reduction: "measured_token_reduction";
+        no_measured_change: "no_measured_change";
+        regressed: "regressed";
+        inconclusive: "inconclusive";
+    }>;
+    metricEvidence: z.ZodEnum<{
+        missing: "missing";
+        calculated: "calculated";
+    }>;
+    matchingEvidence: z.ZodEnum<{
+        verified: "verified";
+        missing: "missing";
+        observed: "observed";
+        user_declared: "user_declared";
+    }>;
+    qualityStatus: z.ZodEnum<{
+        regressed: "regressed";
+        held: "held";
+        insufficient: "insufficient";
+    }>;
+    qualityEvidence: z.ZodEnum<{
+        verified: "verified";
+        missing: "missing";
+        observed: "observed";
+        user_declared: "user_declared";
+    }>;
+    baseline: z.ZodObject<{
+        includedSessions: z.ZodNumber;
+        medianTotalTokens: z.ZodNullable<z.ZodNumber>;
+        componentMedians: z.ZodObject<{
+            uncachedInputTokens: z.ZodNullable<z.ZodNumber>;
+            cacheReadTokens: z.ZodNullable<z.ZodNumber>;
+            cacheWriteTokens: z.ZodNullable<z.ZodNumber>;
+            toolTokens: z.ZodNullable<z.ZodNumber>;
+            outputTokens: z.ZodNullable<z.ZodNumber>;
+            thoughtTokens: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    postChange: z.ZodObject<{
+        includedSessions: z.ZodNumber;
+        medianTotalTokens: z.ZodNullable<z.ZodNumber>;
+        componentMedians: z.ZodObject<{
+            uncachedInputTokens: z.ZodNullable<z.ZodNumber>;
+            cacheReadTokens: z.ZodNullable<z.ZodNumber>;
+            cacheWriteTokens: z.ZodNullable<z.ZodNumber>;
+            toolTokens: z.ZodNullable<z.ZodNumber>;
+            outputTokens: z.ZodNullable<z.ZodNumber>;
+            thoughtTokens: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    reductionPercent: z.ZodNullable<z.ZodNumber>;
+    exclusions: z.ZodArray<z.ZodObject<{
+        phase: z.ZodEnum<{
+            baseline: "baseline";
+            post_change: "post_change";
+        }>;
+        sessionRef: z.ZodString;
+        reasons: z.ZodArray<z.ZodEnum<{
+            duplicate_session: "duplicate_session";
+            reused_across_phases: "reused_across_phases";
+            intervention_not_applied: "intervention_not_applied";
+            crosses_intervention_boundary: "crosses_intervention_boundary";
+            wrong_side_of_intervention: "wrong_side_of_intervention";
+            missing_total_tokens: "missing_total_tokens";
+            inconsistent_total_tokens: "inconsistent_total_tokens";
+            agent_mismatch: "agent_mismatch";
+            provider_mismatch: "provider_mismatch";
+            model_mismatch: "model_mismatch";
+            project_mismatch: "project_mismatch";
+            session_type_mismatch: "session_type_mismatch";
+            work_type_mismatch: "work_type_mismatch";
+            missing_work_unit: "missing_work_unit";
+            source_version_mismatch: "source_version_mismatch";
+        }>>;
+    }, z.core.$strict>>;
+    rollbackRecommended: z.ZodBoolean;
+}, z.core.$strict>;
+declare const experimentObjectSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"aibill.token_reduction_experiment">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    createdAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    finding: z.ZodObject<{
+        kind: z.ZodLiteral<"aibill.waste_finding">;
+        schemaVersion: z.ZodLiteral<"0.1.0">;
+        generatedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        window: z.ZodObject<{
+            start: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            end: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        }, z.core.$strict>;
+        findingType: z.ZodEnum<{
+            configured_not_observed: "configured_not_observed";
+            repeated_context_read: "repeated_context_read";
+            compaction_pressure: "compaction_pressure";
+            high_context_relative_to_baseline: "high_context_relative_to_baseline";
+            cumulative_context_exposure: "cumulative_context_exposure";
+        }>;
+        objective: z.ZodObject<{
+            metric: z.ZodLiteral<"total_tokens_per_matched_session">;
+            direction: z.ZodLiteral<"reduce">;
+            guard: z.ZodLiteral<"user_declared_quality_must_hold">;
+        }, z.core.$strict>;
+        caveats: z.ZodArray<z.ZodEnum<{
+            signal_not_cause: "signal_not_cause";
+            no_cash_claim: "no_cash_claim";
+            missing_outcome_evidence: "missing_outcome_evidence";
+        }>>;
+        candidateAction: z.ZodObject<{
+            kind: z.ZodEnum<{
+                start_fresh: "start_fresh";
+                inspect_scope: "inspect_scope";
+                lazy_load: "lazy_load";
+                disable: "disable";
+                remove: "remove";
+                reduce_repeated_reads: "reduce_repeated_reads";
+                trim_context: "trim_context";
+            }>;
+            provider: z.ZodString;
+            surface: z.ZodEnum<{
+                local_agent_configuration: "local_agent_configuration";
+                session_workflow: "session_workflow";
+                provider_workload_configuration: "provider_workload_configuration";
+            }>;
+            reversible: z.ZodLiteral<true>;
+            canaryRequired: z.ZodLiteral<true>;
+            rollbackRequired: z.ZodLiteral<true>;
+        }, z.core.$strict>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                session: "session";
+                repeated_read_file: "repeated_read_file";
+                configured_item: "configured_item";
+            }>;
+            ref: z.ZodString;
+        }, z.core.$strict>;
+        scope: z.ZodObject<{
+            agent: z.ZodString;
+            provider: z.ZodString;
+            model: z.ZodOptional<z.ZodString>;
+            projectRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        source: z.ZodObject<{
+            id: z.ZodString;
+            validationCoverage: z.ZodEnum<{
+                live_verified: "live_verified";
+                fixture_verified: "fixture_verified";
+                untested: "untested";
+                failed: "failed";
+            }>;
+            freshness: z.ZodEnum<{
+                fresh: "fresh";
+                stale: "stale";
+                not_checked: "not_checked";
+            }>;
+        }, z.core.$strict>;
+        metric: z.ZodObject<{
+            name: z.ZodEnum<{
+                total_tokens: "total_tokens";
+                input_context_tokens: "input_context_tokens";
+                compaction_events: "compaction_events";
+                repeated_read_events: "repeated_read_events";
+                configured_items: "configured_items";
+            }>;
+            unit: z.ZodEnum<{
+                items: "items";
+                tokens: "tokens";
+                events: "events";
+                ratio: "ratio";
+            }>;
+            value: z.ZodNullable<z.ZodNumber>;
+            sampleCount: z.ZodNumber;
+            evidence: z.ZodEnum<{
+                missing: "missing";
+                observed: "observed";
+                calculated: "calculated";
+            }>;
+        }, z.core.$strict>;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+        causalStatus: z.ZodLiteral<"unproven">;
+        actionability: z.ZodLiteral<"inspect_only">;
+        approvalRequired: z.ZodLiteral<true>;
+        id: z.ZodString;
+        candidateKey: z.ZodString;
+    }, z.core.$strict>;
+    cohort: z.ZodObject<{
+        agent: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodString;
+        projectRef: z.ZodString;
+        sessionType: z.ZodEnum<{
+            subagent: "subagent";
+            parent: "parent";
+        }>;
+        workTypeRef: z.ZodString;
+        workTypeEvidence: z.ZodEnum<{
+            verified: "verified";
+            observed: "observed";
+            user_declared: "user_declared";
+        }>;
+        sourceVersionRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    matchingPolicy: z.ZodObject<{
+        basis: z.ZodEnum<{
+            session_cohort: "session_cohort";
+            accepted_work_unit: "accepted_work_unit";
+        }>;
+        minimumBaselineSessions: z.ZodDefault<z.ZodNumber>;
+        minimumPostSessions: z.ZodDefault<z.ZodNumber>;
+        requireExactSourceVersion: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>;
+    qualityGuard: z.ZodObject<{
+        required: z.ZodLiteral<true>;
+        minimumEvidence: z.ZodEnum<{
+            verified: "verified";
+            observed: "observed";
+            user_declared: "user_declared";
+        }>;
+        rollbackOnRegression: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    baselineSessions: z.ZodArray<z.ZodObject<{
+        sessionRef: z.ZodString;
+        startedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        endedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        agent: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodString;
+        projectRef: z.ZodOptional<z.ZodString>;
+        sessionType: z.ZodEnum<{
+            subagent: "subagent";
+            unknown: "unknown";
+            parent: "parent";
+        }>;
+        workTypeRef: z.ZodOptional<z.ZodString>;
+        workUnitRef: z.ZodOptional<z.ZodString>;
+        workUnitEvidence: z.ZodOptional<z.ZodEnum<{
+            verified: "verified";
+            observed: "observed";
+            user_declared: "user_declared";
+        }>>;
+        sourceVersionRef: z.ZodOptional<z.ZodString>;
+        sourceValidationCoverage: z.ZodEnum<{
+            live_verified: "live_verified";
+            fixture_verified: "fixture_verified";
+            untested: "untested";
+            failed: "failed";
+        }>;
+        tokens: z.ZodObject<{
+            uncachedInputTokens: z.ZodNullable<z.ZodNumber>;
+            cacheReadTokens: z.ZodNullable<z.ZodNumber>;
+            cacheWriteTokens: z.ZodNullable<z.ZodNumber>;
+            toolTokens: z.ZodNullable<z.ZodNumber>;
+            outputTokens: z.ZodNullable<z.ZodNumber>;
+            thoughtTokens: z.ZodNullable<z.ZodNumber>;
+            calculatedTotalTokens: z.ZodNullable<z.ZodNumber>;
+            reportedTotalTokens: z.ZodNullable<z.ZodNumber>;
+            componentEvidence: z.ZodObject<{
+                uncachedInputTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                cacheReadTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                cacheWriteTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                    partial: "partial";
+                }>;
+                toolTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                outputTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                thoughtTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                calculatedTotalTokens: z.ZodEnum<{
+                    missing: "missing";
+                    calculated_complete: "calculated_complete";
+                    calculated_partial: "calculated_partial";
+                }>;
+                reportedTotalTokens: z.ZodEnum<{
+                    provider_reported: "provider_reported";
+                    not_reported: "not_reported";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        quality: z.ZodObject<{
+            status: z.ZodEnum<{
+                missing: "missing";
+                failed: "failed";
+                passed: "passed";
+            }>;
+            evidence: z.ZodEnum<{
+                verified: "verified";
+                missing: "missing";
+                observed: "observed";
+                user_declared: "user_declared";
+            }>;
+            evidenceRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    intervention: z.ZodObject<{
+        approval: z.ZodObject<{
+            status: z.ZodEnum<{
+                pending: "pending";
+                explicit: "explicit";
+            }>;
+            evidence: z.ZodEnum<{
+                verified: "verified";
+                missing: "missing";
+                user_declared: "user_declared";
+            }>;
+            approvedAt: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            approvalRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        appliedAt: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        changeRef: z.ZodOptional<z.ZodString>;
+        rollbackRef: z.ZodOptional<z.ZodString>;
+        canary: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                missing: "missing";
+                failed: "failed";
+                passed: "passed";
+            }>;
+            evidence: z.ZodEnum<{
+                verified: "verified";
+                missing: "missing";
+                observed: "observed";
+                user_declared: "user_declared";
+            }>;
+            evidenceRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        rolledBackAt: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    }, z.core.$strict>;
+    postSessions: z.ZodArray<z.ZodObject<{
+        sessionRef: z.ZodString;
+        startedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        endedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        agent: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodString;
+        projectRef: z.ZodOptional<z.ZodString>;
+        sessionType: z.ZodEnum<{
+            subagent: "subagent";
+            unknown: "unknown";
+            parent: "parent";
+        }>;
+        workTypeRef: z.ZodOptional<z.ZodString>;
+        workUnitRef: z.ZodOptional<z.ZodString>;
+        workUnitEvidence: z.ZodOptional<z.ZodEnum<{
+            verified: "verified";
+            observed: "observed";
+            user_declared: "user_declared";
+        }>>;
+        sourceVersionRef: z.ZodOptional<z.ZodString>;
+        sourceValidationCoverage: z.ZodEnum<{
+            live_verified: "live_verified";
+            fixture_verified: "fixture_verified";
+            untested: "untested";
+            failed: "failed";
+        }>;
+        tokens: z.ZodObject<{
+            uncachedInputTokens: z.ZodNullable<z.ZodNumber>;
+            cacheReadTokens: z.ZodNullable<z.ZodNumber>;
+            cacheWriteTokens: z.ZodNullable<z.ZodNumber>;
+            toolTokens: z.ZodNullable<z.ZodNumber>;
+            outputTokens: z.ZodNullable<z.ZodNumber>;
+            thoughtTokens: z.ZodNullable<z.ZodNumber>;
+            calculatedTotalTokens: z.ZodNullable<z.ZodNumber>;
+            reportedTotalTokens: z.ZodNullable<z.ZodNumber>;
+            componentEvidence: z.ZodObject<{
+                uncachedInputTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                cacheReadTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                cacheWriteTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                    partial: "partial";
+                }>;
+                toolTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                outputTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                thoughtTokens: z.ZodEnum<{
+                    observed: "observed";
+                    not_separately_reported: "not_separately_reported";
+                }>;
+                calculatedTotalTokens: z.ZodEnum<{
+                    missing: "missing";
+                    calculated_complete: "calculated_complete";
+                    calculated_partial: "calculated_partial";
+                }>;
+                reportedTotalTokens: z.ZodEnum<{
+                    provider_reported: "provider_reported";
+                    not_reported: "not_reported";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        quality: z.ZodObject<{
+            status: z.ZodEnum<{
+                missing: "missing";
+                failed: "failed";
+                passed: "passed";
+            }>;
+            evidence: z.ZodEnum<{
+                verified: "verified";
+                missing: "missing";
+                observed: "observed";
+                user_declared: "user_declared";
+            }>;
+            evidenceRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    invalidation: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodEnum<{
+            manual: "manual";
+            scope_changed: "scope_changed";
+            source_semantics_changed: "source_semantics_changed";
+            concurrent_change: "concurrent_change";
+        }>;
+        invalidatedAt: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    }, z.core.$strict>>;
+    id: z.ZodString;
+    revisionId: z.ZodString;
+    lifecycle: z.ZodEnum<{
+        complete: "complete";
+        draft: "draft";
+        baseline_ready: "baseline_ready";
+        applied: "applied";
+        collecting: "collecting";
+        rolled_back: "rolled_back";
+        invalidated: "invalidated";
+    }>;
+    evaluation: z.ZodObject<{
+        status: z.ZodEnum<{
+            collecting: "collecting";
+            not_evaluated: "not_evaluated";
+            measured_token_reduction: "measured_token_reduction";
+            no_measured_change: "no_measured_change";
+            regressed: "regressed";
+            inconclusive: "inconclusive";
+        }>;
+        metricEvidence: z.ZodEnum<{
+            missing: "missing";
+            calculated: "calculated";
+        }>;
+        matchingEvidence: z.ZodEnum<{
+            verified: "verified";
+            missing: "missing";
+            observed: "observed";
+            user_declared: "user_declared";
+        }>;
+        qualityStatus: z.ZodEnum<{
+            regressed: "regressed";
+            held: "held";
+            insufficient: "insufficient";
+        }>;
+        qualityEvidence: z.ZodEnum<{
+            verified: "verified";
+            missing: "missing";
+            observed: "observed";
+            user_declared: "user_declared";
+        }>;
+        baseline: z.ZodObject<{
+            includedSessions: z.ZodNumber;
+            medianTotalTokens: z.ZodNullable<z.ZodNumber>;
+            componentMedians: z.ZodObject<{
+                uncachedInputTokens: z.ZodNullable<z.ZodNumber>;
+                cacheReadTokens: z.ZodNullable<z.ZodNumber>;
+                cacheWriteTokens: z.ZodNullable<z.ZodNumber>;
+                toolTokens: z.ZodNullable<z.ZodNumber>;
+                outputTokens: z.ZodNullable<z.ZodNumber>;
+                thoughtTokens: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        postChange: z.ZodObject<{
+            includedSessions: z.ZodNumber;
+            medianTotalTokens: z.ZodNullable<z.ZodNumber>;
+            componentMedians: z.ZodObject<{
+                uncachedInputTokens: z.ZodNullable<z.ZodNumber>;
+                cacheReadTokens: z.ZodNullable<z.ZodNumber>;
+                cacheWriteTokens: z.ZodNullable<z.ZodNumber>;
+                toolTokens: z.ZodNullable<z.ZodNumber>;
+                outputTokens: z.ZodNullable<z.ZodNumber>;
+                thoughtTokens: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        reductionPercent: z.ZodNullable<z.ZodNumber>;
+        exclusions: z.ZodArray<z.ZodObject<{
+            phase: z.ZodEnum<{
+                baseline: "baseline";
+                post_change: "post_change";
+            }>;
+            sessionRef: z.ZodString;
+            reasons: z.ZodArray<z.ZodEnum<{
+                duplicate_session: "duplicate_session";
+                reused_across_phases: "reused_across_phases";
+                intervention_not_applied: "intervention_not_applied";
+                crosses_intervention_boundary: "crosses_intervention_boundary";
+                wrong_side_of_intervention: "wrong_side_of_intervention";
+                missing_total_tokens: "missing_total_tokens";
+                inconsistent_total_tokens: "inconsistent_total_tokens";
+                agent_mismatch: "agent_mismatch";
+                provider_mismatch: "provider_mismatch";
+                model_mismatch: "model_mismatch";
+                project_mismatch: "project_mismatch";
+                session_type_mismatch: "session_type_mismatch";
+                work_type_mismatch: "work_type_mismatch";
+                missing_work_unit: "missing_work_unit";
+                source_version_mismatch: "source_version_mismatch";
+            }>>;
+        }, z.core.$strict>>;
+        rollbackRecommended: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TokenReductionEvaluationV0 = z.infer<typeof evaluationSchema>;
+export type TokenReductionExperimentV0 = z.infer<typeof experimentObjectSchema>;
+/**
+ * Hash a source-native value into the only reference form accepted by action
+ * verification contracts. The original value is never returned or persisted.
+ */
+export declare function createActionVerificationReference(namespace: string, sourceNativeValue: string): string;
+/** Create a canonical, content-addressed waste finding with no raw paths or prose. */
+export declare function createWasteFindingV0(input: WasteFindingV0DraftInput): WasteFindingV0;
+/** Parse a serialized finding and reject a stale or forged content digest. */
+export declare function parseWasteFindingV0(value: unknown): WasteFindingV0;
+/**
+ * Build or advance one experiment. Evaluation is pure: every lifecycle label,
+ * median, exclusion, percentage, and rollback recommendation is derived from
+ * the supplied immutable evidence.
+ */
+export declare function createTokenReductionExperimentV0(input: TokenReductionExperimentV0DraftInput): TokenReductionExperimentV0;
+/** Parse and recompute an experiment, rejecting tampered derived fields. */
+export declare function parseTokenReductionExperimentV0(value: unknown): TokenReductionExperimentV0;
+/** Pure evaluator for callers that already have a validated experiment body. */
+export declare function evaluateTokenReductionExperimentV0(input: TokenReductionExperimentV0DraftInput): Pick<TokenReductionExperimentV0, "lifecycle" | "evaluation">;
+export {};
+//# sourceMappingURL=actionVerification.d.ts.map