@davesheffer/hunch 1.31.1 → 1.32.1

package/dist/constitution/g3.d.ts

@@ -0,0 +1,311 @@
+import { z } from "zod";
+import type { HunchStore } from "../store/hunchStore.js";
+import { type G2ReadinessReport } from "./g2.js";
+export declare const G3_REQUIRED_EXPERIMENTS: readonly ["EXP-01", "EXP-03"];
+export type G3RequiredExperiment = (typeof G3_REQUIRED_EXPERIMENTS)[number];
+export declare const G3PlanSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    gate: z.ZodLiteral<"G3">;
+    g2_readiness_hash: z.ZodString;
+    policy_ids: z.ZodArray<z.ZodString>;
+    clients: z.ZodArray<z.ZodString>;
+    experiments: z.ZodObject<{
+        retrieval: z.ZodString;
+        compiler: z.ZodString;
+    }, z.core.$strict>;
+    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 G3Plan = z.infer<typeof G3PlanSchema>;
+export interface CompileG3PlanInput {
+    g2_readiness_hash: string;
+    policy_ids: string[];
+    clients: string[];
+    experiments: {
+        retrieval: string;
+        compiler: string;
+    };
+    actor: string;
+    reason: string;
+    supersedes?: string | null;
+}
+export declare function g3PlanContentHash(plan: G3Plan): string;
+export declare function compileG3Plan(input: CompileG3PlanInput, opts?: {
+    now?: string;
+}): G3Plan;
+export declare const ExperimentPreregistrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    experiment: z.ZodEnum<{
+        "EXP-03": "EXP-03";
+        "EXP-01": "EXP-01";
+    }>;
+    revision: z.ZodNumber;
+    hypothesis: z.ZodString;
+    primary_metric: z.ZodString;
+    secondary_metrics: z.ZodArray<z.ZodString>;
+    unit: z.ZodEnum<{
+        repository: "repository";
+        pull_request: "pull_request";
+        task: "task";
+        developer: "developer";
+        policy_candidate: "policy_candidate";
+    }>;
+    arms: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strict>>;
+    assignment: z.ZodObject<{
+        method: z.ZodEnum<{
+            randomized: "randomized";
+            blocked_randomized: "blocked_randomized";
+            paired_randomized: "paired_randomized";
+        }>;
+        unit: z.ZodEnum<{
+            repository: "repository";
+            pull_request: "pull_request";
+            task: "task";
+            developer: "developer";
+            policy_candidate: "policy_candidate";
+        }>;
+        seed: z.ZodString;
+    }, z.core.$strict>;
+    strata: z.ZodArray<z.ZodString>;
+    inclusion: z.ZodArray<z.ZodString>;
+    exclusion: z.ZodArray<z.ZodString>;
+    sample_plan: z.ZodObject<{
+        minimum_per_arm: z.ZodNumber;
+        target_per_arm: z.ZodNumber;
+        maximum_total: z.ZodNumber;
+        rationale: z.ZodString;
+    }, z.core.$strict>;
+    analysis_plan: z.ZodObject<{
+        primary_estimator: z.ZodString;
+        effect_size: z.ZodString;
+        uncertainty: z.ZodString;
+        missing_data: z.ZodString;
+        multiple_metrics: z.ZodString;
+    }, z.core.$strict>;
+    stopping_rule: z.ZodString;
+    guardrails: z.ZodArray<z.ZodString>;
+    privacy_class: z.ZodLiteral<"private">;
+    status: z.ZodLiteral<"registered">;
+    actor: z.ZodString;
+    reason: z.ZodString;
+    supersedes: z.ZodNullable<z.ZodString>;
+    authority: z.ZodLiteral<"none">;
+    registered_at: z.ZodString;
+}, z.core.$strict>;
+export type ExperimentPreregistration = z.infer<typeof ExperimentPreregistrationSchema>;
+export type CompileExperimentPreregistrationInput = Omit<ExperimentPreregistration, "id" | "content_hash" | "revision" | "privacy_class" | "status" | "authority" | "registered_at"> & {
+    revision?: number;
+};
+export declare function experimentPreregistrationContentHash(spec: ExperimentPreregistration): string;
+export declare function compileExperimentPreregistration(input: CompileExperimentPreregistrationInput, opts?: {
+    now?: string;
+}): ExperimentPreregistration;
+declare const ComprehensionSchema: z.ZodObject<{
+    requirement: z.ZodEnum<{
+        correct: "correct";
+        incorrect: "incorrect";
+    }>;
+    limitations: z.ZodEnum<{
+        correct: "correct";
+        incorrect: "incorrect";
+    }>;
+    authority: z.ZodEnum<{
+        correct: "correct";
+        incorrect: "incorrect";
+    }>;
+}, z.core.$strict>;
+export declare const ProofReviewMeasurementSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    plan_id: z.ZodString;
+    policy_id: z.ZodString;
+    policy_hash: z.ZodString;
+    proof_id: z.ZodString;
+    proof_hash: z.ZodString;
+    card_hash: z.ZodString;
+    reviewer: z.ZodString;
+    duration_ms: z.ZodNumber;
+    comprehension: z.ZodObject<{
+        requirement: z.ZodEnum<{
+            correct: "correct";
+            incorrect: "incorrect";
+        }>;
+        limitations: z.ZodEnum<{
+            correct: "correct";
+            incorrect: "incorrect";
+        }>;
+        authority: z.ZodEnum<{
+            correct: "correct";
+            incorrect: "incorrect";
+        }>;
+    }, z.core.$strict>;
+    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 ProofReviewMeasurement = z.infer<typeof ProofReviewMeasurementSchema>;
+export interface CompileProofReviewMeasurementInput {
+    plan_id: string;
+    policy_id: string;
+    policy_hash: string;
+    proof_id: string;
+    proof_hash: string;
+    card_hash: string;
+    reviewer: string;
+    duration_ms: number;
+    comprehension: z.infer<typeof ComprehensionSchema>;
+    notes: string;
+    supersedes?: string | null;
+}
+export declare function proofReviewMeasurementContentHash(record: ProofReviewMeasurement): string;
+export declare function compileProofReviewMeasurement(input: CompileProofReviewMeasurementInput, opts?: {
+    now?: string;
+}): ProofReviewMeasurement;
+export declare const AdapterConformanceReceiptSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    plan_id: z.ZodString;
+    clients: z.ZodArray<z.ZodString>;
+    test: z.ZodObject<{
+        file: z.ZodString;
+        name: z.ZodString;
+        source_hash: z.ZodString;
+    }, z.core.$strict>;
+    runner: z.ZodObject<{
+        name: z.ZodLiteral<"node-test-tsx">;
+        isolation_flag: z.ZodString;
+    }, z.core.$strict>;
+    result: z.ZodEnum<{
+        error: "error";
+        passed: "passed";
+        failed: "failed";
+    }>;
+    exit_code: z.ZodNullable<z.ZodNumber>;
+    selected_event: z.ZodNullable<z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+    }>>;
+    verdict_agreement: z.ZodNullable<z.ZodNumber>;
+    confirmed_private_leaks: z.ZodNullable<z.ZodNumber>;
+    error_code: z.ZodOptional<z.ZodString>;
+    log_hash: z.ZodString;
+    supersedes: z.ZodNullable<z.ZodString>;
+    data_class: z.ZodLiteral<"private">;
+    authority: z.ZodLiteral<"none">;
+    effects: z.ZodLiteral<"diagnostic_only">;
+    writes: z.ZodLiteral<"evidence_receipt_only">;
+    executed_at: z.ZodString;
+}, z.core.$strict>;
+export type AdapterConformanceReceipt = z.infer<typeof AdapterConformanceReceiptSchema>;
+export declare function adapterConformanceContentHash(receipt: AdapterConformanceReceipt): string;
+export declare function compileAdapterConformanceReceipt(input: Omit<AdapterConformanceReceipt, "id" | "content_hash" | "data_class" | "authority" | "effects" | "writes" | "executed_at">, opts?: {
+    now?: string;
+}): AdapterConformanceReceipt;
+export declare function currentG3Plans(records: G3Plan[]): G3Plan[];
+export declare function currentExperimentPreregistrations(records: ExperimentPreregistration[]): ExperimentPreregistration[];
+export declare function currentProofReviewMeasurements(records: ProofReviewMeasurement[]): ProofReviewMeasurement[];
+export declare function currentAdapterConformanceReceipts(records: AdapterConformanceReceipt[]): AdapterConformanceReceipt[];
+export type ScoreBand = "green" | "yellow" | "red" | "unmeasured";
+export interface G3Scorecard {
+    median_review_burden_ms: {
+        value: number | null;
+        band: ScoreBand;
+    };
+    proof_comprehension: {
+        correct: number;
+        total: number;
+        rate: number | null;
+        band: ScoreBand;
+    };
+    required_client_verdict_agreement: {
+        value: number | null;
+        band: ScoreBand;
+    };
+    current_proof_rate: {
+        current: number;
+        selected: number;
+        value: number | null;
+        band: ScoreBand;
+    };
+    confirmed_private_leaks: {
+        value: number | null;
+        band: ScoreBand;
+    };
+    overall: ScoreBand;
+}
+export interface G3PolicyEvidence {
+    policy_id: string;
+    state: string | null;
+    authority_kind: string | null;
+    proof_current: boolean;
+    card_hash: string | null;
+    review_id: string | null;
+    review_duration_ms: number | null;
+    comprehension_correct: boolean | null;
+    reasons: string[];
+}
+export interface G3ReadinessReport {
+    id: string;
+    content_hash: string;
+    gate: "G3";
+    manifest: G3Plan | null;
+    g2_readiness: {
+        id: string;
+        content_hash: string;
+        recommendation: string;
+    };
+    policy_evidence: G3PolicyEvidence[];
+    experiments: Array<{
+        experiment: G3RequiredExperiment;
+        id: string | null;
+        content_hash: string | null;
+        current: boolean;
+        reasons: string[];
+    }>;
+    conformance: AdapterConformanceReceipt | null;
+    scorecard: G3Scorecard;
+    active_blocking_policy_ids: string[];
+    blockers: string[];
+    recommendation: "not_ready" | "eligible_for_human_g3_signoff";
+    authority: "none";
+    g3_passed: false;
+}
+export interface ScoreG3ReadinessInput {
+    manifest: G3Plan | null;
+    g2_readiness: G2ReadinessReport;
+    policy_evidence: G3PolicyEvidence[];
+    experiments: G3ReadinessReport["experiments"];
+    conformance: AdapterConformanceReceipt | null;
+    active_blocking_policy_ids: string[];
+}
+export declare function scoreG3Readiness(input: ScoreG3ReadinessInput): G3ReadinessReport;
+/** Private-only append-only storage for G3 plans, preregistrations, measurements, and conformance. */
+export declare class G3EvidenceRepository {
+    private readonly store;
+    constructor(store: HunchStore);
+    private requirePrivate;
+    listPlans(): G3Plan[];
+    currentPlan(): G3Plan | null;
+    putPlan(plan: G3Plan): G3Plan;
+    listExperiments(): ExperimentPreregistration[];
+    currentExperiments(): ExperimentPreregistration[];
+    putExperiment(spec: ExperimentPreregistration): ExperimentPreregistration;
+    listReviews(): ProofReviewMeasurement[];
+    currentReviews(): ProofReviewMeasurement[];
+    putReview(review: ProofReviewMeasurement): ProofReviewMeasurement;
+    listConformance(): AdapterConformanceReceipt[];
+    currentConformance(): AdapterConformanceReceipt[];
+    putConformance(receipt: AdapterConformanceReceipt): AdapterConformanceReceipt;
+}
+export {};

package/dist/constitution/g3Conformance.d.ts

@@ -0,0 +1,33 @@
+import type { G3Plan, AdapterConformanceReceipt } from "./g3.js";
+export declare const G3_CONFORMANCE_CLIENTS: readonly ["ci", "cli", "mcp"];
+export declare const G3_CONFORMANCE_TEST: {
+    readonly file: "test/behavior-workspace.test.ts";
+    readonly name: "CLI, MCP, and check share one non-blocking working-snapshot receipt without public leakage";
+};
+/** The certifiable client profiles. Each maps a HUMAN-SELECTED client set to the
+ *  ONE executable fixture that exercises every named surface end-to-end and
+ *  asserts receipt equality + zero private leaks. The vscode profile executes the
+ *  extension's real spawn seam (vscode-extension/src/spawnCore.ts) against an
+ *  npm-style shim — naming a client never certifies it; only its fixture does. */
+export declare const G3_CONFORMANCE_PROFILES: readonly [{
+    readonly clients: readonly ["ci", "cli", "mcp"];
+    readonly test: {
+        readonly file: "test/behavior-workspace.test.ts";
+        readonly name: "CLI, MCP, and check share one non-blocking working-snapshot receipt without public leakage";
+    };
+}, {
+    readonly clients: readonly ["ci", "cli", "mcp", "vscode"];
+    readonly test: {
+        readonly file: "test/behavior-workspace.test.ts";
+        readonly name: "CLI, MCP, check, and the VS Code seam share one non-blocking working-snapshot receipt without public leakage";
+    };
+}];
+export declare function g3ConformanceSourceHash(root: string): string;
+/** Execute the real end-to-end fixture matching the plan's human-selected client
+ * profile. Unsupported client sets return an error receipt rather than being
+ * silently treated as equivalent to a certified profile. */
+export declare function executeG3AdapterConformance(root: string, plan: G3Plan, opts?: {
+    timeoutMs?: number;
+    now?: string;
+    supersedes?: string | null;
+}): AdapterConformanceReceipt;

package/dist/constitution/lifecycle.d.ts

@@ -0,0 +1,25 @@
+import { type HistoryDisposition, type PolicyProof, type PolicySpec } from "./schema.js";
+import type { G2BehaviorAttestation } from "./g2BehaviorAttestation.js";
+export declare function blockingEvidenceError(proof: PolicyProof, dispositions?: HistoryDisposition[]): string | null;
+/** Activation is a runtime property, not merely an approval-time check. The
+ * audit fallback keeps correction policies compiled before `origin` was added
+ * fail-closed after they are loaded by the current schema. */
+export declare function activationGateError(policy: PolicySpec): string | null;
+/** Rechecked on every blocking evaluation; a hand-edited lifecycle flag without
+ * a current P3 proof is a configuration error, never authority. */
+export declare function blockingProofError(policy: PolicySpec, proof: PolicyProof | undefined, dispositions?: HistoryDisposition[], composition?: PolicySpec[], currentBehaviorAttestations?: G2BehaviorAttestation[]): string | null;
+export declare function proposeProvedPolicy(policy: PolicySpec, proof: PolicyProof, at: string, composition?: PolicySpec[], currentBehaviorAttestations?: G2BehaviorAttestation[]): PolicySpec;
+export declare function approvePolicy(policy: PolicySpec, proof: PolicyProof, mode: "advisory" | "blocking", actor: string, at: string, dispositions?: HistoryDisposition[], composition?: PolicySpec[], currentBehaviorAttestations?: G2BehaviorAttestation[]): PolicySpec;
+/** Human-authored exception relationship only. It invalidates the child's old
+ * proof/authority; the broad parent remains the separately activated unit. */
+export declare function linkPolicyException(child: PolicySpec, parent: PolicySpec, actor: string, reason: string, at: string): PolicySpec;
+export declare function demotePolicy(policy: PolicySpec, actor: string, reason: string, at: string): PolicySpec;
+/** Targeted advisory withdrawal (the §57 gap): pull the human authority back and
+ *  return the policy to `proposed`. It stops surfacing as an active rule and
+ *  RE-ENTERS the inline escalation loop ("activate or reject?") — the reversible
+ *  half of retirement. History is append-only; nothing is erased. */
+export declare function withdrawPolicy(policy: PolicySpec, actor: string, reason: string, at: string): PolicySpec;
+/** Permanent retirement: the rule is deliberately DONE — it stops surfacing
+ *  anywhere (active rules, escalations) but its full history and audit trail stay
+ *  (supersede-never-erase, HC-08). Closes the valid-time window. */
+export declare function retirePolicy(policy: PolicySpec, actor: string, reason: string, at: string): PolicySpec;

package/dist/constitution/mutation.d.ts

@@ -0,0 +1,15 @@
+import { type GraphSnapshot } from "./evaluator.js";
+import { type MutationReceipt, type PolicyEvaluation, type PolicySpec, type ProofPlan } from "./schema.js";
+type PlannedMutation = ProofPlan["mutations"][number];
+export interface MutationHarnessResult {
+    receipts: MutationReceipt[];
+    primary_evaluations: PolicyEvaluation[];
+}
+/** Execute only canonical evaluator/parser mutations. Project scripts, builds,
+ * tests, models, and providers are deliberately outside this evidence path. */
+export declare function runMutationHarness(root: string, policy: PolicySpec, base: GraphSnapshot, planned: PlannedMutation[], opts?: {
+    policyHash?: string;
+    mutationPolicy?: PolicySpec;
+    evaluate?: (snapshot: GraphSnapshot) => PolicyEvaluation;
+}): MutationHarnessResult;
+export {};

package/dist/constitution/nodeTestEvidence.d.ts

@@ -0,0 +1,13 @@
+export declare const NODE_TEST_REPORTER_PROTOCOL = "hunch-node-test-reporter-v1";
+export declare const NODE_TEST_REPORTER_SOURCE = "export default async function* hunchReporter(source) {\n  for await (const event of source) {\n    if (event.type !== \"test:pass\" && event.type !== \"test:fail\") continue;\n    yield JSON.stringify({\n      protocol: \"hunch-node-test-reporter-v1\",\n      type: event.type,\n      name: event.data.name,\n      nesting: event.data.nesting,\n      skip: event.data.skip ?? null,\n      todo: event.data.todo ?? null\n    }) + \"\\n\";\n  }\n}\n";
+export interface NodeTestReporterEvent {
+    protocol: typeof NODE_TEST_REPORTER_PROTOCOL;
+    type: "test:pass" | "test:fail";
+    name: string;
+    nesting?: number;
+    skip: string | boolean | null;
+    todo: string | boolean | null;
+}
+export declare function exactNodeTestPattern(name: string): string;
+export declare function nodeTestIsolationFlag(): string;
+export declare function nodeTestReporterEvents(output: string): NodeTestReporterEvent[];

package/dist/constitution/plan.d.ts

@@ -0,0 +1,18 @@
+import type { HunchStore } from "../store/hunchStore.js";
+import type { PolicyRepository } from "./repository.js";
+export { canonicalStaticGraphBaseline } from "./staticGraphBaseline.js";
+import { type PolicySpec, type ProofPlan } from "./schema.js";
+export interface ProofPlanOptions {
+    maxCommits?: number;
+    maxMutations?: number;
+    maxMinutes?: number;
+    now?: string;
+    publicOnly?: boolean;
+    privateOnly?: boolean;
+    composition?: PolicySpec[];
+    /** Optional stable artifact label for worktree-agnostic materializers. */
+    repositoryName?: string;
+}
+/** Deterministic compiler-to-harness contract. It plans replay and mutations but
+ * executes neither, grants no authority, and performs no provider/model call. */
+export declare function createProofPlan(store: HunchStore, root: string, repository: PolicyRepository, policy: PolicySpec, opts?: ProofPlanOptions): ProofPlan;

package/dist/constitution/policyRuntime.d.ts

@@ -0,0 +1,5 @@
+import { BEHAVIOR_MUTATION_ENGINE, BEHAVIOR_POLICY_EVALUATOR, MUTATION_ENGINE, POLICY_EVALUATOR, type PolicySpec } from "./schema.js";
+export type PolicyEvaluatorIdentity = typeof POLICY_EVALUATOR | typeof BEHAVIOR_POLICY_EVALUATOR;
+export type PolicyMutationEngineIdentity = typeof MUTATION_ENGINE | typeof BEHAVIOR_MUTATION_ENGINE;
+export declare function evaluatorForPolicy(policy: PolicySpec): PolicyEvaluatorIdentity;
+export declare function mutationEngineForPolicy(policy: PolicySpec): PolicyMutationEngineIdentity;

package/dist/constitution/proof.d.ts

@@ -0,0 +1,11 @@
+import { type PolicyProof, type PolicySpec, type ProofPlan } from "./schema.js";
+import type { HunchStore } from "../store/hunchStore.js";
+/** Inward proof execution. A canonical plan uses immutable disposable replay
+ * snapshots; the no-plan fallback preserves the original Gate-G1 current graph
+ * plus one deterministic mutation behavior. */
+export declare function provePolicy(store: HunchStore, root: string, policy: PolicySpec, opts?: {
+    publicOnly?: boolean;
+    now?: string;
+    plan?: ProofPlan;
+    composition?: PolicySpec[];
+}): PolicyProof;

package/dist/constitution/repairPolicies.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Policy binding self-repair (Phase 5 slice 2). Same zero-guessing contract as
+ * core/repair.ts: git-confirmed renames only, EXACT matches only.
+ *
+ * Repairable bindings:
+ *   - scope.paths entries that are exact paths (globs are scope-intent, untouched);
+ *   - `symbol:<file>:<name>` selector file parts (mirrors evaluator.ts's
+ *     lastIndexOf(":") parse exactly); bare `symbol:<name>`, `symbol-id:`,
+ *     `external:` and component selectors carry no file identity and are untouched.
+ *
+ * Deliberately NOT repairable: executable-behavior test pins. Their file path is
+ * hash-pinned to a source_commit where the OLD path exists — rewriting the path
+ * would silently break the pin. A renamed pinned test needs re-attestation, which
+ * is a human/evidence act, not a repair.
+ *
+ * A repaired policy gets revision+1 and a system-actor "repaired" audit event.
+ * Its authority is NOT touched: the existing proof-hash revalidation already
+ * fails blocking safe when semantics moved under a stale proof, and the repaired
+ * policy surfaces as an inline escalation asking for a re-prove.
+ */
+import type { PolicySpec } from "./schema.js";
+import type { RenamePair } from "../core/repair.js";
+export interface PolicyBindingRewrite {
+    id: string;
+    field: "scope.paths" | "assertion.selector";
+    from: string;
+    to: string;
+}
+/** Live policies only — a superseded/retired/rejected policy's history stays as
+ *  written. Returns the rewrites; empty when the renames touch nothing exactly. */
+export declare function planPolicyRepair(renames: readonly RenamePair[], policies: readonly PolicySpec[]): PolicyBindingRewrite[];
+/** Apply a policy's rewrites (pure): revision+1, system-actor audit, updated_at.
+ *  Returns the original reference when nothing in the plan touches this policy. */
+export declare function repairPolicySpec(policy: PolicySpec, rewrites: readonly PolicyBindingRewrite[], at: string): PolicySpec;

package/dist/constitution/replacementFreeGit.d.ts

@@ -0,0 +1,14 @@
+import { type CommitMeta } from "../extractors/git.js";
+/** Constitution proof identity is the repository's real object graph, never a
+ * clone-local `refs/replace/*` or legacy graft view. Keep this environment
+ * private to proof planning so every traversal and ancestry check agrees with
+ * replay, which uses the same Git invariant. */
+export declare function replacementFreeGitEnvironment(source?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/** Resolve one commit-ish through the real object graph. */
+export declare function replacementFreeExactCommit(root: string, ref: string): string | null;
+/** Files changed by an exact commit, ignoring local replacement objects. */
+export declare function replacementFreeCommitFiles(root: string, commit: string): string[];
+export declare function replacementFreeCommitMeta(root: string, commit: string): CommitMeta | null;
+/** Exact introducing commit for a Git-native policy record. */
+export declare function replacementFreeFirstCommitForFile(root: string, file: string): string;
+export declare function replacementFreeIsAncestorOrSame(root: string, ancestor: string, descendant: string): boolean;

package/dist/constitution/replay.d.ts

@@ -0,0 +1,40 @@
+import { type GraphSnapshot } from "./evaluator.js";
+import { type PolicySpec, type ProofPlan, type ReplayReceipt } from "./schema.js";
+export type ReplayLeg = ReplayReceipt["leg"];
+export interface ProofReplayResult {
+    current: ReplayReceipt;
+    known_bad: ReplayReceipt[];
+    known_good: ReplayReceipt[];
+    accepted_history: ReplayReceipt[];
+    replay_receipts: ReplayReceipt[];
+    selected_history_commits: string[];
+    history_complete: boolean;
+    cache_stats: {
+        hits: number;
+        misses: number;
+        rebuilds: number;
+        memory_hits: number;
+    };
+    worker_stats: {
+        limit: number;
+        peak: number;
+        scheduled: number;
+    };
+    current_snapshot?: GraphSnapshot;
+}
+export interface ReplayExecutionOptions {
+    /** Operational scheduling only; never enters canonical proof semantics. */
+    maxWorkers?: number;
+    composition?: PolicySpec[];
+}
+export declare const DEFAULT_REPLAY_WORKERS = 4;
+export declare const MAX_REPLAY_WORKERS = 8;
+export declare function replaySafeEnvironment(home: string, gitConfig: string): NodeJS.ProcessEnv;
+export declare function hasUnsafeReplayFilter(root: string, env: NodeJS.ProcessEnv): boolean;
+export declare function replayGitArgs(root: string, hooks: string, args: string[]): string[];
+export declare function cleanupReplayWorktree(root: string, hooks: string, env: NodeJS.ProcessEnv, run: string, checkout: string): boolean;
+/** Execute an immutable ProofPlan with the current in-process static evaluator.
+ * Repository hooks, user-global Git configuration, overlay discovery, project
+ * scripts, provider calls, and project tests are outside this path. Every
+ * disposable worktree and derived graph is removed in a finally block. */
+export declare function replayProofPlan(root: string, policy: PolicySpec, inputPlan: ProofPlan, opts?: ReplayExecutionOptions): ProofReplayResult;

package/dist/constitution/replayCache.d.ts

@@ -0,0 +1,14 @@
+import { type GraphSnapshot } from "./evaluator.js";
+import { type DataClass } from "./schema.js";
+export declare const REPLAY_CACHE_ENGINE: {
+    readonly name: "hunch-tsjs-static-index";
+    readonly version: "4";
+};
+export type ReplayCacheStatus = "hit" | "miss" | "invalid";
+export declare function replayCacheKey(commit: string, dataClass: DataClass, engineVersion?: "4"): string;
+export declare function replayCacheFile(root: string, commit: string, dataClass: DataClass, engineVersion?: "4"): string;
+export declare function loadReplaySnapshot(root: string, commit: string, dataClass: DataClass, engineVersion?: "4"): {
+    status: ReplayCacheStatus;
+    snapshot?: GraphSnapshot;
+};
+export declare function putReplaySnapshot(root: string, snapshot: GraphSnapshot, dataClass: DataClass, engineVersion?: "4"): string;

package/dist/constitution/replayWorker.d.ts

@@ -0,0 +1 @@
+export {};