audit-tools 0.51.7 → 0.51.9

package/dist/shared/decompose/charterExtraction.d.ts

@@ -1,18 +1,17 @@
 import { z } from "zod";
-import { type Charter, type CharterKind, type CharterDelta, type ChannelDisagreement, type GoalGraph, type TeleologyNode, type TriangulatedTelos } from "../types/charter.js";
+import { type CharterLaneGraph, type CharterLaneKind, type CorrespondenceCandidate, type CharterCorrespondence, type CharterDifference, type CharterProvenance, type DifferenceRoute } from "../types/charter.js";
 import type { Finding } from "../types/finding.js";
 /**
- * The charter-EXTRACTION submission (Phase C.1): ONE blind lane's self-organized
- * teleology. Deltas are NOT authored here — the independent delta miner mines
- * them in a second pass over the joined charters, so no author marks its own
- * homework. Lanes from every kind are merged (concatenated) before assembly;
- * the join is by file-set overlap, so lanes never need to agree on node ids.
+ * The charter-EXTRACTION submission (step 1): ONE blind lane's goal DAG. The lane
+ * mints local ids; `premise_height` is not asked for (the tool derives it);
+ * `files` is optional (the Stated lane cites provenance only).
  */
 export declare const CharterSubmissionSchema: z.ZodObject<{
-    nodes: z.ZodDefault<z.ZodArray<z.ZodObject<Omit<{
-        charter_id: z.ZodString;
-        kind: z.ZodEnum<["stated", "structural", "revealed", "true"]>;
+    kind: z.ZodEnum<["stated", "structural", "revealed"]>;
+    nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        node_id: z.ZodString;
         purpose: z.ZodString;
+        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;
@@ -27,126 +26,333 @@ export declare const CharterSubmissionSchema: z.ZodObject<{
             quote?: string | undefined;
         }>, "many">;
         confidence: z.ZodEnum<["high", "medium", "low"]>;
-        nominated_alternative: z.ZodOptional<z.ZodString>;
-        nominated_cost: z.ZodOptional<z.ZodString>;
-    }, "charter_id"> & Omit<{
-        purpose: z.ZodString;
-        premise_height: z.ZodNumber;
-        files: z.ZodArray<z.ZodString, "many">;
-    }, "purpose">, "strict", z.ZodTypeAny, {
-        files: string[];
+    }, "strict", z.ZodTypeAny, {
         confidence: "high" | "low" | "medium";
-        kind: "stated" | "structural" | "revealed" | "true";
         purpose: string;
         provenance: {
             kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
             ref: string;
             quote?: string | undefined;
         }[];
-        premise_height: number;
-        nominated_alternative?: string | undefined;
-        nominated_cost?: string | undefined;
+        node_id: string;
+        files?: string[] | undefined;
     }, {
-        files: string[];
         confidence: "high" | "low" | "medium";
-        kind: "stated" | "structural" | "revealed" | "true";
         purpose: string;
         provenance: {
             kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
             ref: string;
             quote?: string | undefined;
         }[];
-        premise_height: number;
-        nominated_alternative?: string | undefined;
-        nominated_cost?: string | undefined;
+        node_id: string;
+        files?: string[] | undefined;
+    }>, "many">>;
+    edges: z.ZodDefault<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: {
-        files: string[];
         confidence: "high" | "low" | "medium";
-        kind: "stated" | "structural" | "revealed" | "true";
         purpose: string;
         provenance: {
             kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
             ref: string;
             quote?: string | undefined;
         }[];
-        premise_height: number;
-        nominated_alternative?: string | undefined;
-        nominated_cost?: string | undefined;
+        node_id: string;
+        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?: {
-        files: string[];
         confidence: "high" | "low" | "medium";
-        kind: "stated" | "structural" | "revealed" | "true";
         purpose: string;
         provenance: {
             kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
             ref: string;
             quote?: string | undefined;
         }[];
-        premise_height: number;
-        nominated_alternative?: string | undefined;
-        nominated_cost?: string | undefined;
+        node_id: string;
+        files?: string[] | undefined;
+    }[] | undefined;
+    edges?: {
+        from: string;
+        to: string;
+        provenance: {
+            kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+            ref: string;
+            quote?: string | undefined;
+        }[];
     }[] | undefined;
 }>;
 export type CharterSubmission = z.infer<typeof CharterSubmissionSchema>;
-/**
- * The charter-DELTA submission (Phase C.2): the independent miner's channel-pair
- * gaps across the already-joined charters, its TRIANGULATED TELOS per subsystem
- * (a unified opinion the owner reacts to — a lead, never a reconciliation), any
- * True nominations (deepest only), plus the goal DAG it reads off all subsystems
- * (it is the only pass that sees every joined unit, so it owns `goal_graph`).
- */
-export declare const CharterDeltaSubmissionSchema: z.ZodEffects<z.ZodObject<{
-    subsystems: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        node_id: z.ZodString;
-        deltas: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            pair: z.ZodTuple<[z.ZodEnum<["stated", "structural", "revealed", "true"]>, z.ZodEnum<["stated", "structural", "revealed", "true"]>], null>;
-            summary: z.ZodString;
+/** The TOOL-merged extraction submission: every lane's DAG, handed to the executor by path. */
+export declare const CharterExtractionMergedSchema: z.ZodObject<{
+    lanes: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["stated", "structural", "revealed"]>;
+        nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            node_id: z.ZodString;
+            purpose: z.ZodString;
+            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;
+            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;
+            files?: string[] | undefined;
+        }>, "many">>;
+        edges: z.ZodDefault<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, {
-            summary: string;
-            pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
+            from: string;
+            to: string;
+            provenance: {
+                kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+                ref: string;
+                quote?: string | undefined;
+            }[];
         }, {
-            summary: string;
-            pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
+            from: string;
+            to: string;
+            provenance: {
+                kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+                ref: string;
+                quote?: string | undefined;
+            }[];
         }>, "many">>;
     }, "strict", z.ZodTypeAny, {
-        node_id: string;
-        deltas: {
-            summary: string;
-            pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
+        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;
+            files?: string[] | undefined;
+        }[];
+        edges: {
+            from: string;
+            to: string;
+            provenance: {
+                kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+                ref: string;
+                quote?: string | undefined;
+            }[];
         }[];
     }, {
-        node_id: string;
-        deltas?: {
-            summary: string;
-            pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
+        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;
+            files?: string[] | undefined;
         }[] | undefined;
-    }>, "many">>;
-    triangulated: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        node_id: z.ZodString;
-        telos: z.ZodString;
-        confidence: z.ZodEnum<["high", "medium", "low"]>;
-    }, "strict", z.ZodTypeAny, {
-        confidence: "high" | "low" | "medium";
-        node_id: string;
-        telos: string;
-    }, {
-        confidence: "high" | "low" | "medium";
-        node_id: string;
-        telos: string;
-    }>, "many">>;
-    true_nominations: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        node_id: z.ZodString;
-        /** The nominated ideal, in telos terms. */
-        purpose: z.ZodString;
-        nominated_alternative: z.ZodString;
-        nominated_cost: z.ZodString;
-        confidence: z.ZodEnum<["high", "medium", "low"]>;
-        /** May be empty — the ideal cites no source. */
-        provenance: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        edges?: {
+            from: string;
+            to: string;
+            provenance: {
+                kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+                ref: string;
+                quote?: string | undefined;
+            }[];
+        }[] | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    lanes: {
+        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;
+            files?: string[] | undefined;
+        }[];
+        edges: {
+            from: string;
+            to: string;
+            provenance: {
+                kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+                ref: string;
+                quote?: string | undefined;
+            }[];
+        }[];
+    }[];
+}, {
+    lanes: {
+        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;
+            files?: string[] | undefined;
+        }[] | undefined;
+        edges?: {
+            from: string;
+            to: string;
+            provenance: {
+                kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
+                ref: string;
+                quote?: string | undefined;
+            }[];
+        }[] | undefined;
+    }[];
+}>;
+export type CharterExtractionMerged = z.infer<typeof CharterExtractionMergedSchema>;
+export interface AssembledLaneGraph {
+    graph: CharterLaneGraph;
+    validation_issues: string[];
+}
+/**
+ * Validate one lane's submission into its persisted DAG. Deterministic: same
+ * submission + same universe → same graph. Refusals, per node/edge, are recorded
+ * as validation issues (surfaced, never silent):
+ * - a duplicate `node_id` keeps the first and drops the rest;
+ * - an edge naming an unknown node, or a self-edge, is dropped;
+ * - a file outside the universe is dropped from the node's scope (a node left with
+ *   an EMPTY declared scope keeps `files` absent, i.e. becomes provenance-only);
+ * - a CYCLE refuses the whole edge set: every edge on a cycle is dropped and the
+ *   issue names the cycle, because a level cannot be derived from a cyclic graph
+ *   and a silently broken cycle would hide which edge the lane drafted backwards
+ *   ([[inverted-neighbor-edges-manufacture-a-cycle]]).
+ * `premise_height` = longest path from a ROOT (a node that serves nothing) down to
+ * the node, so 0 is a top-level purpose and a leaf mechanism sits deepest.
+ */
+export declare function assembleLaneGraph(submission: CharterSubmission, params: {
+    universe: ReadonlySet<string>;
+}): AssembledLaneGraph;
+/** The path part of a provenance ref: `<path>#<symbol>` or `<path>:<line>` → `<path>`. */
+export declare function provenancePath(ref: string): string;
+/**
+ * Propose correspondence candidates between every pair of lanes. Two signals, both
+ * deterministic and content-derived:
+ * - `file_overlap`: the nodes' file scopes share ≥1 path;
+ * - `cross_ref`: a node's provenance cites a path (`<path>#<symbol>` / `<path>:<line>`)
+ *   that lies in the other node's file scope (the Stated lane's usual key).
+ * A pair related by both is reported once, as `file_overlap` (the stronger signal),
+ * with the union of evidence paths. Candidate ids are content-keyed on the member
+ * set, so re-proposal never churns the artifact.
+ */
+export declare function proposeCorrespondences(graphs: readonly CharterLaneGraph[]): CorrespondenceCandidate[];
+/**
+ * The charter-COMPARISON submission (steps 2–3): the comparison reader's verdicts
+ * on the tool candidates (plus any it adds), and the typed differences. An empty
+ * result must affirm `no_correspondences: true` (a silent empty is indistinguishable
+ * from a reader that never ran).
+ */
+export declare const CharterComparisonSubmissionSchema: z.ZodEffects<z.ZodObject<{
+    correspondences: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        candidate_id: z.ZodOptional<z.ZodString>;
+        verdict: z.ZodEnum<["confirm", "reject", "widen"]>;
+        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">;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
             kind: z.ZodEnum<["doc", "intent_checkpoint", "user_feedback", "code", "comment", "inferred"]>;
             ref: z.ZodString;
             quote: z.ZodOptional<z.ZodString>;
@@ -160,323 +366,391 @@ export declare const CharterDeltaSubmissionSchema: z.ZodEffects<z.ZodObject<{
             quote?: string | undefined;
         }>, "many">>;
     }, "strict", z.ZodTypeAny, {
-        confidence: "high" | "low" | "medium";
-        purpose: string;
-        provenance: {
+        members: {
+            kind: "stated" | "structural" | "revealed";
+            node_ids: string[];
+        }[];
+        evidence: {
             kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
             ref: string;
             quote?: string | undefined;
         }[];
-        nominated_alternative: string;
-        nominated_cost: string;
-        node_id: string;
+        verdict: "confirm" | "reject" | "widen";
+        candidate_id?: string | undefined;
     }, {
-        confidence: "high" | "low" | "medium";
-        purpose: string;
-        nominated_alternative: string;
-        nominated_cost: string;
-        node_id: string;
-        provenance?: {
+        members: {
+            kind: "stated" | "structural" | "revealed";
+            node_ids: string[];
+        }[];
+        verdict: "confirm" | "reject" | "widen";
+        evidence?: {
             kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
             ref: string;
             quote?: string | undefined;
         }[] | undefined;
+        candidate_id?: string | undefined;
     }>, "many">>;
-    goal_graph: z.ZodOptional<z.ZodObject<{
-        nodes: z.ZodArray<z.ZodObject<{
-            node_id: z.ZodString;
-            premise_height: z.ZodNumber;
-            statement: z.ZodString;
+    differences: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** The candidate_id, or the 0-based index into `correspondences`, this rests on. */
+        correspondence: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        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, {
-            statement: string;
-            node_id: string;
-            premise_height: number;
+            kind: "two_against_one";
+            odd: "stated" | "structural" | "revealed";
         }, {
-            statement: string;
-            node_id: string;
-            premise_height: number;
-        }>, "many">;
-        edges: z.ZodArray<z.ZodObject<{
-            from: z.ZodString;
-            to: z.ZodString;
+            kind: "two_against_one";
+            odd: "stated" | "structural" | "revealed";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"three_way">;
         }, "strict", z.ZodTypeAny, {
-            from: string;
-            to: string;
+            kind: "three_way";
         }, {
-            from: string;
-            to: string;
+            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">;
+        gap: z.ZodString;
+        covered_channel_gap: z.ZodOptional<z.ZodBoolean>;
     }, "strict", z.ZodTypeAny, {
-        nodes: {
-            statement: string;
-            node_id: string;
-            premise_height: number;
-        }[];
-        edges: {
-            from: string;
-            to: 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;
+        correspondence: string | number;
+        split?: {
+            kind: "two_against_one";
+            odd: "stated" | "structural" | "revealed";
+        } | {
+            kind: "three_way";
+        } | undefined;
+        covered_channel_gap?: boolean | undefined;
     }, {
-        nodes: {
-            statement: string;
-            node_id: string;
-            premise_height: number;
+        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;
+            }[];
         }[];
-        edges: {
-            from: string;
-            to: string;
-        }[];
-    }>>;
-    /**
-     * Explicit clean affirmation — "I mined every subsystem and found no deltas."
-     * REQUIRED when the submission carries zero deltas, and REFUSED alongside any
-     * delta, so a dead miner (which submits nothing) can never be mistaken for a
-     * clean one (same contract as `reviewed_clean` on a zero-finding AuditResult).
-     * Keyed to DELTAS only: a clean mine may still carry triangulated teloses.
-     */
-    no_deltas: z.ZodOptional<z.ZodBoolean>;
+        gap: string;
+        correspondence: string | number;
+        split?: {
+            kind: "two_against_one";
+            odd: "stated" | "structural" | "revealed";
+        } | {
+            kind: "three_way";
+        } | undefined;
+        covered_channel_gap?: boolean | undefined;
+    }>, "many">>;
+    no_correspondences: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
-    subsystems: {
-        node_id: string;
-        deltas: {
-            summary: string;
-            pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
+    correspondences: {
+        members: {
+            kind: "stated" | "structural" | "revealed";
+            node_ids: string[];
         }[];
-    }[];
-    triangulated: {
-        confidence: "high" | "low" | "medium";
-        node_id: string;
-        telos: string;
-    }[];
-    true_nominations: {
-        confidence: "high" | "low" | "medium";
-        purpose: string;
-        provenance: {
+        evidence: {
             kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
             ref: string;
             quote?: string | undefined;
         }[];
-        nominated_alternative: string;
-        nominated_cost: string;
-        node_id: string;
+        verdict: "confirm" | "reject" | "widen";
+        candidate_id?: string | undefined;
     }[];
-    goal_graph?: {
-        nodes: {
-            statement: string;
-            node_id: string;
-            premise_height: number;
-        }[];
-        edges: {
-            from: string;
-            to: string;
+    differences: {
+        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;
+            }[];
         }[];
-    } | undefined;
-    no_deltas?: boolean | undefined;
+        gap: string;
+        correspondence: string | number;
+        split?: {
+            kind: "two_against_one";
+            odd: "stated" | "structural" | "revealed";
+        } | {
+            kind: "three_way";
+        } | undefined;
+        covered_channel_gap?: boolean | undefined;
+    }[];
+    no_correspondences?: boolean | undefined;
 }, {
-    subsystems?: {
-        node_id: string;
-        deltas?: {
-            summary: string;
-            pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
-        }[] | undefined;
-    }[] | undefined;
-    triangulated?: {
-        confidence: "high" | "low" | "medium";
-        node_id: string;
-        telos: string;
-    }[] | undefined;
-    true_nominations?: {
-        confidence: "high" | "low" | "medium";
-        purpose: string;
-        nominated_alternative: string;
-        nominated_cost: string;
-        node_id: string;
-        provenance?: {
+    correspondences?: {
+        members: {
+            kind: "stated" | "structural" | "revealed";
+            node_ids: string[];
+        }[];
+        verdict: "confirm" | "reject" | "widen";
+        evidence?: {
             kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
             ref: string;
             quote?: string | undefined;
         }[] | undefined;
+        candidate_id?: string | undefined;
     }[] | undefined;
-    goal_graph?: {
-        nodes: {
-            statement: string;
-            node_id: string;
-            premise_height: number;
+    differences?: {
+        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;
+            }[];
         }[];
-        edges: {
-            from: string;
-            to: string;
-        }[];
-    } | undefined;
-    no_deltas?: boolean | undefined;
+        gap: string;
+        correspondence: string | number;
+        split?: {
+            kind: "two_against_one";
+            odd: "stated" | "structural" | "revealed";
+        } | {
+            kind: "three_way";
+        } | undefined;
+        covered_channel_gap?: boolean | undefined;
+    }[] | undefined;
+    no_correspondences?: boolean | undefined;
 }>, {
-    subsystems: {
-        node_id: string;
-        deltas: {
-            summary: string;
-            pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
+    correspondences: {
+        members: {
+            kind: "stated" | "structural" | "revealed";
+            node_ids: string[];
         }[];
-    }[];
-    triangulated: {
-        confidence: "high" | "low" | "medium";
-        node_id: string;
-        telos: string;
-    }[];
-    true_nominations: {
-        confidence: "high" | "low" | "medium";
-        purpose: string;
-        provenance: {
+        evidence: {
             kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
             ref: string;
             quote?: string | undefined;
         }[];
-        nominated_alternative: string;
-        nominated_cost: string;
-        node_id: string;
+        verdict: "confirm" | "reject" | "widen";
+        candidate_id?: string | undefined;
     }[];
-    goal_graph?: {
-        nodes: {
-            statement: string;
-            node_id: string;
-            premise_height: number;
+    differences: {
+        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;
+            }[];
         }[];
-        edges: {
-            from: string;
-            to: string;
-        }[];
-    } | undefined;
-    no_deltas?: boolean | undefined;
+        gap: string;
+        correspondence: string | number;
+        split?: {
+            kind: "two_against_one";
+            odd: "stated" | "structural" | "revealed";
+        } | {
+            kind: "three_way";
+        } | undefined;
+        covered_channel_gap?: boolean | undefined;
+    }[];
+    no_correspondences?: boolean | undefined;
 }, {
-    subsystems?: {
-        node_id: string;
-        deltas?: {
-            summary: string;
-            pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
-        }[] | undefined;
-    }[] | undefined;
-    triangulated?: {
-        confidence: "high" | "low" | "medium";
-        node_id: string;
-        telos: string;
-    }[] | undefined;
-    true_nominations?: {
-        confidence: "high" | "low" | "medium";
-        purpose: string;
-        nominated_alternative: string;
-        nominated_cost: string;
-        node_id: string;
-        provenance?: {
+    correspondences?: {
+        members: {
+            kind: "stated" | "structural" | "revealed";
+            node_ids: string[];
+        }[];
+        verdict: "confirm" | "reject" | "widen";
+        evidence?: {
             kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
             ref: string;
             quote?: string | undefined;
         }[] | undefined;
+        candidate_id?: string | undefined;
     }[] | undefined;
-    goal_graph?: {
-        nodes: {
-            statement: string;
-            node_id: string;
-            premise_height: number;
-        }[];
-        edges: {
-            from: string;
-            to: string;
+    differences?: {
+        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;
+            }[];
         }[];
-    } | undefined;
-    no_deltas?: boolean | undefined;
+        gap: string;
+        correspondence: string | number;
+        split?: {
+            kind: "two_against_one";
+            odd: "stated" | "structural" | "revealed";
+        } | {
+            kind: "three_way";
+        } | undefined;
+        covered_channel_gap?: boolean | undefined;
+    }[] | undefined;
+    no_correspondences?: boolean | undefined;
 }>;
-export type CharterDeltaSubmission = z.infer<typeof CharterDeltaSubmissionSchema>;
+export type CharterComparisonSubmission = z.infer<typeof CharterComparisonSubmissionSchema>;
+export interface AssembledComparison {
+    correspondences: CharterCorrespondence[];
+    differences: CharterDifference[];
+    validation_issues: string[];
+}
+interface Route {
+    routed_to: DifferenceRoute;
+    severity: Finding["severity"];
+}
 /**
- * One joined subsystem UNIT: its file members, the tool-selected per-kind
- * charters, and every lane's full teleology slice that joined into it (levels
- * preserved — the self-organized structure is the product, the charter is the
- * unit's best-overlap representative of it).
+ * The design's routing table (step 5), keyed on `(dimension, relation, split)`.
+ * The host never picks a route. Non-incompatible records route nowhere except a
+ * covered-channel Presence gap, which routes by the silent channel (Stated silent →
+ * doc rot for the remediator; a code channel silent → a clarification).
  */
-export interface CharterSubsystem {
-    node_id: string;
-    members: string[];
-    charters: Charter[];
-    teleologies: Partial<Record<CharterKind, TeleologyNode[]>>;
-}
+export declare function routeDifference(input: {
+    dimension: CharterDifference["dimension"];
+    relation: CharterDifference["relation"];
+    split?: CharterDifference["split"];
+    covered_channel_gap?: boolean;
+    silent?: CharterLaneKind;
+}): Route;
 /**
- * The assembled charter layer (Phase C.1): joined per-unit charters + a record
- * of everything the gates dropped (surfaced, never silently discarded).
+ * Assemble the confirmed correspondences and the difference records from the
+ * comparison submission. Refusals are validation issues, never silent:
+ * - a member naming a node absent from its lane's DAG;
+ * - a `confirm`/`widen` naming an unknown candidate;
+ * - a host-added correspondence (no candidate) with fewer than two evidence refs
+ *   whose PATHS lie in the repo universe, or whose refs are all on one side;
+ * - a difference naming no confirmed correspondence, an account for a lane not in
+ *   that correspondence, an `incompatible` relation without a `split`, or a split
+ *   with a non-incompatible relation.
+ * Ids are content-keyed (member set / correspondence + dimension + gap).
  */
-export interface AssembledCharters {
-    subsystems: CharterSubsystem[];
-    validation_issues: string[];
-}
+export declare function assembleComparison(submission: CharterComparisonSubmission, params: {
+    candidates: readonly CorrespondenceCandidate[];
+    graphs: readonly CharterLaneGraph[];
+    universe: ReadonlySet<string>;
+}): AssembledComparison;
+/** The fidelity lane's submission: one verdict per difference in its packet. */
+export declare const CharterFidelitySubmissionSchema: z.ZodObject<{
+    verdicts: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodObject<{
+        difference_id: z.ZodString;
+        verdict: z.ZodEnum<["supported", "interpretation", "unverifiable"]>;
+        over_read_side: z.ZodOptional<z.ZodEnum<["stated", "structural", "revealed"]>>;
+        rationale: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        rationale: string;
+        verdict: "supported" | "interpretation" | "unverifiable";
+        difference_id: string;
+        over_read_side?: "stated" | "structural" | "revealed" | undefined;
+    }, {
+        rationale: string;
+        verdict: "supported" | "interpretation" | "unverifiable";
+        difference_id: string;
+        over_read_side?: "stated" | "structural" | "revealed" | undefined;
+    }>, {
+        rationale: string;
+        verdict: "supported" | "interpretation" | "unverifiable";
+        difference_id: string;
+        over_read_side?: "stated" | "structural" | "revealed" | undefined;
+    }, {
+        rationale: string;
+        verdict: "supported" | "interpretation" | "unverifiable";
+        difference_id: string;
+        over_read_side?: "stated" | "structural" | "revealed" | undefined;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    verdicts: {
+        rationale: string;
+        verdict: "supported" | "interpretation" | "unverifiable";
+        difference_id: string;
+        over_read_side?: "stated" | "structural" | "revealed" | undefined;
+    }[];
+}, {
+    verdicts?: {
+        rationale: string;
+        verdict: "supported" | "interpretation" | "unverifiable";
+        difference_id: string;
+        over_read_side?: "stated" | "structural" | "revealed" | undefined;
+    }[] | undefined;
+}>;
+export type CharterFidelitySubmission = z.infer<typeof CharterFidelitySubmissionSchema>;
 /**
- * A CharterDelta with its subsystem identity carried as EXPLICIT fields
- * (INV-CDI-EXPLICIT-NODE-FIELDS) — `delta_id` is therefore an OPAQUE identity,
- * free to gain a per-delta discriminator (see `assembleDeltas` below) without
- * any consumer, INCLUDING this module's own disagreement-density computation,
- * needing to parse it apart. Declared here as an extension of `CharterDelta`
- * rather than by widening `CharterDeltaSchema` itself
- * (src/shared/types/charter.ts, outside this module's write scope) — this is
- * the assembler's own return shape; the wire schema's `.strict()` boundary is
- * a separate, differently-owned concern (the seam
- * charter-clarification-ingestion--charter-delta-identity--node-id-recovery
- * names charter-clarification-ingestion as the consumer that reads these
- * fields once it stops parsing delta_id).
+ * The MECHANICAL pre-check (step 4, first half): given, per provenance ref, whether
+ * its quote was found at its ref on disk (`quoteFound(ref, quote)` — the ingest reads
+ * the files; this module never does), stamp `unverifiable` (decided_by `tool`) on
+ * every finding candidate that has a side whose cited quote is absent. Records with
+ * every quote present are left for the lane. Returns the differences with the tool
+ * verdicts stamped, plus the ids still owed a lane verdict.
  */
-export interface CharterDeltaWithIdentity extends CharterDelta {
-    node_id: string;
-    /** Present when `node_id` is linked into the mined goal graph. */
-    goal_node_id?: string;
-}
+export declare function precheckFidelity(differences: readonly CharterDifference[], quoteFound: (provenance: CharterProvenance) => boolean | undefined): {
+    differences: CharterDifference[];
+    pendingLane: string[];
+};
 /**
- * The assembled delta layer (Phase C.2): the routed+gated deltas across all
- * units, the deltas surfaced as Finding leads, the triangulated teloses, the
- * tool-computed disagreement density, the (possibly True-augmented) subsystems,
- * the goal DAG, and the gate drops.
+ * Stamp the lane's verdicts (step 4, second half). A verdict naming an unknown
+ * difference, or a difference the tool already settled, is a validation issue; a
+ * finding candidate left without any verdict stays pending (never assumed
+ * `supported`).
  */
-export interface AssembledDeltas {
-    subsystems: CharterSubsystem[];
-    deltas: CharterDeltaWithIdentity[];
-    findings: Finding[];
-    triangulated: TriangulatedTelos[];
-    disagreement: ChannelDisagreement[];
-    goal_graph: GoalGraph;
+export declare function applyFidelity(differences: readonly CharterDifference[], submission: CharterFidelitySubmission): {
+    differences: CharterDifference[];
     validation_issues: string[];
-}
-export interface AssembleChartersParams {
-    /**
-     * The decomposition HINT: consensus `node_id → members`. A scaffold
-     * suggestion the join prefers when a node's scope overlaps it — never a
-     * forced node list (a lane may organize boundaries the decomposition missed).
-     */
-    hint: Map<string, string[]>;
-    /**
-     * The repo file universe. Every teleology node's scope must ground here —
-     * a node citing files outside the universe is dropped with an issue (the
-     * host cannot conjure files the repo does not contain). The ingest
-     * chokepoint additionally REFUSES such lanes loudly before assembly.
-     */
-    universe: ReadonlySet<string>;
-}
+    still_pending: string[];
+};
 /**
- * Assemble the joined charter layer (Phase C.1) from the merged per-lane
- * submissions. Deterministic: same nodes + same hint + same universe always
- * yield the same units, ids, and charter selection.
- *
- * Join: each grounded node maps to the hint unit with the largest file overlap
- * (ties → lexicographically first hint id); nodes overlapping NO hint unit are
- * union-found into residual units on any shared file, across kinds. A unit's id
- * is its hint `node_id` when hinted, else the lexicographically first file of
- * its scope union (provably collision-free: a residual scope contains no hint
- * member, so its first file can never equal a hint id, which IS a hint member).
- * Per unit per kind, the best-overlap node becomes the kind's charter
- * (`charter_id = unit:kind`); every joined node persists in the unit's
- * teleology, levels intact.
+ * Surface every `supported` finding candidate as a Finding LEAD (leads-not-verdicts).
+ * `affected_files` = the union of the corresponding nodes' scopes (the report's
+ * grouping evidence); `confidence` = the weakest account's source confidence.
  */
-export declare function assembleCharters(submission: CharterSubmission, params: AssembleChartersParams): AssembledCharters;
-export interface AssembleDeltasParams {
-    /**
-     * Whether True nominations are admissible — true ONLY at the `deepest`
-     * ceiling (the consent gate that used to live on the extraction lane set;
-     * the executor derives this from the confirmed checkpoint's ceiling).
-     */
-    allowTrueNominations: boolean;
-}
-export declare function assembleDeltas(submission: CharterDeltaSubmission, subsystems: CharterSubsystem[], params: AssembleDeltasParams): AssembledDeltas;
+export declare function differenceFindings(differences: readonly CharterDifference[], correspondences: readonly CharterCorrespondence[], graphs: readonly CharterLaneGraph[]): Finding[];
+export {};
 //# sourceMappingURL=charterExtraction.d.ts.map