@davesheffer/hunch 1.31.1 → 1.32.1

package/dist/core/stateDelivery.d.ts

@@ -0,0 +1,78 @@
+/**
+ * nuryel.state/1 — search and delivery of the five state kinds (receipts, commitments,
+ * derived, entities, relationships). Registered in 1.25 as store kinds, they were stored and
+ * counted but neither indexed nor delivered: `hunch_query("customer:Site:7")` could not surface
+ * a current summary, an open commitment or a verified receipt, and `hunch_context` had no
+ * "State" section. This module is the single place that says, per kind:
+ *
+ *   - what text goes into the `search` FTS row (subject + content/title + actor + status, so a
+ *     subject id and a human phrase both hit),
+ *   - whether a record is LIVE (current / in_force / verified…) or HISTORY (superseded, done,
+ *     cancelled, failed, retired) — history stays indexed and findable, it only ranks below,
+ *   - the one-line render every reader gets (`[commitment/in_force] customer:Site:7 — …`),
+ *   - the bounded, deterministically ordered "State" supplements for a context brief.
+ *
+ * Pure functions over records; no store or SQLite dependency, so the CLI, the MCP server and
+ * the store's own reindex/rank paths cannot drift from each other.
+ */
+import type { ActionReceipt, Commitment, DerivedState, ExternalEntity, StateRelationship } from "./stateRecords.js";
+import type { DeliverySupplement } from "./delivery.js";
+export declare const STATE_KINDS: readonly ["receipts", "commitments", "derived", "entities", "relationships"];
+export type StateKind = (typeof STATE_KINDS)[number];
+export declare function isStateKind(kind: string): kind is StateKind;
+export type StateRecord = ActionReceipt | Commitment | DerivedState | ExternalEntity | StateRelationship;
+export interface StateLiveness {
+    /** The contract's own word for the record's standing: current, in_force, verified, done, superseded … */
+    label: string;
+    /** True when the record is the state of record NOW; false for history (still indexed, ranked below). */
+    live: boolean;
+}
+/** Liveness per kind, mirroring readState's state_of_record predicates exactly
+ *  (derived `current` with an open window; commitment open/waiting with an open window;
+ *  receipt succeeded/verified; entity active; a relationship is always current). */
+export declare function stateLiveness(kind: StateKind, record: StateRecord): StateLiveness;
+/** The subject key a reader would type: the commitment/derived subject, the receipt's target
+ *  object (`event:10042`), the entity id, or the relationship's `from` endpoint. */
+export declare function stateSubject(kind: StateKind, record: StateRecord): string;
+/** The instant that orders "latest first": computed_at, valid_from, verified_at ?? occurred_at,
+ *  updated_at. Relationships carry no clock and sort last among equals. */
+export declare function stateObservedAt(kind: StateKind, record: StateRecord): string;
+/** The FTS document for a state record: title = the subject key (so an id query hits the
+ *  title column, which the snippet and LIKE fallback both prefer), body = the human words plus
+ *  the actor/owner, the status label and the dates. Every reader's query — a subject id, a
+ *  phrase from a summary, an action kind, a principal — lands on one of these. */
+export declare function stateSearchDoc(kind: StateKind, record: StateRecord): {
+    title: string;
+    body: string;
+};
+/** The one-line render shared by hunch_query, `hunch query` and the context "State" section:
+ *    [commitment/in_force] customer:Site:7 — "send report" due 2026-09-11 (owner sofia)
+ *    [derived/current] customer:Site:7 — <first 120 chars of the summary>
+ *    [receipt/verified] event:10042 — events_add_actions by sofia@david 2026-09-08 */
+export declare function renderStateLine(kind: StateKind, record: StateRecord): string;
+/** One ranked state hit, as the store's stateSlice() returns it. `score` is the search
+ *  score (bm25: lower is better; 0 for the LIKE fallback and exact-subject matches). */
+export interface StateHit<K extends StateKind = StateKind> {
+    kind: K;
+    record: StateRecord;
+    score: number;
+}
+/** Bounded caps for the context "State" section: current derived, in-force commitments,
+ *  latest receipts. Deliberately small — a brief, not a dump; `nuryel_read` is the full view. */
+export declare const STATE_SLICE_CAPS: {
+    readonly derived: 3;
+    readonly commitments: 5;
+    readonly receipts: 3;
+};
+export interface StateSlice {
+    derived: StateHit<"derived">[];
+    commitments: StateHit<"commitments">[];
+    receipts: StateHit<"receipts">[];
+}
+/** Deterministic order for a state slice: score (best first), then observed_at DESC (latest
+ *  first), then id ASC. Applied after liveness filtering, before the cap. */
+export declare function compareStateHits(a: StateHit, b: StateHit): number;
+/** Render a state slice as delivery supplements (one header + one line per record) so the
+ *  section shares the context brief's hard budget and receipt like every other grounding.
+ *  Empty slice → no supplements at all: a store with zero state records is byte-identical. */
+export declare function stateSupplements(slice: StateSlice, target: string): DeliverySupplement[];

package/dist/core/stateRecords.d.ts

@@ -0,0 +1,383 @@
+/**
+ * nuryel.state/1 — the RECORD schemas (the facets that are new record kinds in the store).
+ *
+ * Kept separate from stateContract.ts (verbs, invariants, hashing) because the store's kind
+ * registry in types.ts must reference these schemas, and stateContract imports types.ts —
+ * this module imports only zod, the id helpers and the provenance leaf, so there is no cycle.
+ *
+ * Facets here: done (ActionReceipt), committed (Commitment), current (DerivedState with
+ * mandatory dependencies), entity / relationship (external, Landscape-shaped), plus the
+ * credential-free ExternalRef ("changed") and DependencyRef they share. Scope is the one
+ * graph's partition: organization › team › user › repository.
+ */
+import { z } from "zod";
+import { edgeId, resourceId } from "./ids.js";
+export declare const RECEIPT_SCHEMA_VERSION: "nuryel.receipt/1";
+export declare const COMMITMENT_SCHEMA_VERSION: "nuryel.commitment/1";
+export declare const DERIVED_SCHEMA_VERSION: "nuryel.derived/1";
+export declare const ENTITY_SCHEMA_VERSION: "nuryel.entity/1";
+export declare const RELATIONSHIP_SCHEMA_VERSION: "nuryel.relationship/1";
+/** organization › team › user › repository — partitions of ONE graph, not separate stores. */
+export declare const SCOPE_KINDS: readonly ["organization", "team", "user", "repository"];
+export declare const ScopeSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        repository: "repository";
+        organization: "organization";
+        team: "team";
+        user: "user";
+    }>;
+    id: z.ZodString;
+}, z.core.$strict>;
+export type Scope = z.infer<typeof ScopeSchema>;
+export declare const scopePath: (scope: Scope) => string;
+/** "What changed" and "where this came from": a credential-free pointer to an object that
+ *  stays authoritative in its own system. Nuryel never mirrors its content. */
+export declare const ExternalRefSchema: z.ZodObject<{
+    system: z.ZodString;
+    object_type: z.ZodString;
+    object_key: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    content_hash: z.ZodOptional<z.ZodString>;
+    observed_at: z.ZodString;
+    locator: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ExternalRef = z.infer<typeof ExternalRefSchema>;
+/** The external system's own key, canonicalized so two writers that copied it from the same
+ *  system agree byte for byte: Unicode NFC, trimmed, internal whitespace collapsed. Case is
+ *  preserved — the key belongs to the external system, and folding it could merge two of its
+ *  records. No other guessing: identity here is explicit refs, never similarity. */
+export declare function canonicalObjectKey(key: string): string;
+/** The identity of an external record across writers: system, type and canonical key. Two
+ *  entities in one partition that carry the same external key are the same thing. */
+export declare function externalKey(ref: Pick<ExternalRef, "system" | "object_type" | "object_key">): string;
+/** The subject an external record is known by, the convention the read verb already uses for
+ *  receipts (`event:26904`): the object type and the canonical key. When an entity in the
+ *  partition carries the ref, that entity's id is the subject and this form resolves to it. */
+export declare function subjectOfRef(ref: Pick<ExternalRef, "object_type" | "object_key">): string;
+/** What a derived statement rests on. Exactly what a currentness check re-validates. */
+export declare const DependencyRefSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"record">;
+    id: z.ZodString;
+    record_hash: z.ZodString;
+    scope: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"external">;
+    ref: z.ZodObject<{
+        system: z.ZodString;
+        object_type: z.ZodString;
+        object_key: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        content_hash: z.ZodOptional<z.ZodString>;
+        observed_at: z.ZodString;
+        locator: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"schema">;
+    name: z.ZodString;
+    fingerprint: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type DependencyRef = z.infer<typeof DependencyRefSchema>;
+/** done — a side effect that happened. Never replayable as a read; idempotency is explicit. */
+export declare const ActionReceiptSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.receipt/1">;
+    id: z.ZodString;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    actor: z.ZodString;
+    action_kind: z.ZodString;
+    target: z.ZodObject<{
+        system: z.ZodString;
+        object_type: z.ZodString;
+        object_key: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        content_hash: z.ZodOptional<z.ZodString>;
+        observed_at: z.ZodString;
+        locator: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    request_fingerprint: z.ZodString;
+    idempotency_key: z.ZodOptional<z.ZodString>;
+    state: z.ZodEnum<{
+        unknown: "unknown";
+        requested: "requested";
+        succeeded: "succeeded";
+        failed: "failed";
+        verified: "verified";
+    }>;
+    occurred_at: z.ZodString;
+    verified_at: z.ZodOptional<z.ZodString>;
+    result_fingerprint: z.ZodOptional<z.ZodString>;
+    invalidates: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    rests_on: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"record">;
+        id: z.ZodString;
+        record_hash: z.ZodString;
+        scope: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"external">;
+        ref: z.ZodObject<{
+            system: z.ZodString;
+            object_type: z.ZodString;
+            object_key: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            content_hash: z.ZodOptional<z.ZodString>;
+            observed_at: z.ZodString;
+            locator: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"schema">;
+        name: z.ZodString;
+        fingerprint: z.ZodString;
+    }, z.core.$strict>], "kind">>>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type ActionReceipt = z.infer<typeof ActionReceiptSchema>;
+/** committed — an obligation with a due date and an in-force window. */
+export declare const CommitmentSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.commitment/1">;
+    id: z.ZodString;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    subject: z.ZodString;
+    title: z.ZodString;
+    owner: z.ZodString;
+    due: z.ZodString;
+    status: z.ZodEnum<{
+        open: "open";
+        waiting: "waiting";
+        done: "done";
+        cancelled: "cancelled";
+    }>;
+    source: z.ZodOptional<z.ZodObject<{
+        system: z.ZodString;
+        object_type: z.ZodString;
+        object_key: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        content_hash: z.ZodOptional<z.ZodString>;
+        observed_at: z.ZodString;
+        locator: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    evidence_excerpt: z.ZodOptional<z.ZodString>;
+    closed_by: z.ZodOptional<z.ZodString>;
+    valid_from: z.ZodString;
+    valid_to: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type Commitment = z.infer<typeof CommitmentSchema>;
+/** current — a statement that is true now, and on what it rests. Dependencies are mandatory:
+ *  a derived statement without them cannot be invalidated and therefore cannot be trusted. */
+export declare const DerivedStateSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.derived/1">;
+    id: z.ZodString;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    subject: z.ZodString;
+    content: z.ZodString;
+    content_hash: z.ZodString;
+    dependencies: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"record">;
+        id: z.ZodString;
+        record_hash: z.ZodString;
+        scope: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"external">;
+        ref: z.ZodObject<{
+            system: z.ZodString;
+            object_type: z.ZodString;
+            object_key: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            content_hash: z.ZodOptional<z.ZodString>;
+            observed_at: z.ZodString;
+            locator: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"schema">;
+        name: z.ZodString;
+        fingerprint: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    transform_version: z.ZodString;
+    computed_at: z.ZodString;
+    valid_to: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    state: z.ZodEnum<{
+        unknown: "unknown";
+        current: "current";
+        stale: "stale";
+    }>;
+    review: z.ZodOptional<z.ZodObject<{
+        by: z.ZodString;
+        at: z.ZodString;
+        previous_hash: z.ZodString;
+        reason: z.ZodString;
+        evidence: z.ZodArray<z.ZodObject<{
+            ref: z.ZodObject<{
+                system: z.ZodString;
+                object_type: z.ZodString;
+                object_key: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+                content_hash: z.ZodOptional<z.ZodString>;
+                observed_at: z.ZodString;
+                locator: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            excerpt: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type DerivedState = z.infer<typeof DerivedStateSchema>;
+/** entity — a customer, an incident, a thread: a non-code node, Landscape-shaped (kind-qualified
+ *  id, lifecycle, provenance), with provenance pointers instead of mirrored content. Stored in
+ *  an index file, like resources, because kind-qualified ids are not safe file names. */
+export declare const ExternalEntitySchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.entity/1">;
+    id: z.ZodString;
+    kind: z.ZodString;
+    name: z.ZodString;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    refs: z.ZodArray<z.ZodObject<{
+        system: z.ZodString;
+        object_type: z.ZodString;
+        object_key: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        content_hash: z.ZodOptional<z.ZodString>;
+        observed_at: z.ZodString;
+        locator: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+    lifecycle: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        deprecated: "deprecated";
+        retired: "retired";
+    }>>;
+    merged_into: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strict>;
+export type ExternalEntity = z.infer<typeof ExternalEntitySchema>;
+/** relationship — rides the same identity rule as the graph's edges. Index-file stored. */
+export declare const StateRelationshipSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.relationship/1">;
+    id: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    type: z.ZodString;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    reason: z.ZodDefault<z.ZodString>;
+    observation_hash: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodOptional<z.ZodObject<{
+        system: z.ZodString;
+        object_type: z.ZodString;
+        object_key: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        content_hash: z.ZodOptional<z.ZodString>;
+        observed_at: z.ZodString;
+        locator: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    lifecycle: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        retired: "retired";
+    }>>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type StateRelationship = z.infer<typeof StateRelationshipSchema>;
+/** DNA facet: existing Project DNA profiles, keyed by scope. No new schema — the reference only. */
+export declare const DnaFacetRefSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"hunch.project-dna/1">;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    profile_id: z.ZodString;
+}, z.core.$strict>;
+export declare const entityId: typeof resourceId;
+export declare const relationshipId: typeof edgeId;

package/dist/core/stats.d.ts

@@ -0,0 +1,88 @@
+/** `hunch stats` — the ONE data contract (dec_6253f7e6d6). A pure aggregation over
+ *  the graph Hunch already builds plus the append-only catch-log (core/events.ts):
+ *  STOCK (what's accumulated) → RETURN (what that stock caught) → COMPOUNDING (the
+ *  ratio that should climb). Every surface — CLI receipt, VS Code extension, the
+ *  public proof-curve — is a read-only pane of glass over this object; if a number
+ *  can't come from here it doesn't exist.
+ *
+ *  HONESTY (the red-team baked into the decision): nothing here fabricates a number
+ *  the live graph can't produce. `coverage.pct` is 0 until decisions actually carry
+ *  `related_components`; `bugs_reprevented` is 0 until a bug reaches `regressed`;
+ *  catches come only from real gate events, never a hypothetical. A skeptic running
+ *  this on a young graph SHOULD see zeros — that's the honest state, not a bug. */
+import type { Bug, Constraint, Decision } from "./types.js";
+import type { HunchEvent } from "./events.js";
+export interface StatsInput {
+    decisions: Decision[];
+    constraints: Constraint[];
+    bugs: Bug[];
+    /** Component ids in the graph (for coverage = decisions-touching ÷ total). */
+    componentIds: string[];
+    runbooksCount: number;
+    events: HunchEvent[];
+    /** Count of constraints whose guarded code moved since last verified (from the
+     *  store's staleness walk — passed in so this module stays pure). */
+    staleConstraints: number;
+    /** ms epoch "now" and the start of the recent window (now − since). */
+    now: number;
+    windowStart: number;
+    windowLabel: string;
+}
+export interface StatsReturn {
+    violations_caught: number;
+    drifts_flagged: number;
+    bugs_reprevented: number;
+    vetoes_fired: number;
+}
+export interface Stats {
+    schema: "hunch.stats/1";
+    generated_at: string;
+    window: {
+        since: string;
+        from: string;
+        to: string;
+    };
+    stock: {
+        decisions: {
+            total: number;
+            accepted: number;
+            superseded: number;
+            proposed: number;
+            rejected: number;
+        };
+        invariants: {
+            total: number;
+            locked: number;
+            advisory: number;
+            stale: number;
+        };
+        components: number;
+        bugs: {
+            total: number;
+            open: number;
+            investigating: number;
+            fixed: number;
+            regressed: number;
+        };
+        runbooks: number;
+        coverage: {
+            components_with_decision: number;
+            components_total: number;
+            pct: number;
+        };
+    };
+    return: {
+        window: StatsReturn;
+        lifetime: StatsReturn;
+    };
+    compounding: {
+        rules_recorded: number;
+        catches_lifetime: number;
+        payback_ratio: number;
+    };
+}
+export declare function computeStats(input: StatsInput): Stats;
+/** Human-readable receipt for the terminal (the CLI's default, non-`--json` output).
+ *  Same three blocks as the JSON: stock → return → compounding. Honest zeros are
+ *  shown plainly, never hidden — a young graph reads as young, not as broken. */
+export declare function formatStats(s: Stats): string;

package/dist/core/strictgate.d.ts

@@ -0,0 +1,33 @@
+export declare const STRICT_MIN_CONFIDENCE = 0.8;
+/** Is a provenance source HUMAN-CONFIRMED? Token-aware, so a composite source like
+ *  "llm_draft+human_confirmed" counts, but a lookalike ("not_human_confirmed",
+ *  "human_confirmed_pending") does not. The sources Hunch writes are "+"-joined. */
+export declare function isHumanConfirmed(source: string | undefined): boolean;
+export interface StrictConstraint {
+    severity?: string;
+    provenance?: {
+        confidence?: number;
+        source?: string;
+    };
+}
+/** May this invariant FAIL a commit under --strict? Requires blocking severity,
+ *  a fresh (non-stale) record, and either high provenance confidence or a
+ *  human-confirmed source (a person vouched for it). Near/blast-radius hits never
+ *  reach here — the caller passes only directly-scoped invariants. */
+export declare function isStrictBlocker(c: StrictConstraint, stale: boolean): boolean;
+export type VetoTier = "dep" | "symbol" | "pattern" | "semantic";
+/** May a VETO fail a commit? Sibling of isStrictBlocker, but keys on the TRIPWIRE's
+ *  trust — not the rejecting decision's — and uses ONE rule for every tier: only a
+ *  `human_confirmed` tripwire blocks. An llm_draft tripwire never blocks regardless
+ *  of confidence (an LLM self-score is not a licence to fail a commit); it only
+ *  warns. Semantic similarity never blocks. In-force + non-stale gates run first.
+ *  This is what makes the "day-one is advisory" DX true (dec_a466655539). */
+export declare function isVetoBlocker(d: {
+    status?: string;
+    superseded_by?: string | null;
+    valid_to?: string | null;
+}, tw: {
+    provenance?: {
+        source?: string;
+    };
+}, tier: VetoTier, stale: boolean): boolean;