@knights-eye-chess/ai-analysis 0.0.0-stage → 0.1.0-dev.14

package/dist/types/chess-reasoning/ablation-direct-synthesis.d.ts

@@ -0,0 +1,1030 @@
+import { type AblationEvidenceClosureBundle } from "./ablation-evidence-bundle.js";
+import type { ReasoningClaimKind, ReasoningHypothesisProposal, ReasoningHypothesisProvenance, ReasoningHypothesisRecord, ReasoningHypothesisRelationProposal, ReasoningHypothesisRelationRecord, ReasoningNarrativeSegment } from "./poc-contracts.js";
+import type { ProofStrength } from "./types.js";
+/**
+ * Contract used by the direct ablation arms only.  It deliberately ends before
+ * C's observation review, criticism, terminal review, graph selection,
+ * checkpoint, discourse, rendering, or repair stages.
+ */
+export declare const ABLATION_DIRECT_SYNTHESIS_VERSION: "architecture-ablation-direct-synthesis/2";
+/**
+ * Provider-facing schema. Strict structured-output providers require every
+ * object field to be required and every object to be closed. The parser below
+ * maps explicit nulls and entry-encoded attribute values back to the existing
+ * optional/object-valued semantic contract before materialization.
+ */
+export declare const DIRECT_SYNTHESIS_PROPOSAL_JSON_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["schemaVersion", "hypotheses", "relations", "claims", "demonstrations", "coverage", "limitations", "riskProfile"];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly const: "architecture-ablation-direct-synthesis/2";
+        };
+        readonly hypotheses: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly maxItems: 16;
+            readonly items: {
+                readonly $ref: "#/$defs/hypothesis";
+            };
+        };
+        readonly relations: {
+            readonly type: "array";
+            readonly maxItems: 24;
+            readonly items: {
+                readonly $ref: "#/$defs/relation";
+            };
+        };
+        readonly claims: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly maxItems: 16;
+            readonly items: {
+                readonly $ref: "#/$defs/claim";
+            };
+        };
+        readonly demonstrations: {
+            readonly type: readonly ["array", "null"];
+            readonly maxItems: 8;
+            readonly items: {
+                readonly $ref: "#/$defs/demonstration";
+            };
+        };
+        readonly coverage: {
+            readonly $ref: "#/$defs/coverage";
+        };
+        readonly limitations: {
+            readonly type: "array";
+            readonly maxItems: 24;
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 1000;
+            };
+        };
+        readonly riskProfile: {
+            readonly $ref: "#/$defs/riskProfile";
+        };
+    };
+    readonly $defs: {
+        readonly reference: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["domain", "id"];
+            readonly properties: {
+                readonly domain: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 160;
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 200;
+                };
+            };
+        };
+        readonly participant: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["role", "ref"];
+            readonly properties: {
+                readonly role: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 160;
+                };
+                readonly ref: {
+                    readonly $ref: "#/$defs/reference";
+                };
+            };
+        };
+        readonly anchor: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["participant", "disposition"];
+            readonly properties: {
+                readonly participant: {
+                    readonly $ref: "#/$defs/participant";
+                };
+                readonly disposition: {
+                    readonly const: "required";
+                };
+            };
+        };
+        readonly attributeEntry: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["key", "value"];
+            readonly properties: {
+                readonly key: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 160;
+                };
+                readonly value: {
+                    readonly $ref: "#/$defs/attributeValue";
+                };
+            };
+        };
+        readonly attributeObject: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["entries"];
+            readonly properties: {
+                readonly entries: {
+                    readonly type: "array";
+                    readonly maxItems: 32;
+                    readonly items: {
+                        readonly $ref: "#/$defs/attributeEntry";
+                    };
+                };
+            };
+        };
+        readonly attributeValue: {
+            readonly anyOf: readonly [{
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["type", "value"];
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "string";
+                    };
+                    readonly value: {
+                        readonly type: "string";
+                        readonly maxLength: 1000;
+                    };
+                };
+            }, {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["type", "value"];
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "number";
+                    };
+                    readonly value: {
+                        readonly type: "number";
+                    };
+                };
+            }, {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["type", "value"];
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "boolean";
+                    };
+                    readonly value: {
+                        readonly type: "boolean";
+                    };
+                };
+            }, {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["type", "value"];
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "null";
+                    };
+                    readonly value: {
+                        readonly type: "null";
+                    };
+                };
+            }, {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["type", "items"];
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "array";
+                    };
+                    readonly items: {
+                        readonly type: "array";
+                        readonly maxItems: 32;
+                        readonly items: {
+                            readonly $ref: "#/$defs/attributeValue";
+                        };
+                    };
+                };
+            }, {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["type", "entries"];
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "object";
+                    };
+                    readonly entries: {
+                        readonly type: "array";
+                        readonly maxItems: 32;
+                        readonly items: {
+                            readonly $ref: "#/$defs/attributeEntry";
+                        };
+                    };
+                };
+            }];
+        };
+        readonly hypothesis: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["localId", "entityType", "concepts", "owner", "participants", "attributes", "proofStrength", "evidenceIds", "sourceObservationIds", "parentHypothesisIds", "anchorRequirements"];
+            readonly properties: {
+                readonly localId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 160;
+                };
+                readonly entityType: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 160;
+                };
+                readonly concepts: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly maxItems: 4;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 160;
+                    };
+                };
+                readonly owner: {
+                    readonly enum: readonly ["w", "b", null];
+                };
+                readonly participants: {
+                    readonly type: "array";
+                    readonly maxItems: 12;
+                    readonly items: {
+                        readonly $ref: "#/$defs/participant";
+                    };
+                };
+                readonly attributes: {
+                    readonly $ref: "#/$defs/attributeObject";
+                };
+                readonly proofStrength: {
+                    readonly enum: readonly ["observed", "supported", "forced", null];
+                };
+                readonly evidenceIds: {
+                    readonly type: "array";
+                    readonly maxItems: 12;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 200;
+                    };
+                };
+                readonly sourceObservationIds: {
+                    readonly type: "array";
+                    readonly maxItems: 12;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 200;
+                    };
+                };
+                readonly parentHypothesisIds: {
+                    readonly type: "array";
+                    readonly maxItems: 8;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 200;
+                    };
+                };
+                readonly anchorRequirements: {
+                    readonly type: "array";
+                    readonly maxItems: 12;
+                    readonly items: {
+                        readonly $ref: "#/$defs/anchor";
+                    };
+                };
+            };
+        };
+        readonly relation: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["localId", "relationType", "from", "to", "attributes", "evidenceIds", "sourceObservationIds"];
+            readonly properties: {
+                readonly localId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 160;
+                };
+                readonly relationType: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 160;
+                };
+                readonly from: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 160;
+                };
+                readonly to: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 160;
+                };
+                readonly attributes: {
+                    readonly $ref: "#/$defs/attributeObject";
+                };
+                readonly evidenceIds: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly maxItems: 12;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 200;
+                    };
+                };
+                readonly sourceObservationIds: {
+                    readonly type: "array";
+                    readonly maxItems: 12;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 200;
+                    };
+                };
+            };
+        };
+        readonly segment: {
+            readonly anyOf: readonly [{
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["type", "text"];
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "text";
+                    };
+                    readonly text: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 600;
+                    };
+                };
+            }, {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["type", "pieceId", "form", "capitalize", "label"];
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "piece";
+                    };
+                    readonly pieceId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 200;
+                    };
+                    readonly form: {
+                        readonly enum: readonly ["definite", "color-qualified", "square-qualified", "canonical", "bare", "bare-square-qualified", null];
+                    };
+                    readonly capitalize: {
+                        readonly type: readonly ["boolean", "null"];
+                    };
+                    readonly label: {
+                        readonly type: readonly ["string", "null"];
+                        readonly minLength: 1;
+                        readonly maxLength: 120;
+                    };
+                };
+            }, {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["type", "pieceKind", "color", "label"];
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "piece-kind";
+                    };
+                    readonly pieceKind: {
+                        readonly enum: readonly ["bishop", "king", "knight", "pawn", "queen", "rook"];
+                    };
+                    readonly color: {
+                        readonly enum: readonly ["w", "b", null];
+                    };
+                    readonly label: {
+                        readonly type: readonly ["string", "null"];
+                        readonly minLength: 1;
+                        readonly maxLength: 120;
+                    };
+                };
+            }, {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["type", "square", "label"];
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "square";
+                    };
+                    readonly square: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 2;
+                    };
+                    readonly label: {
+                        readonly type: readonly ["string", "null"];
+                        readonly minLength: 1;
+                        readonly maxLength: 120;
+                    };
+                };
+            }, {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["type", "uci", "pieceId", "san", "label"];
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "move";
+                    };
+                    readonly uci: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 5;
+                    };
+                    readonly pieceId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 200;
+                    };
+                    readonly san: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 40;
+                    };
+                    readonly label: {
+                        readonly type: readonly ["string", "null"];
+                        readonly minLength: 1;
+                        readonly maxLength: 120;
+                    };
+                };
+            }, {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["type", "entityLocalId", "label"];
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "entity";
+                    };
+                    readonly entityLocalId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 160;
+                    };
+                    readonly label: {
+                        readonly type: readonly ["string", "null"];
+                        readonly minLength: 1;
+                        readonly maxLength: 120;
+                    };
+                };
+            }, {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["type", "relationLocalId", "fromEntityLocalId", "toEntityLocalId", "label"];
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "relation";
+                    };
+                    readonly relationLocalId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 160;
+                    };
+                    readonly fromEntityLocalId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 160;
+                    };
+                    readonly toEntityLocalId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 160;
+                    };
+                    readonly label: {
+                        readonly type: readonly ["string", "null"];
+                        readonly minLength: 1;
+                        readonly maxLength: 120;
+                    };
+                };
+            }];
+        };
+        readonly claim: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["localId", "kind", "content", "proofStrength", "evidenceIds", "qualifications"];
+            readonly properties: {
+                readonly localId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 160;
+                };
+                readonly kind: {
+                    readonly enum: readonly ["fact", "interpretation", "consequence", "defense", "uncertainty"];
+                };
+                readonly content: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly maxItems: 32;
+                    readonly items: {
+                        readonly $ref: "#/$defs/segment";
+                    };
+                };
+                readonly proofStrength: {
+                    readonly enum: readonly ["observed", "supported", "forced", null];
+                };
+                readonly evidenceIds: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly maxItems: 12;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 200;
+                    };
+                };
+                readonly qualifications: {
+                    readonly type: "array";
+                    readonly maxItems: 8;
+                    readonly items: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly maxItems: 16;
+                        readonly items: {
+                            readonly $ref: "#/$defs/segment";
+                        };
+                    };
+                };
+            };
+        };
+        readonly demonstration: {
+            readonly anyOf: readonly [{
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["localId", "type", "start", "moves", "label", "evidenceIds"];
+                readonly properties: {
+                    readonly localId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 160;
+                    };
+                    readonly type: {
+                        readonly const: "legal-variation";
+                    };
+                    readonly start: {
+                        readonly enum: readonly ["before", "after"];
+                    };
+                    readonly moves: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly maxItems: 16;
+                        readonly items: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["uci", "pieceId", "san"];
+                            readonly properties: {
+                                readonly uci: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly maxLength: 5;
+                                };
+                                readonly pieceId: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly maxLength: 200;
+                                };
+                                readonly san: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly maxLength: 40;
+                                };
+                            };
+                        };
+                    };
+                    readonly label: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 160;
+                    };
+                    readonly evidenceIds: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly maxItems: 12;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly maxLength: 200;
+                        };
+                    };
+                };
+            }, {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["localId", "type", "pieceId", "waypoints", "prerequisiteRefs", "label", "evidenceIds"];
+                readonly properties: {
+                    readonly localId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 160;
+                    };
+                    readonly type: {
+                        readonly const: "conditional-route";
+                    };
+                    readonly pieceId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 200;
+                    };
+                    readonly waypoints: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly maxItems: 16;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly maxLength: 1000;
+                        };
+                    };
+                    readonly prerequisiteRefs: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly maxItems: 16;
+                        readonly items: {
+                            readonly $ref: "#/$defs/segment";
+                        };
+                    };
+                    readonly label: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 160;
+                    };
+                    readonly evidenceIds: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly maxItems: 12;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly maxLength: 200;
+                        };
+                    };
+                };
+            }, {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["localId", "type", "relationLocalId", "fromEntityLocalId", "toEntityLocalId", "label", "evidenceIds"];
+                readonly properties: {
+                    readonly localId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 160;
+                    };
+                    readonly type: {
+                        readonly const: "static-relationship";
+                    };
+                    readonly relationLocalId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 160;
+                    };
+                    readonly fromEntityLocalId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 160;
+                    };
+                    readonly toEntityLocalId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 160;
+                    };
+                    readonly label: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 160;
+                    };
+                    readonly evidenceIds: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly maxItems: 12;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly maxLength: 200;
+                        };
+                    };
+                };
+            }];
+        };
+        readonly coverageLane: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["status", "evidenceIds", "unresolved"];
+            readonly properties: {
+                readonly status: {
+                    readonly enum: readonly ["complete", "partial", "unavailable"];
+                };
+                readonly evidenceIds: {
+                    readonly type: "array";
+                    readonly maxItems: 12;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 200;
+                    };
+                };
+                readonly unresolved: {
+                    readonly type: "array";
+                    readonly maxItems: 24;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 1000;
+                    };
+                };
+            };
+        };
+        readonly omission: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["localId", "reason"];
+            readonly properties: {
+                readonly localId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 160;
+                };
+                readonly reason: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 500;
+                };
+            };
+        };
+        readonly coverage: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["responseCoverage", "continuationCoverage", "unresolvedEvidenceObligations", "omittedHypotheses", "omittedRelations"];
+            readonly properties: {
+                readonly responseCoverage: {
+                    readonly $ref: "#/$defs/coverageLane";
+                };
+                readonly continuationCoverage: {
+                    readonly $ref: "#/$defs/coverageLane";
+                };
+                readonly unresolvedEvidenceObligations: {
+                    readonly type: "array";
+                    readonly maxItems: 24;
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["id", "reason"];
+                        readonly properties: {
+                            readonly id: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly maxLength: 160;
+                            };
+                            readonly reason: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly maxLength: 500;
+                            };
+                        };
+                    };
+                };
+                readonly omittedHypotheses: {
+                    readonly type: "array";
+                    readonly maxItems: 24;
+                    readonly items: {
+                        readonly $ref: "#/$defs/omission";
+                    };
+                };
+                readonly omittedRelations: {
+                    readonly type: "array";
+                    readonly maxItems: 24;
+                    readonly items: {
+                        readonly $ref: "#/$defs/omission";
+                    };
+                };
+            };
+        };
+        readonly riskProfile: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["level", "reasons"];
+            readonly properties: {
+                readonly level: {
+                    readonly enum: readonly ["low", "medium", "high"];
+                };
+                readonly reasons: {
+                    readonly type: "array";
+                    readonly maxItems: 12;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 1000;
+                    };
+                };
+            };
+        };
+    };
+};
+export type DirectSynthesisArm = "A1" | "B" | "B-prime";
+export type DirectSynthesisSegment = Exclude<ReasoningNarrativeSegment, {
+    type: "move" | "entity" | "relation";
+}> | {
+    type: "move";
+    uci: string;
+    pieceId: string;
+    san: string;
+    label?: string;
+} | {
+    type: "entity";
+    entityLocalId: string;
+    label?: string;
+} | {
+    type: "relation";
+    relationLocalId: string;
+    fromEntityLocalId: string;
+    toEntityLocalId: string;
+    label?: string;
+};
+export type DirectSynthesisClaim = {
+    localId: string;
+    kind: ReasoningClaimKind;
+    content: DirectSynthesisSegment[];
+    proofStrength: ProofStrength | null;
+    evidenceIds: string[];
+    qualifications: DirectSynthesisSegment[][];
+};
+export type DirectSynthesisDemonstration = {
+    localId: string;
+    type: "legal-variation";
+    start: "before" | "after";
+    moves: Array<{
+        uci: string;
+        pieceId: string;
+        san: string;
+    }>;
+    label: string;
+    evidenceIds: string[];
+} | {
+    localId: string;
+    type: "conditional-route";
+    pieceId: string;
+    waypoints: string[];
+    prerequisiteRefs: DirectSynthesisSegment[];
+    label: string;
+    evidenceIds: string[];
+} | {
+    localId: string;
+    type: "static-relationship";
+    relationLocalId: string;
+    fromEntityLocalId: string;
+    toEntityLocalId: string;
+    label: string;
+    evidenceIds: string[];
+};
+export type DirectSynthesisRiskProfile = {
+    level: "low" | "medium" | "high";
+    reasons: string[];
+};
+export type DirectSynthesisCoverageStatus = "complete" | "partial" | "unavailable";
+export type DirectSynthesisCoverage = {
+    responseCoverage: {
+        status: DirectSynthesisCoverageStatus;
+        evidenceIds: string[];
+        unresolved: string[];
+    };
+    continuationCoverage: {
+        status: DirectSynthesisCoverageStatus;
+        evidenceIds: string[];
+        unresolved: string[];
+    };
+    unresolvedEvidenceObligations: Array<{
+        id: string;
+        reason: string;
+    }>;
+    omittedHypotheses: Array<{
+        localId: string;
+        reason: string;
+    }>;
+    omittedRelations: Array<{
+        localId: string;
+        reason: string;
+    }>;
+};
+/** A local relation handle is transport-only and is discarded after remapping. */
+export type DirectSynthesisRelationProposal = ReasoningHypothesisRelationProposal & {
+    localId: string;
+};
+/** Model-local handles are permitted only in this inbound proposal. */
+export type DirectSynthesisProposal = {
+    schemaVersion: typeof ABLATION_DIRECT_SYNTHESIS_VERSION;
+    hypotheses: ReasoningHypothesisProposal[];
+    relations: DirectSynthesisRelationProposal[];
+    claims: DirectSynthesisClaim[];
+    demonstrations?: DirectSynthesisDemonstration[];
+    coverage: DirectSynthesisCoverage;
+    limitations: string[];
+    riskProfile: DirectSynthesisRiskProfile;
+};
+export type CanonicalDirectSynthesisClaim = Omit<DirectSynthesisClaim, "localId" | "content" | "qualifications"> & {
+    id: string;
+    content: ReasoningNarrativeSegment[];
+    qualifications: ReasoningNarrativeSegment[][];
+};
+export type CanonicalDirectSynthesisDemonstration = {
+    id: string;
+    type: "legal-variation";
+    start: "before" | "after";
+    moves: Array<{
+        uci: string;
+        pieceId: string;
+        san: string;
+    }>;
+    label: string;
+    evidenceIds: string[];
+} | {
+    id: string;
+    type: "conditional-route";
+    pieceId: string;
+    waypoints: string[];
+    prerequisiteRefs: ReasoningNarrativeSegment[];
+    label: string;
+    evidenceIds: string[];
+} | {
+    id: string;
+    type: "static-relationship";
+    relationId: string;
+    fromEntityId: string;
+    toEntityId: string;
+    relationType: string;
+    label: string;
+    evidenceIds: string[];
+};
+/** The Ledger's localId is an input-only helper and is never persisted here. */
+export type CanonicalDirectSynthesisHypothesis = Omit<ReasoningHypothesisRecord, "localId">;
+/**
+ * This artifact is intentionally pre-checkpoint.  It contains only canonical
+ * Ledger records plus directly validated narrative material; it does not
+ * manufacture acceptance, graph selection, or a C-stage checkpoint.
+ */
+export type DirectSynthesisArtifact = {
+    schemaVersion: typeof ABLATION_DIRECT_SYNTHESIS_VERSION;
+    contextHash: string;
+    bundleHash: string;
+    hypotheses: CanonicalDirectSynthesisHypothesis[];
+    relations: ReasoningHypothesisRelationRecord[];
+    claims: CanonicalDirectSynthesisClaim[];
+    demonstrations: CanonicalDirectSynthesisDemonstration[];
+    coverage: Omit<DirectSynthesisCoverage, "omittedHypotheses" | "omittedRelations"> & {
+        omittedHypothesisIds: Array<{
+            hypothesisId: string;
+            reason: string;
+        }>;
+        omittedRelationIds: Array<{
+            relationId: string;
+            reason: string;
+        }>;
+    };
+    admission: "pre-checkpoint-proposed";
+    productSupport: "not-a-validated-graph-checkpoint-or-product-result";
+    limitations: string[];
+    riskProfile: DirectSynthesisRiskProfile;
+};
+export type DirectSynthesisIssue = {
+    path: string;
+    code: string;
+    message: string;
+    permittedReferences: string[];
+};
+export type DirectSynthesisMaterializationResult = {
+    ok: true;
+    metadata: {
+        arm: DirectSynthesisArm;
+    };
+    artifact: DirectSynthesisArtifact;
+} | {
+    ok: false;
+    metadata: {
+        arm: DirectSynthesisArm;
+    };
+    code: "direct-synthesis-rejected";
+    issues: DirectSynthesisIssue[];
+};
+export type MaterializeDirectSynthesisInput = {
+    arm: DirectSynthesisArm;
+    bundle: Readonly<AblationEvidenceClosureBundle>;
+    proposal: unknown;
+    provenance?: ReasoningHypothesisProvenance;
+};
+/** Strict parser intended for a later model-runtime adapter. */
+export declare function parseDirectSynthesisProposal(value: unknown): DirectSynthesisProposal;
+/**
+ * Deterministically validates and materializes a direct A1/B/B-prime result.
+ * It returns a typed failure instead of narrowing, repairing, or inventing
+ * chess meaning.
+ */
+export declare function materializeDirectSynthesis(input: MaterializeDirectSynthesisInput): DirectSynthesisMaterializationResult;