audit-tools 0.51.7 → 0.51.9

package/dist/shared/types/charter.d.ts

@@ -121,13 +121,13 @@ export declare const GoalNodeSchema: z.ZodObject<{
     premise_height: z.ZodNumber;
     statement: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    statement: string;
     node_id: string;
     premise_height: number;
-}, {
     statement: string;
+}, {
     node_id: string;
     premise_height: number;
+    statement: string;
 }>;
 export type GoalNode = z.infer<typeof GoalNodeSchema>;
 /**
@@ -152,13 +152,13 @@ export declare const GoalGraphSchema: z.ZodObject<{
         premise_height: z.ZodNumber;
         statement: z.ZodString;
     }, "strict", z.ZodTypeAny, {
-        statement: string;
         node_id: string;
         premise_height: number;
-    }, {
         statement: string;
+    }, {
         node_id: string;
         premise_height: number;
+        statement: string;
     }>, "many">;
     edges: z.ZodArray<z.ZodObject<{
         from: z.ZodString;
@@ -172,9 +172,9 @@ export declare const GoalGraphSchema: z.ZodObject<{
     }>, "many">;
 }, "strict", z.ZodTypeAny, {
     nodes: {
-        statement: string;
         node_id: string;
         premise_height: number;
+        statement: string;
     }[];
     edges: {
         from: string;
@@ -182,9 +182,9 @@ export declare const GoalGraphSchema: z.ZodObject<{
     }[];
 }, {
     nodes: {
-        statement: string;
         node_id: string;
         premise_height: number;
+        statement: string;
     }[];
     edges: {
         from: string;
@@ -213,173 +213,656 @@ export declare const CeilingSchema: z.ZodObject<{
 }>;
 export type Ceiling = z.infer<typeof CeilingSchema>;
 /**
- * A routed pairwise charter delta — the product of the overlay-and-delta operator at
- * the charter layer (produced in Phase C). `pair` is a SYMMETRIC tuple of the two
- * charter kinds compared: the design forbids anointing any single estimator as
- * ground truth, so a delta is never modeled as `{ from: stated, to: X }`. Each
- * channel PAIR has one defined meaning; `routed_to` names who acts on it (a
- * low-confidence side forces `human` regardless of kind — gateCharterDelta):
- * - `doc_rot` (stated ↔ structural: testimony vs organization — doc rot / naming
- *   drift) → `remediator`.
- * - `says_does_drift` (stated ↔ revealed: testimony vs behavior) → `remediator`.
- * - `architecture_betrayal` (structural ↔ revealed: the organization's promise vs
- *   what the implementation actually does) → `clarification` (which governs?).
- * - `wrong_goal` (any estimator ↔ true) → `human` (provocation only; `deepest`).
+ * How answerable a charter question is — the axes the VOI ranking scores. A
+ * `blast_radius` is how far up the goal DAG the answer ripples (goals are a DAG,
+ * not a tree, so one answer can force reframes on multiple parents); a
+ * `cascade_count` is how many other still-open deltas the answer is expected to
+ * settle. High on both = highest value-of-information (resolve it first).
  */
-export declare const CharterDeltaSchema: z.ZodObject<{
-    delta_id: z.ZodString;
-    pair: z.ZodTuple<[z.ZodEnum<["stated", "structural", "revealed", "true"]>, z.ZodEnum<["stated", "structural", "revealed", "true"]>], null>;
-    kind: z.ZodEnum<["doc_rot", "says_does_drift", "architecture_betrayal", "wrong_goal"]>;
-    routed_to: z.ZodEnum<["remediator", "clarification", "human"]>;
-    summary: z.ZodString;
-    /**
-     * The subsystem this delta was mined in. `delta_id` is OPAQUE — the assembler
-     * mints it with a content-derived discriminator when one subsystem carries two
-     * deltas on the same channel pair — so the originating node is carried as its
-     * own field and never recovered by parsing the id.
-     */
-    node_id: z.ZodOptional<z.ZodString>;
-    /** Present when `node_id` is linked into the mined goal graph. */
-    goal_node_id: z.ZodOptional<z.ZodString>;
+export declare const ClarificationValueSchema: z.ZodObject<{
+    /** How far up the goal DAG the fix ripples (0 = leaf). Priority AND risk. */
+    blast_radius: z.ZodNumber;
+    /** How many other open deltas this answer is expected to cascade-settle. */
+    cascade_count: z.ZodNumber;
 }, "strict", z.ZodTypeAny, {
-    kind: "doc_rot" | "says_does_drift" | "architecture_betrayal" | "wrong_goal";
-    summary: string;
-    delta_id: string;
-    pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
-    routed_to: "remediator" | "clarification" | "human";
-    node_id?: string | undefined;
-    goal_node_id?: string | undefined;
+    blast_radius: number;
+    cascade_count: number;
 }, {
-    kind: "doc_rot" | "says_does_drift" | "architecture_betrayal" | "wrong_goal";
-    summary: string;
-    delta_id: string;
-    pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
-    routed_to: "remediator" | "clarification" | "human";
-    node_id?: string | undefined;
-    goal_node_id?: string | undefined;
+    blast_radius: number;
+    cascade_count: number;
 }>;
-export type CharterDelta = z.infer<typeof CharterDeltaSchema>;
-/**
- * A delta as the Phase-C ASSEMBLER emits it — `node_id` required. The identity
- * fields are optional on `CharterDelta` because the type also describes a delta
- * mid-assembly (the gate operates on one before the register exists), but every
- * delta that reaches the persisted register carries its node, so the register
- * declares this narrower shape and consumers read the field instead of parsing
- * `delta_id`.
- */
-export interface StampedCharterDelta extends CharterDelta {
-    node_id: string;
-}
+export type ClarificationValue = z.infer<typeof ClarificationValueSchema>;
+/** The three ESTIMATOR kinds — the lanes that author a goal DAG. `true` is never a lane. */
+export declare const CharterLaneKindSchema: z.ZodEnum<["stated", "structural", "revealed"]>;
+export type CharterLaneKind = z.infer<typeof CharterLaneKindSchema>;
 /**
- * One node of a kind's self-organized leveled teleology. The lane organizes its
- * OWN view of the repo's purposes — `premise_height` is the emergent level
- * (0 = the telos, higher = closer to a leaf mechanism; an integer, NEVER a fixed
- * L0/L1/L2 enum), and `files` is the node's FILE SCOPE: content-derived join keys
- * no agent can mangle. The tool joins teleologies to each other and to the
- * decomposition hint mechanically by file-set overlap (assembleCharters).
+ * One node of a lane's goal DAG as PERSISTED. `node_id` is the lane's own local
+ * slug (never a join key); `premise_height` is DERIVED by the tool from the edges
+ * (longest path from a root purpose), never lane-stated; `files` is optional —
+ * the Stated lane may cite provenance only (step 1, "scope follows the evidence").
  */
-export declare const TeleologyNodeSchema: z.ZodObject<{
-    /** Purpose in telos terms, never mechanism (same discipline as `Charter`). */
+export declare const LaneGoalNodeSchema: z.ZodObject<{
+    node_id: z.ZodString;
+    /** Purpose in telos terms, never mechanism. */
     purpose: z.ZodString;
-    /** Emergent level: 0 = the telos, higher = nearer a leaf mechanism. */
     premise_height: z.ZodNumber;
-    /** The node's file scope — the join key. At least one repo-relative path. */
-    files: z.ZodArray<z.ZodString, "many">;
+    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    provenance: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["doc", "intent_checkpoint", "user_feedback", "code", "comment", "inferred"]>;
+        ref: z.ZodString;
+        quote: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }, {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }>, "many">;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
 }, "strict", z.ZodTypeAny, {
-    files: string[];
+    confidence: "high" | "low" | "medium";
     purpose: string;
+    provenance: {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }[];
+    node_id: string;
     premise_height: number;
+    files?: string[] | undefined;
 }, {
-    files: string[];
+    confidence: "high" | "low" | "medium";
     purpose: string;
+    provenance: {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }[];
+    node_id: string;
     premise_height: number;
+    files?: string[] | undefined;
+}>;
+export type LaneGoalNode = z.infer<typeof LaneGoalNodeSchema>;
+/** One edge of a lane's goal DAG: `from` SERVES `to`, with its own evidence. */
+export declare const LaneGoalEdgeSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    provenance: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["doc", "intent_checkpoint", "user_feedback", "code", "comment", "inferred"]>;
+        ref: z.ZodString;
+        quote: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }, {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    from: string;
+    to: string;
+    provenance: {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }[];
+}, {
+    from: string;
+    to: string;
+    provenance: {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }[];
+}>;
+export type LaneGoalEdge = z.infer<typeof LaneGoalEdgeSchema>;
+/** A lane's whole goal DAG, persisted as its own graph — never merged with the others. */
+export declare const CharterLaneGraphSchema: z.ZodObject<{
+    kind: z.ZodEnum<["stated", "structural", "revealed"]>;
+    nodes: z.ZodArray<z.ZodObject<{
+        node_id: z.ZodString;
+        /** Purpose in telos terms, never mechanism. */
+        purpose: z.ZodString;
+        premise_height: z.ZodNumber;
+        files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        provenance: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<["doc", "intent_checkpoint", "user_feedback", "code", "comment", "inferred"]>;
+            ref: z.ZodString;
+            quote: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }, {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }>, "many">;
+        confidence: z.ZodEnum<["high", "medium", "low"]>;
+    }, "strict", z.ZodTypeAny, {
+        confidence: "high" | "low" | "medium";
+        purpose: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+        node_id: string;
+        premise_height: number;
+        files?: string[] | undefined;
+    }, {
+        confidence: "high" | "low" | "medium";
+        purpose: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+        node_id: string;
+        premise_height: number;
+        files?: string[] | undefined;
+    }>, "many">;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        provenance: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<["doc", "intent_checkpoint", "user_feedback", "code", "comment", "inferred"]>;
+            ref: z.ZodString;
+            quote: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }, {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        from: string;
+        to: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+    }, {
+        from: string;
+        to: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    kind: "stated" | "structural" | "revealed";
+    nodes: {
+        confidence: "high" | "low" | "medium";
+        purpose: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+        node_id: string;
+        premise_height: number;
+        files?: string[] | undefined;
+    }[];
+    edges: {
+        from: string;
+        to: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+    }[];
+}, {
+    kind: "stated" | "structural" | "revealed";
+    nodes: {
+        confidence: "high" | "low" | "medium";
+        purpose: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+        node_id: string;
+        premise_height: number;
+        files?: string[] | undefined;
+    }[];
+    edges: {
+        from: string;
+        to: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+    }[];
+}>;
+export type CharterLaneGraph = z.infer<typeof CharterLaneGraphSchema>;
+/** A reference to a set of nodes in ONE lane's DAG (one node, several, or a subgraph). */
+export declare const CorrespondenceMemberSchema: z.ZodObject<{
+    kind: z.ZodEnum<["stated", "structural", "revealed"]>;
+    node_ids: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    kind: "stated" | "structural" | "revealed";
+    node_ids: string[];
+}, {
+    kind: "stated" | "structural" | "revealed";
+    node_ids: string[];
 }>;
-export type TeleologyNode = z.infer<typeof TeleologyNodeSchema>;
+export type CorrespondenceMember = z.infer<typeof CorrespondenceMemberSchema>;
 /**
- * The delta miner's TRIANGULATED TELOS for one subsystem — a unified opinion the
- * owner reacts to, distilled from the three blind estimators. A LEAD, never a
- * reconciliation: the charters stay held un-merged, the deltas stay the primary
- * product, and no consumer may treat this as ground truth (the spec's
- * "never reconciled into one truth" boundary; the rejected thing is a merge that
- * DESTROYS the deltas, and this preserves them).
+ * A TOOL-PROPOSED correspondence candidate (step 2): two lanes' nodes related by
+ * file-scope overlap or by a provenance cross-reference. Always exactly two members;
+ * the host may widen it.
  */
-export declare const TriangulatedTelosSchema: z.ZodObject<{
-    /** The subsystem (joined unit) this estimate belongs to. */
-    node_id: z.ZodString;
-    /** The unified best-estimate telos, in telos terms. */
-    telos: z.ZodString;
-    confidence: z.ZodEnum<["high", "medium", "low"]>;
+export declare const CorrespondenceCandidateSchema: z.ZodObject<{
+    candidate_id: z.ZodString;
+    members: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["stated", "structural", "revealed"]>;
+        node_ids: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "stated" | "structural" | "revealed";
+        node_ids: string[];
+    }, {
+        kind: "stated" | "structural" | "revealed";
+        node_ids: string[];
+    }>, "many">;
+    basis: z.ZodEnum<["file_overlap", "cross_ref"]>;
+    /** What the basis rested on: overlapping paths, or the cross-referenced path. */
+    evidence_paths: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
-    confidence: "high" | "low" | "medium";
-    node_id: string;
-    telos: string;
+    members: {
+        kind: "stated" | "structural" | "revealed";
+        node_ids: string[];
+    }[];
+    candidate_id: string;
+    basis: "file_overlap" | "cross_ref";
+    evidence_paths: string[];
 }, {
-    confidence: "high" | "low" | "medium";
-    node_id: string;
-    telos: string;
+    members: {
+        kind: "stated" | "structural" | "revealed";
+        node_ids: string[];
+    }[];
+    candidate_id: string;
+    basis: "file_overlap" | "cross_ref";
+    evidence_paths: string[];
 }>;
-export type TriangulatedTelos = z.infer<typeof TriangulatedTelosSchema>;
+export type CorrespondenceCandidate = z.infer<typeof CorrespondenceCandidateSchema>;
 /**
- * Tool-computed disagreement density: how many deltas one subsystem carries per
- * channel pair — the quantitative surface for "which parts of the triangulation
- * need clarification." Deterministic (counted at assembly), never host-supplied.
+ * A CONFIRMED correspondence (step 2 product): regions of two or three lane DAGs
+ * that speak about the same thing. A record ABOUT the graphs, never a merge of them.
  */
-export declare const ChannelDisagreementSchema: z.ZodObject<{
-    node_id: z.ZodString;
-    pair: z.ZodTuple<[z.ZodEnum<["stated", "structural", "revealed", "true"]>, z.ZodEnum<["stated", "structural", "revealed", "true"]>], null>;
-    count: z.ZodNumber;
+export declare const CharterCorrespondenceSchema: z.ZodObject<{
+    correspondence_id: z.ZodString;
+    members: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["stated", "structural", "revealed"]>;
+        node_ids: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "stated" | "structural" | "revealed";
+        node_ids: string[];
+    }, {
+        kind: "stated" | "structural" | "revealed";
+        node_ids: string[];
+    }>, "many">;
+    /** `tool` = a confirmed candidate; `host` = added by the comparison reader. */
+    basis: z.ZodEnum<["tool", "host"]>;
+    /** The candidate this confirmed or widened, when any. */
+    candidate_id: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["doc", "intent_checkpoint", "user_feedback", "code", "comment", "inferred"]>;
+        ref: z.ZodString;
+        quote: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }, {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }>, "many">;
 }, "strict", z.ZodTypeAny, {
-    node_id: string;
-    pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
-    count: number;
+    members: {
+        kind: "stated" | "structural" | "revealed";
+        node_ids: string[];
+    }[];
+    evidence: {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }[];
+    basis: "tool" | "host";
+    correspondence_id: string;
+    candidate_id?: string | undefined;
 }, {
-    node_id: string;
-    pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
-    count: number;
+    members: {
+        kind: "stated" | "structural" | "revealed";
+        node_ids: string[];
+    }[];
+    evidence: {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }[];
+    basis: "tool" | "host";
+    correspondence_id: string;
+    candidate_id?: string | undefined;
 }>;
-export type ChannelDisagreement = z.infer<typeof ChannelDisagreementSchema>;
+export type CharterCorrespondence = z.infer<typeof CharterCorrespondenceSchema>;
+/** The closed dimension enum (step 3, seven dimensions with decision rules in the spec). */
+export declare const DifferenceDimensionSchema: z.ZodEnum<["purpose", "presence", "responsibility", "hierarchy", "scope", "standing", "standard"]>;
+export type DifferenceDimension = z.infer<typeof DifferenceDimensionSchema>;
+/** The relation judged across ALL accounts in the correspondence. */
+export declare const DifferenceRelationSchema: z.ZodEnum<["equivalent", "complementary", "incompatible"]>;
+export type DifferenceRelation = z.infer<typeof DifferenceRelationSchema>;
+/** An incompatible record's split: two-against-one (naming the odd channel) or three-way. */
+export declare const DifferenceSplitSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"two_against_one">;
+    odd: z.ZodEnum<["stated", "structural", "revealed"]>;
+}, "strict", z.ZodTypeAny, {
+    kind: "two_against_one";
+    odd: "stated" | "structural" | "revealed";
+}, {
+    kind: "two_against_one";
+    odd: "stated" | "structural" | "revealed";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"three_way">;
+}, "strict", z.ZodTypeAny, {
+    kind: "three_way";
+}, {
+    kind: "three_way";
+}>]>;
+export type DifferenceSplit = z.infer<typeof DifferenceSplitSchema>;
+/** One channel's account of the goal under comparison, with the provenance it rests on. */
+export declare const DifferenceAccountSchema: z.ZodObject<{
+    kind: z.ZodEnum<["stated", "structural", "revealed"]>;
+    claim: z.ZodString;
+    provenance: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["doc", "intent_checkpoint", "user_feedback", "code", "comment", "inferred"]>;
+        ref: z.ZodString;
+        quote: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }, {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    kind: "stated" | "structural" | "revealed";
+    claim: string;
+    provenance: {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }[];
+}, {
+    kind: "stated" | "structural" | "revealed";
+    claim: string;
+    provenance: {
+        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+        ref: string;
+        quote?: string | undefined;
+    }[];
+}>;
+export type DifferenceAccount = z.infer<typeof DifferenceAccountSchema>;
+/** Who acts on a difference — derived by the tool from `(dimension, relation, split)`. */
+export declare const DifferenceRouteSchema: z.ZodEnum<["remediator", "clarification", "human", "none"]>;
+export type DifferenceRoute = z.infer<typeof DifferenceRouteSchema>;
+/** The fidelity lane's verdict on one difference (step 4). */
+export declare const FidelityVerdictSchema: z.ZodObject<{
+    verdict: z.ZodEnum<["supported", "interpretation", "unverifiable"]>;
+    /** Only with `interpretation`: the channel whose claim over-read its source. */
+    over_read_side: z.ZodOptional<z.ZodEnum<["stated", "structural", "revealed"]>>;
+    rationale: z.ZodString;
+    /** `tool` when the mechanical pre-check settled it (a missing quote); `lane` otherwise. */
+    decided_by: z.ZodEnum<["tool", "lane"]>;
+}, "strict", z.ZodTypeAny, {
+    rationale: string;
+    verdict: "supported" | "interpretation" | "unverifiable";
+    decided_by: "tool" | "lane";
+    over_read_side?: "stated" | "structural" | "revealed" | undefined;
+}, {
+    rationale: string;
+    verdict: "supported" | "interpretation" | "unverifiable";
+    decided_by: "tool" | "lane";
+    over_read_side?: "stated" | "structural" | "revealed" | undefined;
+}>;
+export type FidelityVerdict = z.infer<typeof FidelityVerdictSchema>;
 /**
- * How answerable a charter question is — the axes the VOI ranking scores. A
- * `blast_radius` is how far up the goal DAG the answer ripples (goals are a DAG,
- * not a tree, so one answer can force reframes on multiple parents); a
- * `cascade_count` is how many other still-open deltas the answer is expected to
- * settle. High on both = highest value-of-information (resolve it first).
+ * A DIFFERENCE record (step 3 product, stamped by steps 4 and 5): what the
+ * corresponding accounts disagree on, typed on one dimension and one relation,
+ * holding EVERY channel's account in its correspondence (two or three).
  */
-export declare const ClarificationValueSchema: z.ZodObject<{
-    /** How far up the goal DAG the fix ripples (0 = leaf). Priority AND risk. */
-    blast_radius: z.ZodNumber;
-    /** How many other open deltas this answer is expected to cascade-settle. */
-    cascade_count: z.ZodNumber;
+export declare const CharterDifferenceSchema: z.ZodObject<{
+    difference_id: z.ZodString;
+    correspondence_id: z.ZodString;
+    dimension: z.ZodEnum<["purpose", "presence", "responsibility", "hierarchy", "scope", "standing", "standard"]>;
+    relation: z.ZodEnum<["equivalent", "complementary", "incompatible"]>;
+    /** Required when `relation` is `incompatible`; absent otherwise. */
+    split: z.ZodOptional<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"two_against_one">;
+        odd: z.ZodEnum<["stated", "structural", "revealed"]>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "two_against_one";
+        odd: "stated" | "structural" | "revealed";
+    }, {
+        kind: "two_against_one";
+        odd: "stated" | "structural" | "revealed";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"three_way">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "three_way";
+    }, {
+        kind: "three_way";
+    }>]>>;
+    accounts: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["stated", "structural", "revealed"]>;
+        claim: z.ZodString;
+        provenance: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<["doc", "intent_checkpoint", "user_feedback", "code", "comment", "inferred"]>;
+            ref: z.ZodString;
+            quote: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }, {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "stated" | "structural" | "revealed";
+        claim: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+    }, {
+        kind: "stated" | "structural" | "revealed";
+        claim: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+    }>, "many">;
+    /** One-sentence statement of the gap. */
+    gap: z.ZodString;
+    /** For `presence`: the silent channel SHOULD have covered the goal. */
+    covered_channel_gap: z.ZodOptional<z.ZodBoolean>;
+    /** Tool-derived routing from the fixed `(dimension, relation, split)` table. */
+    routed_to: z.ZodEnum<["remediator", "clarification", "human", "none"]>;
+    /** Whether this record is a finding candidate (incompatible, or a covered-channel gap). */
+    finding_candidate: z.ZodBoolean;
+    /** Set by the fidelity step; absent until it runs. */
+    fidelity: z.ZodOptional<z.ZodObject<{
+        verdict: z.ZodEnum<["supported", "interpretation", "unverifiable"]>;
+        /** Only with `interpretation`: the channel whose claim over-read its source. */
+        over_read_side: z.ZodOptional<z.ZodEnum<["stated", "structural", "revealed"]>>;
+        rationale: z.ZodString;
+        /** `tool` when the mechanical pre-check settled it (a missing quote); `lane` otherwise. */
+        decided_by: z.ZodEnum<["tool", "lane"]>;
+    }, "strict", z.ZodTypeAny, {
+        rationale: string;
+        verdict: "supported" | "interpretation" | "unverifiable";
+        decided_by: "tool" | "lane";
+        over_read_side?: "stated" | "structural" | "revealed" | undefined;
+    }, {
+        rationale: string;
+        verdict: "supported" | "interpretation" | "unverifiable";
+        decided_by: "tool" | "lane";
+        over_read_side?: "stated" | "structural" | "revealed" | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
-    blast_radius: number;
-    cascade_count: number;
+    correspondence_id: string;
+    difference_id: string;
+    dimension: "purpose" | "presence" | "responsibility" | "hierarchy" | "scope" | "standing" | "standard";
+    relation: "equivalent" | "complementary" | "incompatible";
+    accounts: {
+        kind: "stated" | "structural" | "revealed";
+        claim: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+    }[];
+    gap: string;
+    routed_to: "remediator" | "clarification" | "human" | "none";
+    finding_candidate: boolean;
+    split?: {
+        kind: "two_against_one";
+        odd: "stated" | "structural" | "revealed";
+    } | {
+        kind: "three_way";
+    } | undefined;
+    covered_channel_gap?: boolean | undefined;
+    fidelity?: {
+        rationale: string;
+        verdict: "supported" | "interpretation" | "unverifiable";
+        decided_by: "tool" | "lane";
+        over_read_side?: "stated" | "structural" | "revealed" | undefined;
+    } | undefined;
 }, {
-    blast_radius: number;
-    cascade_count: number;
+    correspondence_id: string;
+    difference_id: string;
+    dimension: "purpose" | "presence" | "responsibility" | "hierarchy" | "scope" | "standing" | "standard";
+    relation: "equivalent" | "complementary" | "incompatible";
+    accounts: {
+        kind: "stated" | "structural" | "revealed";
+        claim: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+    }[];
+    gap: string;
+    routed_to: "remediator" | "clarification" | "human" | "none";
+    finding_candidate: boolean;
+    split?: {
+        kind: "two_against_one";
+        odd: "stated" | "structural" | "revealed";
+    } | {
+        kind: "three_way";
+    } | undefined;
+    covered_channel_gap?: boolean | undefined;
+    fidelity?: {
+        rationale: string;
+        verdict: "supported" | "interpretation" | "unverifiable";
+        decided_by: "tool" | "lane";
+        over_read_side?: "stated" | "structural" | "revealed" | undefined;
+    } | undefined;
 }>;
-export type ClarificationValue = z.infer<typeof ClarificationValueSchema>;
+export type CharterDifference = z.infer<typeof CharterDifferenceSchema>;
 /**
- * A single charter-alignment question — the audit-side ClarificationRequest,
- * sourced from a routed CharterDelta. `options` are SYMMETRIC (any of the four
- * charters may move, including Stated; "leave open" is a first-class answer), so a
- * question never silently anoints Stated as ground truth. `value` carries the
- * blast-radius + cascade estimate the VOI queue ranks on. `answer` is set once the
- * user (or the autonomous zero-attention mode) resolves it.
+ * The n-ary clarification answer (decision 6): the governing channel by name, a
+ * rewrite of all accounts, or a deliberate held tension.
  */
-export declare const CharterClarificationAnswerSchema: z.ZodEnum<["this_side_wins", "that_side_wins", "rewrite_both", "leave_open"]>;
-export type CharterClarificationAnswer = z.infer<typeof CharterClarificationAnswerSchema>;
-export declare const CharterClarificationRequestSchema: z.ZodObject<{
-    /** Stable id, derived from the source delta (`${delta_id}:q`). */
+export declare const CharterDifferenceAnswerSchema: z.ZodUnion<[z.ZodObject<{
+    governs: z.ZodEnum<["stated", "structural", "revealed"]>;
+}, "strict", z.ZodTypeAny, {
+    governs: "stated" | "structural" | "revealed";
+}, {
+    governs: "stated" | "structural" | "revealed";
+}>, z.ZodLiteral<"rewrite_all">, z.ZodLiteral<"leave_open">]>;
+export type CharterDifferenceAnswer = z.infer<typeof CharterDifferenceAnswerSchema>;
+/**
+ * A charter-alignment question sourced from a DIFFERENCE (the n-ary successor of
+ * {@link CharterClarificationRequestSchema}). Every account in the correspondence
+ * is shown; the answer names the channel that governs.
+ */
+export declare const CharterDifferenceQuestionSchema: z.ZodObject<{
     request_id: z.ZodString;
-    /** The routed delta this question triangulates. */
-    delta_id: z.ZodString;
-    /** The subsystem the delta belongs to (for grouping + reporting). */
-    node_id: z.ZodString;
-    /** The symmetric charter pair in tension. */
-    pair: z.ZodTuple<[z.ZodEnum<["stated", "structural", "revealed", "true"]>, z.ZodEnum<["stated", "structural", "revealed", "true"]>], null>;
-    /** The decidable question ("code optimizes X, docs say Y — which governs?"). */
+    difference_id: z.ZodString;
+    /** The report's grouping subsystem (structure-decomposition unit), when placed. */
+    subsystem_id: z.ZodOptional<z.ZodString>;
+    dimension: z.ZodEnum<["purpose", "presence", "responsibility", "hierarchy", "scope", "standing", "standard"]>;
+    relation: z.ZodEnum<["equivalent", "complementary", "incompatible"]>;
+    split: z.ZodOptional<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"two_against_one">;
+        odd: z.ZodEnum<["stated", "structural", "revealed"]>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "two_against_one";
+        odd: "stated" | "structural" | "revealed";
+    }, {
+        kind: "two_against_one";
+        odd: "stated" | "structural" | "revealed";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"three_way">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "three_way";
+    }, {
+        kind: "three_way";
+    }>]>>;
+    accounts: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["stated", "structural", "revealed"]>;
+        claim: z.ZodString;
+        provenance: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<["doc", "intent_checkpoint", "user_feedback", "code", "comment", "inferred"]>;
+            ref: z.ZodString;
+            quote: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }, {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "stated" | "structural" | "revealed";
+        claim: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+    }, {
+        kind: "stated" | "structural" | "revealed";
+        claim: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+    }>, "many">;
     question: z.ZodString;
-    /** The VOI axes this question is ranked on. */
     value: z.ZodObject<{
         /** How far up the goal DAG the fix ripples (0 = leaf). Priority AND risk. */
         blast_radius: z.ZodNumber;
@@ -392,39 +875,74 @@ export declare const CharterClarificationRequestSchema: z.ZodObject<{
         blast_radius: number;
         cascade_count: number;
     }>;
-    /**
-     * Whether this question is CLEARED for the interactive human channel or must
-     * only be written as a finding. A high-blast question that has not cleared the
-     * risk gate's higher adversarial bar (or any question under zero attention) is
-     * `finding_only`. `interactive` questions form the VOI queue the user answers.
-     */
     disposition: z.ZodEnum<["interactive", "finding_only"]>;
-    /** Resolved answer (symmetric); absent while the question is still open. */
-    answer: z.ZodOptional<z.ZodEnum<["this_side_wins", "that_side_wins", "rewrite_both", "leave_open"]>>;
+    answer: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        governs: z.ZodEnum<["stated", "structural", "revealed"]>;
+    }, "strict", z.ZodTypeAny, {
+        governs: "stated" | "structural" | "revealed";
+    }, {
+        governs: "stated" | "structural" | "revealed";
+    }>, z.ZodLiteral<"rewrite_all">, z.ZodLiteral<"leave_open">]>>;
 }, "strict", z.ZodTypeAny, {
     value: {
         blast_radius: number;
         cascade_count: number;
     };
-    node_id: string;
-    delta_id: string;
-    pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
+    difference_id: string;
+    dimension: "purpose" | "presence" | "responsibility" | "hierarchy" | "scope" | "standing" | "standard";
+    relation: "equivalent" | "complementary" | "incompatible";
+    accounts: {
+        kind: "stated" | "structural" | "revealed";
+        claim: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+    }[];
     request_id: string;
     question: string;
     disposition: "interactive" | "finding_only";
-    answer?: "this_side_wins" | "that_side_wins" | "rewrite_both" | "leave_open" | undefined;
+    split?: {
+        kind: "two_against_one";
+        odd: "stated" | "structural" | "revealed";
+    } | {
+        kind: "three_way";
+    } | undefined;
+    subsystem_id?: string | undefined;
+    answer?: {
+        governs: "stated" | "structural" | "revealed";
+    } | "rewrite_all" | "leave_open" | undefined;
 }, {
     value: {
         blast_radius: number;
         cascade_count: number;
     };
-    node_id: string;
-    delta_id: string;
-    pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
+    difference_id: string;
+    dimension: "purpose" | "presence" | "responsibility" | "hierarchy" | "scope" | "standing" | "standard";
+    relation: "equivalent" | "complementary" | "incompatible";
+    accounts: {
+        kind: "stated" | "structural" | "revealed";
+        claim: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
+    }[];
     request_id: string;
     question: string;
     disposition: "interactive" | "finding_only";
-    answer?: "this_side_wins" | "that_side_wins" | "rewrite_both" | "leave_open" | undefined;
+    split?: {
+        kind: "two_against_one";
+        odd: "stated" | "structural" | "revealed";
+    } | {
+        kind: "three_way";
+    } | undefined;
+    subsystem_id?: string | undefined;
+    answer?: {
+        governs: "stated" | "structural" | "revealed";
+    } | "rewrite_all" | "leave_open" | undefined;
 }>;
-export type CharterClarificationRequest = z.infer<typeof CharterClarificationRequestSchema>;
+export type CharterDifferenceQuestion = z.infer<typeof CharterDifferenceQuestionSchema>;
 //# sourceMappingURL=charter.d.ts.map