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

package/dist/research.js

@@ -0,0 +1,2274 @@
+import {
+  ABLATION_ADAPTIVE_EVIDENCE_LOOP_VERSION,
+  ABLATION_EVIDENCE_BUNDLE_VERSION,
+  ABLATION_LEAN_DIRECT_PROPOSAL_VERSION,
+  ABLATION_LEAN_DIRECT_RUNTIME_VERSION,
+  ABLATION_PROBE_TELEMETRY_VERSION,
+  AI_SDK_ANSWER_OBLIGATION_RUNTIME,
+  AI_SDK_CRITIC_RUNTIME,
+  AI_SDK_DISCOURSE_RUNTIME,
+  AI_SDK_GRAPH_PLANNING_RUNTIME,
+  AI_SDK_GRAPH_SELECTION_RUNTIME,
+  AI_SDK_HYPOTHESIS_RUNTIME,
+  AI_SDK_PURPOSE_PROBE_RUNTIME,
+  AI_SDK_REASONING_RUNTIME,
+  AI_SDK_RENDER_RUNTIME,
+  AI_SDK_REPAIR_RUNTIME,
+  AI_SDK_RESOLUTION_AUDIT_RUNTIME,
+  AI_SDK_TERMINAL_REVIEW_RUNTIME,
+  ANALYSIS_CONTEXT_PROVENANCE_TIER,
+  ATTRIBUTE_KEYS,
+  BRANCH_EXPANSION_OPTIONS,
+  CANONICAL_EDGE_ANALYSIS_SNAPSHOT_VERSION,
+  CAPTURE_RESPONSE_FACT_KIND,
+  CHESS_FACT_REQUEST_VERSION,
+  CHESS_FACT_RESULT_VERSION,
+  CHESS_FACT_SCHEMA_VERSION,
+  CHESS_REFERENCE_DICTIONARY,
+  CLASSIFICATION_REASSESSMENT_GUIDANCE,
+  COMPACT_ENGINE_INSTRUCTIONS,
+  COMPLETED_TOOL_REPLAY_ADMISSION_KEY,
+  CONCEPT_KEYS,
+  CONVERSATION_CONTEXT_INSTRUCTIONS,
+  ChessFactObservationProvider,
+  CompositeObservationProvider,
+  CriticResolutionAuditHarnessRejection,
+  DEFAULT_CONCEPT_REGISTRY,
+  DEFAULT_MATERIAL_FORMAT,
+  DETERMINISTIC_DISCOURSE_RUNTIME,
+  DETERMINISTIC_OBSERVATION_PROVIDER_VERSION,
+  DeterministicObservationProvider,
+  ENTITY_TYPES,
+  EXISTING_ANALYSIS_CONTEXT_MODE,
+  EXISTING_ANALYSIS_CONTEXT_VERSION,
+  EXISTING_ANALYSIS_OBSERVATION_PROVIDER_ID,
+  EXISTING_ANALYSIS_RECORD_VERSION,
+  EXPLAIN_PLAN_SELECTION_DESCRIPTOR,
+  EXPLANATION_REVIEW_SCHEMA,
+  ExistingAnalysisObservationProvider,
+  FACT_DELIVERY_INSTRUCTIONS,
+  FACT_OBSERVATION_ADAPTER_VERSION,
+  GraphSelectionHarnessRejection,
+  HypothesisHarnessRejection,
+  HypothesisLedger,
+  HypothesisProviderRuntimeFailure,
+  HypothesisReviewHarnessRejection,
+  LEAN_DIRECT_PROPOSAL_JSON_SCHEMA,
+  LEGACY_EXISTING_ANALYSIS_CONTEXT_VERSION,
+  MATCHED_COMPARISON_GUIDANCE,
+  MATERIAL_OFFER_SET_VERSION,
+  MAX_ANSWER_TOOL_REQUESTS_PER_TURN,
+  MECHANICAL_CHESS_FACT_PROVIDER_ID,
+  MECHANICAL_CHESS_FACT_PROVIDER_VERSION,
+  MECHANISM_FACT_INSTRUCTIONS,
+  MechanicalChessFactProvider,
+  ModelOwnedAdaptiveEvidenceLoop,
+  OPENING_SOURCE_INSTRUCTIONS,
+  PARTICIPANT_ROLES,
+  PRECOMMITTED_PROBE_ATTRIBUTION_CATEGORIES,
+  PRODUCTION_OBSERVATION_PROVIDER_VERSION,
+  QUESTION_SALIENCE_POLICY_VERSION,
+  QuestionConditionedSaliencePolicy,
+  RECORDED_POSITION_DESCRIPTORS,
+  RECORD_HYPOTHESES_DESCRIPTOR,
+  REFERENCE_DOMAINS,
+  RELATION_TYPES,
+  REVIEW_HYPOTHESES_DESCRIPTOR,
+  ReasoningCriticHarnessRejection,
+  ReasoningWorkflowFailure,
+  SIMPLE_BOARD_ANALYSIS_GUIDANCE,
+  SIMPLE_BUDGETS,
+  SIMPLE_CONTENT_SELECTION_GUIDANCE,
+  SIMPLE_DISCLOSURE,
+  SIMPLE_EVIDENCE_VIEW_VERSION,
+  SIMPLE_EXAMPLE_GUIDANCE,
+  SIMPLE_EXPANDED_BUDGETS,
+  SIMPLE_EXPLANATION_GUIDANCE,
+  SIMPLE_MODELS,
+  SIMPLE_PURPOSE_GUIDANCE,
+  SIMPLE_RECOVERY_BUDGETS,
+  SIMPLE_REFERENCE_INSTRUCTIONS,
+  SIMPLE_SEARCH_BREADTH_GUIDANCE,
+  SIMPLE_SECTION_GUIDANCE,
+  SIMPLE_STOPPING_GUIDANCE,
+  SIMPLE_SYSTEM,
+  SimpleFactDelivery,
+  TerminalReviewHarnessRejection,
+  ablationHistoryThroughTargetHash,
+  ablationLeanDirectSystem,
+  abortSource,
+  assertDirectedDestinationAnchors,
+  assertFactProofWithinAuthority,
+  bytes,
+  captureAblationOriginalEvidenceBundle,
+  checkCausalClaims,
+  chessFactRecordLicenses,
+  chessSquareColor,
+  classificationReassessment,
+  classifyGraphSelectionHarnessRejection,
+  classifyGraphSelectionRuntimeFailure,
+  classifyHypothesisHarnessRejection,
+  classifyProviderHypothesisRejection,
+  classifyReasoningCriticHarnessRejection,
+  classifyRuntimeFailure,
+  compactLeanEvidencePacket,
+  compactMechanism,
+  compactPreparedSearchResult,
+  compactSearchRecord,
+  compactSimpleEngineResult,
+  compactSimpleInitialPacket,
+  compactSimpleToolResult,
+  conceptDefinition,
+  conceptsOf,
+  consolidatePreparedSearches,
+  createAblationEvidenceClosureBundle,
+  createAblationProbeTelemetry,
+  createConceptRegistry,
+  createDefaultObservationProvider,
+  createDefaultSaliencePolicy,
+  createIdeaGraph,
+  createMechanicalFactRequest,
+  createNativeAnswerConnector,
+  createPocToolHost,
+  createProductionObservationProvider,
+  createSemanticEntity,
+  createSemanticRelation,
+  createToolInputLoopGuard,
+  deepestError,
+  deriveAdmittedCaptureResponseAvailabilityFact,
+  emitObservableTrace,
+  enrichAblationEvidenceBundleWithAdmittedCaptureResponses,
+  enrichAblationEvidenceClosureBundle,
+  evidenceFallback,
+  expandCompactEngineEvidence,
+  expandMechanismPresentation,
+  expandPrincipalBranches,
+  explanationBranches,
+  explanationCoverage,
+  explanationSummary,
+  extendConceptRegistry,
+  extendIdeaGraph,
+  factCoverageSupportsAbsence,
+  factProofStrength,
+  forcedWinPremiseFallback,
+  forkIdeaGraph,
+  graphIdentityCompatible,
+  hasConcept,
+  isChessFactAuthority,
+  isTerminalEntity,
+  matchedRootComparison,
+  materializeLeanDirectProposal,
+  maximumFactProofStrength,
+  memoizeToolResults,
+  normalizeExistingAnalysisContext,
+  numericUsage,
+  observableTraceMessages,
+  openEntityCount,
+  parseExplainPlanRequest,
+  participant,
+  participantIds,
+  planInitialSearches,
+  planningEvidence,
+  precommittedProbeAttributionCategories,
+  prepareOpponentThreats,
+  prepareSimpleEvidence,
+  preparedMoveComparison,
+  primaryConcept,
+  projectAblationEvidenceForModel,
+  projectCompactEngineEvidence,
+  projectEnginePresentation,
+  projectLeanDirectEvidence,
+  projectLeanEpisodeEvidence,
+  projectMaterial,
+  reasoningMetrics,
+  recordedPositionContext,
+  requestId,
+  resolveAndSelectPlan,
+  retainedEvidenceCatalogue,
+  runAnswerPipeline,
+  runLeanDirect,
+  runPreparedAnswer,
+  scoreComparisonNotices,
+  selectBranchHost,
+  simpleBoardAnalysis,
+  simpleInitialEvidenceView,
+  simplePastHistory,
+  simpleSystemPolicy,
+  simpleToolDescription,
+  simpleUsageForTrace,
+  squaresBetween,
+  stabilizeSimplePolicy,
+  stringListAttribute,
+  validateAblationEvidenceClosureBundle,
+  validateAblationProbeTelemetry,
+  validateAnswerReferences,
+  validateChessFactRecord,
+  validateChessFactRequest,
+  validateExplanationReview,
+  validateHypothesisAcceptancePolicies,
+  validateSimpleToolInput,
+  visibleSupportLines,
+  wikibooksTargetsForTool,
+  withBranchPreparation,
+  withRecordedPositionTools
+} from "./chunk-PLKNJRPF.js";
+import {
+  CHESS_REASONING_POLICY_VERSION,
+  CHESS_REASONING_SCHEMA_VERSION,
+  DEFAULT_REASONING_RUN_CONTROLS,
+  EVALUATED_ASTRA_CONFIG,
+  EVIDENCE_LICENSE,
+  EVIDENCE_SHARING_GUIDANCE_CHARS,
+  EVIDENCE_SHARING_INSTRUCTIONS,
+  EVIDENCE_SHARING_VERSION,
+  MAX_FRESH_ENGINE_WITNESS_ACQUISITIONS,
+  MAX_INTERACTIVE_LINE_PLIES,
+  ModelRuntimeFailure,
+  OPENING_SOURCE_LICENSE_URL,
+  QUESTION_ROUTING_VERSION,
+  REASONING_DISCOURSE_PLAN_VERSION,
+  REASONING_POC_CRITIC_CORRECTION_ALLOWANCE,
+  REASONING_POC_MAX_CRITIC_OUTPUT_TOKENS,
+  REASONING_POC_MAX_DISCOURSE_OUTPUT_TOKENS,
+  REASONING_POC_MAX_GRAPH_SELECTION_OUTPUT_TOKENS,
+  REASONING_POC_MAX_HYPOTHESIS_BATCHES,
+  REASONING_POC_MAX_HYPOTHESIS_OUTPUT_TOKENS,
+  REASONING_POC_MAX_OUTPUT_TOKENS,
+  REASONING_POC_MAX_PURPOSE_PROBE_OUTPUT_TOKENS,
+  REASONING_POC_MAX_RENDER_OUTPUT_TOKENS,
+  REASONING_POC_MAX_RESOLUTION_AUDIT_OUTPUT_TOKENS,
+  REASONING_POC_MAX_TERMINAL_REVIEW_OUTPUT_TOKENS,
+  REASONING_POC_PURPOSE_PROBE_ALLOWANCE,
+  REASONING_POC_RESERVED_MANDATORY_STEPS,
+  REASONING_POC_REVISION_EVIDENCE_ALLOWANCE,
+  REASONING_POC_VERSION,
+  REVIEW_SUBJECTS,
+  SIMPLE_EXTENSION_CONFIGS,
+  SIMPLE_MODEL_CATALOGUE,
+  SIMPLE_REFERENCE_VERSION,
+  SIMPLE_TOOL_AGENT_VERSION,
+  SIMPLE_VENDOR_CONFIGS,
+  admitFreshEnginePvWitnesses,
+  applyIdentityMove,
+  canonicalPieceLabel,
+  classificationTargetAtSelection,
+  classifyQuestionRoutingAnswers,
+  classifyReviewSubject,
+  collectReasoningMoveWitnesses,
+  createContextEvidence,
+  createIdentityState,
+  createPocIdentityTimeline,
+  createQueryContract,
+  decodeWikibooksIndex,
+  decorateSimpleVariations,
+  effectiveEvidenceLicenses,
+  effectiveLicensesForRecord,
+  evidenceLicenseInput,
+  expandSharedEvidence,
+  forkIdentityState,
+  hasMoveClassificationQuestion,
+  hasSharedEvidence,
+  historyPositionContext,
+  licensesBoundedRouteRelevance,
+  licensesSemanticChessGrounding,
+  makeQuestionRoutingRequest,
+  materialAlongLine,
+  materialAtPosition,
+  materialForVariations,
+  maximumEvidenceLicenses,
+  moveMechanismFacts,
+  moveSectionScope,
+  normalizedEvidenceCitations,
+  openingSourceLinks,
+  openingSourcesInMessages,
+  openingTitle,
+  parseOpeningSourceCredits,
+  parseQuestionRoutingAnswers,
+  pieceIdAt,
+  pieceIdentity,
+  positionKey,
+  priorConversationMessages,
+  reasoningContextHash,
+  reasoningEvidenceReplayStartPhase,
+  recordedMainLineResult,
+  recordedNavigation,
+  repairFrozenCitationLabels,
+  replayWikibooksTitle,
+  safeSimpleSourceLink,
+  savedScorePresentation,
+  scopePositionAnalysis,
+  selectIndexedOpening,
+  selectSimpleModel,
+  shareEvidence,
+  shareEvidenceMessages,
+  simpleEffortsForModel,
+  simpleProseReferences,
+  squareForPiece,
+  stableHash,
+  stableJson,
+  stripSimpleCitationLinks,
+  stripSimpleMarkdownFences,
+  toLegacyPositionAnalysis,
+  toLegacyPositionAnalysisProvider,
+  toPositionAnalysis,
+  toPositionAnalysisProvider,
+  validateEvidenceLicenseClaims,
+  validateReasoningPositionContext,
+  validateSimpleAgentConfig,
+  withEvidenceLicenses
+} from "./chunk-XQDZJOYD.js";
+
+// src/chess-reasoning/ablation-direct-synthesis.ts
+import { SQUARES } from "chess.js";
+
+// src/chess-reasoning/poc-semantic-text.ts
+var RAW_CHESS_TEXT_PATTERN_SOURCE = String.raw`(?:\b(?:(?:[Ww]hite|[Bb]lack)(?:['’]s)?\s+)?(?:[Bb]ishop|[Kk]night(?!['’]s\s+[Ee]ye\b)|[Rr]ook|[Qq]ueen(?!-[Ss]ide\b)|[Kk]ing(?!-[Ss]ide\b)|[Pp]awn)\b|\b(?:[a-h][1-8][a-h][1-8][qrbn]?|[KQRBN][a-h1-8]?x?[a-h][1-8](?:=[QRBN])?[+#]?|[a-h]x[a-h][1-8](?:=[QRBN])?[+#]?|O-O(?:-O)?|[a-h][1-8])\b)`;
+var RAW_CHESS_TEXT = new RegExp(RAW_CHESS_TEXT_PATTERN_SOURCE, "i");
+var SEMANTIC_TEXT_JSON_PATTERN = `^(?![\\s\\S]*${RAW_CHESS_TEXT_PATTERN_SOURCE})[\\s\\S]{1,600}$`;
+
+// src/chess-reasoning/ablation-direct-synthesis.ts
+var ABLATION_DIRECT_SYNTHESIS_VERSION = "architecture-ablation-direct-synthesis/2";
+var DIRECT_SYNTHESIS_PROPOSAL_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["schemaVersion", "hypotheses", "relations", "claims", "demonstrations", "coverage", "limitations", "riskProfile"],
+  properties: {
+    schemaVersion: { const: ABLATION_DIRECT_SYNTHESIS_VERSION },
+    hypotheses: { type: "array", minItems: 1, maxItems: 16, items: { $ref: "#/$defs/hypothesis" } },
+    relations: { type: "array", maxItems: 24, items: { $ref: "#/$defs/relation" } },
+    claims: { type: "array", minItems: 1, maxItems: 16, items: { $ref: "#/$defs/claim" } },
+    demonstrations: { type: ["array", "null"], maxItems: 8, items: { $ref: "#/$defs/demonstration" } },
+    coverage: { $ref: "#/$defs/coverage" },
+    limitations: { type: "array", maxItems: 24, items: { type: "string", minLength: 1, maxLength: 1e3 } },
+    riskProfile: { $ref: "#/$defs/riskProfile" }
+  },
+  $defs: {
+    reference: { type: "object", additionalProperties: false, required: ["domain", "id"], properties: { domain: { type: "string", minLength: 1, maxLength: 160 }, id: { type: "string", minLength: 1, maxLength: 200 } } },
+    participant: { type: "object", additionalProperties: false, required: ["role", "ref"], properties: { role: { type: "string", minLength: 1, maxLength: 160 }, ref: { $ref: "#/$defs/reference" } } },
+    anchor: { type: "object", additionalProperties: false, required: ["participant", "disposition"], properties: { participant: { $ref: "#/$defs/participant" }, disposition: { const: "required" } } },
+    attributeEntry: { type: "object", additionalProperties: false, required: ["key", "value"], properties: { key: { type: "string", minLength: 1, maxLength: 160 }, value: { $ref: "#/$defs/attributeValue" } } },
+    attributeObject: { type: "object", additionalProperties: false, required: ["entries"], properties: { entries: { type: "array", maxItems: 32, items: { $ref: "#/$defs/attributeEntry" } } } },
+    attributeValue: { anyOf: [
+      { type: "object", additionalProperties: false, required: ["type", "value"], properties: { type: { const: "string" }, value: { type: "string", maxLength: 1e3 } } },
+      { type: "object", additionalProperties: false, required: ["type", "value"], properties: { type: { const: "number" }, value: { type: "number" } } },
+      { type: "object", additionalProperties: false, required: ["type", "value"], properties: { type: { const: "boolean" }, value: { type: "boolean" } } },
+      { type: "object", additionalProperties: false, required: ["type", "value"], properties: { type: { const: "null" }, value: { type: "null" } } },
+      { type: "object", additionalProperties: false, required: ["type", "items"], properties: { type: { const: "array" }, items: { type: "array", maxItems: 32, items: { $ref: "#/$defs/attributeValue" } } } },
+      { type: "object", additionalProperties: false, required: ["type", "entries"], properties: { type: { const: "object" }, entries: { type: "array", maxItems: 32, items: { $ref: "#/$defs/attributeEntry" } } } }
+    ] },
+    hypothesis: {
+      type: "object",
+      additionalProperties: false,
+      required: ["localId", "entityType", "concepts", "owner", "participants", "attributes", "proofStrength", "evidenceIds", "sourceObservationIds", "parentHypothesisIds", "anchorRequirements"],
+      properties: {
+        localId: { type: "string", minLength: 1, maxLength: 160 },
+        entityType: { type: "string", minLength: 1, maxLength: 160 },
+        concepts: { type: "array", minItems: 1, maxItems: 4, items: { type: "string", minLength: 1, maxLength: 160 } },
+        owner: { enum: ["w", "b", null] },
+        participants: { type: "array", maxItems: 12, items: { $ref: "#/$defs/participant" } },
+        attributes: { $ref: "#/$defs/attributeObject" },
+        proofStrength: { enum: ["observed", "supported", "forced", null] },
+        evidenceIds: { type: "array", maxItems: 12, items: { type: "string", minLength: 1, maxLength: 200 } },
+        sourceObservationIds: { type: "array", maxItems: 12, items: { type: "string", minLength: 1, maxLength: 200 } },
+        parentHypothesisIds: { type: "array", maxItems: 8, items: { type: "string", minLength: 1, maxLength: 200 } },
+        anchorRequirements: { type: "array", maxItems: 12, items: { $ref: "#/$defs/anchor" } }
+      }
+    },
+    relation: { type: "object", additionalProperties: false, required: ["localId", "relationType", "from", "to", "attributes", "evidenceIds", "sourceObservationIds"], properties: { localId: { type: "string", minLength: 1, maxLength: 160 }, relationType: { type: "string", minLength: 1, maxLength: 160 }, from: { type: "string", minLength: 1, maxLength: 160 }, to: { type: "string", minLength: 1, maxLength: 160 }, attributes: { $ref: "#/$defs/attributeObject" }, evidenceIds: { type: "array", minItems: 1, maxItems: 12, items: { type: "string", minLength: 1, maxLength: 200 } }, sourceObservationIds: { type: "array", maxItems: 12, items: { type: "string", minLength: 1, maxLength: 200 } } } },
+    segment: { anyOf: [
+      { type: "object", additionalProperties: false, required: ["type", "text"], properties: { type: { const: "text" }, text: { type: "string", minLength: 1, maxLength: 600 } } },
+      { type: "object", additionalProperties: false, required: ["type", "pieceId", "form", "capitalize", "label"], properties: { type: { const: "piece" }, pieceId: { type: "string", minLength: 1, maxLength: 200 }, form: { enum: ["definite", "color-qualified", "square-qualified", "canonical", "bare", "bare-square-qualified", null] }, capitalize: { type: ["boolean", "null"] }, label: { type: ["string", "null"], minLength: 1, maxLength: 120 } } },
+      { type: "object", additionalProperties: false, required: ["type", "pieceKind", "color", "label"], properties: { type: { const: "piece-kind" }, pieceKind: { enum: ["bishop", "king", "knight", "pawn", "queen", "rook"] }, color: { enum: ["w", "b", null] }, label: { type: ["string", "null"], minLength: 1, maxLength: 120 } } },
+      { type: "object", additionalProperties: false, required: ["type", "square", "label"], properties: { type: { const: "square" }, square: { type: "string", minLength: 1, maxLength: 2 }, label: { type: ["string", "null"], minLength: 1, maxLength: 120 } } },
+      { type: "object", additionalProperties: false, required: ["type", "uci", "pieceId", "san", "label"], properties: { type: { const: "move" }, uci: { type: "string", minLength: 1, maxLength: 5 }, pieceId: { type: "string", minLength: 1, maxLength: 200 }, san: { type: "string", minLength: 1, maxLength: 40 }, label: { type: ["string", "null"], minLength: 1, maxLength: 120 } } },
+      { type: "object", additionalProperties: false, required: ["type", "entityLocalId", "label"], properties: { type: { const: "entity" }, entityLocalId: { type: "string", minLength: 1, maxLength: 160 }, label: { type: ["string", "null"], minLength: 1, maxLength: 120 } } },
+      { type: "object", additionalProperties: false, required: ["type", "relationLocalId", "fromEntityLocalId", "toEntityLocalId", "label"], properties: { type: { const: "relation" }, relationLocalId: { type: "string", minLength: 1, maxLength: 160 }, fromEntityLocalId: { type: "string", minLength: 1, maxLength: 160 }, toEntityLocalId: { type: "string", minLength: 1, maxLength: 160 }, label: { type: ["string", "null"], minLength: 1, maxLength: 120 } } }
+    ] },
+    claim: { type: "object", additionalProperties: false, required: ["localId", "kind", "content", "proofStrength", "evidenceIds", "qualifications"], properties: { localId: { type: "string", minLength: 1, maxLength: 160 }, kind: { enum: ["fact", "interpretation", "consequence", "defense", "uncertainty"] }, content: { type: "array", minItems: 1, maxItems: 32, items: { $ref: "#/$defs/segment" } }, proofStrength: { enum: ["observed", "supported", "forced", null] }, evidenceIds: { type: "array", minItems: 1, maxItems: 12, items: { type: "string", minLength: 1, maxLength: 200 } }, qualifications: { type: "array", maxItems: 8, items: { type: "array", minItems: 1, maxItems: 16, items: { $ref: "#/$defs/segment" } } } } },
+    demonstration: { anyOf: [
+      { type: "object", additionalProperties: false, required: ["localId", "type", "start", "moves", "label", "evidenceIds"], properties: { localId: { type: "string", minLength: 1, maxLength: 160 }, type: { const: "legal-variation" }, start: { enum: ["before", "after"] }, moves: { type: "array", minItems: 1, maxItems: 16, items: { type: "object", additionalProperties: false, required: ["uci", "pieceId", "san"], properties: { uci: { type: "string", minLength: 1, maxLength: 5 }, pieceId: { type: "string", minLength: 1, maxLength: 200 }, san: { type: "string", minLength: 1, maxLength: 40 } } } }, label: { type: "string", minLength: 1, maxLength: 160 }, evidenceIds: { type: "array", minItems: 1, maxItems: 12, items: { type: "string", minLength: 1, maxLength: 200 } } } },
+      { type: "object", additionalProperties: false, required: ["localId", "type", "pieceId", "waypoints", "prerequisiteRefs", "label", "evidenceIds"], properties: { localId: { type: "string", minLength: 1, maxLength: 160 }, type: { const: "conditional-route" }, pieceId: { type: "string", minLength: 1, maxLength: 200 }, waypoints: { type: "array", minItems: 1, maxItems: 16, items: { type: "string", minLength: 1, maxLength: 1e3 } }, prerequisiteRefs: { type: "array", minItems: 1, maxItems: 16, items: { $ref: "#/$defs/segment" } }, label: { type: "string", minLength: 1, maxLength: 160 }, evidenceIds: { type: "array", minItems: 1, maxItems: 12, items: { type: "string", minLength: 1, maxLength: 200 } } } },
+      { type: "object", additionalProperties: false, required: ["localId", "type", "relationLocalId", "fromEntityLocalId", "toEntityLocalId", "label", "evidenceIds"], properties: { localId: { type: "string", minLength: 1, maxLength: 160 }, type: { const: "static-relationship" }, relationLocalId: { type: "string", minLength: 1, maxLength: 160 }, fromEntityLocalId: { type: "string", minLength: 1, maxLength: 160 }, toEntityLocalId: { type: "string", minLength: 1, maxLength: 160 }, label: { type: "string", minLength: 1, maxLength: 160 }, evidenceIds: { type: "array", minItems: 1, maxItems: 12, items: { type: "string", minLength: 1, maxLength: 200 } } } }
+    ] },
+    coverageLane: { type: "object", additionalProperties: false, required: ["status", "evidenceIds", "unresolved"], properties: { status: { enum: ["complete", "partial", "unavailable"] }, evidenceIds: { type: "array", maxItems: 12, items: { type: "string", minLength: 1, maxLength: 200 } }, unresolved: { type: "array", maxItems: 24, items: { type: "string", minLength: 1, maxLength: 1e3 } } } },
+    omission: { type: "object", additionalProperties: false, required: ["localId", "reason"], properties: { localId: { type: "string", minLength: 1, maxLength: 160 }, reason: { type: "string", minLength: 1, maxLength: 500 } } },
+    coverage: { type: "object", additionalProperties: false, required: ["responseCoverage", "continuationCoverage", "unresolvedEvidenceObligations", "omittedHypotheses", "omittedRelations"], properties: { responseCoverage: { $ref: "#/$defs/coverageLane" }, continuationCoverage: { $ref: "#/$defs/coverageLane" }, unresolvedEvidenceObligations: { type: "array", maxItems: 24, items: { type: "object", additionalProperties: false, required: ["id", "reason"], properties: { id: { type: "string", minLength: 1, maxLength: 160 }, reason: { type: "string", minLength: 1, maxLength: 500 } } } }, omittedHypotheses: { type: "array", maxItems: 24, items: { $ref: "#/$defs/omission" } }, omittedRelations: { type: "array", maxItems: 24, items: { $ref: "#/$defs/omission" } } } },
+    riskProfile: { type: "object", additionalProperties: false, required: ["level", "reasons"], properties: { level: { enum: ["low", "medium", "high"] }, reasons: { type: "array", maxItems: 12, items: { type: "string", minLength: 1, maxLength: 1e3 } } } }
+  }
+};
+var AdmissionFailure = class extends Error {
+  constructor(issue) {
+    super(issue.message);
+    this.issue = issue;
+  }
+  issue;
+};
+function fail(path, code, message, permittedReferences = []) {
+  throw new AdmissionFailure({ path, code, message, permittedReferences });
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function exactKeys(value, keys, path) {
+  if (Object.keys(value).some((key) => !keys.includes(key))) fail(path, "unsupported_field", "Direct synthesis contains an unsupported field");
+}
+function nonEmptyString(value, path, max = 1e3) {
+  if (typeof value !== "string" || !value.trim() || value.length > max) fail(path, "invalid_string", "Expected a bounded non-empty string");
+  return value.trim();
+}
+function stringArray(value, path, max, allowEmpty = true) {
+  if (!Array.isArray(value) || value.length > max || !allowEmpty && !value.length) fail(path, "invalid_string_array", "Expected a bounded string array");
+  const result = value.map((item, index) => nonEmptyString(item, `${path}[${index}]`));
+  if (new Set(result).size !== result.length) fail(path, "duplicate_reference", "References must not be duplicated");
+  return result;
+}
+function proof(value, path) {
+  if (value === null) return null;
+  if (value === "observed" || value === "supported" || value === "forced") return value;
+  return fail(path, "invalid_proof_strength", "Proof strength must be observed, supported, forced, or null");
+}
+function parseProviderAttributeEntries(value, path) {
+  if (!Array.isArray(value) || value.length > 32) fail(path, "invalid_attribute_entries", "Attribute entries must be a bounded array");
+  const attributes = {};
+  for (const [index, entry] of value.entries()) {
+    if (!isRecord(entry)) fail(`${path}[${index}]`, "invalid_attribute_entry", "Attribute entry must be structured");
+    exactKeys(entry, ["key", "value"], `${path}[${index}]`);
+    const key = nonEmptyString(entry.key, `${path}[${index}].key`, 160);
+    if (Object.hasOwn(attributes, key)) fail(`${path}[${index}].key`, "duplicate_attribute_key", "Attribute keys must be unique");
+    attributes[key] = parseProviderAttributeValue(entry.value, `${path}[${index}].value`);
+  }
+  return attributes;
+}
+function parseProviderAttributeValue(value, path) {
+  if (!isRecord(value)) fail(path, "invalid_attribute_value", "Attribute values must use the typed provider transport");
+  const type = value.type;
+  if (type === "string") {
+    exactKeys(value, ["type", "value"], path);
+    return nonEmptyString(value.value, `${path}.value`, 1e3);
+  }
+  if (type === "number") {
+    exactKeys(value, ["type", "value"], path);
+    if (typeof value.value !== "number" || !Number.isFinite(value.value)) fail(`${path}.value`, "invalid_attribute_number", "Attribute number must be finite");
+    return value.value;
+  }
+  if (type === "boolean") {
+    exactKeys(value, ["type", "value"], path);
+    if (typeof value.value !== "boolean") fail(`${path}.value`, "invalid_attribute_boolean", "Attribute boolean must be boolean");
+    return value.value;
+  }
+  if (type === "null") {
+    exactKeys(value, ["type", "value"], path);
+    if (value.value !== null) fail(`${path}.value`, "invalid_attribute_null", "Null attribute must carry null");
+    return null;
+  }
+  if (type === "array") {
+    exactKeys(value, ["type", "items"], path);
+    if (!Array.isArray(value.items) || value.items.length > 32) fail(`${path}.items`, "invalid_attribute_array", "Attribute array must be bounded");
+    return value.items.map((item, index) => parseProviderAttributeValue(item, `${path}.items[${index}]`));
+  }
+  if (type === "object") {
+    exactKeys(value, ["type", "entries"], path);
+    return parseProviderAttributeEntries(value.entries, `${path}.entries`);
+  }
+  return fail(`${path}.type`, "invalid_attribute_type", "Attribute value type is invalid");
+}
+function parseAttributes(value, path) {
+  if (!isRecord(value)) fail(path, "invalid_attributes", "Attributes must be an object");
+  if (Array.isArray(value.entries)) {
+    exactKeys(value, ["entries"], path);
+    return parseProviderAttributeEntries(value.entries, `${path}.entries`);
+  }
+  return value;
+}
+function assertNoCArtifacts(value, path = "proposal", topLevel = true) {
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertNoCArtifacts(item, `${path}[${index}]`, false));
+    return;
+  }
+  if (!isRecord(value)) return;
+  const forbiddenTopLevel = /* @__PURE__ */ new Set([
+    "review",
+    "reviews",
+    "critic",
+    "critics",
+    "challenge",
+    "challenges",
+    "terminalReview",
+    "answerObligation",
+    "answerObligations",
+    "selectedGraph",
+    "selectedEntities",
+    "selectedRelations",
+    "graphRefs",
+    "hypothesisLedgerRevision",
+    "discourse",
+    "discoursePlan",
+    "render",
+    "repair"
+  ]);
+  if (topLevel) {
+    for (const key of Object.keys(value)) if (forbiddenTopLevel.has(key)) {
+      fail(`${path}.${key}`, "semantic_c_artifact", "Direct synthesis must not transport staged-C semantic artifacts");
+    }
+  }
+  if (Array.isArray(value.selectedEntities) || Array.isArray(value.selectedRelations) || typeof value.hypothesisLedgerRevision === "string" || isRecord(value.discoursePlan) && typeof value.discoursePlan.checkpointId === "string" || isRecord(value.reasoningCheckpoint) && typeof value.reasoningCheckpoint.checkpointVersion === "string") {
+    fail(path, "semantic_c_artifact", "Direct synthesis must not transport a staged-C envelope");
+  }
+  for (const [key, child] of Object.entries(value)) assertNoCArtifacts(child, `${path}.${key}`, false);
+}
+function parseSegment(value, path) {
+  if (!isRecord(value)) return fail(path, "invalid_segment", "Narrative segments must be typed objects");
+  const type = nonEmptyString(value.type, `${path}.type`, 64);
+  if (type === "text") {
+    exactKeys(value, ["type", "text"], path);
+    const text = nonEmptyString(value.text, `${path}.text`, 600);
+    if (RAW_CHESS_TEXT.test(text)) fail(`${path}.text`, "raw_chess_reference", "Concrete chess references must use typed segments");
+    return { type: "text", text };
+  }
+  if (type === "piece") {
+    exactKeys(value, ["type", "pieceId", "form", "capitalize", "label"], path);
+    const form = value.form;
+    if (form !== void 0 && form !== null && form !== "definite" && form !== "color-qualified" && form !== "square-qualified" && form !== "canonical" && form !== "bare" && form !== "bare-square-qualified") {
+      fail(`${path}.form`, "invalid_piece_form", "Piece reference form is invalid");
+    }
+    if (value.capitalize !== void 0 && value.capitalize !== null && typeof value.capitalize !== "boolean") fail(`${path}.capitalize`, "invalid_piece_capitalization", "Piece capitalization must be boolean");
+    if (value.label !== void 0 && value.label !== null) nonEmptyString(value.label, `${path}.label`, 120);
+    return { type: "piece", pieceId: nonEmptyString(value.pieceId, `${path}.pieceId`, 200), ...form === void 0 || form === null ? {} : { form }, ...value.capitalize === void 0 || value.capitalize === null ? {} : { capitalize: value.capitalize }, ...value.label === void 0 || value.label === null ? {} : { label: value.label } };
+  }
+  if (type === "piece-kind") {
+    exactKeys(value, ["type", "pieceKind", "color", "label"], path);
+    const pieceKind = nonEmptyString(value.pieceKind, `${path}.pieceKind`, 20);
+    if (!["bishop", "king", "knight", "pawn", "queen", "rook"].includes(pieceKind)) fail(`${path}.pieceKind`, "invalid_piece_kind", "Piece kind is invalid");
+    if (value.color !== "w" && value.color !== "b" && value.color !== null) fail(`${path}.color`, "invalid_piece_color", "Piece-kind color is invalid");
+    if (value.label !== void 0 && value.label !== null) nonEmptyString(value.label, `${path}.label`, 120);
+    return { type: "piece-kind", pieceKind, color: value.color, ...value.label === void 0 || value.label === null ? {} : { label: value.label } };
+  }
+  if (type === "square") {
+    exactKeys(value, ["type", "square", "label"], path);
+    if (value.label !== void 0 && value.label !== null) nonEmptyString(value.label, `${path}.label`, 120);
+    return { type: "square", square: nonEmptyString(value.square, `${path}.square`, 2), ...value.label === void 0 || value.label === null ? {} : { label: value.label } };
+  }
+  if (type === "move") {
+    exactKeys(value, ["type", "uci", "pieceId", "san", "label"], path);
+    if (value.label !== void 0 && value.label !== null) nonEmptyString(value.label, `${path}.label`, 120);
+    return { type: "move", uci: nonEmptyString(value.uci, `${path}.uci`, 5), pieceId: nonEmptyString(value.pieceId, `${path}.pieceId`, 200), san: nonEmptyString(value.san, `${path}.san`, 40), ...value.label === void 0 || value.label === null ? {} : { label: value.label } };
+  }
+  if (type === "entity") {
+    exactKeys(value, ["type", "entityLocalId", "label"], path);
+    if (value.label !== void 0 && value.label !== null) nonEmptyString(value.label, `${path}.label`, 120);
+    return { type: "entity", entityLocalId: nonEmptyString(value.entityLocalId, `${path}.entityLocalId`, 160), ...value.label === void 0 || value.label === null ? {} : { label: value.label } };
+  }
+  if (type === "relation") {
+    exactKeys(value, ["type", "relationLocalId", "fromEntityLocalId", "toEntityLocalId", "label"], path);
+    if (value.label !== void 0 && value.label !== null) nonEmptyString(value.label, `${path}.label`, 120);
+    return {
+      type: "relation",
+      relationLocalId: nonEmptyString(value.relationLocalId, `${path}.relationLocalId`, 160),
+      fromEntityLocalId: nonEmptyString(value.fromEntityLocalId, `${path}.fromEntityLocalId`, 160),
+      toEntityLocalId: nonEmptyString(value.toEntityLocalId, `${path}.toEntityLocalId`, 160),
+      ...value.label === void 0 || value.label === null ? {} : { label: value.label }
+    };
+  }
+  return fail(`${path}.type`, "unknown_segment_type", "Narrative segment type is not supported");
+}
+function parseClaim(value, path) {
+  if (!isRecord(value)) return fail(path, "invalid_claim", "Claim must be an object");
+  exactKeys(value, ["localId", "kind", "content", "proofStrength", "evidenceIds", "qualifications"], path);
+  const kind = value.kind;
+  if (kind !== "fact" && kind !== "interpretation" && kind !== "consequence" && kind !== "defense" && kind !== "uncertainty") fail(`${path}.kind`, "invalid_claim_kind", "Claim kind is invalid");
+  if (!Array.isArray(value.content) || !value.content.length || value.content.length > 32) fail(`${path}.content`, "invalid_claim_content", "Claim requires bounded typed content");
+  if (!Array.isArray(value.qualifications) || value.qualifications.length > 8) fail(`${path}.qualifications`, "invalid_qualifications", "Claim qualifications must be bounded typed segment arrays");
+  return {
+    localId: nonEmptyString(value.localId, `${path}.localId`, 160),
+    kind,
+    content: value.content.map((segment, index) => parseSegment(segment, `${path}.content[${index}]`)),
+    proofStrength: proof(value.proofStrength, `${path}.proofStrength`),
+    evidenceIds: stringArray(value.evidenceIds, `${path}.evidenceIds`, 12, false),
+    qualifications: value.qualifications.map((qualification, index) => {
+      if (!Array.isArray(qualification) || !qualification.length || qualification.length > 16) fail(`${path}.qualifications[${index}]`, "invalid_qualification", "Each qualification requires typed content");
+      return qualification.map((segment, segmentIndex) => parseSegment(segment, `${path}.qualifications[${index}][${segmentIndex}]`));
+    })
+  };
+}
+function parseHypothesis(value, path) {
+  if (!isRecord(value)) return fail(path, "invalid_hypothesis", "Hypothesis must be an object");
+  exactKeys(value, ["localId", "entityType", "concepts", "owner", "participants", "attributes", "proofStrength", "evidenceIds", "sourceObservationIds", "parentHypothesisIds", "anchorRequirements"], path);
+  if (value.owner !== "w" && value.owner !== "b" && value.owner !== null) fail(`${path}.owner`, "invalid_owner", "Hypothesis owner is invalid");
+  if (!Array.isArray(value.participants) || value.participants.length > 12) fail(`${path}.participants`, "invalid_participants", "Hypothesis participants must be bounded");
+  const participants = value.participants.map((participant2, index) => {
+    if (!isRecord(participant2) || !isRecord(participant2.ref)) fail(`${path}.participants[${index}]`, "invalid_participant", "Participant must have a typed reference");
+    exactKeys(participant2, ["role", "ref"], `${path}.participants[${index}]`);
+    exactKeys(participant2.ref, ["domain", "id"], `${path}.participants[${index}].ref`);
+    return {
+      role: nonEmptyString(participant2.role, `${path}.participants[${index}].role`, 160),
+      ref: {
+        domain: nonEmptyString(participant2.ref.domain, `${path}.participants[${index}].ref.domain`, 160),
+        id: nonEmptyString(participant2.ref.id, `${path}.participants[${index}].ref.id`, 200)
+      }
+    };
+  });
+  if (!Array.isArray(value.anchorRequirements) || value.anchorRequirements.length > 12) fail(`${path}.anchorRequirements`, "invalid_anchor_requirements", "Hypothesis anchors must be bounded");
+  const anchorRequirements = value.anchorRequirements.map((anchor, index) => {
+    if (!isRecord(anchor) || !isRecord(anchor.participant) || !isRecord(anchor.participant.ref)) fail(`${path}.anchorRequirements[${index}]`, "invalid_anchor_requirement", "Anchor requirement is malformed");
+    exactKeys(anchor, ["participant", "disposition"], `${path}.anchorRequirements[${index}]`);
+    exactKeys(anchor.participant, ["role", "ref"], `${path}.anchorRequirements[${index}].participant`);
+    exactKeys(anchor.participant.ref, ["domain", "id"], `${path}.anchorRequirements[${index}].participant.ref`);
+    if (anchor.disposition !== "required") fail(`${path}.anchorRequirements[${index}].disposition`, "invalid_anchor_disposition", "Anchor disposition must be required");
+    return {
+      disposition: "required",
+      participant: {
+        role: nonEmptyString(anchor.participant.role, `${path}.anchorRequirements[${index}].participant.role`, 160),
+        ref: {
+          domain: nonEmptyString(anchor.participant.ref.domain, `${path}.anchorRequirements[${index}].participant.ref.domain`, 160),
+          id: nonEmptyString(anchor.participant.ref.id, `${path}.anchorRequirements[${index}].participant.ref.id`, 200)
+        }
+      }
+    };
+  });
+  return {
+    localId: nonEmptyString(value.localId, `${path}.localId`, 160),
+    entityType: nonEmptyString(value.entityType, `${path}.entityType`, 160),
+    concepts: stringArray(value.concepts, `${path}.concepts`, 4, false),
+    owner: value.owner,
+    participants,
+    attributes: parseAttributes(value.attributes, `${path}.attributes`),
+    proofStrength: proof(value.proofStrength, `${path}.proofStrength`),
+    evidenceIds: stringArray(value.evidenceIds, `${path}.evidenceIds`, 12),
+    sourceObservationIds: stringArray(value.sourceObservationIds, `${path}.sourceObservationIds`, 12),
+    parentHypothesisIds: stringArray(value.parentHypothesisIds, `${path}.parentHypothesisIds`, 8),
+    anchorRequirements
+  };
+}
+function parseRelation(value, path) {
+  if (!isRecord(value)) return fail(path, "invalid_relation", "Relation must be an object");
+  exactKeys(value, ["localId", "relationType", "from", "to", "attributes", "evidenceIds", "sourceObservationIds"], path);
+  return {
+    localId: nonEmptyString(value.localId, `${path}.localId`, 160),
+    relationType: nonEmptyString(value.relationType, `${path}.relationType`, 160),
+    from: nonEmptyString(value.from, `${path}.from`, 160),
+    to: nonEmptyString(value.to, `${path}.to`, 160),
+    attributes: parseAttributes(value.attributes, `${path}.attributes`),
+    evidenceIds: stringArray(value.evidenceIds, `${path}.evidenceIds`, 12, false),
+    sourceObservationIds: stringArray(value.sourceObservationIds, `${path}.sourceObservationIds`, 12)
+  };
+}
+function parseCoverageLane(value, path) {
+  if (!isRecord(value)) return fail(path, "invalid_coverage_lane", "Coverage lane must be structured");
+  exactKeys(value, ["status", "evidenceIds", "unresolved"], path);
+  if (value.status !== "complete" && value.status !== "partial" && value.status !== "unavailable") fail(`${path}.status`, "invalid_coverage_status", "Coverage status is invalid");
+  const evidenceIds = stringArray(value.evidenceIds, `${path}.evidenceIds`, 12);
+  const unresolved = stringArray(value.unresolved, `${path}.unresolved`, 24);
+  if (value.status === "complete" && unresolved.length) fail(`${path}.unresolved`, "complete_coverage_has_unresolved", "Complete coverage cannot retain unresolved obligations");
+  return { status: value.status, evidenceIds, unresolved };
+}
+function parseOmissions(value, path) {
+  if (!Array.isArray(value) || value.length > 24) fail(path, "invalid_omissions", "Omissions must be a bounded array");
+  const omissions = value.map((item, index) => {
+    if (!isRecord(item)) return fail(`${path}[${index}]`, "invalid_omission", "Omission must be structured");
+    exactKeys(item, ["localId", "reason"], `${path}[${index}]`);
+    return { localId: nonEmptyString(item.localId, `${path}[${index}].localId`, 160), reason: nonEmptyString(item.reason, `${path}[${index}].reason`, 500) };
+  });
+  if (new Set(omissions.map((item) => item.localId)).size !== omissions.length) fail(path, "duplicate_omission", "Omitted local IDs must be unique");
+  return omissions;
+}
+function parseCoverage(value, path) {
+  if (!isRecord(value)) return fail(path, "invalid_coverage", "Direct synthesis requires structured coverage");
+  exactKeys(value, ["responseCoverage", "continuationCoverage", "unresolvedEvidenceObligations", "omittedHypotheses", "omittedRelations"], path);
+  if (!Array.isArray(value.unresolvedEvidenceObligations) || value.unresolvedEvidenceObligations.length > 24) fail(`${path}.unresolvedEvidenceObligations`, "invalid_unresolved_obligations", "Unresolved evidence obligations must be bounded");
+  const unresolvedEvidenceObligations = value.unresolvedEvidenceObligations.map((item, index) => {
+    if (!isRecord(item)) return fail(`${path}.unresolvedEvidenceObligations[${index}]`, "invalid_unresolved_obligation", "Unresolved evidence obligation must be structured");
+    exactKeys(item, ["id", "reason"], `${path}.unresolvedEvidenceObligations[${index}]`);
+    return { id: nonEmptyString(item.id, `${path}.unresolvedEvidenceObligations[${index}].id`, 160), reason: nonEmptyString(item.reason, `${path}.unresolvedEvidenceObligations[${index}].reason`, 500) };
+  });
+  if (new Set(unresolvedEvidenceObligations.map((item) => item.id)).size !== unresolvedEvidenceObligations.length) fail(`${path}.unresolvedEvidenceObligations`, "duplicate_unresolved_obligation", "Unresolved evidence obligations must be unique");
+  return {
+    responseCoverage: parseCoverageLane(value.responseCoverage, `${path}.responseCoverage`),
+    continuationCoverage: parseCoverageLane(value.continuationCoverage, `${path}.continuationCoverage`),
+    unresolvedEvidenceObligations,
+    omittedHypotheses: parseOmissions(value.omittedHypotheses, `${path}.omittedHypotheses`),
+    omittedRelations: parseOmissions(value.omittedRelations, `${path}.omittedRelations`)
+  };
+}
+function parseDemonstration(value, path) {
+  if (!isRecord(value)) return fail(path, "invalid_demonstration", "Demonstration must be an object");
+  const type = value.type;
+  if (type === "legal-variation") {
+    exactKeys(value, ["localId", "type", "start", "moves", "label", "evidenceIds"], path);
+    if (value.start !== "before" && value.start !== "after") fail(`${path}.start`, "invalid_variation_start", "Variation start must be before or after");
+    if (!Array.isArray(value.moves) || !value.moves.length || value.moves.length > 16) fail(`${path}.moves`, "invalid_variation_moves", "Variation requires bounded moves");
+    return {
+      localId: nonEmptyString(value.localId, `${path}.localId`, 160),
+      type,
+      start: value.start,
+      moves: value.moves.map((move, index) => {
+        if (!isRecord(move)) return fail(`${path}.moves[${index}]`, "invalid_variation_move", "Variation move must be typed");
+        exactKeys(move, ["uci", "pieceId", "san"], `${path}.moves[${index}]`);
+        return { uci: nonEmptyString(move.uci, `${path}.moves[${index}].uci`, 5), pieceId: nonEmptyString(move.pieceId, `${path}.moves[${index}].pieceId`, 200), san: nonEmptyString(move.san, `${path}.moves[${index}].san`, 40) };
+      }),
+      label: nonEmptyString(value.label, `${path}.label`, 160),
+      evidenceIds: stringArray(value.evidenceIds, `${path}.evidenceIds`, 12, false)
+    };
+  }
+  if (type === "conditional-route") {
+    exactKeys(value, ["localId", "type", "pieceId", "waypoints", "prerequisiteRefs", "label", "evidenceIds"], path);
+    if (!Array.isArray(value.prerequisiteRefs) || !value.prerequisiteRefs.length || value.prerequisiteRefs.length > 16) fail(`${path}.prerequisiteRefs`, "invalid_route_prerequisites", "Route prerequisites require typed references");
+    return {
+      localId: nonEmptyString(value.localId, `${path}.localId`, 160),
+      type,
+      pieceId: nonEmptyString(value.pieceId, `${path}.pieceId`, 200),
+      waypoints: stringArray(value.waypoints, `${path}.waypoints`, 16, false),
+      prerequisiteRefs: value.prerequisiteRefs.map((segment, index) => parseSegment(segment, `${path}.prerequisiteRefs[${index}]`)),
+      label: nonEmptyString(value.label, `${path}.label`, 160),
+      evidenceIds: stringArray(value.evidenceIds, `${path}.evidenceIds`, 12, false)
+    };
+  }
+  if (type === "static-relationship") {
+    exactKeys(value, ["localId", "type", "relationLocalId", "fromEntityLocalId", "toEntityLocalId", "label", "evidenceIds"], path);
+    return {
+      localId: nonEmptyString(value.localId, `${path}.localId`, 160),
+      type,
+      relationLocalId: nonEmptyString(value.relationLocalId, `${path}.relationLocalId`, 160),
+      fromEntityLocalId: nonEmptyString(value.fromEntityLocalId, `${path}.fromEntityLocalId`, 160),
+      toEntityLocalId: nonEmptyString(value.toEntityLocalId, `${path}.toEntityLocalId`, 160),
+      label: nonEmptyString(value.label, `${path}.label`, 160),
+      evidenceIds: stringArray(value.evidenceIds, `${path}.evidenceIds`, 12, false)
+    };
+  }
+  return fail(`${path}.type`, "invalid_demonstration_type", "Demonstration type is invalid");
+}
+function parseDirectSynthesisProposal(value) {
+  assertNoCArtifacts(value);
+  if (!isRecord(value)) return fail("proposal", "invalid_proposal", "Direct synthesis proposal must be an object");
+  exactKeys(value, ["schemaVersion", "hypotheses", "relations", "claims", "demonstrations", "coverage", "limitations", "riskProfile"], "proposal");
+  if (value.schemaVersion !== ABLATION_DIRECT_SYNTHESIS_VERSION) fail("proposal.schemaVersion", "unsupported_version", "Unsupported direct synthesis schema version");
+  if (!Array.isArray(value.hypotheses) || !value.hypotheses.length || value.hypotheses.length > 16) fail("proposal.hypotheses", "invalid_hypotheses", "Direct synthesis requires one bounded hypothesis batch");
+  if (!Array.isArray(value.relations) || value.relations.length > 24) fail("proposal.relations", "invalid_relations", "Relations must be a bounded array");
+  if (!Array.isArray(value.claims) || !value.claims.length || value.claims.length > 16) fail("proposal.claims", "invalid_claims", "Direct synthesis requires bounded typed claims");
+  if (value.demonstrations !== void 0 && value.demonstrations !== null && (!Array.isArray(value.demonstrations) || value.demonstrations.length > 8)) fail("proposal.demonstrations", "invalid_demonstrations", "Demonstrations must be a bounded array or null");
+  if (!isRecord(value.riskProfile)) fail("proposal.riskProfile", "invalid_risk_profile", "Risk profile must be structured");
+  exactKeys(value.riskProfile, ["level", "reasons"], "proposal.riskProfile");
+  if (value.riskProfile.level !== "low" && value.riskProfile.level !== "medium" && value.riskProfile.level !== "high") fail("proposal.riskProfile.level", "invalid_risk_level", "Risk level is invalid");
+  return {
+    schemaVersion: ABLATION_DIRECT_SYNTHESIS_VERSION,
+    hypotheses: value.hypotheses.map((hypothesis, index) => parseHypothesis(hypothesis, `proposal.hypotheses[${index}]`)),
+    relations: value.relations.map((relation, index) => parseRelation(relation, `proposal.relations[${index}]`)),
+    claims: value.claims.map((claim, index) => parseClaim(claim, `proposal.claims[${index}]`)),
+    ...value.demonstrations === void 0 || value.demonstrations === null ? {} : { demonstrations: value.demonstrations.map((demonstration, index) => parseDemonstration(demonstration, `proposal.demonstrations[${index}]`)) },
+    coverage: parseCoverage(value.coverage, "proposal.coverage"),
+    limitations: stringArray(value.limitations, "proposal.limitations", 24),
+    riskProfile: { level: value.riskProfile.level, reasons: stringArray(value.riskProfile.reasons, "proposal.riskProfile.reasons", 12) }
+  };
+}
+function proofRank(value) {
+  return value === "observed" ? 1 : value === "supported" ? 2 : 3;
+}
+function assertDistinctLocalIds(proposal) {
+  const localIds = [
+    ...proposal.hypotheses.map((item) => item.localId),
+    ...proposal.relations.map((item) => item.localId),
+    ...proposal.claims.map((item) => item.localId),
+    ...(proposal.demonstrations || []).map((item) => item.localId)
+  ];
+  if (new Set(localIds).size !== localIds.length) fail("proposal", "duplicate_local_id", "Model-local IDs must be unique within one direct synthesis result");
+}
+function admittedEvidenceIds(bundle, ids, path) {
+  const allowed = new Set(bundle.referenceAllowlists.evidenceIds);
+  const records = new Map(bundle.evidence.map((record) => [record.id, record]));
+  for (const id of ids) if (!allowed.has(id) || !records.has(id)) fail(path, "unknown_evidence", "Evidence is outside the frozen closure", [...allowed]);
+  return ids.map((id) => records.get(id));
+}
+function assertEvidenceProof(bundle, ids, path, requestedProof) {
+  const records = admittedEvidenceIds(bundle, ids, path);
+  if (requestedProof && !records.some((record) => record.proofStrength && proofRank(record.proofStrength) >= proofRank(requestedProof))) {
+    fail(path, "unsupported_proof_strength", "Claimed proof strength exceeds cited evidence");
+  }
+  return records;
+}
+function hasMeaningLicense(record) {
+  return record.some((item) => licensesSemanticChessGrounding(effectiveLicensesForRecord(item)));
+}
+function assertEvidenceSupportsMeaning(bundle, ids, path, requestedProof) {
+  const records = assertEvidenceProof(bundle, ids, path, requestedProof);
+  if (!hasMeaningLicense(records)) fail(path, "underlicensed_semantic_meaning", "Semantic meaning requires centrally licensed position, bounded-engine, or reviewed-semantic evidence; legality and identity alone are insufficient");
+}
+function assertEvidenceSupportsRouteMeaning(bundle, ids, path) {
+  const records = admittedEvidenceIds(bundle, ids, path);
+  if (!records.some((record) => licensesBoundedRouteRelevance(effectiveLicensesForRecord(record)))) {
+    fail(path, "underlicensed_route_meaning", "Conditional routes and plans require bounded continuation, comparison, or response-coverage evidence");
+  }
+}
+function assertEvidenceSupportsClaim(bundle, ids, path, kind, requestedProof) {
+  const records = assertEvidenceProof(bundle, ids, path, requestedProof);
+  const licenses = records.flatMap((record) => effectiveLicensesForRecord(record));
+  if (kind === "fact" || kind === "uncertainty") {
+    if (!licenses.some((license) => license === EVIDENCE_LICENSE.CHESS_LEGALITY || license === EVIDENCE_LICENSE.CHESS_IDENTITY || license === EVIDENCE_LICENSE.CHESS_POSITION_FACT || license.startsWith("engine."))) {
+      fail(path, "underlicensed_fact_claim", "Fact claim lacks exact or bounded-engine evidence");
+    }
+    return;
+  }
+  if (kind === "interpretation" || kind === "consequence") {
+    if (!hasMeaningLicense(records)) fail(path, "underlicensed_semantic_meaning", "Interpretation/consequence claims cannot be grounded only by legality, identity, or bounded comparison score evidence");
+    return;
+  }
+  if (!licenses.includes(EVIDENCE_LICENSE.ENGINE_BOUNDED_RESPONSE_COVERAGE) && !licenses.includes(EVIDENCE_LICENSE.ENGINE_BOUNDED_CONTINUATION)) {
+    fail(path, "underlicensed_defense_claim", "Defense claims require bounded response or continuation evidence");
+  }
+}
+function referenceAuthority(bundle) {
+  const pieces = new Set(bundle.referenceAllowlists.semanticReferences.filter((item) => item.domain === REFERENCE_DOMAINS.PIECE).map((item) => item.id));
+  const squares = new Set(bundle.referenceAllowlists.semanticReferences.filter((item) => item.domain === REFERENCE_DOMAINS.SQUARE).map((item) => item.id));
+  const moveIds = new Set(bundle.referenceAllowlists.semanticReferences.filter((item) => item.domain === REFERENCE_DOMAINS.MOVE).map((item) => item.id));
+  const moves = /* @__PURE__ */ new Map();
+  for (const witness of bundle.referenceAllowlists.moveWitnesses) {
+    const key = `${witness.uci}:${witness.pieceId}:${witness.san}`;
+    const evidence = moves.get(key) || /* @__PURE__ */ new Set();
+    evidence.add(witness.evidenceId);
+    moves.set(key, evidence);
+  }
+  return { pieces, squares, moveIds, moves };
+}
+function addClosureReferences(value, global, scoped) {
+  if (typeof value === "string") {
+    if (global.pieces.has(value)) scoped.pieces.add(value);
+    if (global.squares.has(value)) scoped.squares.add(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item) => addClosureReferences(item, global, scoped));
+    return;
+  }
+  if (isRecord(value)) Object.values(value).forEach((item) => addClosureReferences(item, global, scoped));
+}
+function scopedReferenceAuthority(bundle, evidenceIds, semanticParticipants = []) {
+  const global = referenceAuthority(bundle);
+  const pieces = /* @__PURE__ */ new Set();
+  const squares = /* @__PURE__ */ new Set();
+  const moves = /* @__PURE__ */ new Map();
+  const addWitness = (witness) => {
+    if (!global.moveIds.has(witness.uci)) return;
+    const key = `${witness.uci}:${witness.pieceId}:${witness.san}`;
+    const sources = moves.get(key) || /* @__PURE__ */ new Set();
+    sources.add(witness.evidenceId);
+    moves.set(key, sources);
+    if (global.pieces.has(witness.pieceId)) pieces.add(witness.pieceId);
+    if (global.squares.has(witness.uci.slice(0, 2))) squares.add(witness.uci.slice(0, 2));
+    if (global.squares.has(witness.uci.slice(2, 4))) squares.add(witness.uci.slice(2, 4));
+  };
+  bundle.referenceAllowlists.moveWitnesses.filter((witness) => witness.uci === bundle.context.moveUci).forEach(addWitness);
+  const requested = new Set(evidenceIds);
+  for (const record of bundle.evidence) {
+    if (!requested.has(record.id)) continue;
+    addClosureReferences(record.data, global, { pieces, squares });
+    collectReasoningMoveWitnesses([record], bundle.context).forEach(addWitness);
+  }
+  for (const participant2 of semanticParticipants) {
+    if (participant2.ref.domain === REFERENCE_DOMAINS.PIECE && global.pieces.has(participant2.ref.id)) pieces.add(participant2.ref.id);
+    if (participant2.ref.domain === REFERENCE_DOMAINS.SQUARE && global.squares.has(participant2.ref.id)) squares.add(participant2.ref.id);
+  }
+  return { pieces, squares, moveIds: global.moveIds, moves };
+}
+function assertTypedParticipantReference(reference, evidenceIds, authority, path) {
+  if (reference.domain === REFERENCE_DOMAINS.PIECE) {
+    if (!authority.pieces.has(reference.id)) fail(path, "participant_outside_closure", "Piece participant is outside the frozen semantic-reference allowlist", [...authority.pieces]);
+    return;
+  }
+  if (reference.domain === REFERENCE_DOMAINS.SQUARE) {
+    if (!authority.squares.has(reference.id)) fail(path, "participant_outside_closure", "Square participant is outside the frozen semantic-reference allowlist", [...authority.squares]);
+    return;
+  }
+  if (reference.domain === REFERENCE_DOMAINS.MOVE) {
+    const witnessed = [...authority.moves.entries()].some(([key, evidence]) => key.startsWith(`${reference.id}:`) && [...evidence].some((id) => evidenceIds.includes(id)));
+    if (!authority.moveIds.has(reference.id) || !witnessed) fail(path, "participant_move_unwitnessed", "Move participant lacks a typed allowlist entry or cited exact witness in the frozen closure", [...authority.moves.keys()]);
+    return;
+  }
+  fail(path, "participant_outside_closure", "Participant domain is outside the frozen semantic-reference allowlist", [REFERENCE_DOMAINS.PIECE, REFERENCE_DOMAINS.SQUARE, REFERENCE_DOMAINS.MOVE]);
+}
+function assertHypothesisReferenceAuthority(hypothesis, evidenceIds, authority, path) {
+  hypothesis.participants.forEach((participant2, index) => assertTypedParticipantReference(participant2.ref, evidenceIds, authority, `${path}.participants[${index}].ref`));
+  hypothesis.anchorRequirements.forEach((anchor, index) => assertTypedParticipantReference(anchor.participant.ref, evidenceIds, authority, `${path}.anchorRequirements[${index}].participant.ref`));
+}
+function hasEvidenceAssociation(itemEvidenceIds, semanticEvidenceIds) {
+  return itemEvidenceIds.some((id) => semanticEvidenceIds.includes(id));
+}
+function semanticParticipantsForSegments(segments, hypothesesByLocalId, relationsByLocalId) {
+  const participants = [];
+  const addHypothesis = (localId) => {
+    const hypothesis = hypothesesByLocalId.get(localId);
+    if (hypothesis) participants.push(...hypothesis.participants);
+  };
+  for (const segment of segments) {
+    if (segment.type === "entity") addHypothesis(segment.entityLocalId);
+    if (segment.type === "relation") {
+      const relation = relationsByLocalId.get(segment.relationLocalId);
+      if (relation) {
+        addHypothesis(relation.from);
+        addHypothesis(relation.to);
+      }
+    }
+  }
+  return participants;
+}
+function remapSegments(segments, path, evidenceIds, authority, localToCanonical, relationByLocalId, hypothesisByCanonicalId, semanticParticipants, bundle) {
+  const itemAuthority = scopedReferenceAuthority(bundle, evidenceIds, semanticParticipants);
+  const evidenceSet = new Set(evidenceIds);
+  const timeline = createPocIdentityTimeline(bundle.context);
+  return segments.map((segment, index) => {
+    const segmentPath = `${path}[${index}]`;
+    if (segment.type === "text") return segment;
+    if (segment.type === "piece") {
+      if (!authority.pieces.has(segment.pieceId) || !pieceIdentity(timeline.before, segment.pieceId) && !pieceIdentity(timeline.after, segment.pieceId)) {
+        fail(segmentPath, "untyped_piece_reference", "Piece reference is not admitted by the frozen closure", [...authority.pieces]);
+      }
+      if (!itemAuthority.pieces.has(segment.pieceId)) {
+        fail(segmentPath, "item_unscoped_piece_reference", "Piece reference is not grounded by this item's target, cited evidence, or typed semantic binding", [...itemAuthority.pieces]);
+      }
+      return segment;
+    }
+    if (segment.type === "piece-kind") {
+      const type = { bishop: "b", king: "k", knight: "n", pawn: "p", queen: "q", rook: "r" }[segment.pieceKind];
+      const authorized = [...itemAuthority.pieces].some((pieceId) => {
+        const identity = pieceIdentity(timeline.before, pieceId) || pieceIdentity(timeline.after, pieceId);
+        return identity?.type === type && (segment.color === null || identity.color === segment.color);
+      });
+      if (!authorized) fail(segmentPath, "item_unscoped_piece_kind_reference", "Generic piece reference is not grounded by this item's authority", [...itemAuthority.pieces]);
+      return segment;
+    }
+    if (segment.type === "square") {
+      if (!SQUARES.includes(segment.square) || !authority.squares.has(segment.square)) {
+        fail(segmentPath, "untyped_square_reference", "Square reference is not admitted by the frozen closure", [...authority.squares]);
+      }
+      if (!itemAuthority.squares.has(segment.square)) {
+        fail(segmentPath, "item_unscoped_square_reference", "Square reference is not grounded by this item's target, cited evidence, or typed semantic binding", [...itemAuthority.squares]);
+      }
+      return segment;
+    }
+    if (segment.type === "move") {
+      const witnesses = itemAuthority.moves.get(`${segment.uci}:${segment.pieceId}:${segment.san}`);
+      if (!itemAuthority.moveIds.has(segment.uci) || !witnesses || ![...witnesses].some((id) => evidenceSet.has(id))) {
+        fail(segmentPath, "untyped_move_reference", "Move reference lacks an exact cited evidence witness", [...itemAuthority.moves.keys()]);
+      }
+      return { type: "move", uci: segment.uci, pieceId: segment.pieceId, san: segment.san, ...segment.label === void 0 ? {} : { label: segment.label } };
+    }
+    if (segment.type === "entity") {
+      const entityId = localToCanonical[segment.entityLocalId];
+      if (!entityId) fail(segmentPath, "unknown_local_entity", "Entity local reference is not declared by this proposal");
+      const hypothesis = hypothesisByCanonicalId.get(entityId);
+      if (!hypothesis || !hasEvidenceAssociation(evidenceIds, hypothesis.evidenceIds)) {
+        fail(segmentPath, "unrelated_semantic_evidence", "Entity segment must cite evidence associated with its canonical hypothesis");
+      }
+      return { type: "entity", entityId, ...segment.label === void 0 ? {} : { label: segment.label } };
+    }
+    const relation = relationByLocalId.get(segment.relationLocalId);
+    const fromEntityId = localToCanonical[segment.fromEntityLocalId];
+    const toEntityId = localToCanonical[segment.toEntityLocalId];
+    if (!relation || !fromEntityId || !toEntityId) fail(segmentPath, "dangling_local_relation", "Relation local reference is not declared by this proposal");
+    if (relation.fromHypothesisId !== fromEntityId || relation.toHypothesisId !== toEntityId) {
+      fail(segmentPath, "relation_endpoint_mismatch", "Relation segment endpoints do not match the canonical relation");
+    }
+    if (!hasEvidenceAssociation(evidenceIds, relation.evidenceIds)) {
+      fail(segmentPath, "unrelated_semantic_evidence", "Relation segment must cite evidence associated with its canonical relation");
+    }
+    return { type: "relation", relationId: relation.id, fromEntityId, toEntityId, ...segment.label === void 0 ? {} : { label: segment.label } };
+  });
+}
+function validateVariation(demonstration, bundle, path) {
+  const citedEvidence = new Set(demonstration.evidenceIds);
+  const witnesses = collectReasoningMoveWitnesses(
+    bundle.evidence.filter((record) => citedEvidence.has(record.id)),
+    bundle.context
+  );
+  const submitted = demonstration.moves.map((move) => `${move.uci}:${move.pieceId}:${move.san}`);
+  for (const key of submitted) if (!witnesses.some((witness) => `${witness.uci}:${witness.pieceId}:${witness.san}` === key)) {
+    fail(path, "variation_witness_missing", "Variation move lacks an exact cited evidence witness");
+  }
+  const starts = bundle.evidence.filter((record) => citedEvidence.has(record.id)).flatMap((record) => {
+    const replay = record.replay;
+    if (!replay) return [];
+    const start = replay.fen === bundle.context.fenBefore ? "before" : replay.fen === bundle.context.fenAfter ? "after" : null;
+    const moves = Array.isArray(replay.movesUci) ? replay.movesUci : Array.isArray(replay.moves) ? replay.moves : Array.isArray(replay.line) ? replay.line : typeof replay.move === "string" ? [replay.move] : [];
+    return start && moves.every((move) => typeof move === "string") ? [{ start, moves }] : [];
+  });
+  const submittedUci = demonstration.moves.map((move) => move.uci);
+  if (!starts.some((candidate) => candidate.start === demonstration.start && submittedUci.every((move, index) => candidate.moves[index] === move))) {
+    fail(path, "variation_sequence_not_grounded", "Variation must be an exact prefix of one cited replayable evidence line");
+  }
+}
+function assertCoverageEvidence(bundle, coverage) {
+  for (const [path, lane] of [["responseCoverage", coverage.responseCoverage], ["continuationCoverage", coverage.continuationCoverage]]) {
+    admittedEvidenceIds(bundle, lane.evidenceIds, `proposal.coverage.${path}.evidenceIds`);
+  }
+}
+function validateAndMaterializeCoverage(coverage, records, relations, localToCanonical, relationByLocalId, claims, demonstrations) {
+  const omittedHypotheses = coverage.omittedHypotheses.map((item) => {
+    const hypothesisId = localToCanonical[item.localId];
+    if (!hypothesisId) fail("proposal.coverage.omittedHypotheses", "unknown_omitted_hypothesis", "Omitted hypothesis does not name a local hypothesis");
+    return { hypothesisId, reason: item.reason };
+  });
+  const omittedRelations = coverage.omittedRelations.map((item) => {
+    const relation = relationByLocalId.get(item.localId);
+    if (!relation) fail("proposal.coverage.omittedRelations", "unknown_omitted_relation", "Omitted relation does not name a local relation");
+    return { relationId: relation.id, reason: item.reason };
+  });
+  const presentedHypothesisIds = /* @__PURE__ */ new Set();
+  const presentedRelationIds = /* @__PURE__ */ new Set();
+  const visitSegments = (segments) => {
+    for (const segment of segments) {
+      if (segment.type === "entity") presentedHypothesisIds.add(segment.entityId);
+      if (segment.type === "relation") {
+        presentedRelationIds.add(segment.relationId);
+        presentedHypothesisIds.add(segment.fromEntityId);
+        presentedHypothesisIds.add(segment.toEntityId);
+      }
+    }
+  };
+  claims.forEach((claim) => {
+    visitSegments(claim.content);
+    claim.qualifications.forEach(visitSegments);
+  });
+  demonstrations.forEach((demonstration) => {
+    if (demonstration.type === "conditional-route") visitSegments(demonstration.prerequisiteRefs);
+    if (demonstration.type === "static-relationship") {
+      presentedRelationIds.add(demonstration.relationId);
+      presentedHypothesisIds.add(demonstration.fromEntityId);
+      presentedHypothesisIds.add(demonstration.toEntityId);
+    }
+  });
+  const omittedHypothesisIds = new Set(omittedHypotheses.map((item) => item.hypothesisId));
+  const omittedRelationIds = new Set(omittedRelations.map((item) => item.relationId));
+  for (const record of records) {
+    if (!presentedHypothesisIds.has(record.id) && !omittedHypothesisIds.has(record.id)) {
+      fail("proposal.coverage.omittedHypotheses", "uncommunicated_hypothesis", "Every emitted hypothesis must be typed-presented or explicitly omitted");
+    }
+    if (presentedHypothesisIds.has(record.id) && omittedHypothesisIds.has(record.id)) {
+      fail("proposal.coverage.omittedHypotheses", "presented_and_omitted_hypothesis", "A hypothesis cannot be both presented and omitted");
+    }
+  }
+  for (const relation of relations) {
+    if (!presentedRelationIds.has(relation.id) && !omittedRelationIds.has(relation.id)) {
+      fail("proposal.coverage.omittedRelations", "uncommunicated_relation", "Every emitted relation must be typed-presented or explicitly omitted");
+    }
+    if (presentedRelationIds.has(relation.id) && omittedRelationIds.has(relation.id)) {
+      fail("proposal.coverage.omittedRelations", "presented_and_omitted_relation", "A relation cannot be both presented and omitted");
+    }
+  }
+  return {
+    responseCoverage: { ...coverage.responseCoverage, evidenceIds: [...coverage.responseCoverage.evidenceIds], unresolved: [...coverage.responseCoverage.unresolved] },
+    continuationCoverage: { ...coverage.continuationCoverage, evidenceIds: [...coverage.continuationCoverage.evidenceIds], unresolved: [...coverage.continuationCoverage.unresolved] },
+    unresolvedEvidenceObligations: coverage.unresolvedEvidenceObligations.map((item) => ({ ...item })),
+    omittedHypothesisIds: omittedHypotheses,
+    omittedRelationIds: omittedRelations
+  };
+}
+function materializeDirectSynthesis(input) {
+  const metadata = { arm: input.arm };
+  try {
+    if (input.arm !== "A1" && input.arm !== "B" && input.arm !== "B-prime") fail("arm", "invalid_arm", "Direct synthesis arm is invalid");
+    validateAblationEvidenceClosureBundle(input.bundle);
+    const sourceBundleHash = input.bundle.bundleHash;
+    input = { ...input, bundle: projectAblationEvidenceForModel(input.bundle).bundle };
+    const proposal = parseDirectSynthesisProposal(input.proposal);
+    assertDistinctLocalIds(proposal);
+    const authority = referenceAuthority(input.bundle);
+    assertCoverageEvidence(input.bundle, proposal.coverage);
+    const hypothesisIds = new Set(proposal.hypotheses.map((item) => item.localId));
+    for (const [index, relation] of proposal.relations.entries()) {
+      if (!hypothesisIds.has(relation.from) || !hypothesisIds.has(relation.to)) fail(`proposal.relations[${index}]`, "dangling_local_relation", "Relation endpoint does not name a local hypothesis");
+      assertEvidenceSupportsMeaning(input.bundle, relation.evidenceIds, `proposal.relations[${index}].evidenceIds`, null);
+    }
+    for (const [index, hypothesis] of proposal.hypotheses.entries()) {
+      assertEvidenceSupportsMeaning(input.bundle, hypothesis.evidenceIds, `proposal.hypotheses[${index}].evidenceIds`, hypothesis.proofStrength);
+      if (hypothesis.entityType === "plan") assertEvidenceSupportsRouteMeaning(input.bundle, hypothesis.evidenceIds, `proposal.hypotheses[${index}].evidenceIds`);
+      assertHypothesisReferenceAuthority(
+        hypothesis,
+        hypothesis.evidenceIds,
+        scopedReferenceAuthority(input.bundle, hypothesis.evidenceIds),
+        `proposal.hypotheses[${index}]`
+      );
+      for (const observationId of hypothesis.sourceObservationIds) {
+        if (!input.bundle.referenceAllowlists.observationIds.includes(observationId)) fail(`proposal.hypotheses[${index}].sourceObservationIds`, "unknown_observation", "Source observation is outside the frozen closure");
+      }
+    }
+    const observations = {
+      schemaVersion: input.bundle.observations[0]?.schemaVersion || "conceptual-explanation-poc/57",
+      contextHash: input.bundle.contextHash,
+      observations: input.bundle.observations.map((observation) => ({ ...observation, salience: 1, salienceReasons: ["frozen-ablation-closure"], presentedToModel: true })),
+      evidence: input.bundle.evidence,
+      providers: [],
+      limitations: [...input.bundle.coverage.limitations],
+      saliencePolicy: "ablation-direct-frozen-closure/1"
+    };
+    const ledger = new HypothesisLedger(
+      input.bundle.contextHash,
+      observations,
+      new Map(input.bundle.evidence.map((record) => [record.id, record])),
+      proposal.hypotheses.length,
+      input.bundle.context
+    );
+    const recorded = ledger.record(
+      {
+        hypotheses: proposal.hypotheses,
+        relations: proposal.relations.map((relation) => {
+          const withoutLocalId = { ...relation };
+          Reflect.deleteProperty(withoutLocalId, "localId");
+          return withoutLocalId;
+        })
+      },
+      input.provenance || { provider: "knights-eye/ablation-direct", version: ABLATION_DIRECT_SYNTHESIS_VERSION, origin: "model" }
+    );
+    const evidenceById = new Map(input.bundle.evidence.map((record) => [record.id, record]));
+    const observationById = new Map(input.bundle.observations.map((observation) => [observation.id, observation]));
+    for (const [index, record] of recorded.records.entries()) {
+      const policyIssues = validateHypothesisAcceptancePolicies(record, evidenceById);
+      if (policyIssues.length) fail(`proposal.hypotheses[${index}]`, "acceptance_policy_rejected", "Direct hypothesis fails a registered production acceptance policy");
+      const usesConditionalRouteAffordance = record.sourceObservationIds.some((id) => observationById.get(id)?.observationType === "conditional-route-affordance");
+      if (usesConditionalRouteAffordance && !record.evidenceIds.some((id) => {
+        const evidence = evidenceById.get(id);
+        return Boolean(evidence && licensesBoundedRouteRelevance(effectiveLicensesForRecord(evidence)));
+      })) {
+        fail(`proposal.hypotheses[${index}].evidenceIds`, "underlicensed_route_meaning", "Hypotheses sourced from conditional-route affordances require separate bounded route-relevance evidence");
+      }
+    }
+    const relationByLocalId = new Map(proposal.relations.map((relation, index) => [relation.localId, recorded.relations[index]]));
+    const hypothesisByCanonicalId = new Map(recorded.records.map((record) => [record.id, record]));
+    const hypothesesByLocalId = new Map(proposal.hypotheses.map((hypothesis) => [hypothesis.localId, hypothesis]));
+    const relationsByLocalId = new Map(proposal.relations.map((relation) => [relation.localId, relation]));
+    const claimIds = /* @__PURE__ */ new Set();
+    const claims = proposal.claims.map((claim, index) => {
+      if (claimIds.has(claim.localId)) fail(`proposal.claims[${index}].localId`, "duplicate_local_id", "Claim local ID is duplicated");
+      claimIds.add(claim.localId);
+      assertEvidenceSupportsClaim(input.bundle, claim.evidenceIds, `proposal.claims[${index}].evidenceIds`, claim.kind, claim.proofStrength);
+      const semanticParticipants = semanticParticipantsForSegments([...claim.content, ...claim.qualifications.flat()], hypothesesByLocalId, relationsByLocalId);
+      const content = remapSegments(claim.content, `proposal.claims[${index}].content`, claim.evidenceIds, authority, recorded.localToHypothesisIds, relationByLocalId, hypothesisByCanonicalId, semanticParticipants, input.bundle);
+      const qualifications = claim.qualifications.map((segments, qualificationIndex) => remapSegments(segments, `proposal.claims[${index}].qualifications[${qualificationIndex}]`, claim.evidenceIds, authority, recorded.localToHypothesisIds, relationByLocalId, hypothesisByCanonicalId, semanticParticipants, input.bundle));
+      return { id: `direct-claim:${stableHash({ contextHash: input.bundle.contextHash, kind: claim.kind, content, evidenceIds: claim.evidenceIds, qualifications })}`, kind: claim.kind, content, proofStrength: claim.proofStrength, evidenceIds: [...claim.evidenceIds], qualifications };
+    });
+    const demonstrationIds = /* @__PURE__ */ new Set();
+    const demonstrations = (proposal.demonstrations || []).map((demonstration, index) => {
+      if (demonstrationIds.has(demonstration.localId)) fail(`proposal.demonstrations[${index}].localId`, "duplicate_local_id", "Demonstration local ID is duplicated");
+      demonstrationIds.add(demonstration.localId);
+      if (demonstration.type === "legal-variation") {
+        admittedEvidenceIds(input.bundle, demonstration.evidenceIds, `proposal.demonstrations[${index}].evidenceIds`);
+        validateVariation(demonstration, input.bundle, `proposal.demonstrations[${index}].moves`);
+        return { id: `direct-demonstration:${stableHash({ contextHash: input.bundle.contextHash, type: demonstration.type, start: demonstration.start, moves: demonstration.moves, evidenceIds: demonstration.evidenceIds })}`, type: demonstration.type, start: demonstration.start, moves: demonstration.moves.map((move) => ({ ...move })), label: demonstration.label, evidenceIds: [...demonstration.evidenceIds] };
+      }
+      if (demonstration.type === "static-relationship") {
+        assertEvidenceSupportsMeaning(input.bundle, demonstration.evidenceIds, `proposal.demonstrations[${index}].evidenceIds`, null);
+        const relation = relationByLocalId.get(demonstration.relationLocalId);
+        const fromEntityId = recorded.localToHypothesisIds[demonstration.fromEntityLocalId];
+        const toEntityId = recorded.localToHypothesisIds[demonstration.toEntityLocalId];
+        if (!relation || !fromEntityId || !toEntityId) fail(`proposal.demonstrations[${index}]`, "dangling_local_relation", "Static relationship does not name direct local records");
+        if (relation.fromHypothesisId !== fromEntityId || relation.toHypothesisId !== toEntityId) fail(`proposal.demonstrations[${index}]`, "relation_endpoint_mismatch", "Static relationship endpoints do not match the canonical relation");
+        if (!hasEvidenceAssociation(demonstration.evidenceIds, relation.evidenceIds)) fail(`proposal.demonstrations[${index}].evidenceIds`, "unrelated_semantic_evidence", "Static relationship must cite evidence associated with its canonical relation");
+        return { id: `direct-demonstration:${stableHash({ contextHash: input.bundle.contextHash, type: demonstration.type, relationId: relation.id, fromEntityId, toEntityId, evidenceIds: demonstration.evidenceIds })}`, type: demonstration.type, relationId: relation.id, fromEntityId, toEntityId, relationType: relation.relationType, label: demonstration.label, evidenceIds: [...demonstration.evidenceIds] };
+      }
+      assertEvidenceSupportsRouteMeaning(input.bundle, demonstration.evidenceIds, `proposal.demonstrations[${index}].evidenceIds`);
+      const routeAuthority = scopedReferenceAuthority(input.bundle, demonstration.evidenceIds, semanticParticipantsForSegments(demonstration.prerequisiteRefs, hypothesesByLocalId, relationsByLocalId));
+      if (!routeAuthority.pieces.has(demonstration.pieceId) || demonstration.waypoints.some((square) => !routeAuthority.squares.has(square))) {
+        fail(`proposal.demonstrations[${index}]`, "untyped_route_reference", "Route references are outside the frozen closure");
+      }
+      const prerequisiteRefs = remapSegments(demonstration.prerequisiteRefs, `proposal.demonstrations[${index}].prerequisiteRefs`, demonstration.evidenceIds, authority, recorded.localToHypothesisIds, relationByLocalId, hypothesisByCanonicalId, semanticParticipantsForSegments(demonstration.prerequisiteRefs, hypothesesByLocalId, relationsByLocalId), input.bundle);
+      return { id: `direct-demonstration:${stableHash({ contextHash: input.bundle.contextHash, type: demonstration.type, pieceId: demonstration.pieceId, waypoints: demonstration.waypoints, prerequisiteRefs, evidenceIds: demonstration.evidenceIds })}`, type: demonstration.type, pieceId: demonstration.pieceId, waypoints: [...demonstration.waypoints], prerequisiteRefs, label: demonstration.label, evidenceIds: [...demonstration.evidenceIds] };
+    });
+    const coverage = validateAndMaterializeCoverage(proposal.coverage, recorded.records, recorded.relations, recorded.localToHypothesisIds, relationByLocalId, claims, demonstrations);
+    return {
+      ok: true,
+      metadata,
+      artifact: {
+        schemaVersion: ABLATION_DIRECT_SYNTHESIS_VERSION,
+        contextHash: input.bundle.contextHash,
+        bundleHash: sourceBundleHash,
+        hypotheses: recorded.records.map((record) => {
+          const withoutLocalId = { ...record };
+          Reflect.deleteProperty(withoutLocalId, "localId");
+          return withoutLocalId;
+        }),
+        relations: recorded.relations,
+        claims,
+        demonstrations,
+        coverage,
+        admission: "pre-checkpoint-proposed",
+        productSupport: "not-a-validated-graph-checkpoint-or-product-result",
+        limitations: [...proposal.limitations],
+        riskProfile: { level: proposal.riskProfile.level, reasons: [...proposal.riskProfile.reasons] }
+      }
+    };
+  } catch (error) {
+    const issue = error instanceof AdmissionFailure ? error.issue : { path: "proposal", code: "production_admission_failure", message: "Direct synthesis failed production admission", permittedReferences: [] };
+    return { ok: false, metadata, code: "direct-synthesis-rejected", issues: [issue] };
+  }
+}
+
+// src/chess-reasoning/ablation-transport-correction.ts
+var AblationTransportCorrectionError = class extends Error {
+  code = "transport-correction-outside-validator-paths";
+  constructor(message) {
+    super(message);
+    this.name = "AblationTransportCorrectionError";
+  }
+};
+function sameRecord(left, right) {
+  return stableJson(left) === stableJson(right);
+}
+function transportCorrectionPath(issue) {
+  if (!(/* @__PURE__ */ new Set(["unknown_evidence", "unknown_local_entity", "unknown_local_relation", "invalid_piece_form", "raw_chess_reference"])).has(issue.code)) return null;
+  const tokens = [...issue.path.matchAll(/(?:^|\.)([A-Za-z_][A-Za-z0-9_]*)|\[(\d+)\]/g)].map((match) => match[1] || Number(match[2]));
+  if (tokens[0] !== "proposal" || tokens.length < 3 || tokens.some((token) => typeof token === "string" && token === "__proto__")) return null;
+  const leaf = tokens.at(-1);
+  if (issue.code === "raw_chess_reference") {
+    const [proposal, claims, claimIndex, qualifications, qualificationIndex, segmentIndex, text] = tokens;
+    return proposal === "proposal" && claims === "claims" && typeof claimIndex === "number" && qualifications === "qualifications" && typeof qualificationIndex === "number" && typeof segmentIndex === "number" && text === "text" && tokens.length === 7 ? tokens : null;
+  }
+  if (!["evidenceIds", "entityLocalId", "relationLocalId", "form"].includes(leaf)) return null;
+  if (issue.code === "unknown_evidence" && leaf !== "evidenceIds") return null;
+  if (issue.code === "unknown_local_entity" && leaf !== "entityLocalId" || issue.code === "unknown_local_relation" && leaf !== "relationLocalId" || issue.code === "invalid_piece_form" && leaf !== "form") return null;
+  return tokens;
+}
+function deleteExactPath(value, path) {
+  let cursor = value;
+  for (const token of path.slice(1, -1)) {
+    if (typeof token === "number") {
+      if (!Array.isArray(cursor) || !Object.prototype.hasOwnProperty.call(cursor, token)) throw new AblationTransportCorrectionError("Transport correction issue path is not an exact existing array path");
+      cursor = cursor[token];
+    } else {
+      if (!cursor || typeof cursor !== "object" || Array.isArray(cursor) || !Object.prototype.hasOwnProperty.call(cursor, token)) throw new AblationTransportCorrectionError("Transport correction issue path is not an exact existing object path");
+      cursor = cursor[token];
+    }
+  }
+  const leaf = path.at(-1);
+  if (typeof leaf !== "string" || !cursor || typeof cursor !== "object" || Array.isArray(cursor) || !Object.prototype.hasOwnProperty.call(cursor, leaf)) {
+    throw new AblationTransportCorrectionError("Transport correction issue path is too broad or absent");
+  }
+  delete cursor[leaf];
+}
+function isTransportCorrectableDirectSynthesisIssues(issues) {
+  return issues.length > 0 && issues.every((issue) => transportCorrectionPath(issue) !== null);
+}
+function assertTransportOnlyDirectCorrection(originalProposal, correctedProposal, issues) {
+  const paths = issues.map(transportCorrectionPath);
+  if (!paths.length || paths.some((path) => path === null)) throw new AblationTransportCorrectionError("Transport correction does not have a narrow validator-authorized path");
+  if (!originalProposal || typeof originalProposal !== "object" || Array.isArray(originalProposal) || !correctedProposal || typeof correctedProposal !== "object" || Array.isArray(correctedProposal)) {
+    throw new AblationTransportCorrectionError("Transport correction requires complete object proposals");
+  }
+  for (const collection of ["hypotheses", "relations", "claims", "demonstrations"]) {
+    const before2 = originalProposal[collection];
+    const after2 = correctedProposal[collection];
+    if (!Array.isArray(before2) || !Array.isArray(after2) || before2.length !== after2.length) throw new AblationTransportCorrectionError("Transport correction changed proposal item cardinality");
+    for (let index = 0; index < before2.length; index += 1) {
+      const beforeId = before2[index] && typeof before2[index] === "object" ? before2[index].localId : void 0;
+      const afterId = after2[index] && typeof after2[index] === "object" ? after2[index].localId : void 0;
+      if (beforeId !== afterId) throw new AblationTransportCorrectionError("Transport correction changed a proposal item identity");
+    }
+  }
+  const before = structuredClone(originalProposal);
+  const after = structuredClone(correctedProposal);
+  for (const path of paths) {
+    deleteExactPath(before, path);
+    deleteExactPath(after, path);
+  }
+  if (!sameRecord(before, after)) throw new AblationTransportCorrectionError("Transport correction changed semantic content outside validator-authorized paths");
+}
+
+// src/chess-reasoning/ablation-adaptive-runtime.ts
+import { Output, generateText, jsonSchema } from "ai";
+var ABLATION_ADAPTIVE_RUNTIME_VERSION = "architecture-ablation-adaptive-runtime/2";
+var ABLATION_B_SYSTEM = `You are Knight's Eye in adaptive direct arm B. You may use only the supplied bounded fact and probe tools to acquire evidence about the selected move. Work iteratively, stop as soon as the available evidence is sufficient, and do not infer purpose, safety, forcedness, or a plan merely from a legal move. The verbatim user question is authoritative. You receive no later game history, evaluator answer keys, graph, critic, review, checkpoint, or render state.`;
+var ABLATION_B_DIRECT_SYSTEM = `You are Knight's Eye in adaptive direct arm B. Return exactly one object matching the direct-synthesis schema over the frozen evidence closure. This is a pre-checkpoint proposal, not a supported product answer. Cite only allowed evidence and observations. Evidence licenses are strict ceilings: legal sequence evidence establishes legality and identity, and bounded engine evidence establishes only the recorded bounded line, score, comparison, or response coverage. Do not claim intent, a forced plan, or strategic relevance unless the evidence itself licenses the bounded claim.`;
+var ABLATION_B_PRIME_CRITIC_SYSTEM = `You are the single bounded semantic reconsideration for Knight's Eye architecture-ablation arm B-prime. You have no tools and may not acquire evidence. Given a frozen direct proposal, explicit generic trigger values, and the same frozen evidence closure, decide whether the proposal can be retained or needs one corrected replacement. A correction may only use existing IDs and evidence licenses; it may narrow, qualify, or remove unsupported meaning but may not add evidence, broaden authority, change the user question, or invoke another critic. Return exactly the required object.`;
+var ABLATION_B_PRIME_TRIGGER_VALUES = Object.freeze([
+  "claim.forced-best-unique-safe-winning-principal-purpose",
+  "coverage.requested-defense-or-continuation-incomplete",
+  "evidence.conflict",
+  "claim.sacrifice-or-long-multistep",
+  "plan.legal-affordance-only",
+  "model.high-uncertainty",
+  "validation.semantic-reconsideration-required"
+]);
+var AdaptiveAblationPreconditionError = class extends Error {
+  code = "starting-bundle-must-be-original";
+  constructor() {
+    super("Adaptive ablation B/B-prime must start from an original initial-exact evidence bundle");
+    this.name = "AdaptiveAblationPreconditionError";
+  }
+};
+var CRITIC_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["schemaVersion", "decision", "rationale"],
+  properties: {
+    schemaVersion: { const: ABLATION_ADAPTIVE_RUNTIME_VERSION },
+    decision: { enum: ["retain", "replace"] },
+    rationale: { type: "string", minLength: 1, maxLength: 2e3 },
+    replacement: DIRECT_SYNTHESIS_PROPOSAL_JSON_SCHEMA
+  }
+};
+var PRESEMANTIC_TOOLS = /* @__PURE__ */ new Set([
+  "inspect_position",
+  "analyze_move",
+  "explore_continuations",
+  "compare_moves",
+  "enumerate_defenses",
+  "test_line"
+]);
+var FORBIDDEN_ADAPTIVE_TELEMETRY_KEYS = /* @__PURE__ */ new Set([
+  "evaluatorAnchor",
+  "evaluatorAnchors",
+  "idealProse",
+  "answerKey",
+  "laterMoves"
+]);
+function bytes2(value) {
+  return new TextEncoder().encode(typeof value === "string" ? value : JSON.stringify(value)).length;
+}
+function nonEmptyNonce(value) {
+  if (!/^[A-Za-z0-9._:-]{1,128}$/.test(value)) throw new Error("Adaptive ablation calls require a bounded supplied benchmark nonce");
+  return value;
+}
+function firstPrefix(nonce, body) {
+  return `[Benchmark cache-isolation nonce: ${nonce}. Ignore this opaque identifier; it has no chess, workflow, or output meaning.]
+
+${body}`;
+}
+function sum(values) {
+  return values.every((value) => value === null) ? null : values.reduce((total, value) => total + (value || 0), 0);
+}
+function sameRecord2(left, right) {
+  return stableJson(left) === stableJson(right);
+}
+function assertNoEvaluatorTelemetryPayload(value, path = "adaptive loop telemetry") {
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertNoEvaluatorTelemetryPayload(item, `${path}[${index}]`));
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  for (const [key, child] of Object.entries(value)) {
+    if (FORBIDDEN_ADAPTIVE_TELEMETRY_KEYS.has(key)) throw new Error(`Adaptive loop telemetry contains evaluator-only payload at ${path}.${key}`);
+    assertNoEvaluatorTelemetryPayload(child, `${path}.${key}`);
+  }
+}
+function createAdaptiveAbortScope(external, maxWallTimeMs) {
+  const controller = new AbortController();
+  let stopped = null;
+  const abortExternally = () => {
+    if (stopped) return;
+    stopped = "adaptive-aborted";
+    controller.abort(new Error("Adaptive ablation episode cancelled"));
+  };
+  if (external?.aborted) abortExternally();
+  else external?.addEventListener("abort", abortExternally, { once: true });
+  const timer = setTimeout(() => {
+    if (stopped) return;
+    stopped = "adaptive-timeout";
+    controller.abort(new Error("Adaptive ablation episode exceeded its wall-time budget"));
+  }, maxWallTimeMs);
+  return {
+    signal: controller.signal,
+    code: () => stopped,
+    dispose: () => {
+      clearTimeout(timer);
+      external?.removeEventListener("abort", abortExternally);
+    }
+  };
+}
+function throwIfAdaptiveStopped(scope) {
+  const code = scope.code();
+  if (code) throw Object.assign(new Error("Adaptive ablation episode stopped"), { adaptiveAbortCode: code });
+}
+function adaptiveAbortCode(scope, error) {
+  const explicit = error && typeof error === "object" ? error.adaptiveAbortCode : null;
+  return explicit === "adaptive-timeout" || explicit === "adaptive-aborted" ? explicit : scope.code();
+}
+async function abortable(scope, work) {
+  if (scope.signal.aborted) {
+    void work.catch(() => void 0);
+    throwIfAdaptiveStopped(scope);
+  }
+  return await new Promise((resolve, reject) => {
+    const abort = () => reject(Object.assign(new Error("Adaptive ablation episode stopped"), { adaptiveAbortCode: scope.code() || "adaptive-aborted" }));
+    scope.signal.addEventListener("abort", abort, { once: true });
+    work.then(
+      (value) => {
+        scope.signal.removeEventListener("abort", abort);
+        resolve(value);
+      },
+      (error) => {
+        scope.signal.removeEventListener("abort", abort);
+        reject(error);
+      }
+    );
+  });
+}
+function deriveAblationBPrimeTriggers(input) {
+  const triggers = /* @__PURE__ */ new Set();
+  const claimText = input.artifact?.claims.flatMap((claim) => [
+    ...claim.content.filter((segment) => segment.type === "text").map((segment) => segment.text),
+    ...claim.qualifications.flatMap((qualification) => qualification.filter((segment) => segment.type === "text").map((segment) => segment.text))
+  ]).join(" ").toLowerCase() || "";
+  const riskReasons = input.artifact?.riskProfile.reasons.join(" ").toLowerCase() || "";
+  if (/\b(forced|best|unique|safe|winning|principal purpose)\b/.test(claimText)) triggers.add("claim.forced-best-unique-safe-winning-principal-purpose");
+  if (input.artifact && (input.artifact.coverage.responseCoverage.status !== "complete" || input.artifact.coverage.continuationCoverage.status !== "complete")) {
+    triggers.add("coverage.requested-defense-or-continuation-incomplete");
+  }
+  if (input.artifact && input.artifact.coverage.unresolvedEvidenceObligations.length > 0 && /\b(always|only|must|cannot)\b/.test(claimText)) triggers.add("evidence.conflict");
+  if (/\b(sacrifice|sac|long[- ]term|multi[- ]step)\b/.test(claimText)) triggers.add("claim.sacrifice-or-long-multistep");
+  const planHypotheses = input.artifact?.hypotheses.filter((hypothesis) => hypothesis.entityType === "plan" || hypothesis.concepts.some((concept) => concept.startsWith("plan."))) || [];
+  if (planHypotheses.length && input.artifact && !planHypotheses.some((hypothesis) => hypothesis.evidenceIds.some((id) => {
+    const evidence = input.bundle.evidence.find((record) => record.id === id);
+    return evidence ? effectiveLicensesForRecord(evidence).some((license) => license.startsWith("engine.bounded-")) : false;
+  }))) {
+    triggers.add("plan.legal-affordance-only");
+  }
+  if (input.artifact?.riskProfile.level === "high" || /\b(uncertain|unclear|unknown|insufficient)\b/.test(riskReasons)) triggers.add("model.high-uncertainty");
+  if (input.initialIssues.length) triggers.add("validation.semantic-reconsideration-required");
+  return [...triggers].sort();
+}
+function exactTriggers(values) {
+  if (values.some((value) => !ABLATION_B_PRIME_TRIGGER_VALUES.includes(value))) throw new Error("Adaptive B-prime trigger policy returned an unsupported trigger");
+  return [...new Set(values)].sort();
+}
+function normalizedDescriptors(values) {
+  return [...values].map((value) => structuredClone(value)).sort((left, right) => left.name.localeCompare(right.name));
+}
+function validateLoopResult(original, result, limits, advertisedTools) {
+  if (!Number.isInteger(result.modelCalls) || result.modelCalls < 0 || result.modelCalls > limits.maxModelSteps || !Array.isArray(result.rounds) || !Array.isArray(result.failedToolCalls) || result.rounds.length + result.failedToolCalls.length > limits.maxToolCalls) {
+    throw new Error("Adaptive evidence loop exceeded its model or tool budget");
+  }
+  if (!result.coverage || !result.stopping?.rationale?.trim() || !Array.isArray(result.stopping.unusedRelevantTools) || !["model-finished", "tool-budget-exhausted", "probe-budget-exhausted", "model-decision-budget-exhausted"].includes(result.stopping.reason)) {
+    throw new Error("Adaptive evidence loop omitted explicit stopping telemetry");
+  }
+  if (!Array.isArray(result.coverage.covered) || !Array.isArray(result.coverage.omitted) || !Array.isArray(result.coverage.unavailable) || !Array.isArray(result.coverage.limitations)) {
+    throw new Error("Adaptive evidence loop omitted explicit coverage telemetry");
+  }
+  if (!Array.isArray(result.saliencePresentedFactIds) || result.saliencePresentedFactIds.some((id) => typeof id !== "string" || !id.trim())) throw new Error("Adaptive evidence loop omitted salience membership");
+  const descriptors = normalizedDescriptors(result.availableTools);
+  if (sameRecord2(descriptors, normalizedDescriptors(advertisedTools)) === false) throw new Error("Adaptive evidence loop changed the advertised tool set");
+  const descriptorByName = new Map(descriptors.map((item) => [item.name, item]));
+  const calls = /* @__PURE__ */ new Set();
+  const attempts = /* @__PURE__ */ new Set();
+  let probes = 0;
+  for (const round of result.rounds) {
+    if (!Number.isInteger(round.attempt) || round.attempt < 1 || attempts.has(round.attempt) || !round.callId?.trim() || calls.has(round.callId) || !round.requestId?.trim() || !PRESEMANTIC_TOOLS.has(round.tool)) {
+      throw new Error("Adaptive evidence loop returned an invalid tool round");
+    }
+    attempts.add(round.attempt);
+    calls.add(round.callId);
+    assertNoEvaluatorTelemetryPayload(round.input, `adaptive tool round ${round.callId}.input`);
+    assertNoEvaluatorTelemetryPayload(round.result, `adaptive tool round ${round.callId}.result`);
+    if (!descriptorByName.has(round.tool) || round.result.schemaVersion !== REASONING_POC_VERSION || round.result.callId !== round.callId || round.result.tool !== round.tool || round.result.contextHash !== original.contextHash) throw new Error("Adaptive evidence loop returned a cross-context or unadvertised tool result");
+    if (round.tool !== "inspect_position" && round.tool !== "analyze_move") probes += 1;
+    if (!round.selectionRationale?.trim() || !round.result || !Array.isArray(round.result.evidence)) throw new Error("Adaptive evidence loop round lacks its model-owned selection rationale");
+  }
+  for (const failed of result.failedToolCalls) {
+    if (!Number.isInteger(failed.attempt) || failed.attempt < 1 || attempts.has(failed.attempt) || !failed.callId?.trim() || calls.has(failed.callId) || !failed.requestId?.trim() || !PRESEMANTIC_TOOLS.has(failed.tool) || !descriptorByName.has(failed.tool) || !failed.selectionRationale?.trim() || !failed.input || typeof failed.input !== "object" || Array.isArray(failed.input) || failed.failureCode !== "tool-execution-failed") {
+      throw new Error("Adaptive evidence loop returned malformed failed-tool telemetry");
+    }
+    attempts.add(failed.attempt);
+    calls.add(failed.callId);
+    assertNoEvaluatorTelemetryPayload(failed.input, `adaptive failed tool ${failed.callId}.input`);
+    if (failed.tool !== "inspect_position" && failed.tool !== "analyze_move") probes += 1;
+  }
+  if (probes > limits.maxProbeCalls) throw new Error("Adaptive evidence loop exceeded its probe budget");
+  if (result.stopping.unusedRelevantTools.some((tool) => !descriptorByName.has(tool) || result.rounds.some((round) => round.tool === tool) || result.failedToolCalls.some((failed) => failed.tool === tool))) {
+    throw new Error("Adaptive evidence loop reported invalid unused tools");
+  }
+  const attemptedToolCalls = result.rounds.length + result.failedToolCalls.length;
+  if (result.stopping.reason === "tool-budget-exhausted" && attemptedToolCalls !== limits.maxToolCalls || result.stopping.reason === "model-decision-budget-exhausted" && result.modelCalls !== limits.maxModelSteps || result.stopping.reason === "probe-budget-exhausted" && (probes < limits.maxProbeCalls || descriptors.some((descriptor) => descriptor.name === "inspect_position" || descriptor.name === "analyze_move"))) {
+    throw new Error("Adaptive evidence loop stopping reason does not match its recorded budget state");
+  }
+  const modelFacingIds = new Set(projectAblationEvidenceForModel(original).visibleEvidenceIds);
+  for (const round of result.rounds) for (const evidence of round.result.evidence) modelFacingIds.add(evidence.id);
+  if (result.saliencePresentedFactIds.some((id) => !modelFacingIds.has(id))) throw new Error("Adaptive evidence loop presented evidence that was never available to the model");
+  return descriptors;
+}
+function enrichedBundle(original, result) {
+  const additions = result.rounds.flatMap((round) => round.result.evidence);
+  if (!additions.length) return original;
+  const allEvidence = [...original.evidence, ...additions];
+  const witnesses = collectReasoningMoveWitnesses(allEvidence, original.context);
+  const addedReferences = witnesses.flatMap((witness) => [
+    { domain: "move", id: witness.uci },
+    { domain: "piece", id: witness.pieceId }
+  ]);
+  const oldReferences = original.referenceAllowlists.semanticReferences;
+  const references = [...new Map([...oldReferences, ...addedReferences].map((value) => [`${value.domain}:${value.id}`, value])).values()];
+  return enrichAblationEvidenceClosureBundle(original, {
+    observations: [...result.addedObservations || []],
+    evidence: additions,
+    coverage: mergedCoverage(original.coverage, result.coverage),
+    referenceAllowlists: {
+      evidenceIds: allEvidence.map((record) => record.id),
+      observationIds: [...original.observations, ...result.addedObservations || []].map((observation) => observation.id),
+      toolNames: [.../* @__PURE__ */ new Set([...original.referenceAllowlists.toolNames, ...result.rounds.map((round) => round.tool)])].sort(),
+      semanticReferences: references,
+      moveWitnesses: witnesses
+    }
+  });
+}
+function mergedCoverage(original, acquired) {
+  const union = (items, key) => [...new Map(items.map((item) => [key(item), item])).values()];
+  const omitted = union([...original.omitted, ...acquired.omitted], (item) => `${item.domain}:${item.id}`).sort((left, right) => `${left.domain}:${left.id}`.localeCompare(`${right.domain}:${right.id}`));
+  const unavailable = union([...original.unavailable, ...acquired.unavailable], (item) => item.id).sort((left, right) => left.id.localeCompare(right.id));
+  return {
+    // An acquisition pass can add coverage but cannot erase inherited scope
+    // limits or turn an incomplete starting cell into an exhaustive closure.
+    complete: original.complete && acquired.complete && !omitted.length && !unavailable.length,
+    covered: [.../* @__PURE__ */ new Set([...original.covered, ...acquired.covered])].sort(),
+    omitted,
+    unavailable,
+    limitations: [.../* @__PURE__ */ new Set([...original.limitations, ...acquired.limitations])].sort()
+  };
+}
+function probeTelemetry(bundle, descriptors, result, artifact, diagnostics, limits) {
+  const modelView = projectAblationEvidenceForModel(bundle);
+  const modelBundle = modelView.bundle;
+  const hypothesisIdsForEvidence = (evidenceIds) => artifact ? artifact.hypotheses.filter((hypothesis) => hypothesis.evidenceIds.some((id) => evidenceIds.includes(id))).map((hypothesis) => hypothesis.id).sort() : [];
+  const priorEvidenceIds = new Set(modelView.visibleEvidenceIds.filter((id) => bundle.lineage.kind !== "enriched" || !bundle.lineage.acquiredEvidenceIds.includes(id)));
+  const beforeProbeEvidenceIds = new Set(priorEvidenceIds);
+  const effectForRound = (round, evidenceIds, hypotheses, hypothesesWithCompleteBasis) => {
+    if (!evidenceIds.length || !hypotheses.length) return "no-change";
+    if (round.result.support === "unsupported") return "rejected";
+    const complete = artifact.hypotheses.filter((hypothesis) => hypothesesWithCompleteBasis.includes(hypothesis.id));
+    return complete.some((hypothesis) => hypothesis.evidenceIds.every((id) => !beforeProbeEvidenceIds.has(id))) ? "materially-changed" : "supported";
+  };
+  const calls = [...result.rounds].sort((left, right) => left.attempt - right.attempt).map((round, callIndex) => {
+    const evidenceIds = round.result.evidence.map((record) => record.id).filter((id) => modelBundle.referenceAllowlists.evidenceIds.includes(id));
+    const candidateHypotheses = hypothesisIdsForEvidence(evidenceIds);
+    const availableAfterThisRound = /* @__PURE__ */ new Set([...priorEvidenceIds, ...evidenceIds]);
+    const hypothesesWithCompleteBasis = artifact ? artifact.hypotheses.filter((hypothesis) => candidateHypotheses.includes(hypothesis.id) && hypothesis.evidenceIds.every((id) => availableAfterThisRound.has(id))).map((hypothesis) => hypothesis.id).sort() : [];
+    const hypotheses = candidateHypotheses;
+    const admitted = evidenceIds.length > 0;
+    const consumed = admitted && hypotheses.length > 0;
+    const descriptor = descriptors.find((item) => item.name === round.tool);
+    const lineRecord = round.result.evidence.find((record) => Array.isArray(record.data.lines));
+    const coverage = lineRecord?.coverage || { complete: false, covered: [], unresolved: [] };
+    const effect = artifact ? effectForRound(round, evidenceIds, hypotheses, hypothesesWithCompleteBasis) : "no-change";
+    for (const evidenceId of evidenceIds) priorEvidenceIds.add(evidenceId);
+    return { attempt: round.attempt, call: {
+      callId: round.callId,
+      requestId: round.requestId,
+      tool: round.tool,
+      request: { descriptor, input: structuredClone(round.input), selectionRationale: round.selectionRationale },
+      target: { fen: bundle.context.fenAfter, historyThroughTargetHash: ablationHistoryThroughTargetHash(bundle.context) },
+      permittedLimits: { maxToolCalls: limits.maxToolCalls, maxProbeCalls: limits.maxProbeCalls, engine: null },
+      approval: {
+        approved: true,
+        budgetReason: "within-frozen-adaptive-budget",
+        remainingToolCalls: Math.max(0, limits.maxToolCalls - callIndex - 1),
+        remainingProbeCalls: Math.max(0, limits.maxProbeCalls - result.rounds.slice(0, callIndex + 1).filter((item) => item.tool !== "inspect_position" && item.tool !== "analyze_move").length)
+      },
+      status: { started: true, finished: "returned" },
+      returned: { lines: Array.isArray(lineRecord?.data.lines) ? lineRecord.data.lines.length : 0, coverage },
+      admission: { status: admitted ? "admitted" : "not-produced", reason: admitted ? "admitted-into-frozen-direct-closure" : "tool-returned-no-admissible-evidence" },
+      admittedEvidence: evidenceIds.map((evidenceId) => ({ evidenceId, licenses: effectiveLicensesForRecord(modelBundle.evidence.find((record) => record.id === evidenceId)) })),
+      presentation: { presentedToModel: admitted, reason: admitted ? "frozen-direct-submission-context" : "no-admitted-evidence" },
+      semanticConsumption: { status: consumed ? "consumed" : "not-consumed", hypothesisIds: hypotheses },
+      modelStatedRationale: round.modelStatedRationale,
+      effect,
+      hypothesisIds: hypotheses,
+      usage: { ...round.usage, corrections: 0 }
+    } };
+  });
+  for (const failed of result.failedToolCalls) {
+    const descriptor = descriptors.find((item) => item.name === failed.tool);
+    calls.push({ attempt: failed.attempt, call: {
+      callId: failed.callId,
+      requestId: failed.requestId,
+      tool: failed.tool,
+      request: { descriptor, input: structuredClone(failed.input), selectionRationale: failed.selectionRationale },
+      target: { fen: bundle.context.fenAfter, historyThroughTargetHash: ablationHistoryThroughTargetHash(bundle.context) },
+      permittedLimits: { maxToolCalls: limits.maxToolCalls, maxProbeCalls: limits.maxProbeCalls, engine: null },
+      approval: { approved: true, budgetReason: "within-frozen-adaptive-budget", remainingToolCalls: Math.max(0, limits.maxToolCalls - failed.attempt), remainingProbeCalls: Math.max(0, limits.maxProbeCalls - result.rounds.filter((round) => round.attempt <= failed.attempt && round.tool !== "inspect_position" && round.tool !== "analyze_move").length) },
+      status: { started: true, finished: "failed" },
+      returned: null,
+      admission: { status: "not-produced", reason: failed.failureCode },
+      admittedEvidence: [],
+      presentation: { presentedToModel: false, reason: failed.failureCode },
+      semanticConsumption: { status: "not-reached", hypothesisIds: [] },
+      modelStatedRationale: failed.modelStatedRationale,
+      effect: "failure",
+      hypothesisIds: [],
+      usage: { ...failed.usage, corrections: 0 }
+    } });
+  }
+  const orderedCalls = calls.sort((left, right) => left.attempt - right.attempt).map((item) => item.call);
+  const modelDiagnostics = diagnostics.filter((item) => item.stage !== "B-evidence");
+  const acquiredEvidenceIds = bundle.lineage.kind === "enriched" ? bundle.lineage.acquiredEvidenceIds : [];
+  return createAblationProbeTelemetry(bundle, {
+    beforeProbeEvidenceIds: modelView.visibleEvidenceIds.filter((id) => !acquiredEvidenceIds.includes(id)),
+    postSaliencePresentedFactIds: [...result.saliencePresentedFactIds].filter((id) => modelView.visibleEvidenceIds.includes(id)),
+    availableTools: [...descriptors],
+    calledProbes: orderedCalls,
+    missedAnchorAttributions: [],
+    stopping: { rationale: result.stopping.rationale, unusedRelevantTools: result.stopping.unusedRelevantTools },
+    usage: {
+      modelCalls: result.modelCalls + modelDiagnostics.filter((item) => item.outcome !== "skipped").length,
+      toolCalls: orderedCalls.length,
+      // `result.usage` is the loop's complete evidence-decision accounting.
+      // Round usage is only the tool execution view and must not replace it.
+      inputTokens: sum([result.usage.inputTokens, ...modelDiagnostics.map((item) => item.inputTokens)]),
+      outputTokens: sum([result.usage.outputTokens, ...modelDiagnostics.map((item) => item.outputTokens)]),
+      latencyMs: sum([result.usage.latencyMs, ...modelDiagnostics.map((item) => item.latencyMs)]),
+      cache: { hits: result.usage.cache.hits, misses: result.usage.cache.misses },
+      cost: sum([result.usage.cost, ...modelDiagnostics.map((item) => item.cost)]),
+      corrections: result.usage.corrections + modelDiagnostics.reduce((total, item) => total + item.correctionCount, 0)
+    }
+  });
+}
+function prepareAblationAdaptiveEvidenceForStagedReference(original, loop, evidenceTools, limits) {
+  validateAblationEvidenceClosureBundle(original);
+  if (original.lineage.kind !== "original") throw new AdaptiveAblationPreconditionError();
+  const descriptors = validateLoopResult(original, loop, limits, evidenceTools);
+  const bundle = enrichedBundle(original, loop);
+  return Object.freeze({ bundle, telemetry: probeTelemetry(bundle, descriptors, loop, void 0, [], limits) });
+}
+function providerDiagnostic(stage, nonce, input) {
+  return { stage, nonce, inputBytes: bytes2(input), outputBytes: null, latencyMs: null, inputTokens: null, outputTokens: null, cacheTokens: null, cost: null, correctionCount: 0, outcome: "failed", failureCode: null };
+}
+function abortedAfterValidLoop(scope, arm, bundle, descriptors, loop, diagnostics, options, triggers = []) {
+  const code = scope.code();
+  if (!code) throw new Error("Adaptive abort result requires a stopped episode");
+  return {
+    arm,
+    ok: false,
+    bundle,
+    telemetry: probeTelemetry(bundle, descriptors, loop, void 0, diagnostics, options),
+    triggers,
+    diagnostics: [...diagnostics],
+    failure: { code }
+  };
+}
+function finishDiagnostic(diagnostic, result) {
+  diagnostic.outputBytes = bytes2(result.output ?? result.text);
+  const input = result.usage.inputTokens;
+  const output = result.usage.outputTokens;
+  diagnostic.inputTokens = typeof input === "number" ? input : input && typeof input === "object" && typeof input.total === "number" ? input.total : null;
+  diagnostic.outputTokens = typeof output === "number" ? output : output && typeof output === "object" && typeof output.total === "number" ? output.total : null;
+  diagnostic.latencyMs = result.steps.at(-1)?.performance.responseTimeMs ?? null;
+  diagnostic.outcome = "succeeded";
+}
+async function directCall(options, abort, arm, bundle, nonce, stage, correction) {
+  throwIfAdaptiveStopped(abort);
+  const modelView = projectAblationEvidenceForModel(bundle);
+  const modelFacingBundle = modelView.bundle;
+  const prompt = correction ? JSON.stringify({ sourceBundleHash: modelView.sourceBundleHash, modelFacingEvidenceViewVersion: modelView.schemaVersion, modelFacingEvidenceViewHash: modelView.viewHash, bundle: modelFacingBundle, correction: { issues: correction, instruction: "Return a complete replacement. Fix only the listed transport/reference/schema paths; do not add evidence, observations, concepts, claims, relations, or demonstrations. For raw_chess_reference in a qualification text segment, retain the qualification's bounded meaning but replace only that raw text with a narrower generic text phrase that omits the unsupported concrete reference. Preserve all item IDs, evidence IDs, scope, and every other semantic association." } }) : JSON.stringify({ schemaVersion: ABLATION_ADAPTIVE_RUNTIME_VERSION, arm, sourceBundleHash: modelView.sourceBundleHash, modelFacingEvidenceViewVersion: modelView.schemaVersion, modelFacingEvidenceViewHash: modelView.viewHash, bundle: modelFacingBundle });
+  const system = firstPrefix(nonce, ABLATION_B_DIRECT_SYSTEM);
+  const diagnostic = providerDiagnostic(stage, nonce, { system, prompt, schema: DIRECT_SYNTHESIS_PROPOSAL_JSON_SCHEMA });
+  const started = performance.now();
+  try {
+    const result = await abortable(abort, generateText({
+      model: options.model,
+      system,
+      prompt,
+      output: Output.object({ schema: jsonSchema(DIRECT_SYNTHESIS_PROPOSAL_JSON_SCHEMA), name: "knights_eye_ablation_adaptive_direct", description: "Pre-checkpoint direct synthesis proposal." }),
+      abortSignal: abort.signal,
+      maxOutputTokens: options.maxOutputTokens,
+      maxRetries: 0,
+      reasoning: options.reasoning || "provider-default",
+      ...options.temperature === void 0 ? {} : { temperature: options.temperature }
+    }));
+    diagnostic.latencyMs = Math.round(performance.now() - started);
+    finishDiagnostic(diagnostic, result);
+    if (correction) diagnostic.correctionCount = 1;
+    return { proposal: result.output, diagnostic };
+  } catch (error) {
+    diagnostic.latencyMs = Math.round(performance.now() - started);
+    const code = adaptiveAbortCode(abort, error);
+    diagnostic.outcome = code ? "aborted" : "failed";
+    diagnostic.failureCode = code || "provider-or-structured-output";
+    throw Object.assign(error instanceof Error ? error : new Error("Adaptive direct provider failure"), { adaptiveDiagnostic: diagnostic });
+  }
+}
+function ensureUniqueNonce(used, options, stage) {
+  const nonce = nonEmptyNonce(options.benchmarkNonceForCall(stage, used.size));
+  if (used.has(nonce)) throw new Error("Every adaptive provider call requires a distinct benchmark nonce");
+  used.add(nonce);
+  return nonce;
+}
+function criticPayload(bundle, proposal, triggers, initialIssues) {
+  const modelView = projectAblationEvidenceForModel(bundle);
+  return {
+    schemaVersion: ABLATION_ADAPTIVE_RUNTIME_VERSION,
+    sourceBundleHash: modelView.sourceBundleHash,
+    modelFacingEvidenceViewVersion: modelView.schemaVersion,
+    modelFacingEvidenceViewHash: modelView.viewHash,
+    bundle: modelView.bundle,
+    proposal,
+    triggers,
+    validationIssues: initialIssues
+  };
+}
+function assertCriticDecision(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("B-prime critic returned no object");
+  const record = value;
+  if (record.schemaVersion !== ABLATION_ADAPTIVE_RUNTIME_VERSION || record.decision !== "retain" && record.decision !== "replace" || typeof record.rationale !== "string" || !record.rationale.trim()) throw new Error("B-prime critic returned an invalid decision");
+  if (record.decision === "replace" && !("replacement" in record)) throw new Error("B-prime critic replacement is missing");
+  if (record.decision === "retain" && "replacement" in record) throw new Error("B-prime critic retain decision cannot rewrite the proposal");
+}
+async function runAblationAdaptiveDirect(options, arm, original, signal) {
+  if (arm !== "B" && arm !== "B-prime") throw new Error("Adaptive ablation arm must be B or B-prime");
+  if (!Number.isInteger(options.maxToolCalls) || options.maxToolCalls < 0 || !Number.isInteger(options.maxProbeCalls) || options.maxProbeCalls < 0 || !Number.isInteger(options.maxModelSteps) || options.maxModelSteps < 1 || !Number.isInteger(options.maxOutputTokens) || options.maxOutputTokens < 1 || !Number.isInteger(options.maxWallTimeMs) || options.maxWallTimeMs < 1) throw new Error("Adaptive ablation runtime requires bounded positive budgets and a positive wall-time budget");
+  validateAblationEvidenceClosureBundle(original);
+  if (original.lineage.kind !== "original") throw new AdaptiveAblationPreconditionError();
+  const abort = createAdaptiveAbortScope(signal, options.maxWallTimeMs);
+  try {
+    const diagnostics = [];
+    const usedNonces = /* @__PURE__ */ new Set();
+    const evidenceNonce = ensureUniqueNonce(usedNonces, options, "evidence");
+    const originalModelView = projectAblationEvidenceForModel(original);
+    const evidenceDiagnostic = providerDiagnostic("B-evidence", evidenceNonce, {
+      system: firstPrefix(evidenceNonce, ABLATION_B_SYSTEM),
+      sourceBundleHash: originalModelView.sourceBundleHash,
+      modelFacingEvidenceViewVersion: originalModelView.schemaVersion,
+      modelFacingEvidenceViewHash: originalModelView.viewHash,
+      bundle: originalModelView.bundle
+    });
+    if (abort.code()) {
+      evidenceDiagnostic.outcome = "aborted";
+      evidenceDiagnostic.failureCode = abort.code();
+      diagnostics.push(evidenceDiagnostic);
+      const telemetry2 = createAblationProbeTelemetry(original, {
+        beforeProbeEvidenceIds: [...originalModelView.visibleEvidenceIds],
+        postSaliencePresentedFactIds: [...originalModelView.visibleEvidenceIds],
+        availableTools: [],
+        calledProbes: [],
+        missedAnchorAttributions: [],
+        stopping: { rationale: "Adaptive ablation stopped before evidence collection began.", unusedRelevantTools: [] },
+        usage: { modelCalls: 0, toolCalls: 0, inputTokens: null, outputTokens: null, latencyMs: null, cache: { hits: 0, misses: 0 }, cost: null, corrections: 0 }
+      });
+      return { arm, ok: false, bundle: original, telemetry: telemetry2, triggers: [], diagnostics, failure: { code: abort.code() } };
+    }
+    let loop;
+    let descriptors;
+    let bundle = original;
+    try {
+      loop = await abortable(abort, options.evidenceLoop.run({
+        arm,
+        system: firstPrefix(evidenceNonce, ABLATION_B_SYSTEM),
+        firstProviderVisiblePrefix: `[Benchmark cache-isolation nonce: ${evidenceNonce}. Ignore this opaque identifier; it has no chess, workflow, or output meaning.]`,
+        nextProviderVisiblePrefix: () => {
+          const nonce = ensureUniqueNonce(usedNonces, options, "evidence");
+          return `[Benchmark cache-isolation nonce: ${nonce}. Ignore this opaque identifier; it has no chess, workflow, or output meaning.]`;
+        },
+        bundle: original,
+        tools: options.evidenceTools,
+        maxToolCalls: options.maxToolCalls,
+        maxProbeCalls: options.maxProbeCalls,
+        maxModelSteps: options.maxModelSteps,
+        signal: abort.signal
+      }));
+      descriptors = validateLoopResult(original, loop, options, options.evidenceTools);
+      bundle = enrichedBundle(original, loop);
+      evidenceDiagnostic.outcome = "succeeded";
+      evidenceDiagnostic.latencyMs = loop.usage.latencyMs;
+      evidenceDiagnostic.inputTokens = loop.usage.inputTokens;
+      evidenceDiagnostic.outputTokens = loop.usage.outputTokens;
+      evidenceDiagnostic.cost = loop.usage.cost;
+    } catch (error) {
+      const code = adaptiveAbortCode(abort, error);
+      evidenceDiagnostic.failureCode = code || "adaptive-evidence-loop-rejected";
+      evidenceDiagnostic.outcome = code ? "aborted" : "failed";
+      diagnostics.push(evidenceDiagnostic);
+      const emptyLoop = { rounds: [], failedToolCalls: [], availableTools: [], saliencePresentedFactIds: [], coverage: original.coverage, stopping: { reason: "model-finished", rationale: "Adaptive evidence loop failed before a valid closure was available.", unusedRelevantTools: [] }, modelCalls: 0, usage: { inputTokens: null, outputTokens: null, latencyMs: null, cache: { hits: 0, misses: 0 }, cost: null, corrections: 0 } };
+      const telemetry2 = createAblationProbeTelemetry(original, { beforeProbeEvidenceIds: [...originalModelView.visibleEvidenceIds], postSaliencePresentedFactIds: [...originalModelView.visibleEvidenceIds], availableTools: [], calledProbes: [], missedAnchorAttributions: [], stopping: { rationale: emptyLoop.stopping.rationale, unusedRelevantTools: emptyLoop.stopping.unusedRelevantTools }, usage: { modelCalls: 0, toolCalls: 0, inputTokens: null, outputTokens: null, latencyMs: null, cache: { hits: 0, misses: 0 }, cost: null, corrections: 0 } });
+      return { arm, ok: false, bundle: original, telemetry: telemetry2, triggers: [], diagnostics, failure: { code: code || "adaptive-evidence-loop-rejected" } };
+    }
+    diagnostics.push(evidenceDiagnostic);
+    if (abort.code()) return abortedAfterValidLoop(abort, arm, bundle, descriptors, loop, diagnostics, options);
+    let proposal;
+    let initialIssues = [];
+    let artifact;
+    let transportCorrectionAttempted = false;
+    try {
+      const direct = await directCall(options, abort, arm, bundle, ensureUniqueNonce(usedNonces, options, "direct"), "B-direct", null);
+      diagnostics.push(direct.diagnostic);
+      proposal = direct.proposal;
+      const admission = materializeDirectSynthesis({ arm, bundle, proposal, provenance: { provider: `knights-eye/ablation-${arm}`, version: ABLATION_ADAPTIVE_RUNTIME_VERSION, origin: "model" } });
+      if (admission.ok) artifact = admission.artifact;
+      else initialIssues = admission.issues;
+    } catch (error) {
+      const diagnostic = error.adaptiveDiagnostic;
+      if (diagnostic) diagnostics.push(diagnostic);
+      const telemetry2 = probeTelemetry(bundle, descriptors, loop, void 0, diagnostics, options);
+      const code = adaptiveAbortCode(abort, error);
+      return code ? abortedAfterValidLoop(abort, arm, bundle, descriptors, loop, diagnostics, options) : { arm, ok: false, bundle, telemetry: telemetry2, triggers: [], diagnostics, failure: { code: "provider-or-structured-output" } };
+    }
+    if (abort.code()) return abortedAfterValidLoop(abort, arm, bundle, descriptors, loop, diagnostics, options);
+    if (!artifact && isTransportCorrectableDirectSynthesisIssues(initialIssues)) {
+      try {
+        const corrected = await directCall(options, abort, arm, bundle, ensureUniqueNonce(usedNonces, options, "transport-correction"), "B-transport-correction", initialIssues);
+        diagnostics.push(corrected.diagnostic);
+        transportCorrectionAttempted = true;
+        assertTransportOnlyDirectCorrection(proposal, corrected.proposal, initialIssues);
+        proposal = corrected.proposal;
+        const admission = materializeDirectSynthesis({ arm, bundle, proposal, provenance: { provider: `knights-eye/ablation-${arm}`, version: ABLATION_ADAPTIVE_RUNTIME_VERSION, origin: "model" } });
+        if (admission.ok) artifact = admission.artifact;
+        else {
+          initialIssues = admission.issues;
+          diagnostics[diagnostics.length - 1] = { ...diagnostics.at(-1), outcome: "failed", failureCode: "transport-correction-rejected" };
+        }
+      } catch (error) {
+        const diagnostic = error.adaptiveDiagnostic;
+        if (diagnostic) diagnostics.push(diagnostic);
+        else if (diagnostics.at(-1)?.stage === "B-transport-correction") {
+          diagnostics[diagnostics.length - 1] = { ...diagnostics.at(-1), outcome: "failed", failureCode: error instanceof AblationTransportCorrectionError ? error.code : "transport-correction-rejected" };
+        }
+        if (adaptiveAbortCode(abort, error)) return abortedAfterValidLoop(abort, arm, bundle, descriptors, loop, diagnostics, options);
+      }
+    }
+    if (abort.code()) return abortedAfterValidLoop(abort, arm, bundle, descriptors, loop, diagnostics, options);
+    let triggers = [];
+    if (arm === "B-prime") {
+      triggers = exactTriggers((options.triggerPolicy || deriveAblationBPrimeTriggers)({ bundle, proposal, artifact: artifact || null, initialIssues }));
+      if (triggers.length && (artifact || initialIssues.length)) {
+        const nonce = ensureUniqueNonce(usedNonces, options, "critic");
+        const payload = criticPayload(bundle, proposal, triggers, initialIssues);
+        const diagnostic = providerDiagnostic("B-prime-critic", nonce, { system: firstPrefix(nonce, ABLATION_B_PRIME_CRITIC_SYSTEM), payload, schema: CRITIC_SCHEMA });
+        const started = performance.now();
+        try {
+          throwIfAdaptiveStopped(abort);
+          const result = await abortable(abort, generateText({
+            model: options.criticModel || options.model,
+            system: firstPrefix(nonce, ABLATION_B_PRIME_CRITIC_SYSTEM),
+            prompt: JSON.stringify(payload),
+            output: Output.object({ schema: jsonSchema(CRITIC_SCHEMA), name: "knights_eye_ablation_b_prime_critic", description: "One bounded tool-free semantic reconsideration." }),
+            abortSignal: abort.signal,
+            maxOutputTokens: options.maxOutputTokens,
+            maxRetries: 0,
+            reasoning: options.criticReasoning || options.reasoning || "provider-default",
+            ...options.temperature === void 0 ? {} : { temperature: options.temperature }
+          }));
+          diagnostic.latencyMs = Math.round(performance.now() - started);
+          finishDiagnostic(diagnostic, result);
+          assertCriticDecision(result.output);
+          if (result.output.decision === "replace") {
+            const reconsidered = materializeDirectSynthesis({ arm, bundle, proposal: result.output.replacement, provenance: { provider: "knights-eye/ablation-b-prime-critic", version: ABLATION_ADAPTIVE_RUNTIME_VERSION, origin: "model" } });
+            if (!reconsidered.ok) {
+              diagnostic.outcome = "failed";
+              diagnostic.failureCode = "critic-rejected";
+              artifact = void 0;
+              initialIssues = reconsidered.issues;
+            } else artifact = reconsidered.artifact;
+          } else if (!artifact) {
+            diagnostic.outcome = "failed";
+            diagnostic.failureCode = "critic-rejected";
+          }
+        } catch (error) {
+          diagnostic.latencyMs = Math.round(performance.now() - started);
+          const code = adaptiveAbortCode(abort, error);
+          diagnostic.outcome = code ? "aborted" : "failed";
+          diagnostic.failureCode = code || "critic-rejected";
+          artifact = void 0;
+        }
+        diagnostics.push(diagnostic);
+        if (abort.code()) return abortedAfterValidLoop(abort, arm, bundle, descriptors, loop, diagnostics, options, triggers);
+      } else {
+        diagnostics.push({ ...providerDiagnostic("B-prime-critic", "skipped", {}), outcome: "skipped" });
+      }
+    }
+    const telemetry = probeTelemetry(bundle, descriptors, loop, artifact, diagnostics, options);
+    if (!artifact) {
+      return { arm, ok: false, bundle, telemetry, triggers, diagnostics, failure: { code: transportCorrectionAttempted ? "transport-correction-rejected" : "direct-synthesis-rejected", issues: initialIssues } };
+    }
+    return { arm, ok: true, bundle, artifact, telemetry, triggers, diagnostics };
+  } finally {
+    abort.dispose();
+  }
+}
+
+// src/chess-reasoning/recorded-selected-classification.ts
+import { Chess } from "chess.js";
+function recordedSelectedClassification(context, line) {
+  if (context.kind === "position" || !line || line.selectedAtStart || !Array.isArray(line.moves) || !Number.isInteger(line.selectedIndex) || line.selectedIndex < 0 || line.selectedIndex >= line.moves.length || line.selectedIndex !== context.historyUci.length || line.moves.length > 512 || line.startFen !== (context.historyStartFen ?? new Chess().fen())) return void 0;
+  try {
+    validateReasoningPositionContext(context);
+    const selected = line.moves[line.selectedIndex];
+    if (selected.san !== context.moveSan || selected.uci !== context.moveUci) return void 0;
+    const prefix = line.moves.slice(0, line.selectedIndex + 1);
+    const validated = recordedMainLineResult({ ...line, moves: prefix, totalPlies: prefix.length, truncated: false }, context);
+    const row = validated.recordedAnalysis.rows.find((item) => item[0] === line.selectedIndex + 1);
+    if (!row) return void 0;
+    const [
+      ply,
+      engine,
+      recordedDepth,
+      requestedDepth,
+      classifierVersion,
+      classification,
+      beforeCp,
+      afterCp,
+      lossCp,
+      mateBefore,
+      mateAfter
+    ] = row;
+    const snapshot = {
+      version: "recorded-selected-classification/1",
+      authority: "historical-reported-label-only",
+      source: "loaded-game-stored-selected-move-analysis",
+      position: { fenBefore: context.fenBefore, fenAfter: context.fenAfter, moveUci: context.moveUci, moveSan: context.moveSan, ply },
+      classification,
+      classifierVersion,
+      engine,
+      reportedDepth: recordedDepth,
+      recordedRequestedDepth: requestedDepth,
+      freshlyRecomputed: false,
+      savedEvaluation: { perspective: "selected-mover", units: "centipawns; mate separate", beforeCp, afterCp, lossCp, mateBefore, mateAfter },
+      limitations: [
+        "This is the recorded classification under the supplied historical classifier version, not necessarily the current app badge or current policy.",
+        "Preparation and subsequent engine searches do not recompute this stored label. Prefer a separately supplied refreshed board classification when available.",
+        "The label is not proof of its chess explanation. Saved scores may differ from fresh searches; lossCp is a saved search delta, not a matched comparison.",
+        "No future recorded moves, alternative candidates or other moves' classifications are included."
+      ]
+    };
+    const contextHash = reasoningContextHash(context);
+    const record = {
+      schemaVersion: REASONING_POC_VERSION,
+      id: `evidence:recorded-selected-classification:${stableHash({ contextHash, snapshot })}`,
+      contextHash,
+      kind: "context",
+      source: snapshot.source,
+      proofStrength: null,
+      summary: `The stored analysis labelled ${context.moveSan} ${classification} under classifier version ${classifierVersion}; this is historical reported context, not a new classification.`,
+      data: snapshot,
+      coverage: { complete: false, covered: ["historical-selected-classification"], unresolved: ["current-policy-classification", "causal-explanation"] },
+      replay: { fen: context.fenBefore, moveUci: context.moveUci },
+      licenses: [EVIDENCE_LICENSE.ATTENTION_AFFORDANCE]
+    };
+    return { record, snapshot: { ...snapshot, evidenceId: record.id } };
+  } catch {
+    return void 0;
+  }
+}
+export {
+  ABLATION_ADAPTIVE_EVIDENCE_LOOP_VERSION,
+  ABLATION_ADAPTIVE_RUNTIME_VERSION,
+  ABLATION_B_PRIME_TRIGGER_VALUES,
+  ABLATION_B_SYSTEM,
+  ABLATION_DIRECT_SYNTHESIS_VERSION,
+  ABLATION_EVIDENCE_BUNDLE_VERSION,
+  ABLATION_LEAN_DIRECT_PROPOSAL_VERSION,
+  ABLATION_LEAN_DIRECT_RUNTIME_VERSION,
+  ABLATION_PROBE_TELEMETRY_VERSION,
+  AI_SDK_ANSWER_OBLIGATION_RUNTIME,
+  AI_SDK_CRITIC_RUNTIME,
+  AI_SDK_DISCOURSE_RUNTIME,
+  AI_SDK_GRAPH_PLANNING_RUNTIME,
+  AI_SDK_GRAPH_SELECTION_RUNTIME,
+  AI_SDK_HYPOTHESIS_RUNTIME,
+  AI_SDK_PURPOSE_PROBE_RUNTIME,
+  AI_SDK_REASONING_RUNTIME,
+  AI_SDK_RENDER_RUNTIME,
+  AI_SDK_REPAIR_RUNTIME,
+  AI_SDK_RESOLUTION_AUDIT_RUNTIME,
+  AI_SDK_TERMINAL_REVIEW_RUNTIME,
+  ANALYSIS_CONTEXT_PROVENANCE_TIER,
+  ATTRIBUTE_KEYS,
+  AblationTransportCorrectionError,
+  AdaptiveAblationPreconditionError,
+  BRANCH_EXPANSION_OPTIONS,
+  CANONICAL_EDGE_ANALYSIS_SNAPSHOT_VERSION,
+  CAPTURE_RESPONSE_FACT_KIND,
+  CHESS_FACT_REQUEST_VERSION,
+  CHESS_FACT_RESULT_VERSION,
+  CHESS_FACT_SCHEMA_VERSION,
+  CHESS_REASONING_POLICY_VERSION,
+  CHESS_REASONING_SCHEMA_VERSION,
+  CHESS_REFERENCE_DICTIONARY,
+  CLASSIFICATION_REASSESSMENT_GUIDANCE,
+  COMPACT_ENGINE_INSTRUCTIONS,
+  COMPLETED_TOOL_REPLAY_ADMISSION_KEY,
+  CONCEPT_KEYS,
+  CONVERSATION_CONTEXT_INSTRUCTIONS,
+  ChessFactObservationProvider,
+  CompositeObservationProvider,
+  CriticResolutionAuditHarnessRejection,
+  DEFAULT_CONCEPT_REGISTRY,
+  DEFAULT_MATERIAL_FORMAT,
+  DEFAULT_REASONING_RUN_CONTROLS,
+  DETERMINISTIC_DISCOURSE_RUNTIME,
+  DETERMINISTIC_OBSERVATION_PROVIDER_VERSION,
+  DIRECT_SYNTHESIS_PROPOSAL_JSON_SCHEMA,
+  DeterministicObservationProvider,
+  ENTITY_TYPES,
+  EVALUATED_ASTRA_CONFIG,
+  EVIDENCE_LICENSE,
+  EVIDENCE_SHARING_GUIDANCE_CHARS,
+  EVIDENCE_SHARING_INSTRUCTIONS,
+  EVIDENCE_SHARING_VERSION,
+  EXISTING_ANALYSIS_CONTEXT_MODE,
+  EXISTING_ANALYSIS_CONTEXT_VERSION,
+  EXISTING_ANALYSIS_OBSERVATION_PROVIDER_ID,
+  EXISTING_ANALYSIS_RECORD_VERSION,
+  EXPLAIN_PLAN_SELECTION_DESCRIPTOR,
+  EXPLANATION_REVIEW_SCHEMA,
+  ExistingAnalysisObservationProvider,
+  FACT_DELIVERY_INSTRUCTIONS,
+  FACT_OBSERVATION_ADAPTER_VERSION,
+  GraphSelectionHarnessRejection,
+  HypothesisHarnessRejection,
+  HypothesisLedger,
+  HypothesisProviderRuntimeFailure,
+  HypothesisReviewHarnessRejection,
+  LEAN_DIRECT_PROPOSAL_JSON_SCHEMA,
+  LEGACY_EXISTING_ANALYSIS_CONTEXT_VERSION,
+  MATCHED_COMPARISON_GUIDANCE,
+  MATERIAL_OFFER_SET_VERSION,
+  MAX_ANSWER_TOOL_REQUESTS_PER_TURN,
+  MAX_FRESH_ENGINE_WITNESS_ACQUISITIONS,
+  MAX_INTERACTIVE_LINE_PLIES,
+  MECHANICAL_CHESS_FACT_PROVIDER_ID,
+  MECHANICAL_CHESS_FACT_PROVIDER_VERSION,
+  MECHANISM_FACT_INSTRUCTIONS,
+  MechanicalChessFactProvider,
+  ModelOwnedAdaptiveEvidenceLoop,
+  ModelRuntimeFailure,
+  OPENING_SOURCE_INSTRUCTIONS,
+  OPENING_SOURCE_LICENSE_URL,
+  PARTICIPANT_ROLES,
+  PRECOMMITTED_PROBE_ATTRIBUTION_CATEGORIES,
+  PRODUCTION_OBSERVATION_PROVIDER_VERSION,
+  QUESTION_ROUTING_VERSION,
+  QUESTION_SALIENCE_POLICY_VERSION,
+  QuestionConditionedSaliencePolicy,
+  RAW_CHESS_TEXT,
+  RAW_CHESS_TEXT_PATTERN_SOURCE,
+  REASONING_DISCOURSE_PLAN_VERSION,
+  REASONING_POC_CRITIC_CORRECTION_ALLOWANCE,
+  REASONING_POC_MAX_CRITIC_OUTPUT_TOKENS,
+  REASONING_POC_MAX_DISCOURSE_OUTPUT_TOKENS,
+  REASONING_POC_MAX_GRAPH_SELECTION_OUTPUT_TOKENS,
+  REASONING_POC_MAX_HYPOTHESIS_BATCHES,
+  REASONING_POC_MAX_HYPOTHESIS_OUTPUT_TOKENS,
+  REASONING_POC_MAX_OUTPUT_TOKENS,
+  REASONING_POC_MAX_PURPOSE_PROBE_OUTPUT_TOKENS,
+  REASONING_POC_MAX_RENDER_OUTPUT_TOKENS,
+  REASONING_POC_MAX_RESOLUTION_AUDIT_OUTPUT_TOKENS,
+  REASONING_POC_MAX_TERMINAL_REVIEW_OUTPUT_TOKENS,
+  REASONING_POC_PURPOSE_PROBE_ALLOWANCE,
+  REASONING_POC_RESERVED_MANDATORY_STEPS,
+  REASONING_POC_REVISION_EVIDENCE_ALLOWANCE,
+  REASONING_POC_VERSION,
+  RECORDED_POSITION_DESCRIPTORS,
+  RECORD_HYPOTHESES_DESCRIPTOR,
+  REFERENCE_DOMAINS,
+  RELATION_TYPES,
+  REVIEW_HYPOTHESES_DESCRIPTOR,
+  REVIEW_SUBJECTS,
+  ReasoningCriticHarnessRejection,
+  ReasoningWorkflowFailure,
+  SEMANTIC_TEXT_JSON_PATTERN,
+  SIMPLE_BOARD_ANALYSIS_GUIDANCE,
+  SIMPLE_BUDGETS,
+  SIMPLE_CONTENT_SELECTION_GUIDANCE,
+  SIMPLE_DISCLOSURE,
+  SIMPLE_EVIDENCE_VIEW_VERSION,
+  SIMPLE_EXAMPLE_GUIDANCE,
+  SIMPLE_EXPANDED_BUDGETS,
+  SIMPLE_EXPLANATION_GUIDANCE,
+  SIMPLE_EXTENSION_CONFIGS,
+  SIMPLE_MODELS,
+  SIMPLE_MODEL_CATALOGUE,
+  SIMPLE_PURPOSE_GUIDANCE,
+  SIMPLE_RECOVERY_BUDGETS,
+  SIMPLE_REFERENCE_INSTRUCTIONS,
+  SIMPLE_REFERENCE_VERSION,
+  SIMPLE_SEARCH_BREADTH_GUIDANCE,
+  SIMPLE_SECTION_GUIDANCE,
+  SIMPLE_STOPPING_GUIDANCE,
+  SIMPLE_SYSTEM,
+  SIMPLE_TOOL_AGENT_VERSION,
+  SIMPLE_VENDOR_CONFIGS,
+  SimpleFactDelivery,
+  TerminalReviewHarnessRejection,
+  ablationHistoryThroughTargetHash,
+  ablationLeanDirectSystem,
+  abortSource,
+  admitFreshEnginePvWitnesses,
+  applyIdentityMove,
+  assertDirectedDestinationAnchors,
+  assertFactProofWithinAuthority,
+  assertTransportOnlyDirectCorrection,
+  bytes,
+  canonicalPieceLabel,
+  captureAblationOriginalEvidenceBundle,
+  checkCausalClaims,
+  chessFactRecordLicenses,
+  chessSquareColor,
+  classificationReassessment,
+  classificationTargetAtSelection,
+  classifyGraphSelectionHarnessRejection,
+  classifyGraphSelectionRuntimeFailure,
+  classifyHypothesisHarnessRejection,
+  classifyProviderHypothesisRejection,
+  classifyQuestionRoutingAnswers,
+  classifyReasoningCriticHarnessRejection,
+  classifyReviewSubject,
+  classifyRuntimeFailure,
+  collectReasoningMoveWitnesses,
+  compactLeanEvidencePacket,
+  compactMechanism,
+  compactPreparedSearchResult,
+  compactSearchRecord,
+  compactSimpleEngineResult,
+  compactSimpleInitialPacket,
+  compactSimpleToolResult,
+  conceptDefinition,
+  conceptsOf,
+  consolidatePreparedSearches,
+  createAblationEvidenceClosureBundle,
+  createAblationProbeTelemetry,
+  createConceptRegistry,
+  createContextEvidence,
+  createDefaultObservationProvider,
+  createDefaultSaliencePolicy,
+  createIdeaGraph,
+  createIdentityState,
+  createMechanicalFactRequest,
+  createNativeAnswerConnector,
+  createPocIdentityTimeline,
+  createPocToolHost,
+  createProductionObservationProvider,
+  createQueryContract,
+  createSemanticEntity,
+  createSemanticRelation,
+  createToolInputLoopGuard,
+  decodeWikibooksIndex,
+  decorateSimpleVariations,
+  deepestError,
+  deriveAblationBPrimeTriggers,
+  deriveAdmittedCaptureResponseAvailabilityFact,
+  effectiveEvidenceLicenses,
+  effectiveLicensesForRecord,
+  emitObservableTrace,
+  enrichAblationEvidenceBundleWithAdmittedCaptureResponses,
+  enrichAblationEvidenceClosureBundle,
+  evidenceFallback,
+  evidenceLicenseInput,
+  expandCompactEngineEvidence,
+  expandMechanismPresentation,
+  expandPrincipalBranches,
+  expandSharedEvidence,
+  explanationBranches,
+  explanationCoverage,
+  explanationSummary,
+  extendConceptRegistry,
+  extendIdeaGraph,
+  factCoverageSupportsAbsence,
+  factProofStrength,
+  forcedWinPremiseFallback,
+  forkIdeaGraph,
+  forkIdentityState,
+  graphIdentityCompatible,
+  hasConcept,
+  hasMoveClassificationQuestion,
+  hasSharedEvidence,
+  historyPositionContext,
+  isChessFactAuthority,
+  isTerminalEntity,
+  isTransportCorrectableDirectSynthesisIssues,
+  licensesBoundedRouteRelevance,
+  licensesSemanticChessGrounding,
+  makeQuestionRoutingRequest,
+  matchedRootComparison,
+  materialAlongLine,
+  materialAtPosition,
+  materialForVariations,
+  materializeDirectSynthesis,
+  materializeLeanDirectProposal,
+  maximumEvidenceLicenses,
+  maximumFactProofStrength,
+  memoizeToolResults,
+  moveMechanismFacts,
+  moveSectionScope,
+  normalizeExistingAnalysisContext,
+  normalizedEvidenceCitations,
+  numericUsage,
+  observableTraceMessages,
+  openEntityCount,
+  openingSourceLinks,
+  openingSourcesInMessages,
+  openingTitle,
+  parseDirectSynthesisProposal,
+  parseExplainPlanRequest,
+  parseOpeningSourceCredits,
+  parseQuestionRoutingAnswers,
+  participant,
+  participantIds,
+  pieceIdAt,
+  pieceIdentity,
+  planInitialSearches,
+  planningEvidence,
+  positionKey,
+  precommittedProbeAttributionCategories,
+  prepareAblationAdaptiveEvidenceForStagedReference,
+  prepareOpponentThreats,
+  prepareSimpleEvidence,
+  preparedMoveComparison,
+  primaryConcept,
+  priorConversationMessages,
+  projectAblationEvidenceForModel,
+  projectCompactEngineEvidence,
+  projectEnginePresentation,
+  projectLeanDirectEvidence,
+  projectLeanEpisodeEvidence,
+  projectMaterial,
+  reasoningContextHash,
+  reasoningEvidenceReplayStartPhase,
+  reasoningMetrics,
+  recordedMainLineResult,
+  recordedNavigation,
+  recordedPositionContext,
+  recordedSelectedClassification,
+  repairFrozenCitationLabels,
+  replayWikibooksTitle,
+  requestId,
+  resolveAndSelectPlan,
+  retainedEvidenceCatalogue,
+  runAblationAdaptiveDirect,
+  runAnswerPipeline,
+  runLeanDirect,
+  runPreparedAnswer,
+  safeSimpleSourceLink,
+  savedScorePresentation,
+  scopePositionAnalysis,
+  scoreComparisonNotices,
+  selectBranchHost,
+  selectIndexedOpening,
+  selectSimpleModel,
+  shareEvidence,
+  shareEvidenceMessages,
+  simpleBoardAnalysis,
+  simpleEffortsForModel,
+  simpleInitialEvidenceView,
+  simplePastHistory,
+  simpleProseReferences,
+  simpleSystemPolicy,
+  simpleToolDescription,
+  simpleUsageForTrace,
+  squareForPiece,
+  squaresBetween,
+  stabilizeSimplePolicy,
+  stableHash,
+  stableJson,
+  stringListAttribute,
+  stripSimpleCitationLinks,
+  stripSimpleMarkdownFences,
+  toLegacyPositionAnalysis,
+  toLegacyPositionAnalysisProvider,
+  toPositionAnalysis,
+  toPositionAnalysisProvider,
+  validateAblationEvidenceClosureBundle,
+  validateAblationProbeTelemetry,
+  validateAnswerReferences,
+  validateChessFactRecord,
+  validateChessFactRequest,
+  validateEvidenceLicenseClaims,
+  validateExplanationReview,
+  validateHypothesisAcceptancePolicies,
+  validateReasoningPositionContext,
+  validateSimpleAgentConfig,
+  validateSimpleToolInput,
+  visibleSupportLines,
+  wikibooksTargetsForTool,
+  withBranchPreparation,
+  withEvidenceLicenses,
+  withRecordedPositionTools
+};