@davesheffer/hunch 1.31.1 → 1.32.1

package/dist/constitution/repository.d.ts

@@ -0,0 +1,129 @@
+import type { HunchStore } from "../store/hunchStore.js";
+import { type EvidenceEvent, type HistoryDisposition, type ProofCorpus, type PolicyProof, type ProofPlan, type PolicySpec, type ShadowDisposition, type ShadowEvaluationRecord } from "./schema.js";
+/** Git-native policy/proof source of truth. Kept separate from the legacy entity
+ * registry for the first slice so existing schema-v2 repositories and SQLite
+ * compatibility remain unchanged. */
+export declare class PolicyRepository {
+    private readonly store;
+    private readonly publicHome;
+    private readonly privateHome?;
+    constructor(root: string, store: HunchStore);
+    private dir;
+    private policiesIn;
+    private proofsIn;
+    private evidenceIn;
+    private plansIn;
+    private corporaIn;
+    private dispositionsIn;
+    private shadowIn;
+    listPolicies(opts?: {
+        publicOnly?: boolean;
+        privateOnly?: boolean;
+    }): PolicySpec[];
+    getPolicy(id: string, opts?: {
+        publicOnly?: boolean;
+        privateOnly?: boolean;
+    }): PolicySpec | undefined;
+    getProof(id: string, opts?: {
+        publicOnly?: boolean;
+        privateOnly?: boolean;
+    }): PolicyProof | undefined;
+    listProofs(opts?: {
+        publicOnly?: boolean;
+        privateOnly?: boolean;
+    }): PolicyProof[];
+    listPlans(opts?: {
+        publicOnly?: boolean;
+        privateOnly?: boolean;
+    }): ProofPlan[];
+    getPlan(id: string, opts?: {
+        publicOnly?: boolean;
+        privateOnly?: boolean;
+    }): ProofPlan | undefined;
+    getCorpus(policyId: string, opts?: {
+        publicOnly?: boolean;
+        privateOnly?: boolean;
+    }): ProofCorpus | undefined;
+    listCorpora(opts?: {
+        publicOnly?: boolean;
+        privateOnly?: boolean;
+    }): ProofCorpus[];
+    listEvidence(opts?: {
+        publicOnly?: boolean;
+        privateOnly?: boolean;
+    }): EvidenceEvent[];
+    getEvidence(id: string, opts?: {
+        publicOnly?: boolean;
+        privateOnly?: boolean;
+    }): EvidenceEvent | undefined;
+    listDispositions(opts?: {
+        publicOnly?: boolean;
+        privateOnly?: boolean;
+    }): HistoryDisposition[];
+    listShadowEvaluations(opts?: {
+        publicOnly?: boolean;
+        privateOnly?: boolean;
+    }): ShadowEvaluationRecord[];
+    listShadowDispositions(opts?: {
+        publicOnly?: boolean;
+        privateOnly?: boolean;
+    }): ShadowDisposition[];
+    homeOfPolicy(id: string): "public" | "private" | undefined;
+    putPolicy(policy: PolicySpec, opts?: {
+        private?: boolean;
+    }): PolicySpec;
+    /** Publish a new policy lifecycle record without overwriting a concurrent
+     * writer. Used by automated proposal materializers so human authority always
+     * wins a race. */
+    putPolicyIfAbsent(policy: PolicySpec, opts?: {
+        private?: boolean;
+        public?: boolean;
+    }): {
+        policy: PolicySpec;
+        created: boolean;
+    };
+    putProof(proof: PolicyProof, policyId: string, opts?: {
+        private?: boolean;
+        public?: boolean;
+    }): PolicyProof;
+    /** Publish an immutable proof without replacing a concurrent writer. */
+    putProofIfAbsent(proof: PolicyProof, policyId: string, opts?: {
+        private?: boolean;
+        public?: boolean;
+    }): {
+        proof: PolicyProof;
+        created: boolean;
+    };
+    putPlan(plan: ProofPlan, policyId: string, opts?: {
+        private?: boolean;
+        public?: boolean;
+    }): ProofPlan;
+    /** Publish an immutable proof plan without replacing a concurrent writer. */
+    putPlanIfAbsent(plan: ProofPlan, policyId: string, opts?: {
+        private?: boolean;
+        public?: boolean;
+    }): {
+        plan: ProofPlan;
+        created: boolean;
+    };
+    putCorpus(corpus: ProofCorpus, policyId: string): ProofCorpus;
+    putEvidence(event: EvidenceEvent, opts?: {
+        private?: boolean;
+        public?: boolean;
+    }): EvidenceEvent;
+    putDisposition(disposition: HistoryDisposition, policyId: string): HistoryDisposition;
+    putShadowEvaluation(evaluation: ShadowEvaluationRecord, policyId: string): ShadowEvaluationRecord;
+    putShadowDisposition(disposition: ShadowDisposition, policyId: string): ShadowDisposition;
+}
+/** One-time private migration for the Constitution's standalone Git-native
+ * records. Copy/validate everything before deleting the public directories;
+ * private records win on an id collision. */
+export declare function movePolicyArtifactsToPrivate(publicHunchDir: string, privateHunchDir: string): {
+    policies: number;
+    proofs: number;
+    plans: number;
+    evidence: number;
+    corpora: number;
+    dispositions: number;
+    shadow: number;
+};

package/dist/constitution/safeCheckout.d.ts

@@ -0,0 +1,9 @@
+/** Inspect the exact target tree plus repository-local info attributes without
+ * checking it out. Any checkout transform could execute code or make the worktree
+ * bytes diverge from the raw blobs bound by receipts, so fail closed. Merge
+ * attributes are intentionally excluded: worktree materialization never invokes a
+ * merge driver. LFS is allowed only when callers explicitly disable its
+ * smudge/process hooks. */
+export declare function hasUnsafeCheckoutAttributes(root: string, commit: string, env: NodeJS.ProcessEnv, opts?: {
+    allowDisabledLfs?: boolean;
+}): boolean;