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

package/dist/chunk-XQDZJOYD.js

@@ -0,0 +1,2515 @@
+// src/chess-reasoning/question-routing.ts
+var QUESTION_ROUTING_VERSION = "jev-r17-move-classification-20261003";
+var REVIEW_SUBJECTS = ["self", "opponent", "white", "black", "both", "unspecified"];
+var ANSWER_SCOPES = ["move_explanation", "position_analysis", "game_review", "general", "mixed"];
+var reviewSubjectQuestion = {
+  type: "choice",
+  instructions: "Whose play is the user asking to assess across a game or phase? Find the subject of that assessment, even if expressed as past decisions to improve rather than the word review. Ignore separate local-position requests and quoted or excluded instructions. Ownership of a game alone is not a player restriction. If the question explicitly identifies the reviewed player's color, choose white or black rather than self or opponent. Conflicting active review subjects must not select one player.",
+  criteria: {
+    self: "Assessment of the user's own performance or decisions: their errors, what they did wrong, or what they should have done differently across the game. This personal assessment can accompany a request to go through their game. No assessment of the other player's decisions is requested, and the question does not explicitly identify the user's color.",
+    opponent: "The user asks to assess their opponent's play, mistakes or decisions, without requesting review of their own play. The question does not explicitly identify which color that opponent played.",
+    white: "The requested review concerns White's decisions only, whether named directly or identified as the user/opponent by an explicit statement of who played which color. Color mentions that merely describe the opponent or another local question do not count.",
+    black: "The requested review concerns Black's decisions only, whether named directly or identified as the user/opponent by an explicit statement of who played which color. Color mentions that merely describe the opponent or another local question do not count.",
+    both: "The across-game/phase review explicitly covers both players, or contains conflicting review subjects that cannot be resolved to one player. A separate question about a single move or piece does not add a player to this review's scope.",
+    unspecified: "No assessment across multiple played decisions is requested, or no player's decisions are singled out. An overall review of the game, my game or our opening alone has no player restriction. An additional request to assess the user's own decisions DOES specify self instead."
+  }
+};
+var independentCriteria = {
+  yes: "Every active request is independent of the board selection: game-record facts (including final moves), review of a game or phase (including endgames), general knowledge or language, or an explicitly numbered historical move and its alternatives. Quoted or excluded current-position references do not count.",
+  no: "At least one active request is about the current board, selected move, next reply, or continuation relative to it; or refers to an unidentified move or prior answer. A mixed game-review/current-position question belongs here."
+};
+var questions = {
+  independent: {
+    type: "choice",
+    instructions: "Can all active requests be answered using the game record or general knowledge, without knowing which turn the viewer selected?",
+    criteria: independentCriteria
+  },
+  independent_noul: {
+    type: "noul",
+    instructions: "Is the user asking only about subjects identifiable independently of the selected move?",
+    criteria: { true: independentCriteria.yes, false: independentCriteria.no }
+  },
+  board_guard: {
+    type: "choice",
+    instructions: "Does the user actively ask about the board position currently displayed?",
+    criteria: {
+      yes: "An active request for its evaluation, material, threats, legal moves, plans, or another property of the current position. Excluding discussion of the selected move does not exclude the board.",
+      no: "Only game history, phase review, an explicitly numbered historical turn, general knowledge, or discussion/translation of quoted text. No active request about the current board."
+    }
+  },
+  review_only: {
+    "type": "choice",
+    "instructions": "Is the user's entire request a review of how they played across a game or a phase of that game?",
+    "criteria": {
+      "yes": "Assess their play across the opening, middlegame, endgame or whole game. Evaluate performance, identify mistakes or missed chances, or give lessons from that play. No additional request about the selected move, the current board, or what to play next.",
+      "no": "A specific move or current position is being discussed, including a mixed request combining a game review with a selected-move explanation, current-position assessment, next move or continuation. General chess advice without reviewing their played game is also no."
+    }
+  },
+  local_reference: {
+    "type": "choice",
+    "instructions": "Does answering the user's active question require identifying a move or position referred to without an explicit game move number?",
+    "criteria": {
+      "yes": "The question asks about this move, this position, here, now, a next move, an unnamed alternative, or a reference to a previous answer. Include mixed requests even if they also mention game history or reviewing the opening. A question like why this is losing needs the referenced position.",
+      "no": "Every active request is about the whole game, a game phase, general knowledge, or an explicitly numbered historical move. Mentions of the current board that are quoted or explicitly excluded are not active requests."
+    }
+  },
+  game_record: {
+    "type": "choice",
+    "instructions": "Does the user ask what actually happened in this game, including which moves were played?",
+    "criteria": {
+      "yes": "The user asks for actual game events, actual subsequent play, or whether/when a move was played.",
+      "no": "The user is not asking to retrieve actual game events or played moves."
+    }
+  },
+  game_context: {
+    "type": "choice",
+    "instructions": "Does answering the user require their recorded game, beyond the selected move and its immediately surrounding positions?",
+    "criteria": {
+      "yes": "The answer depends on played game history: actual events or later play, review of a game or phase, an explicitly numbered historical move, or advice and variations specific to the opening played in this game. Include coaching requests grounded in their game even when they do not explicitly ask to retrieve moves.",
+      "no": "The current position or selected move alone is sufficient, or the request is general chess knowledge, translation, or unrelated to the played game. A named opening alone without a reference to their game does not require game history. Comparing possible moves in the selected position is a local question, unless another part of the request needs game history."
+    }
+  },
+  game_review: {
+    type: "choice",
+    instructions: "Is a review of play across the game or a phase explicitly requested?",
+    criteria: {
+      yes: "Review multiple decisions, find mistakes across a phase or the game, or recommend lessons from that play. An explicit question about how an earlier phase went still counts when paired with next-move advice. A comprehensive review of the full game counts even without mentioning mistakes or personal performance.",
+      no: "No broad review is requested. Mentioning past mistakes while asking what to do now, or asking about just one move, is not a broad review. Retrieving facts, statistics or played moves without evaluating decisions is not a review. Evaluating only one hypothetical alternative is not a phase review. Opening identification or general planning advice without assessing played decisions is not a review."
+    }
+  },
+  selected_anchor: {
+    type: "choice",
+    instructions: "Is any part of the request about the currently selected chess position or an unidentified local move? Classify the active request, not quoted or explicitly excluded text.",
+    criteria: {
+      yes: "The displayed board, this move, an unnumbered move judged against the engine, an unnamed alternative, what to play from here, or an unresolved reference to previous analysis. General advice alongside a local question still counts.",
+      no: "Only a whole game, a game phase, a move identified by its turn number, actual game events, or a self-contained general topic. A numbered move anchors its consequences and replies too. This includes numbered historical moves written with non-English piece notation."
+    }
+  },
+  numbered_move_target: {
+    type: "choice",
+    instructions: "Is an actual game turn number attached to the target move, separately from its destination square? Ignore quoted or excluded requests.",
+    criteria: {
+      yes: "A turn number precedes a period and move, as in 5.Nxe5 or 12...Nd4, or prose explicitly says bishop move on turn twelve. The user asks about that identified move, its alternatives or consequences.",
+      no: "A square rank is NOT a turn number: Ne6, Na5, a5 and d4 are unnumbered moves. Quantities of plies and ranges of turns are not numbered target moves. Numbered text merely quoted for translation does not count."
+    }
+  },
+  played_opening: {
+    type: "choice",
+    instructions: "Does the user actively ask to identify or teach the opening system or sequence played in their game? Ignore quoted or excluded requests.",
+    criteria: {
+      yes: "Identify the played opening, teach this opening or our opening, give its overall main lines, or coach the opening phase of their game. The request must actually refer to an opening or opening phase.",
+      no: "Only current-position advice, best replies or continuations from the current point. An opening name merely framing a particular move is insufficient. Generic named-opening theory, or opening words inside text being translated, also do not count."
+    }
+  },
+  retrospective_review: {
+    type: "choice",
+    instructions: "Does the user request feedback on how they played across a game or a phase? Classify the active request, not quoted or explicitly excluded text.",
+    criteria: {
+      yes: "Review actual play, diagnose recurring mistakes, or explain how their decisions across the opening, middlegame, endgame or game could have been better. This can be part of a mixed request.",
+      no: "Only one move or position; theory, prospective continuations, hypothetical traps or typical future mistakes. A walkthrough of possible replies is not feedback on played decisions."
+    }
+  }
+};
+var answerScopeQuestion = {
+  type: "choice",
+  instructions: "What is the main task of the user's active request? Classify its requested answer, not the selected board, available game history, routing needs, or quoted/excluded text. A move explanation requires a specific move actually played, including an identified historical game move; a hypothetical candidate from the current position is position analysis. Choose mixed if a move explanation is combined with a substantial whole-game, position, or other independent task.",
+  criteria: {
+    move_explanation: "Explain or evaluate one specific played move, selected now or identified from the recorded game, and its pertinent alternatives or continuations.",
+    position_analysis: "Assess a current or starting position, legal candidates, plans or next moves without a specific played target move.",
+    game_review: "Review decisions or play across the whole recorded game or a phase, even when a selected move happens to be available.",
+    general: "Answer a factual, rules, opening theory, translation or other question that is not a played-move explanation, position analysis or game review.",
+    mixed: "Multiple substantial tasks have different scopes; do not force one played-move structure over the complete answer."
+  }
+};
+var moveClassificationQuestion = {
+  type: "choice",
+  instructions: "Does ANY active part of the question ask to explain, justify, challenge or reassess the quality classification of a PLAYED move? Include mixed questions and played moves identified by SAN, game move number, this move, or previous move. You have only the question: do not infer whether a named or numbered move is selected now or historical. Ignore quoted or expressly excluded requests.",
+  criteria: {
+    yes: "At least one active request asks why or whether a played move deserves a quality label: forced, brilliant, great, interesting, best, good, okay, dubious, mistake, missed opportunity or blunder. Why is this the best move in this position, why is 14.Qg4 great, and why was my opponent's previous move a blunder all count. The request can be one part of a mixed question.",
+    no: "No active played-move quality-classification request. Only move intention, plans, threats, position evaluation, prospective hypothetical candidates, opening lines, general label definitions, translation of quoted classification questions, expressly excluded label explanations, or a label mentioned merely as background."
+  }
+};
+var classificationReferenceQuestion = {
+  type: "choice",
+  instructions: "How is the target of the ACTIVE PLAYED-MOVE CLASSIFICATION request expressed? Describe only the wording, not game facts or which move is selected. Examine classification requests separately from unrelated requests in a mixed question. If ANY active classification request explicitly refers to this/current/selected move or an unnamed local played move, choose selection_relative even alongside named-move questions. Unrelated local plans or next-move requests do not count as selection-relative classification requests. Ignore quoted and expressly excluded text.",
+  criteria: {
+    selection_relative: "An active classification request says this move, the current/selected move, this was a mistake, or otherwise concerns an unnamed local played move. Takes precedence if there is also a named or previous-move classification request. Compare 14.Qg4 with 14.Qh5, and explain why this selected move is marked a mistake is selection_relative.",
+    named_move: "Active played-move classification requests name a move by SAN, optionally with a game move number, and no separate selection-relative classification request exists. Why is 14.Qg4 great, and what should I play next here is named_move: only the plans request is local. The number does not tell you whether that move is currently selected.",
+    other_relative: "Active played-move classification requests identify a previous move, opponent's last move or another relative played move without explicit SAN, with no selection-relative or named-move classification request. This describes the reference wording, not its resolved game position.",
+    none: "No active played-move classification request: only definitions, quoted or excluded label questions, prospective hypothetical moves, move intention, position evaluation, plans, opening lines or labels mentioned as background."
+  }
+};
+var CLASSIFICATION_REFERENCES = ["selection_relative", "named_move", "other_relative", "none"];
+var CLASSIFICATION_TARGETS = ["selected_move", "other_move", "none"];
+function makeQuestionRoutingRequest(question) {
+  if (typeof question !== "string" || !question.trim() || question.length > 8e3) throw new Error("Invalid routing question.");
+  return { model: "typesafe/jev-1.13", state: { question }, questions: structuredClone({ ...questions, review_subject: reviewSubjectQuestion, answer_scope: answerScopeQuestion, move_classification: moveClassificationQuestion, classification_reference: classificationReferenceQuestion }) };
+}
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var probability = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+var keysWithin = (value, keys) => Object.keys(value).every((key2) => keys.includes(key2));
+function parseQuestionRoutingAnswers(value) {
+  if (!record(value) || !record(value.answers) || !keysWithin(value.answers, [...Object.keys(questions), "review_subject", "answer_scope", "current_classification", "classification_target", "move_classification", "classification_reference"])) return null;
+  const parsed = {};
+  for (const id of Object.keys(questions)) {
+    const answer = value.answers[id];
+    if (!record(answer)) return null;
+    if (id === "independent_noul") {
+      if (answer.type !== "noul" || !probability(answer.noul) || !keysWithin(answer, ["type", "noul"])) return null;
+      parsed[id] = { type: "noul", noul: answer.noul };
+    } else {
+      if (answer.type !== "choice" || answer.choice !== "yes" && answer.choice !== "no" || !keysWithin(answer, ["type", "choice", "confidence", "probabilities"])) return null;
+      if (answer.confidence !== void 0 && !probability(answer.confidence)) return null;
+      if (answer.probabilities !== void 0 && (!record(answer.probabilities) || !keysWithin(answer.probabilities, ["yes", "no"]) || Object.values(answer.probabilities).some((value2) => !probability(value2)))) return null;
+      parsed[id] = {
+        type: "choice",
+        choice: answer.choice,
+        ...answer.confidence === void 0 ? {} : { confidence: answer.confidence },
+        ...answer.probabilities === void 0 ? {} : { probabilities: answer.probabilities }
+      };
+    }
+  }
+  const result = parsed;
+  const subject = value.answers.review_subject;
+  if (record(subject) && subject.type === "choice" && REVIEW_SUBJECTS.includes(subject.choice) && keysWithin(subject, ["type", "choice", "confidence", "probabilities"]) && (subject.confidence === void 0 || probability(subject.confidence)) && (subject.probabilities === void 0 || record(subject.probabilities) && keysWithin(subject.probabilities, REVIEW_SUBJECTS) && Object.values(subject.probabilities).every(probability))) {
+    result.review_subject = {
+      type: "choice",
+      choice: subject.choice,
+      ...subject.confidence === void 0 ? {} : { confidence: subject.confidence },
+      ...subject.probabilities === void 0 ? {} : { probabilities: subject.probabilities }
+    };
+  }
+  const scope2 = value.answers.answer_scope;
+  if (record(scope2) && scope2.type === "choice" && ANSWER_SCOPES.includes(scope2.choice) && keysWithin(scope2, ["type", "choice", "confidence", "probabilities"]) && (scope2.confidence === void 0 || probability(scope2.confidence)) && (scope2.probabilities === void 0 || record(scope2.probabilities) && keysWithin(scope2.probabilities, ANSWER_SCOPES) && Object.values(scope2.probabilities).every(probability))) {
+    result.answer_scope = {
+      type: "choice",
+      choice: scope2.choice,
+      ...scope2.confidence === void 0 ? {} : { confidence: scope2.confidence },
+      ...scope2.probabilities === void 0 ? {} : { probabilities: scope2.probabilities }
+    };
+  }
+  const classification = value.answers.current_classification;
+  if (record(classification) && classification.type === "choice" && (classification.choice === "yes" || classification.choice === "no") && keysWithin(classification, ["type", "choice", "confidence", "probabilities"]) && (classification.confidence === void 0 || probability(classification.confidence)) && (classification.probabilities === void 0 || record(classification.probabilities) && keysWithin(classification.probabilities, ["yes", "no"]) && Object.values(classification.probabilities).every(probability))) {
+    result.current_classification = {
+      type: "choice",
+      choice: classification.choice,
+      ...classification.confidence === void 0 ? {} : { confidence: classification.confidence },
+      ...classification.probabilities === void 0 ? {} : { probabilities: classification.probabilities }
+    };
+  }
+  const target = value.answers.classification_target;
+  if (record(target) && target.type === "choice" && CLASSIFICATION_TARGETS.includes(target.choice) && keysWithin(target, ["type", "choice", "confidence", "probabilities"]) && (target.confidence === void 0 || probability(target.confidence)) && (target.probabilities === void 0 || record(target.probabilities) && keysWithin(target.probabilities, CLASSIFICATION_TARGETS) && Object.values(target.probabilities).every(probability))) {
+    result.classification_target = {
+      type: "choice",
+      choice: target.choice,
+      ...target.confidence === void 0 ? {} : { confidence: target.confidence },
+      ...target.probabilities === void 0 ? {} : { probabilities: target.probabilities }
+    };
+  }
+  const moveClassification = value.answers.move_classification;
+  if (record(moveClassification) && moveClassification.type === "choice" && (moveClassification.choice === "yes" || moveClassification.choice === "no") && keysWithin(moveClassification, ["type", "choice", "confidence", "probabilities"]) && (moveClassification.confidence === void 0 || probability(moveClassification.confidence)) && (moveClassification.probabilities === void 0 || record(moveClassification.probabilities) && keysWithin(moveClassification.probabilities, ["yes", "no"]) && Object.values(moveClassification.probabilities).every(probability))) {
+    result.move_classification = {
+      type: "choice",
+      choice: moveClassification.choice,
+      ...moveClassification.confidence === void 0 ? {} : { confidence: moveClassification.confidence },
+      ...moveClassification.probabilities === void 0 ? {} : { probabilities: moveClassification.probabilities }
+    };
+  }
+  const reference = value.answers.classification_reference;
+  if (record(reference) && reference.type === "choice" && CLASSIFICATION_REFERENCES.includes(reference.choice) && keysWithin(reference, ["type", "choice", "confidence", "probabilities"]) && (reference.confidence === void 0 || probability(reference.confidence)) && (reference.probabilities === void 0 || record(reference.probabilities) && keysWithin(reference.probabilities, CLASSIFICATION_REFERENCES) && Object.values(reference.probabilities).every(probability))) {
+    result.classification_reference = {
+      type: "choice",
+      choice: reference.choice,
+      ...reference.confidence === void 0 ? {} : { confidence: reference.confidence },
+      ...reference.probabilities === void 0 ? {} : { probabilities: reference.probabilities }
+    };
+  }
+  return result;
+}
+function moveSectionScope(decision) {
+  if (decision.status !== "classified") return "none";
+  const scope2 = decision.answers?.answer_scope;
+  const score = scope2?.probabilities?.move_explanation;
+  return scope2?.choice === "move_explanation" && typeof score === "number" && score >= 0.75 && Object.entries(scope2.probabilities ?? {}).every(([key2, p]) => key2 === "move_explanation" || p < score) ? "move-explanation" : "none";
+}
+function classifyReviewSubject(answers) {
+  const answer = answers.review_subject;
+  const selected = answer?.probabilities?.[answer.choice] ?? 0;
+  return answer && selected >= 0.75 && Object.entries(answer.probabilities ?? {}).every(([key2, p]) => key2 === answer.choice || p < selected) ? answer.choice : "unspecified";
+}
+function classifyQuestionRoutingAnswers(answers) {
+  const local = answers.local_reference;
+  const retainLocal = local.type !== "choice" || local.probabilities?.yes === void 0 || local.choice === "yes" && local.probabilities.yes >= 0.85;
+  const reviewOnly = answers.review_only;
+  const independentReview = reviewOnly.type === "choice" && reviewOnly.choice === "yes" && (reviewOnly.probabilities?.yes ?? 0) >= 0.85;
+  const independence = independentReview || answers.independent.choice === "yes" || answers.independent_noul.noul > 0.5;
+  const board = answers.board_guard;
+  const historicalOmission = !retainLocal && independence && board.choice === "no";
+  const selected = answers.selected_anchor;
+  const strong = (id, threshold) => {
+    const answer = answers[id];
+    return answer.choice === "yes" && (answer.probabilities?.yes ?? 0) >= threshold;
+  };
+  const selectedGuard = answers.move_classification?.type === "choice" && answers.move_classification.choice === "yes" && answers.classification_reference?.choice === "selection_relative" || selected.probabilities?.no === void 0 || selected.choice === "yes" && (selected.probabilities?.yes ?? 0) >= 0.85;
+  const numbered = strong("numbered_move_target", 0.9), opening = strong("played_opening", 0.9);
+  const numberedExtra = numbered && selected.choice === "no" && (board.probabilities?.yes ?? 1) < 0.7 && (local.type === "choice" ? local.probabilities?.yes ?? 1 : 1) < 0.85;
+  const openingExtra = opening && selected.choice === "no" && board.choice === "no";
+  const reviewExtra = independentReview && strong("game_review", 0.85) && strong("retrospective_review", 0.85) && selected.choice === "no" && (board.probabilities?.yes ?? 1) < 0.7 && (local.type === "choice" ? local.probabilities?.yes ?? 1 : 1) < 0.85;
+  const omitSelectedContext = !selectedGuard && (historicalOmission || numberedExtra || openingExtra || reviewExtra);
+  const retrospective = answers.retrospective_review;
+  const historicalReview = answers.game_review.choice === "yes" || strong("review_only", 0.85);
+  const reviewGame = historicalReview && !(selected.choice === "yes" && retrospective.choice === "no" && (retrospective.probabilities?.no ?? 0) >= 0.85);
+  const explicitRecord = strong("game_context", 0.75);
+  const includeGameRecord = omitSelectedContext || numbered || opening || reviewGame || explicitRecord || answers.game_record.choice === "yes";
+  return { omitSelectedContext, includeGameRecord, reviewGame };
+}
+function hasMoveClassificationQuestion(decision) {
+  const answer = decision.answers?.move_classification;
+  return decision.status === "classified" && answer?.type === "choice" && answer.choice === "yes";
+}
+
+// src/chess-reasoning/classification-question-target.ts
+var normalizedSan = (san) => san.replace(/[+#?!]+$/, "");
+function classificationQuestionMoveReferences(question) {
+  const pattern = /(?<![A-Za-z0-9])(?:(\d+)\s*(\.{1,3}|…)\s*)?(O-O(?:-O)?|[KQRBN][a-h]?[1-8]?x?[a-h][1-8](?:=[QRBN])?|[a-h]x?[a-h]?[1-8](?:=[QRBN])?)[+#]?(?![A-Za-z0-9])/g;
+  return [...question.matchAll(pattern)].map((match) => ({ san: normalizedSan(match[3]), moveNumber: match[1] ? Number(match[1]) : null, color: match[2] ? match[2] === "." ? "w" : "b" : null }));
+}
+function classificationTargetAtSelection(decision, question, context) {
+  if (!hasMoveClassificationQuestion(decision)) return { applies: false, resolution: "no-classification" };
+  if (context.kind === "position" || !context.moveUci) return { applies: false, resolution: "no-played-selection" };
+  const reference = decision.answers?.classification_reference?.choice;
+  if (reference === "selection_relative") return { applies: true, resolution: "selection-relative" };
+  const localReference = decision.answers?.local_reference;
+  if ((!reference || reference === "none") && localReference?.type === "choice" && localReference.choice === "yes" && classificationQuestionMoveReferences(question).length === 0)
+    return { applies: true, resolution: "unnamed-local-classification" };
+  if (reference !== "named_move") return { applies: false, resolution: reference === "other_relative" ? "other-relative" : "unresolved-reference" };
+  const references = classificationQuestionMoveReferences(question);
+  const unique = [...new Map(references.map((ref2) => [JSON.stringify(ref2), ref2])).values()];
+  if (unique.length !== 1) return { applies: false, resolution: "ambiguous-named-reference", references };
+  const ref = unique[0], fields = context.fenBefore.split(" ");
+  const matches = ref.san === normalizedSan(context.moveSan) && (!ref.moveNumber || ref.moveNumber === Number(fields[5])) && (!ref.color || ref.color === fields[1]);
+  return { applies: matches, resolution: matches ? "named-selected-move" : "named-other-move", references };
+}
+
+// src/chess-reasoning/saved-score-presentation.ts
+function savedScorePresentation(a) {
+  const finiteCp = (cp, mate) => mate !== null || cp !== null && Math.abs(cp) >= 1e5 ? null : cp;
+  const beforeCp = finiteCp(a.beforeCp, a.mateBefore), afterCp = finiteCp(a.afterCp, a.mateAfter);
+  return { beforeCp, afterCp, lossCp: a.mateBefore !== null || a.mateAfter !== null || beforeCp === null || afterCp === null || a.lossCp === 9999 ? null : a.lossCp, mateBefore: a.mateBefore, mateAfter: a.mateAfter };
+}
+
+// src/chess-reasoning/material-accounting.ts
+import { Chess } from "chess.js";
+var pieces = { p: "pawn", n: "knight", b: "bishop", r: "rook", q: "queen" };
+var empty = () => ({ pawn: 0, knight: 0, bishop: 0, rook: 0, queen: 0 });
+var difference = (a, b) => Object.fromEntries(
+  Object.values(pieces).map((name) => [name, a[name] - b[name]])
+);
+function materialAtPosition(board) {
+  const white = empty(), black = empty();
+  for (const piece of board.board().flat()) {
+    if (piece && piece.type !== "k") (piece.color === "w" ? white : black)[pieces[piece.type]]++;
+  }
+  const whiteMinusBlack = difference(white, black);
+  const extras = (sign) => Object.entries(whiteMinusBlack).filter(([, n]) => n * sign > 0).map(([name, n]) => `${Math.abs(n)} ${name}${Math.abs(n) === 1 ? "" : "s"}`);
+  const w = extras(1), b = extras(-1);
+  return { white, black, whiteMinusBlack, balance: !w.length && !b.length ? "Equal piece counts." : [
+    w.length ? `White has ${w.join(" and ")} more than Black` : "",
+    b.length ? `Black has ${b.join(" and ")} more than White` : ""
+  ].filter(Boolean).join("; ") + "." };
+}
+function materialAlongLine(startFen, movesUci) {
+  const board = new Chess(startFen), start = materialAtPosition(board);
+  const changes = [];
+  for (const [index, uci] of movesUci.entries()) {
+    if (!/^[a-h][1-8][a-h][1-8][qrbn]?$/.test(uci)) throw Error("Invalid material replay move");
+    const move = board.move({ from: uci.slice(0, 2), to: uci.slice(2, 4), promotion: uci.slice(4) || void 0 });
+    if (move.captured || move.promotion) {
+      const { whiteMinusBlack, balance } = materialAtPosition(board);
+      changes.push({ ply: index + 1, san: move.san, whiteMinusBlack, balance });
+    }
+  }
+  const end = materialAtPosition(board);
+  return {
+    authority: "legal-replay-piece-counts",
+    startFen,
+    plies: movesUci.length,
+    start,
+    changes,
+    endFen: board.fen(),
+    end,
+    balanceChangeFromStart: difference(end.whiteMinusBlack, start.whiteMinusBlack),
+    scope: "Absolute piece counts at the stated positions; balanceChangeFromStart is only a change, not the final balance. Conditional line, not proof of force, safety or compensation."
+  };
+}
+function materialForVariations(startFen, lines) {
+  return lines.map((line) => {
+    try {
+      if (!line.pv.length || line.rootMove !== line.pv[0]) throw Error("Missing root");
+      return { ...line, material: materialAlongLine(startFen, line.pv) };
+    } catch {
+      return { ...line, material: { status: "unavailable", reason: "The complete variation could not be legally replayed from its stated root." } };
+    }
+  });
+}
+
+// src/chess-reasoning/types.ts
+var CHESS_REASONING_SCHEMA_VERSION = "0.2.0";
+var CHESS_REASONING_POLICY_VERSION = "shadow-2";
+
+// src/chess-reasoning/piece-identities.ts
+import { Chess as Chess2, SQUARES } from "chess.js";
+var PIECE_NAMES = {
+  p: "pawn",
+  n: "knight",
+  b: "bishop",
+  r: "rook",
+  q: "queen",
+  k: "king"
+};
+var COLOR_NAMES = { w: "white", b: "black" };
+function pieceId(color, type, square, ordinal = 0) {
+  return `${COLOR_NAMES[color]}-${PIECE_NAMES[type]}:${square}:${ordinal}`;
+}
+function promotionId(color, type, square, ordinal) {
+  return `${COLOR_NAMES[color]}-${PIECE_NAMES[type]}:promotion:${square}:${ordinal}`;
+}
+function clonePieces(pieces2) {
+  return Object.fromEntries(Object.entries(pieces2).map(([id, piece]) => [id, { ...piece }]));
+}
+function createIdentityState(fen = new Chess2().fen(), branchId = "main", ply = 0) {
+  const chess = new Chess2(fen);
+  const pieces2 = {};
+  const squares = {};
+  const seen = /* @__PURE__ */ new Map();
+  for (const square of SQUARES) {
+    const piece = chess.get(square);
+    if (!piece) continue;
+    const key2 = `${piece.color}:${piece.type}:${square}`;
+    const ordinal = seen.get(key2) || 0;
+    seen.set(key2, ordinal + 1);
+    const id = pieceId(piece.color, piece.type, square, ordinal);
+    pieces2[id] = {
+      id,
+      color: piece.color,
+      type: piece.type,
+      originSquare: square,
+      createdPly: ply,
+      promotedFrom: null,
+      capturedAtPly: null,
+      retiredAtPly: null
+    };
+    squares[square] = id;
+  }
+  return {
+    schemaVersion: CHESS_REASONING_SCHEMA_VERSION,
+    branchId,
+    fen: chess.fen(),
+    ply,
+    pieces: pieces2,
+    squares,
+    promotionSequence: 0
+  };
+}
+function forkIdentityState(state, branchId) {
+  return {
+    ...state,
+    branchId,
+    pieces: clonePieces(state.pieces),
+    squares: { ...state.squares }
+  };
+}
+function applyIdentityMove(state, moveInput) {
+  const chess = new Chess2(state.fen);
+  const beforeFen = chess.fen();
+  const move = chess.move(moveInput);
+  const nextPly = state.ply + 1;
+  const pieces2 = clonePieces(state.pieces);
+  const squares = { ...state.squares };
+  const mover = squares[move.from];
+  if (!mover) throw new Error(`No stable piece identity at ${move.from}`);
+  let captured = null;
+  const capturedSquare = move.isEnPassant() ? `${move.to[0]}${move.from[1]}` : move.to;
+  if (move.isCapture() || move.isEnPassant()) {
+    captured = squares[capturedSquare] || null;
+    if (!captured) throw new Error(`No captured piece identity at ${capturedSquare}`);
+    pieces2[captured] = { ...pieces2[captured], capturedAtPly: nextPly };
+    delete squares[capturedSquare];
+  }
+  delete squares[move.from];
+  let rookMoved = null;
+  if (move.isKingsideCastle() || move.isQueensideCastle()) {
+    const rank = move.from[1];
+    const rookFrom = `${move.isKingsideCastle() ? "h" : "a"}${rank}`;
+    const rookTo = `${move.isKingsideCastle() ? "f" : "d"}${rank}`;
+    rookMoved = squares[rookFrom] || null;
+    if (!rookMoved) throw new Error(`No stable rook identity at ${rookFrom}`);
+    delete squares[rookFrom];
+    squares[rookTo] = rookMoved;
+  }
+  let promoted = null;
+  let promotionSequence = state.promotionSequence;
+  if (move.isPromotion()) {
+    promotionSequence += 1;
+    pieces2[mover] = { ...pieces2[mover], retiredAtPly: nextPly };
+    promoted = promotionId(move.color, move.promotion, move.to, promotionSequence);
+    pieces2[promoted] = {
+      id: promoted,
+      color: move.color,
+      type: move.promotion,
+      originSquare: move.to,
+      createdPly: nextPly,
+      promotedFrom: mover,
+      capturedAtPly: null,
+      retiredAtPly: null
+    };
+    squares[move.to] = promoted;
+  } else {
+    squares[move.to] = mover;
+  }
+  const nextState = {
+    schemaVersion: CHESS_REASONING_SCHEMA_VERSION,
+    branchId: state.branchId,
+    fen: chess.fen(),
+    ply: nextPly,
+    pieces: pieces2,
+    squares,
+    promotionSequence
+  };
+  return {
+    state: nextState,
+    delta: {
+      branchId: state.branchId,
+      ply: nextPly,
+      uci: `${move.from}${move.to}${move.promotion || ""}`,
+      san: move.san,
+      mover,
+      captured,
+      promoted,
+      rookMoved,
+      beforeFen,
+      afterFen: chess.fen()
+    }
+  };
+}
+
+// src/chess-reasoning/poc-piece-refs.ts
+import { Chess as Chess3, SQUARES as SQUARES2 } from "chess.js";
+var PIECE_LABELS = {
+  p: "pawn",
+  n: "knight",
+  b: "bishop",
+  r: "rook",
+  q: "queen",
+  k: "king"
+};
+function moveObject(uci) {
+  return {
+    from: uci.slice(0, 2),
+    to: uci.slice(2, 4),
+    promotion: uci.slice(4) || void 0
+  };
+}
+function replayFromStart(historyUci, historyStartFen) {
+  let state = createIdentityState(historyStartFen);
+  try {
+    for (const uci of historyUci) state = applyIdentityMove(state, moveObject(uci)).state;
+    return state;
+  } catch {
+    return null;
+  }
+}
+function createPocIdentityTimeline(context) {
+  const replayed = replayFromStart(context.historyUci, context.historyStartFen);
+  const before = replayed?.fen === new Chess3(context.fenBefore).fen() ? replayed : createIdentityState(context.fenBefore, `reasoning:${context.nodeId}`, context.historyUci.length);
+  const after = context.kind === "position" ? before : applyIdentityMove(before, moveObject(context.moveUci)).state;
+  if (after.fen !== new Chess3(context.fenAfter).fen()) throw new Error("Stable piece-identity replay does not match fenAfter");
+  return { before, after };
+}
+function pieceIdAt(state, square) {
+  return state.squares[square] || null;
+}
+function squareForPiece(state, pieceId2) {
+  return SQUARES2.find((square) => state.squares[square] === pieceId2) || null;
+}
+function pieceIdentity(state, pieceId2) {
+  return state.pieces[pieceId2] || null;
+}
+function canonicalPieceLabel(piece) {
+  return `${piece.color === "w" ? "White" : "Black"} ${PIECE_LABELS[piece.type]}`;
+}
+
+// src/chess-reasoning/move-mechanism-facts.ts
+import { Chess as Chess4, SQUARES as SQUARES3 } from "chess.js";
+var DIRECTIONS = [
+  ["N", 0, 1],
+  ["NE", 1, 1],
+  ["E", 1, 0],
+  ["SE", 1, -1],
+  ["S", 0, -1],
+  ["SW", -1, -1],
+  ["W", -1, 0],
+  ["NW", -1, 1]
+];
+function enemy(color) {
+  return color === "w" ? "b" : "w";
+}
+function attackers(board, square, color) {
+  return board.attackers(square, color).sort((a, b) => SQUARES3.indexOf(a) - SQUARES3.indexOf(b));
+}
+function ray(board, origin, fileStep, rankStep) {
+  const squares = [];
+  const file = origin.charCodeAt(0) - 97;
+  const rank = Number(origin[1]) - 1;
+  for (let distance = 1; distance < 8; distance += 1) {
+    const f = file + fileStep * distance;
+    const r = rank + rankStep * distance;
+    if (f < 0 || f > 7 || r < 0 || r > 7) break;
+    const square = `${String.fromCharCode(97 + f)}${r + 1}`;
+    squares.push(square);
+    if (board.get(square)) break;
+  }
+  return squares;
+}
+function sliderDirections(type) {
+  if (type === "q") return DIRECTIONS;
+  return DIRECTIONS.filter(([, dx, dy]) => type === "r" ? !dx || !dy : !!dx && !!dy);
+}
+function moveMechanismFacts(before, after, from, to, beforeIds, afterIds) {
+  const moverBefore = before.get(from);
+  const moverAfter = after.get(to);
+  if (!moverBefore || !moverAfter || moverBefore.color !== moverAfter.color) {
+    throw new Error(`Move mechanism has no corresponding mover at ${from}-${to}`);
+  }
+  const beforeState = beforeIds || createIdentityState(before.fen());
+  if (beforeState.fen !== before.fen() || afterIds && afterIds.fen !== after.fen()) {
+    throw new Error("Move mechanism identity position does not match the board");
+  }
+  const actualMove = before.moves({ verbose: true }).find((move) => {
+    if (move.from !== from || move.to !== to) return false;
+    const replay = new Chess4(before.fen());
+    replay.move({ from, to, promotion: move.promotion });
+    return replay.fen() === after.fen();
+  });
+  if (!actualMove) throw new Error(`Move mechanism after-position is not a legal ${from}-${to} result`);
+  const afterState = afterIds || applyIdentityMove(beforeState, {
+    from,
+    to,
+    promotion: actualMove.promotion
+  }).state;
+  const pieceId2 = beforeState.squares[from];
+  const pieceIdAfter = afterState.squares[to];
+  if (!pieceId2 || !pieceIdAfter || (actualMove.promotion ? afterState.pieces[pieceIdAfter]?.promotedFrom !== pieceId2 : pieceIdAfter !== pieceId2)) {
+    throw new Error("Move mechanism mover identities do not match");
+  }
+  const attackedUnmovedFriendlyPieces = [];
+  const stationarySliderRays = [];
+  const color = moverBefore.color;
+  for (const square of SQUARES3) {
+    const piece = before.get(square);
+    const samePiece = after.get(square);
+    const id = beforeState.squares[square];
+    if (!piece || !samePiece || !id || afterState.squares[square] !== id || piece.color !== samePiece.color || piece.type !== samePiece.type) continue;
+    if (piece.color === color) {
+      const beforeAttackers = attackers(before, square, enemy(color));
+      const afterAttackers = attackers(after, square, enemy(color));
+      if (beforeAttackers.length || afterAttackers.length) {
+        attackedUnmovedFriendlyPieces.push({
+          pieceId: id,
+          square,
+          pieceType: piece.type,
+          attackersBefore: beforeAttackers,
+          attackersAfter: afterAttackers
+        });
+      }
+    }
+    if (piece.type !== "r" && piece.type !== "b" && piece.type !== "q") continue;
+    for (const [direction, dx, dy] of sliderDirections(piece.type)) {
+      const beforeSquares = ray(before, square, dx, dy);
+      const afterSquares = ray(after, square, dx, dy);
+      const beforeSet = new Set(beforeSquares);
+      const afterSet = new Set(afterSquares);
+      const gainedSquares = afterSquares.filter((target) => !beforeSet.has(target));
+      const lostSquares = beforeSquares.filter((target) => !afterSet.has(target));
+      if (gainedSquares.length || lostSquares.length) {
+        stationarySliderRays.push({
+          pieceId: id,
+          fromSquare: square,
+          color: piece.color,
+          pieceType: piece.type,
+          direction,
+          beforeSquares,
+          afterSquares,
+          gainedSquares,
+          lostSquares
+        });
+      }
+    }
+  }
+  const controlDelta = [];
+  for (const square of SQUARES3) {
+    for (const attackingColor of ["w", "b"]) {
+      const attackersBefore = attackers(before, square, attackingColor);
+      const attackersAfter = attackers(after, square, attackingColor);
+      if (attackersBefore.length !== attackersAfter.length || attackersBefore.some((origin, index) => origin !== attackersAfter[index])) {
+        controlDelta.push({ square, color: attackingColor, attackersBefore, attackersAfter });
+      }
+    }
+  }
+  return {
+    mover: {
+      pieceId: pieceId2,
+      pieceIdAfter,
+      fromSquare: from,
+      toSquare: to,
+      color,
+      pieceTypeBefore: moverBefore.type,
+      pieceTypeAfter: moverAfter.type,
+      attackersBefore: attackers(before, from, enemy(color)),
+      attackersAfter: attackers(after, to, enemy(color))
+    },
+    attackedUnmovedFriendlyPieces,
+    stationarySliderRays,
+    controlDelta,
+    checksRun: [
+      "mover-geometric-attackers-before-after",
+      "unmoved-friendly-piece-geometric-attackers-before-after",
+      "stationary-slider-visible-rays-before-after",
+      "all-square-both-color-geometric-control-delta"
+    ],
+    scope: "Complete board-local geometric measurements at this move. Attackers include pinned pieces; visible slider rays include the first occupied square. Empty lists mean measured none or no change. No claim of legal captures, safe retreat, exchange profit, forced purpose, or strategic importance."
+  };
+}
+
+// src/chess-reasoning/evidence-licenses.ts
+var EVIDENCE_LICENSE = Object.freeze({
+  CHESS_LEGALITY: "chess.legality",
+  CHESS_IDENTITY: "chess.identity",
+  CHESS_POSITION_FACT: "chess.position-fact",
+  ENGINE_BOUNDED_CONTINUATION: "engine.bounded-continuation",
+  ENGINE_BOUNDED_COMPARISON: "engine.bounded-comparison",
+  ENGINE_BOUNDED_SCORE: "engine.bounded-score",
+  ENGINE_BOUNDED_RESPONSE_COVERAGE: "engine.bounded-response-coverage",
+  COVERAGE_EXHAUSTIVE: "coverage.exhaustive",
+  ATTENTION_AFFORDANCE: "attention.affordance",
+  SEMANTIC_REVIEWED_STATE: "semantic.reviewed-state",
+  WORKFLOW_AUDIT: "workflow.audit"
+});
+var LICENSES = new Set(Object.values(EVIDENCE_LICENSE));
+function evidenceLicenseInput(record2) {
+  const data = record2.data || {};
+  const authority = typeof data.authority === "string" ? data.authority : record2.kind === "fact" ? "deterministic-derived" : record2.kind === "probe" ? "bounded-engine" : null;
+  return {
+    kind: record2.kind,
+    source: record2.source,
+    authority,
+    proofStrength: record2.proofStrength,
+    data,
+    coverage: record2.coverage || null,
+    replay: record2.replay || null
+  };
+}
+function exactSequenceOnly(input) {
+  return input.data.scope === "sequence-legality-and-identity";
+}
+function isWorkflowKind(kind) {
+  return kind === "observation-review" || kind === "reasoning-challenge" || kind === "hypothesis-review" || kind === "critic-resolution-audit";
+}
+function maximumEvidenceLicenses(input) {
+  if (input.authority === "heuristic-affordance") return [EVIDENCE_LICENSE.ATTENTION_AFFORDANCE];
+  if (isWorkflowKind(input.kind)) return [EVIDENCE_LICENSE.WORKFLOW_AUDIT];
+  if (input.kind === "graph") return [EVIDENCE_LICENSE.SEMANTIC_REVIEWED_STATE];
+  if (exactSequenceOnly(input)) {
+    if (input.authority !== "legal-exact" && input.authority !== "bounded-engine") return [];
+    const scoped = /* @__PURE__ */ new Set([
+      EVIDENCE_LICENSE.CHESS_LEGALITY,
+      EVIDENCE_LICENSE.CHESS_IDENTITY
+    ]);
+    if (input.coverage?.complete && input.coverage.unresolved.length === 0) {
+      scoped.add(EVIDENCE_LICENSE.COVERAGE_EXHAUSTIVE);
+    }
+    return [...scoped].sort();
+  }
+  const result = /* @__PURE__ */ new Set();
+  if (input.authority === "legal-exact" || input.authority === "deterministic-derived") {
+    result.add(EVIDENCE_LICENSE.CHESS_LEGALITY);
+    result.add(EVIDENCE_LICENSE.CHESS_IDENTITY);
+    result.add(EVIDENCE_LICENSE.CHESS_POSITION_FACT);
+  }
+  if (input.authority === "bounded-engine") {
+    result.add(EVIDENCE_LICENSE.ENGINE_BOUNDED_SCORE);
+    if (/compare[_-]moves|compare-moves/.test(input.source)) {
+      result.add(EVIDENCE_LICENSE.ENGINE_BOUNDED_COMPARISON);
+    } else {
+      result.add(EVIDENCE_LICENSE.ENGINE_BOUNDED_CONTINUATION);
+    }
+    if (/enumerate[_-]defenses|enumerate-defenses/.test(input.source)) {
+      result.add(EVIDENCE_LICENSE.ENGINE_BOUNDED_RESPONSE_COVERAGE);
+    }
+    if (input.replay) {
+      result.add(EVIDENCE_LICENSE.CHESS_LEGALITY);
+      result.add(EVIDENCE_LICENSE.CHESS_IDENTITY);
+    }
+  }
+  if (input.coverage?.complete && input.coverage.unresolved.length === 0) {
+    result.add(EVIDENCE_LICENSE.COVERAGE_EXHAUSTIVE);
+  }
+  return [...result].sort();
+}
+function validateEvidenceLicenseClaims(input, claimed) {
+  if (!Array.isArray(claimed)) throw new Error("Evidence licenses must be an array");
+  const normalized = [...new Set(claimed.map(String))];
+  const unknown = normalized.filter((license) => !LICENSES.has(license));
+  if (unknown.length) throw new Error(`Unknown evidence license(s): ${unknown.join(", ")}`);
+  const maximum = new Set(maximumEvidenceLicenses(input));
+  const excessive = normalized.filter((license) => !maximum.has(license));
+  if (excessive.length) throw new Error(`Evidence claims license(s) beyond its source ceiling: ${excessive.join(", ")}`);
+  return normalized.sort();
+}
+function effectiveEvidenceLicenses(input) {
+  return input.licenses === void 0 ? maximumEvidenceLicenses(input) : validateEvidenceLicenseClaims(input, input.licenses);
+}
+function effectiveLicensesForRecord(record2) {
+  return effectiveEvidenceLicenses({ ...evidenceLicenseInput(record2), licenses: record2.licenses });
+}
+function withEvidenceLicenses(record2) {
+  return { ...record2, licenses: effectiveLicensesForRecord(record2) };
+}
+function licensesSemanticChessGrounding(licenses) {
+  return licenses.some((license) => license === EVIDENCE_LICENSE.CHESS_POSITION_FACT || license === EVIDENCE_LICENSE.ENGINE_BOUNDED_CONTINUATION || license === EVIDENCE_LICENSE.ENGINE_BOUNDED_COMPARISON || license === EVIDENCE_LICENSE.ENGINE_BOUNDED_RESPONSE_COVERAGE || license === EVIDENCE_LICENSE.SEMANTIC_REVIEWED_STATE);
+}
+function licensesBoundedRouteRelevance(licenses) {
+  return licenses.includes(EVIDENCE_LICENSE.ENGINE_BOUNDED_CONTINUATION) || licenses.includes(EVIDENCE_LICENSE.ENGINE_BOUNDED_COMPARISON) || licenses.includes(EVIDENCE_LICENSE.ENGINE_BOUNDED_RESPONSE_COVERAGE);
+}
+
+// src/chess-reasoning/stable.ts
+function stableHash(value) {
+  const text = stableJson(value);
+  let hash = 2166136261;
+  for (let index = 0; index < text.length; index += 1) {
+    hash ^= text.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    const record2 = value;
+    return `{${Object.keys(record2).sort().map((key2) => `${JSON.stringify(key2)}:${stableJson(record2[key2])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+// src/chess-reasoning/poc-contracts.ts
+import { Chess as Chess5 } from "chess.js";
+var REASONING_POC_VERSION = "conceptual-explanation-poc/57";
+var REASONING_POC_MAX_OUTPUT_TOKENS = 2e3;
+var REASONING_POC_MAX_HYPOTHESIS_OUTPUT_TOKENS = 4e3;
+var REASONING_POC_MAX_CRITIC_OUTPUT_TOKENS = 7e3;
+var REASONING_POC_MAX_TERMINAL_REVIEW_OUTPUT_TOKENS = 4e3;
+var REASONING_POC_MAX_RESOLUTION_AUDIT_OUTPUT_TOKENS = 3e3;
+var REASONING_POC_MAX_PURPOSE_PROBE_OUTPUT_TOKENS = 1500;
+var REASONING_POC_MAX_GRAPH_SELECTION_OUTPUT_TOKENS = 2e3;
+var REASONING_POC_MAX_DISCOURSE_OUTPUT_TOKENS = 2500;
+var REASONING_POC_MAX_RENDER_OUTPUT_TOKENS = 4e3;
+var REASONING_POC_MAX_HYPOTHESIS_BATCHES = 2;
+var REASONING_POC_RESERVED_MANDATORY_STEPS = 11;
+var REASONING_POC_REVISION_EVIDENCE_ALLOWANCE = 1;
+var REASONING_POC_PURPOSE_PROBE_ALLOWANCE = 1;
+var REASONING_POC_CRITIC_CORRECTION_ALLOWANCE = 1;
+var DEFAULT_REASONING_RUN_CONTROLS = Object.freeze({
+  maxModelSteps: 15,
+  maxToolCalls: 16,
+  maxProbeCalls: 5,
+  maxEvidenceRecords: 48,
+  maxObservationRecords: 48,
+  maxObservationsPresented: 16,
+  maxHypotheses: 16,
+  maxOutputChars: 2400,
+  maxProviderOutputChars: 64e3,
+  maxWallTimeMs: 3e4
+});
+var REASONING_DISCOURSE_PLAN_VERSION = "reasoning-discourse-plan/2";
+var ModelRuntimeFailure = class extends Error {
+  runtime;
+  model;
+  diagnostics;
+  usage;
+  constructor(input) {
+    super(`Model runtime failed: ${input.diagnostics.at(-1)?.errorCategory || "unknown"}`);
+    this.name = "ModelRuntimeFailure";
+    this.runtime = input.runtime;
+    this.model = input.model;
+    this.diagnostics = input.diagnostics.map((item) => ({ ...item }));
+    this.usage = { ...input.usage };
+  }
+};
+var POSITION_CONTEXT_KEYS = /* @__PURE__ */ new Set(["kind", "nodeId", "parentNodeId", "historyStartFen", "fenBefore", "fenAfter", "historyUci", "moveUci", "moveSan"]);
+function validateReasoningPositionContext(value) {
+  if (!value || typeof value !== "object") throw new Error("Reasoning position context must be an object");
+  for (const key2 of Object.keys(value)) if (!POSITION_CONTEXT_KEYS.has(key2)) throw new Error(`Unsupported reasoning position context field: ${key2}`);
+  if (!value.nodeId?.trim()) throw new Error("Reasoning position context requires nodeId");
+  if (!Array.isArray(value.historyUci) || value.historyUci.some((move) => !/^[a-h][1-8][a-h][1-8][qrbn]?$/.test(move))) throw new Error("Reasoning position context historyUci must contain UCI moves");
+  if (value.kind !== void 0 && value.kind !== "position") throw new Error("Invalid context kind");
+  if (!value.kind && !/^[a-h][1-8][a-h][1-8][qrbn]?$/.test(value.moveUci)) throw new Error("Reasoning position context moveUci is invalid");
+  if (!value.kind && !value.moveSan?.trim()) throw new Error("Reasoning position context requires moveSan");
+  const history = value.historyStartFen ? new Chess5(value.historyStartFen) : new Chess5();
+  for (const [index, moveUci] of value.historyUci.entries()) {
+    let replayed;
+    try {
+      replayed = history.move({ from: moveUci.slice(0, 2), to: moveUci.slice(2, 4), promotion: moveUci.slice(4) || void 0 });
+    } catch {
+      replayed = null;
+    }
+    if (!replayed) throw new Error(`Reasoning position context historyUci is illegal at index ${index}`);
+  }
+  if (history.fen() !== new Chess5(value.fenBefore).fen()) throw new Error("Reasoning position context historyUci does not replay to fenBefore");
+  if (value.kind === "position") {
+    if (value.moveUci !== "" || value.moveSan !== "" || value.parentNodeId || value.historyUci.length || value.fenBefore !== value.fenAfter || !value.historyStartFen || new Chess5(value.historyStartFen).fen() !== value.fenBefore)
+      throw new Error("Invalid starting-position context");
+    return { ...value, historyUci: [] };
+  }
+  const before = new Chess5(value.fenBefore);
+  let applied;
+  try {
+    applied = before.move({ from: value.moveUci.slice(0, 2), to: value.moveUci.slice(2, 4), promotion: value.moveUci.slice(4) || void 0 });
+  } catch {
+    applied = null;
+  }
+  if (!applied) throw new Error("Reasoning position context target move is illegal in fenBefore");
+  if (applied.san !== value.moveSan) throw new Error("Reasoning position context moveSan does not match the target move");
+  if (before.fen() !== value.fenAfter) throw new Error("Reasoning position context fenAfter does not match the target move");
+  return { ...value, historyUci: [...value.historyUci] };
+}
+function reasoningContextHash(context) {
+  const checked = validateReasoningPositionContext(context);
+  return stableHash({ nodeId: checked.nodeId, parentNodeId: checked.parentNodeId || null, historyStartFen: checked.historyStartFen || null, fenBefore: checked.fenBefore, fenAfter: checked.fenAfter, historyUci: checked.historyUci, moveUci: checked.moveUci });
+}
+function createQueryContract(input) {
+  if (!input.requestId?.trim()) throw new Error("Query contract requires requestId");
+  if (!input.question?.trim()) throw new Error("Query contract requires a question");
+  validateReasoningPositionContext(input.context);
+  const responseCoverageRequirement = input.responseCoverageRequirement || "none";
+  if (responseCoverageRequirement !== "none" && responseCoverageRequirement !== "bounded-class") throw new Error("Unsupported response coverage requirement");
+  const continuationCoverageRequirement = input.continuationCoverageRequirement || "none";
+  if (continuationCoverageRequirement !== "none" && continuationCoverageRequirement !== "principal-variation") throw new Error("Unsupported continuation coverage requirement");
+  const minimumContinuationLines = input.minimumContinuationLines ?? (continuationCoverageRequirement === "principal-variation" ? 1 : 0);
+  if (!Number.isInteger(minimumContinuationLines) || minimumContinuationLines < 0 || minimumContinuationLines > 3) throw new Error("minimumContinuationLines must be an integer from 0 through 3");
+  if (continuationCoverageRequirement === "none" && minimumContinuationLines !== 0) throw new Error("minimumContinuationLines must be 0 when continuation coverage is not requested");
+  if (continuationCoverageRequirement === "principal-variation" && minimumContinuationLines < 1) throw new Error("minimumContinuationLines must be at least 1 when principal-variation coverage is requested");
+  const graphRequirements = {
+    minimumEntities: input.graphRequirements?.minimumEntities ?? 1,
+    minimumRelations: input.graphRequirements?.minimumRelations ?? 0
+  };
+  if (!Number.isInteger(graphRequirements.minimumEntities) || graphRequirements.minimumEntities < 1 || graphRequirements.minimumEntities > 12) throw new Error("minimumEntities must be an integer from 1 through 12");
+  if (!Number.isInteger(graphRequirements.minimumRelations) || graphRequirements.minimumRelations < 0 || graphRequirements.minimumRelations > 20) throw new Error("minimumRelations must be an integer from 0 through 20");
+  return { schemaVersion: REASONING_POC_VERSION, requestId: input.requestId, question: input.question.trim(), requestedConclusion: input.context.kind === "position" ? "position-question" : "move-idea", responseCoverageRequirement, continuationCoverageRequirement, minimumContinuationLines, graphRequirements, audience: input.audience || "intermediate", concise: input.concise ?? true, nodeId: input.context.nodeId };
+}
+function createContextEvidence(context, contextHash = reasoningContextHash(context)) {
+  validateReasoningPositionContext(context);
+  const identities = context.kind === "position" ? void 0 : createPocIdentityTimeline(context);
+  const selectedMoveMechanism = identities ? moveMechanismFacts(
+    new Chess5(context.fenBefore),
+    new Chess5(context.fenAfter),
+    context.moveUci.slice(0, 2),
+    context.moveUci.slice(2, 4),
+    identities.before,
+    identities.after
+  ) : void 0;
+  return withEvidenceLicenses({
+    schemaVersion: REASONING_POC_VERSION,
+    id: `evidence:context:${contextHash}`,
+    contextHash,
+    kind: "context",
+    source: "validated-position-context",
+    proofStrength: "observed",
+    summary: context.kind === "position" ? "The supplied legal starting position is the question anchor; no target move has been played." : `${context.moveSan} (${context.moveUci}) is the target move in the supplied legal position.`,
+    data: { ...selectedMoveMechanism ? { selectedMoveMechanism } : {}, material: materialAlongLine(context.fenBefore, context.kind === "position" ? [] : [context.moveUci]), authority: "legal-exact", scope: "sequence-legality-and-identity", nodeId: context.nodeId, parentNodeId: context.parentNodeId || null, historyStartFen: context.historyStartFen || null, moveUci: context.moveUci, moveSan: context.moveSan, fenBefore: context.fenBefore, fenAfter: context.fenAfter },
+    coverage: null,
+    replay: context.kind === "position" ? { fen: context.fenBefore } : { fen: context.fenBefore, move: context.moveUci }
+  });
+}
+
+// src/chess-reasoning/recorded-main-line.ts
+import { Chess as Chess6 } from "chess.js";
+function validRecordedAnalysis(value, before, after, uci) {
+  if (!value || value.version !== "recorded-move-analysis/1" || value.fenBefore !== before || value.fenAfter !== after || value.moveUci !== uci) return false;
+  const boundedText = (s, max) => typeof s === "string" && s.length > 0 && s.length <= max && /^[a-zA-Z0-9@._/ +:-]+$/.test(s);
+  const depth = (n) => Number.isInteger(n) && n > 0 && n <= 256;
+  const score = (n) => n === null || typeof n === "number" && Number.isFinite(n) && Math.abs(n) <= 1e6;
+  return boundedText(value.engine, 64) && boundedText(value.classification, 40) && depth(value.actualDepth) && depth(value.requestedDepth) && Number.isInteger(value.classifierVersion) && value.classifierVersion > 0 && value.classifierVersion <= 1e5 && [value.beforeCp, value.afterCp, value.lossCp, value.mateBefore, value.mateAfter].every(score);
+}
+function recordedMainLineResult(line, context) {
+  if (!line || !Array.isArray(line.moves) || line.moves.length > 512 || !Number.isInteger(line.selectedIndex) || line.selectedIndex < -1 || !Number.isInteger(line.totalPlies) || line.totalPlies < line.moves.length || line.selectedIndex >= line.totalPlies || line.truncated !== line.totalPlies > line.moves.length) throw Error("Invalid recorded main line.");
+  const atStart = context.kind === "position";
+  if (atStart && (line.selectedAtStart !== true || line.selectedIndex !== -1 || line.startFen !== context.fenAfter)) throw Error("Recorded starting-position scope mismatch.");
+  if (!atStart && line.selectedAtStart) throw Error("Recorded anchor kind mismatch.");
+  const chess = new Chess6(line.startFen);
+  const historyRoot = new Chess6(atStart ? context.fenAfter : context.historyStartFen).fen();
+  if (chess.fen() !== historyRoot) throw Error("Recorded main-line root mismatch.");
+  const rows = [];
+  const moves = line.moves.map((item, index) => {
+    if (!/^[a-h][1-8][a-h][1-8][qrbn]?$/.test(item.uci)) throw Error("Invalid recorded move.");
+    const before = chess.fen(), move = chess.move({ from: item.uci.slice(0, 2), to: item.uci.slice(2, 4), promotion: item.uci.slice(4) || void 0 });
+    if (move.san !== item.san) throw Error("Recorded SAN mismatch.");
+    if (index === line.selectedIndex && (before !== context.fenBefore || chess.fen() !== context.fenAfter || item.uci !== context.moveUci || index !== context.historyUci.length || line.moves.slice(0, index).some((m, i) => m.uci !== context.historyUci[i]))) throw Error("Recorded question scope mismatch.");
+    const a = item.analysis;
+    if (validRecordedAnalysis(a, before, chess.fen(), item.uci)) {
+      const score = savedScorePresentation(a);
+      rows.push([
+        index + 1,
+        a.engine,
+        a.actualDepth,
+        a.requestedDepth,
+        a.classifierVersion,
+        a.classification,
+        score.beforeCp,
+        score.afterCp,
+        score.lossCp,
+        score.mateBefore,
+        score.mateAfter
+      ]);
+    }
+    return { uci: item.uci, san: move.san, moveNumber: Number(before.split(" ")[5]), color: move.color };
+  });
+  const continuation = atStart ? moves.map((move) => move.uci) : line.selectedIndex >= 0 && line.selectedIndex < moves.length ? moves.slice(line.selectedIndex + 1).map((move) => move.uci) : [];
+  const contextHash = reasoningContextHash(context);
+  const evidence = continuation.length ? [{
+    schemaVersion: REASONING_POC_VERSION,
+    id: `evidence:recorded-main-line:${contextHash}:${continuation.slice(0, 32).join("-")}`,
+    contextHash,
+    kind: "fact",
+    source: "loaded-game-main-line",
+    proofStrength: "observed",
+    licenses: ["chess.legality", "chess.identity"],
+    summary: "Legally replayed recorded main-line continuation; not an engine recommendation or proof of intent.",
+    data: { authority: "legal-exact", scope: "sequence-legality-and-identity", phase: "after" },
+    coverage: { complete: false, covered: [], unresolved: ["No optimality or human-intent claim."] },
+    replay: { fen: context.fenAfter, movesUci: continuation.slice(0, 32) }
+  }] : [];
+  return {
+    contextHash,
+    evidence,
+    recordedAnalysis: {
+      source: "Current loaded game's stored per-move analysis snapshots",
+      authority: "attributed-existing-analysis",
+      scorePerspective: "mover-at-each-recorded-ply",
+      units: "centipawns; mate separate",
+      coverage: { analyzedPlies: rows.length, totalPlies: line.totalPlies, complete: !line.truncated && rows.length === line.totalPlies },
+      columns: ["ply", "engine", "reportedDepth", "recordedRequestedDepth", "classifierVersion", "classification", "beforeCp", "afterCp", "lossCp", "mateBefore", "mateAfter"],
+      rows,
+      limitations: ["reportedDepth is the stored classification depth, not a verified root-search depth; recordedRequestedDepth is the board setting recorded when classified.", "Matching stored edge analyses are included even when their engine, classifier version or dependency fingerprint is no longer current; missing or invalid plies have no analysis row.", "Scores are from the mover's perspective at each row's ply: positive favors that move's color; lossCp is a saved before/after search delta for that mover, not a controlled regret comparison. Mate-related/sentinel centipawn fields are null; use mateBefore/mateAfter. Best or Forced labels can coexist with search-score changes.", "Classification is a historical decision from the reported classifier version, not necessarily current policy or proof of its explanation. Saved scores may differ from fresh searches.", ...line.truncated ? ["Analysis is limited to the first 512 recorded plies."] : []]
+    },
+    recordedMainLine: {
+      source: "Current loaded game's recorded primary line (may contain user edits)",
+      startFen: line.startFen,
+      moves,
+      selectedIndex: line.selectedIndex,
+      selectedAtStart: atStart,
+      selectedOnMainLine: atStart || line.selectedIndex >= 0,
+      totalPlies: line.totalPlies,
+      truncated: line.truncated,
+      pgn: chess.pgn()
+    },
+    limitations: ["PGN is reconstructed from recorded moves; original headers, clocks and result metadata are not included.", "Recorded play is not engine evidence of best play, force, safety or human intent.", ...!atStart && line.selectedIndex < 0 ? ["The question is on a branch; this main line is not its continuation."] : [], ...line.truncated ? ["Only the first 512 plies are returned."] : []]
+  };
+}
+
+// src/chess-reasoning/reference-limits.ts
+var MAX_INTERACTIVE_LINE_PLIES = 32;
+
+// src/chess-reasoning/poc-move-witnesses.ts
+import { Chess as Chess7 } from "chess.js";
+var UCI_PATTERN = /^[a-h][1-8][a-h][1-8][qrbn]?$/;
+var MAX_REPLAY_MOVES = MAX_INTERACTIVE_LINE_PLIES;
+function canonicalFen(value) {
+  try {
+    return new Chess7(value).fen();
+  } catch {
+    return null;
+  }
+}
+function replayStart(record2, context, before, after) {
+  const phase = reasoningEvidenceReplayStartPhase(record2, context);
+  return phase === "before" ? before : phase === "after" ? after : null;
+}
+function reasoningEvidenceReplayStartPhase(record2, context) {
+  const value = record2.replay?.fen ?? record2.replay?.fenAfter;
+  if (typeof value !== "string") return null;
+  const fen = canonicalFen(value);
+  if (!fen) return null;
+  if (fen === canonicalFen(context.fenBefore)) return "before";
+  if (fen === canonicalFen(context.fenAfter)) return "after";
+  return null;
+}
+function replayMoves(record2) {
+  const replay = record2.replay;
+  if (!replay) return [];
+  const sequence = Array.isArray(replay.movesUci) ? replay.movesUci : Array.isArray(replay.moves) ? replay.moves : Array.isArray(replay.line) ? replay.line : typeof replay.move === "string" ? [replay.move] : [];
+  if (!sequence.length || sequence.length > MAX_REPLAY_MOVES) return [];
+  return sequence.every((value) => typeof value === "string" && UCI_PATTERN.test(value)) ? sequence : [];
+}
+function replayLines(record2) {
+  const lines = record2.replay?.linesUci;
+  if (!Array.isArray(lines) || !lines.length || lines.length > MAX_REPLAY_MOVES) return [];
+  return lines.flatMap((line) => {
+    if (!Array.isArray(line) || !line.length || line.length > MAX_REPLAY_MOVES) return [];
+    return line.every((value) => typeof value === "string" && UCI_PATTERN.test(value)) ? [line] : [];
+  });
+}
+function replaySequence(evidenceId, start, moves) {
+  let identities = start;
+  const witnesses = [];
+  for (const uci of moves) {
+    const from = uci.slice(0, 2);
+    const pieceId2 = pieceIdAt(identities, from);
+    if (!pieceId2) return null;
+    try {
+      const applied = applyIdentityMove(identities, {
+        from,
+        to: uci.slice(2, 4),
+        promotion: uci.slice(4) || void 0
+      });
+      witnesses.push({ evidenceId, uci, pieceId: pieceId2, san: applied.delta.san });
+      identities = applied.state;
+    } catch {
+      return null;
+    }
+  }
+  return witnesses;
+}
+function independentRootMoves(record2) {
+  const roots = record2.data?.rootMoves;
+  if (!Array.isArray(roots) || !roots.length || roots.length > MAX_REPLAY_MOVES) return [];
+  return roots.every((value) => typeof value === "string" && UCI_PATTERN.test(value)) ? roots : [];
+}
+function collectReasoningMoveWitnesses(records, context) {
+  const timeline = createPocIdentityTimeline(context);
+  const collected = [];
+  for (const record2 of records) {
+    const start = replayStart(record2, context, timeline.before, timeline.after);
+    const moves = replayMoves(record2);
+    if (start && moves.length) {
+      const recordWitnesses = replaySequence(record2.id, start, moves);
+      if (recordWitnesses) collected.push(...recordWitnesses);
+    }
+    if (start) {
+      for (const line of replayLines(record2)) {
+        const lineWitnesses = replaySequence(record2.id, start, line);
+        if (lineWitnesses) collected.push(...lineWitnesses);
+      }
+    }
+    const roots = independentRootMoves(record2);
+    if (!start || !roots.length) continue;
+    const rootWitnesses = [];
+    let validRoots = true;
+    for (const uci of roots) {
+      const from = uci.slice(0, 2);
+      const pieceId2 = pieceIdAt(start, from);
+      if (!pieceId2) {
+        validRoots = false;
+        break;
+      }
+      try {
+        const applied = applyIdentityMove(start, {
+          from,
+          to: uci.slice(2, 4),
+          promotion: uci.slice(4) || void 0
+        });
+        rootWitnesses.push({ evidenceId: record2.id, uci, pieceId: pieceId2, san: applied.delta.san });
+      } catch {
+        validRoots = false;
+        break;
+      }
+    }
+    if (validRoots) collected.push(...rootWitnesses);
+  }
+  return [...new Map(collected.map((witness) => [
+    `${witness.evidenceId}:${witness.uci}:${witness.pieceId}:${witness.san}`,
+    witness
+  ])).values()];
+}
+
+// src/chess-reasoning/position-analysis-scope.ts
+function scopePositionAnalysis(result, request) {
+  const turn = request.fen.split(" ")[1];
+  if (turn !== "w" && turn !== "b") throw new Error("Invalid score root turn");
+  const scoreScope = {
+    fen: request.fen,
+    perspective: turn === "w" ? "white" : "black",
+    positiveMeans: "advantage for perspective color",
+    scoreCpUnit: "centipawns",
+    matePlyUnit: "signed mate-in-moves (legacy field name, not plies)"
+  };
+  return { ...result, lines: result.lines.map((line) => {
+    if (line.scoreScope && Object.entries(scoreScope).some(([key2, value]) => line.scoreScope?.[key2] !== value)) {
+      throw new Error("Engine score scope mismatch");
+    }
+    return { ...line, scoreScope };
+  }) };
+}
+
+// src/chess-reasoning/position-analysis-contracts.ts
+var LEGACY_UNIT = "signed mate-in-moves (legacy field name, not plies)";
+var UNIT = "signed mate-in-moves";
+function mateValue(score) {
+  const old = Object.hasOwn(score, "matePly");
+  const current = Object.hasOwn(score, "mateInMoves");
+  if (!old && !current) throw new TypeError("Missing mateInMoves (or legacy matePly).");
+  for (const key2 of ["matePly", "mateInMoves"]) {
+    if (Object.hasOwn(score, key2) && score[key2] !== null && !Number.isSafeInteger(score[key2])) {
+      throw new TypeError(`Invalid ${key2}: expected signed integer moves or null.`);
+    }
+  }
+  if (old && current && score.matePly !== score.mateInMoves) throw new TypeError("Conflicting matePly and mateInMoves.");
+  return current ? score.mateInMoves : score.matePly;
+}
+function scope(value, legacy) {
+  if (!value) return value;
+  const { matePlyUnit, mateInMovesUnit, ...rest } = value;
+  if (matePlyUnit !== void 0 && matePlyUnit !== LEGACY_UNIT) throw new TypeError("Invalid legacy mate score unit.");
+  if (mateInMovesUnit !== void 0 && mateInMovesUnit !== UNIT) throw new TypeError("Invalid mate score unit.");
+  if (matePlyUnit === void 0 && mateInMovesUnit === void 0) return { ...rest };
+  return { ...rest, ...legacy ? { matePlyUnit: LEGACY_UNIT } : { mateInMovesUnit: UNIT } };
+}
+function convertScore(value, legacy) {
+  const mate = mateValue(value);
+  const { matePly: _old, mateInMoves: _current, scoreScope, ...rest } = value;
+  void _old;
+  void _current;
+  return {
+    ...rest,
+    ...legacy ? { matePly: mate } : { mateInMoves: mate },
+    ...scoreScope !== void 0 ? { scoreScope: scope(scoreScope, legacy) } : {}
+  };
+}
+function convert(result, legacy) {
+  return { ...result, lines: result.lines.map((line) => ({
+    ...convertScore(line, legacy),
+    ...line.pvCompletion ? { pvCompletion: {
+      ...line.pvCompletion,
+      segments: line.pvCompletion.segments.map((segment) => convertScore(segment, legacy))
+    } } : {}
+  })) };
+}
+function toPositionAnalysis(result) {
+  return convert(result, false);
+}
+function toLegacyPositionAnalysis(result) {
+  return convert(result, true);
+}
+function toLegacyPositionAnalysisProvider(provider) {
+  return { async analyze(request) {
+    request.signal?.throwIfAborted();
+    const result = await provider.analyze(request);
+    request.signal?.throwIfAborted();
+    return toLegacyPositionAnalysis(result);
+  } };
+}
+function toPositionAnalysisProvider(provider) {
+  return { async analyze(request) {
+    request.signal?.throwIfAborted();
+    const result = await provider.analyze(request);
+    request.signal?.throwIfAborted();
+    return toPositionAnalysis(result);
+  } };
+}
+
+// src/chess-reasoning/recorded-reference-context.ts
+import { Chess as Chess8 } from "chess.js";
+function historyPositionContext(startFen, history) {
+  if (!Array.isArray(history) || history.length > 512) throw Error("Invalid recorded history");
+  const board = new Chess8(startFen);
+  let before = board.fen(), san = "";
+  for (const uci of history) {
+    if (typeof uci !== "string" || !/^[a-h][1-8][a-h][1-8][qrbn]?$/.test(uci)) throw Error("Invalid recorded move");
+    before = board.fen();
+    san = board.move({ from: uci.slice(0, 2), to: uci.slice(2, 4), promotion: uci[4] }).san;
+  }
+  return history.length ? { nodeId: "recorded-reference", historyStartFen: startFen, historyUci: history.slice(0, -1), fenBefore: before, fenAfter: board.fen(), moveUci: history.at(-1), moveSan: san } : { kind: "position", nodeId: "recorded-reference", historyStartFen: startFen, historyUci: [], fenBefore: board.fen(), fenAfter: board.fen(), moveUci: "", moveSan: "" };
+}
+function recordedEvidenceContext(selected, value) {
+  const p = value;
+  if (!p || p.startFen !== (selected.historyStartFen ?? new Chess8().fen()) || !Array.isArray(p.historyUci) || p.ply !== p.historyUci.length) throw Error("Invalid recorded scope");
+  const root = historyPositionContext(p.startFen, p.historyUci);
+  if (typeof p.recordHash !== "string" || reasoningContextHash({ ...root, nodeId: `recorded:${p.recordHash}:${p.ply}` }) !== p.rootContextHash) throw Error("Recorded identity mismatch");
+  if (root.fenAfter !== p.fen) throw Error("Recorded root mismatch");
+  return root;
+}
+function recordedNavigation(context, recorded) {
+  return recorded ? { anchorEdgeId: `recorded-reference:${reasoningContextHash(recorded)}`, context: recorded } : { context };
+}
+function recordedDetailsMatch(root, value) {
+  try {
+    const d = value;
+    if (!d || d.phase !== void 0 && d.phase !== "after") return false;
+    const board = new Chess8(root.fenAfter);
+    if (d.played) for (const move of d.played) {
+      const m = board.move({ from: move.uci.slice(0, 2), to: move.uci.slice(2, 4), promotion: move.uci[4] });
+      if (move.san !== void 0 && move.san !== m.san) return false;
+    }
+    if (d.finalFen !== void 0 && board.fen() !== d.finalFen) return false;
+    if (d.searchScope?.fen !== void 0 && d.searchScope.fen !== board.fen()) return false;
+    if (d.lines) for (const line of d.lines) {
+      if (!Array.isArray(line.pv) || line.rootMove !== line.pv[0] || line.scoreScope?.fen !== void 0 && line.scoreScope.fen !== board.fen()) return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/chess-reasoning/evidence-citation-normalization.ts
+function normalizedEvidenceCitations(answer, records) {
+  const ids = new Set(records.map((record2) => record2.id));
+  const repairs = [];
+  const normalized = answer.replace(/\b(?:evidence:){2,}[\w:-]+/g, (originalId) => {
+    if (ids.has(originalId)) return originalId;
+    const canonicalId = originalId.replace(/^(?:evidence:)+/, "evidence:");
+    if (!ids.has(canonicalId)) return originalId;
+    repairs.push({ originalId, canonicalId });
+    return canonicalId;
+  });
+  return { answer: normalized, repairs };
+}
+
+// src/chess-reasoning/fresh-engine-pv-witnesses.ts
+import { Chess as Chess9 } from "chess.js";
+var MAX_FRESH_ENGINE_WITNESS_ACQUISITIONS = 64;
+var UCI = /^[a-h][1-8][a-h][1-8][qrbn]?$/;
+var positiveInteger = (value) => Number.isSafeInteger(value) && Number(value) > 0;
+function rejectionReason(context, hash, witness) {
+  if (!witness || witness.version !== "fresh-engine-pv-witness/1" || witness.acquisition !== "same-answer-engine" || !positiveInteger(witness.acquisitionId) || typeof witness.evidenceId !== "string" || !witness.evidenceId || witness.evidenceId.length > 200) return "invalid-acquisition";
+  if (witness.authority !== "bounded-engine" || !Array.isArray(witness.licenses) || witness.licenses.length !== 1 || witness.licenses[0] !== "engine.bounded-continuation") return "missing-authority-license";
+  if (witness.contextHash !== hash) return "context-mismatch";
+  if (!["before", "after"].includes(witness.phase) || witness.fen !== (witness.phase === "before" ? context.fenBefore : context.fenAfter)) return "root-mismatch";
+  if (typeof witness.engineBuild !== "string" || !witness.engineBuild || typeof witness.command !== "string" || !witness.command || !positiveInteger(witness.requestedDepth) || !positiveInteger(witness.multiPv) || witness.multiPv > 32 || !Array.isArray(witness.lines) || witness.lines.length !== witness.multiPv || !Array.isArray(witness.rootMoves) || witness.rootMoves.length > 32 || witness.rootMoves.some((root) => typeof root !== "string" || !UCI.test(root)) || new Set(witness.rootMoves).size !== witness.rootMoves.length) return "invalid-search-scope";
+  if (witness.lines.some((line) => !line || typeof line.rootMove !== "string")) return "invalid-pv";
+  const roots = witness.lines.map((line) => line.rootMove);
+  if (new Set(roots).size !== roots.length || witness.rootMoves.some((root) => !roots.includes(root)) || witness.rootMoves.length > 0 && roots.some((root) => !witness.rootMoves.includes(root))) return "root-set-mismatch";
+  for (const line of witness.lines) {
+    if (!positiveInteger(line.depth) || line.depth < witness.requestedDepth) return "depth-mismatch";
+    const provenance = line.scoreProvenance;
+    if (!provenance || provenance.kind !== "root-search" || provenance.fen !== witness.fen || provenance.engineBuild !== witness.engineBuild || provenance.command !== void 0 && provenance.command !== witness.command || provenance.originatingDepth !== line.depth || provenance.reportedDepth !== line.depth) return "provenance-mismatch";
+    if (!(Number.isFinite(line.scoreCp) && line.mateInMoves === null || line.scoreCp === null && Number.isSafeInteger(line.mateInMoves) && line.mateInMoves !== 0)) return "score-mismatch";
+    if (!Array.isArray(line.pv) || !line.pv.length || line.pv.length > 256 || line.pv.some((uci) => typeof uci !== "string" || !UCI.test(uci)) || line.pv[0] !== line.rootMove) return "invalid-pv";
+    try {
+      const board = new Chess9(witness.fen);
+      for (const uci of line.pv) board.move({ from: uci.slice(0, 2), to: uci.slice(2, 4), promotion: uci.slice(4) || void 0 });
+    } catch {
+      return "illegal-pv";
+    }
+    try {
+      structuredClone(provenance);
+    } catch {
+      return "provenance-mismatch";
+    }
+  }
+  return null;
+}
+function admitFreshEnginePvWitnesses(context, witnesses) {
+  const lines = [];
+  const inspected = witnesses.slice(0, MAX_FRESH_ENGINE_WITNESS_ACQUISITIONS);
+  const audit = {
+    version: "fresh-engine-pv-admission/1",
+    inputAcquisitions: witnesses.length,
+    inspectedAcquisitions: inspected.length,
+    acceptedAcquisitions: 0,
+    rejectedAcquisitions: 0,
+    acceptedLines: 0,
+    omittedAcquisitions: witnesses.length - inspected.length,
+    acceptedAcquisitionIds: [],
+    rejectedAcquisitionIds: [],
+    rejections: [],
+    rejectionCounts: {}
+  };
+  const hash = reasoningContextHash(context);
+  for (const witness of inspected) {
+    const reason = rejectionReason(context, hash, witness);
+    if (reason) {
+      const acquisitionId = positiveInteger(witness?.acquisitionId) ? witness.acquisitionId : null;
+      audit.rejections.push({ acquisitionId, reason });
+      audit.rejectedAcquisitionIds.push(acquisitionId);
+      audit.rejectionCounts[reason] = (audit.rejectionCounts[reason] ?? 0) + 1;
+      continue;
+    }
+    audit.acceptedAcquisitionIds.push(witness.acquisitionId);
+    for (const line of witness.lines) {
+      lines.push({
+        start: context.kind === "position" ? "after" : witness.phase,
+        ucis: [...line.pv],
+        evidenceIds: [witness.evidenceId],
+        authority: "Bounded engine line",
+        engineEvidence: [{
+          acquisitionId: witness.acquisitionId,
+          evidenceId: witness.evidenceId,
+          rootFen: witness.fen,
+          rootMove: line.rootMove,
+          depth: line.depth,
+          requestedDepth: witness.requestedDepth,
+          engineBuild: witness.engineBuild,
+          command: witness.command,
+          scoreCp: line.scoreCp,
+          mateInMoves: line.mateInMoves,
+          scoreProvenance: structuredClone(line.scoreProvenance),
+          conditional: true,
+          scoreInterpretation: "Root-search score only; the continuation is conditional, not forced and not a score for a later position."
+        }]
+      });
+    }
+  }
+  if (audit.omittedAcquisitions) audit.rejectionCounts["audit-capacity-exceeded"] = audit.omittedAcquisitions;
+  audit.acceptedAcquisitions = audit.acceptedAcquisitionIds.length;
+  audit.rejectedAcquisitions = audit.rejections.length + audit.omittedAcquisitions;
+  audit.acceptedLines = lines.length;
+  return { lines, audit };
+}
+
+// src/chess-reasoning/simple-prose-references.ts
+import { Chess as Chess11 } from "chess.js";
+
+// src/chess-reasoning/historical-prose.ts
+import { Chess as Chess10 } from "chess.js";
+function historicalProseRoots(selected, records, line) {
+  const roots = /* @__PURE__ */ new Map();
+  const paths = [];
+  const addPath = (ply, context, path) => {
+    if (!path.length || path.length > 256) return;
+    const board = new Chess10(context.fenAfter), sans = [], numbers = [];
+    try {
+      for (const uci of path) {
+        const f = board.fen().split(" ");
+        numbers.push(`${f[5]}${f[1] === "w" ? "." : "..."}`);
+        sans.push(board.move({ from: uci.slice(0, 2), to: uci.slice(2, 4), promotion: uci[4] }).san);
+      }
+      paths.push({ ply, path, sans, numbers });
+    } catch {
+    }
+  };
+  let recorded;
+  const recordedNumbers = [];
+  if (line && line.startFen === (selected.historyStartFen ?? new Chess10().fen()) && line.moves.length <= 512) {
+    try {
+      const board = new Chess10(line.startFen);
+      recorded = line.moves.map((m) => m.uci);
+      let before = board.fen();
+      for (let ply = 0; ply < recorded.length; ply++) {
+        const f = board.fen().split(" ");
+        recordedNumbers.push(`${f[5]}${f[1] === "w" ? "." : "..."}`);
+        const context = ply === 0 ? historyPositionContext(line.startFen, []) : {
+          nodeId: "recorded-reference",
+          historyStartFen: line.startFen,
+          historyUci: recorded.slice(0, ply - 1),
+          fenBefore: before,
+          fenAfter: board.fen(),
+          moveUci: recorded[ply - 1],
+          moveSan: line.moves[ply - 1].san
+        };
+        roots.set(ply, { context, records: [] });
+        before = board.fen();
+        const uci = recorded[ply];
+        if (board.move({ from: uci.slice(0, 2), to: uci.slice(2, 4), promotion: uci[4] }).san !== line.moves[ply].san) throw Error("Invalid recorded SAN");
+      }
+    } catch {
+      recorded = void 0;
+      roots.clear();
+      paths.length = 0;
+    }
+  }
+  for (const e of records) {
+    if (e.contextHash !== reasoningContextHash(selected) || !e.data.recordedPosition) continue;
+    try {
+      const p = e.data.recordedPosition;
+      const context = recordedEvidenceContext(selected, p);
+      if (recorded && p.historyUci.some((uci, i) => recorded[i] !== uci)) continue;
+      const root = roots.get(p.ply) ?? { context, records: [] };
+      if (root.context.fenAfter !== context.fenAfter || JSON.stringify(root.context.historyUci) !== JSON.stringify(context.historyUci)) continue;
+      effectiveLicensesForRecord(e);
+      const data = e.data.details;
+      if (!recordedDetailsMatch(context, data)) continue;
+      const unwrapped = { ...e, contextHash: reasoningContextHash(root.context), data };
+      root.records.push(unwrapped);
+      roots.set(p.ply, root);
+      if (Array.isArray(data.lines)) for (const candidate of data.lines) {
+        const prefix = Array.isArray(data.played) ? data.played.map((m) => m.uci) : [];
+        const pv = candidate?.pv;
+        if (Array.isArray(pv)) addPath(p.ply, context, [...prefix, ...pv]);
+      }
+      if (Array.isArray(data.played)) addPath(p.ply, context, data.played.map((m) => m.uci));
+    } catch {
+    }
+  }
+  const san = "(?:O-O(?:-O)?|[KQRBN](?:[a-h1-8])?x?[a-h][1-8]|[a-h](?:x[a-h])?[1-8](?:=[QRBN])?)[+#]?[!?]*";
+  const sequence = new RegExp(`(?<![\\w])\\d+\\s*(?:\\.{3}|\\.|\u2026)\\s*${san}(?:\\s+(?:\\d+\\s*(?:\\.{3}|\\.|\u2026)\\s*)?${san})*`, "g");
+  const token = new RegExp(`(?:(\\d+)\\s*(\\.{3}|\\.|\u2026)\\s*)?(${san})`, "g");
+  const annotate = (text) => text.replace(sequence, (match, offset) => {
+    const left = text.slice(0, offset), right = text.slice(offset + match.length);
+    if (left.lastIndexOf("[") > left.lastIndexOf("]") || /^\]\(/.test(right)) return match;
+    const moves = [...match.matchAll(token)];
+    const candidates = /* @__PURE__ */ new Map();
+    for (const witness of paths) for (let from = 0; from < witness.path.length; from++) {
+      if (from + moves.length > witness.path.length) continue;
+      if (!moves.every((m, i) => m[3].replace(/[!?]/g, "") === witness.sans[from + i] && (!m[1] || `${Number(m[1])}${m[2] === "." ? "." : "..."}` === witness.numbers[from + i]))) continue;
+      const path = witness.path.slice(0, from + moves.length), root = roots.get(witness.ply);
+      const history = [...root.context.historyUci, ...root.context.kind === "position" ? [] : [root.context.moveUci], ...path];
+      candidates.set(history.join(","), { ply: witness.ply, path });
+    }
+    if (recorded) for (let ply = 0; ply < recorded.length; ply++) {
+      const root = roots.get(ply);
+      if (!root || ply + moves.length > recorded.length) continue;
+      const path = recorded.slice(ply, ply + moves.length);
+      if (moves.every((m, i) => m[3].replace(/[!?]/g, "") === line.moves[ply + i].san && (!m[1] || `${Number(m[1])}${m[2] === "." ? "." : "..."}` === recordedNumbers[ply + i]))) candidates.set(recorded.slice(0, ply + moves.length).join(","), { ply, path });
+    }
+    if (candidates.size !== 1) return match;
+    const c = [...candidates.values()][0];
+    return `[${match}](game:${c.ply}:${c.path.join(",")})`;
+  });
+  const witnessedSuffixes = (ply, path) => {
+    const target = roots.get(ply);
+    if (!recorded || !target || !path.length) return [];
+    const suffixes = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const witness of paths) {
+      if (witness.ply >= ply) continue;
+      const omitted = recorded.slice(witness.ply, ply);
+      if (omitted.length !== ply - witness.ply || witness.path.length < omitted.length + path.length || !omitted.every((uci, i) => witness.path[i] === uci) || !path.every((uci, i) => witness.path[omitted.length + i] === uci)) continue;
+      const root = roots.get(witness.ply);
+      if (!root?.records.length) continue;
+      const board = new Chess10(root.context.fenAfter);
+      try {
+        for (const uci of omitted) board.move({ from: uci.slice(0, 2), to: uci.slice(2, 4), promotion: uci[4] });
+        if (board.fen() !== target.context.fenAfter) continue;
+      } catch {
+        continue;
+      }
+      const fullPath = [...omitted, ...path], key2 = `${witness.ply}:${fullPath.join(",")}`;
+      if (!seen.has(key2)) {
+        seen.add(key2);
+        suffixes.push({ root, path: fullPath });
+      }
+    }
+    return suffixes.sort((a, b) => a.path.length - b.path.length);
+  };
+  return { roots, annotate, recorded, witnessedSuffixes };
+}
+
+// src/chess-reasoning/simple-prose-references.ts
+var SIMPLE_REFERENCE_VERSION = "simple-references/22";
+var MAX_EVIDENCE_REPLAY_PLIES = 256;
+var INTERNAL_WITNESS = /* @__PURE__ */ Symbol("internal-evidence-witness");
+var MAX_AUTHORED_REFERENCE_PLIES = MAX_INTERACTIVE_LINE_PLIES;
+var UCI2 = /^[a-h][1-8][a-h][1-8][qrbn]?$/;
+var names = { p: "pawn", n: "knight", b: "bishop", r: "rook", q: "queen", k: "king" };
+function compatibleMoveSan(authored, canonical) {
+  if (authored.replace(/[+#]$/, "") === canonical.replace(/[+#]$/, "")) return true;
+  const pattern = /^([KQRBN])([a-h]?)([1-8]?)(x?)([a-h][1-8])([+#]?)$/;
+  const given = pattern.exec(authored), actual = pattern.exec(canonical);
+  return Boolean(given && actual && (actual[2] || actual[3]) && given[1] === actual[1] && given[4] === actual[4] && given[5] === actual[5] && (!given[2] || given[2] === actual[2]) && (!given[3] || given[3] === actual[3]) && Number(Boolean(given[2])) + Number(Boolean(given[3])) < Number(Boolean(actual[2])) + Number(Boolean(actual[3])));
+}
+function canonicalMoveLabel(label, refs) {
+  const parts = [...label.trim().matchAll(/(?:(\d+)?(\.{1,3}|…)[ \t]*)?([^\s.]+)/g)];
+  if (parts.length !== refs.length || parts.map((part) => part[0]).join("").replace(/\s/g, "") !== label.replace(/\s/g, "")) return label;
+  let index = 0;
+  return label.replace(/(?:(\d+)?(\.{1,3}|…)[ \t]*)?([^\s.]+)/g, (whole, _number, _dots, san) => {
+    const ref = refs[index++];
+    const canonical = ref.san;
+    if (!canonical || !compatibleMoveSan(san.replace(/[!?]+$/, ""), canonical)) return whole;
+    return whole.slice(0, whole.length - san.length) + canonical + (san.match(/[!?]+$/)?.[0] ?? "");
+  });
+}
+function safeSimpleSourceLink(target) {
+  let url;
+  try {
+    url = new URL(target);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "https:" || url.username || url.password || url.port || url.hash) return null;
+  if (url.hostname === "creativecommons.org") {
+    return url.pathname === "/licenses/by-sa/4.0/" && !url.search ? { href: url.href } : null;
+  }
+  if (url.hostname !== "en.wikibooks.org" || url.pathname !== "/w/index.php") return null;
+  const title = url.searchParams.getAll("title");
+  if (title.length !== 1 || !title[0].trim()) return null;
+  const keys = [...url.searchParams.keys()].sort();
+  const revision = url.searchParams.get("oldid");
+  if (keys.join(",") === "oldid,title" && revision && /^[1-9]\d*$/.test(revision) && Number.isSafeInteger(Number(revision))) return { href: url.href };
+  if (keys.join(",") === "action,title" && url.searchParams.get("action") === "history") return { href: url.href };
+  return null;
+}
+function stripSimpleMarkdownFences(value) {
+  return value.replace(/^[ \t]*```(?:text|plaintext|markdown|md|pgn|chess)?[ \t]*$/gim, "");
+}
+var internalCitationLink = /\[([^\]\n]+)\]\(\s*(?:evidence|recorded-main-line):[\w:-]+\s*\)/g;
+function stripSimpleCitationLinks(value) {
+  return value.replace(internalCitationLink, "");
+}
+function repairFrozenCitationLabels(value, rawParagraph) {
+  let result = stripSimpleCitationLinks(value);
+  const suffix = rawParagraph.match(/(?:\s*\[[^\]\n]+\]\(\s*(?:evidence|recorded-main-line):[\w:-]+\s*\))+\s*$/)?.[0];
+  if (!suffix) return result;
+  const labels = [...suffix.matchAll(internalCitationLink)].map((match) => `[${match[1]}]`).reverse();
+  for (const label of labels) {
+    const trimmed = result.trimEnd();
+    if (!trimmed.endsWith(label)) break;
+    result = trimmed.slice(0, -label.length).trimEnd();
+  }
+  return result;
+}
+function simpleProseReferences(answer, context, records, recordedLine, recordedPath, onReference, internalWitness) {
+  const authoredPathLimit = internalWitness === INTERNAL_WITNESS ? MAX_EVIDENCE_REPLAY_PLIES : MAX_AUTHORED_REFERENCE_PLIES;
+  validateReasoningPositionContext(context);
+  answer = normalizedEvidenceCitations(answer, records.filter((record2) => record2.contextHash === reasoningContextHash(context))).answer;
+  answer = stripSimpleMarkdownFences(answer);
+  const historical = historicalProseRoots(context, records, recordedLine);
+  const historicalVariations = [];
+  const historicalRefs = /* @__PURE__ */ new Map();
+  const timeline = createPocIdentityTimeline(context), hash = reasoningContextHash(context);
+  const evidence = records.filter((record2) => {
+    if (record2.contextHash !== hash) return false;
+    try {
+      effectiveLicensesForRecord(record2);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  const replayCache = /* @__PURE__ */ new Map();
+  const replay = (start, ucis) => {
+    if (ucis.length > MAX_EVIDENCE_REPLAY_PLIES || ucis.some((uci) => !UCI2.test(uci))) throw Error("Invalid or overlong path");
+    const key2 = `${start}:${ucis.join(",")}`;
+    const cached = replayCache.get(key2);
+    if (cached) return cached;
+    let state = timeline[start];
+    const moves = [];
+    let copyText = "";
+    for (const uci of ucis) {
+      const fen = state.fen.split(" ");
+      const applied = applyIdentityMove(state, { from: uci.slice(0, 2), to: uci.slice(2, 4), promotion: uci.slice(4) || void 0 });
+      moves.push({ uci, san: applied.delta.san, pieceId: applied.delta.mover });
+      copyText = `${fen[5]}${fen[1] === "b" ? "..." : "."} ${applied.delta.san}`;
+      state = applied.state;
+    }
+    const result = { state, position: { start, moves, fen: state.fen }, copyText };
+    replayCache.set(key2, result);
+    return result;
+  };
+  const freshEnginePvAdmission = admitFreshEnginePvWitnesses(context, typeof internalWitness === "object" ? internalWitness.freshEnginePvWitnesses ?? [] : []);
+  const lines = freshEnginePvAdmission.lines;
+  if (recordedPath?.length) {
+    try {
+      replay("after", recordedPath);
+      lines.push({ start: "after", ucis: recordedPath, evidenceIds: [], authority: "Recorded game play" });
+    } catch {
+    }
+  }
+  const object2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  for (const record2 of evidence) {
+    if (record2.data.recordedPosition) continue;
+    const replayPhase = reasoningEvidenceReplayStartPhase(record2, context);
+    const start = replayPhase && context.kind === "position" ? "after" : replayPhase, r = record2.replay;
+    const phase = record2.data.phase, played = record2.data.played, scope2 = object2(record2.data.searchScope);
+    if ((phase === "before" || phase === "after") && Array.isArray(played) && Array.isArray(record2.data.lines) && effectiveLicensesForRecord(record2).includes("engine.bounded-continuation")) {
+      try {
+        const prefix = played.map((move) => object2(move)?.uci);
+        if (prefix.some((uci) => typeof uci !== "string")) throw Error("Invalid tested prefix");
+        const tested = replay(phase, prefix);
+        if (tested.position.fen !== r?.fen || tested.position.fen !== scope2?.fen || tested.position.fen !== record2.data.finalFen) throw Error("Tested endpoint mismatch");
+        if (tested.position.moves.some((move, index) => move.san !== object2(played[index])?.san)) throw Error("Tested SAN mismatch");
+        for (const candidate of record2.data.lines) {
+          const line = object2(candidate), pv = line?.pv;
+          if (!Array.isArray(pv) || !pv.length || pv.some((uci) => typeof uci !== "string") || line?.rootMove !== pv[0]) continue;
+          try {
+            const ucis = [...prefix, ...pv];
+            replay(phase, ucis);
+            lines.push({ start: phase, ucis, evidenceIds: [record2.id], authority: "Bounded engine line" });
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    if (!start || !r) continue;
+    const sequence = r.movesUci ?? r.moves ?? r.line ?? (r.move ? [r.move] : []);
+    const candidates = [sequence, ...Array.isArray(r.linesUci) ? r.linesUci : []];
+    if ((phase === start || context.kind === "position" && phase === replayPhase) && scope2?.fen === r.fen && r.fen === timeline[start].fen && Array.isArray(record2.data.lines) && effectiveLicensesForRecord(record2).some((license) => license === "engine.bounded-continuation" || license === "engine.bounded-comparison")) {
+      for (const candidate of record2.data.lines) {
+        const line = object2(candidate), pv = line?.pv;
+        if (!Array.isArray(pv) || !pv.length || pv.some((uci) => typeof uci !== "string") || line?.rootMove !== pv[0] || object2(line?.scoreScope)?.fen !== r.fen) continue;
+        if (!candidates.some((prefix) => Array.isArray(prefix) && prefix.length > 0 && prefix.length <= pv.length && prefix.every((uci, index) => uci === pv[index]))) continue;
+        try {
+          replay(start, pv);
+          lines.push({ start, ucis: pv, evidenceIds: [record2.id], authority: "Bounded engine line" });
+        } catch {
+        }
+      }
+    }
+    for (const value of candidates) {
+      if (!Array.isArray(value) || !value.length || value.some((x) => typeof x !== "string")) continue;
+      try {
+        replay(start, value);
+        lines.push({ start, ucis: value, evidenceIds: [record2.id], authority: effectiveLicensesForRecord(record2).some((license) => license.startsWith("engine.bounded-")) ? "Bounded engine line" : "Illustrative legal line" });
+      } catch {
+      }
+    }
+  }
+  const normalizedPath = (start, moves) => context.kind === "position" ? { start: "after", moves } : start === "before" && moves[0] === context.moveUci ? { start: "after", moves: moves.slice(1) } : { start, moves };
+  const matchingLines = (start, moves) => {
+    if (!moves.length) return [];
+    const path = normalizedPath(start, moves);
+    if (!path.moves.length) return [];
+    return lines.filter((line) => {
+      const candidate = normalizedPath(line.start, line.ucis);
+      return candidate.start === path.start && path.moves.every((uci, i) => candidate.moves[i] === uci);
+    });
+  };
+  const registered = /* @__PURE__ */ new Map();
+  const rejected = /* @__PURE__ */ new Set();
+  for (const match of answer.matchAll(/\[([^\]\n]+)\]\(line:([a-zA-Z][a-zA-Z0-9_-]{0,15}):(before|after):([^)\n]+)\)/g)) {
+    const [, label, id, start, path] = match;
+    if (registered.has(id) || rejected.has(id)) {
+      registered.delete(id);
+      rejected.add(id);
+      continue;
+    }
+    try {
+      const ucis = path.split(",");
+      if (!ucis.length || ucis.length > authoredPathLimit || id === "before" || id === "after") throw Error("Unsupported registered line");
+      const terminal = replay(start, ucis);
+      const authored = label.replace(/^(?:\d+)?(?:\.{1,3}|…)\s*/, "").replace(/[!?]+$/, "");
+      if (ucis.length === 1 && !compatibleMoveSan(authored, terminal.position.moves.at(-1)?.san ?? "")) throw Error("Registered SAN mismatch");
+      if (!matchingLines(start, ucis).length) throw Error("Unwitnessed registered line");
+      registered.set(id, { start, ucis });
+    } catch {
+      rejected.add(id);
+    }
+  }
+  const canonicalTarget = (target) => {
+    const [kind, id, ply, square, ...extra] = target.split(":");
+    if (id === "before" || id === "after") return target;
+    if (!["line", "move", "piece", "square"].includes(kind)) return target;
+    const line = registered.get(id);
+    if (!line || rejected.has(id)) throw Error("Unknown or invalid answer-local variation");
+    if (kind === "line") {
+      if (ply !== line.start || square !== line.ucis.join(",") || extra.length) throw Error("Invalid variation declaration");
+      return `move:${line.start}:${line.ucis.join(",")}`;
+    }
+    if (!/^(0|[1-9]\d*)$/.test(ply) || Number(ply) > line.ucis.length || extra.length || kind === "move" && (square !== void 0 || Number(ply) === 0) || kind !== "move" && !/^[a-h][1-8]$/.test(square || "")) throw Error("Invalid variation ply");
+    const prefix = line.ucis.slice(0, Number(ply)).join(",");
+    return `${kind}:${line.start}:${prefix}${kind === "move" ? "" : `:${square}`}`;
+  };
+  const notationCorrections = [];
+  const resolve = (label, target) => {
+    const parts = target.split(":"), kind = parts.shift(), start = parts.shift();
+    if (!["move", "piece", "square"].includes(kind || "") || start !== "before" && start !== "after") throw Error("Missing exact position");
+    const implicitSquare = kind === "square" && /^[a-h][1-8]$/.test(label) && parts.length === 1 && parts[0].split(",").every((uci) => UCI2.test(uci));
+    const square = kind === "move" ? void 0 : implicitSquare ? label : parts.pop();
+    const ucis = parts.length === 1 && parts[0] ? parts[0].split(",") : [];
+    if (parts.length > 1 || ucis.length > authoredPathLimit) throw Error("Unsupported replay path");
+    const result = replay(start, ucis), matching = matchingLines(start, ucis);
+    if (ucis.length > 1 && !matching.length) throw Error("Path not witnessed in acquired evidence");
+    const evidenceIds = [...new Set(matching.flatMap((line) => line.evidenceIds))];
+    const witnessedEngineEvidence = matching.flatMap((line) => line.engineEvidence ?? []);
+    const engineEvidence = witnessedEngineEvidence.length ? { engineEvidence: witnessedEngineEvidence } : {};
+    if (kind === "move") {
+      const last = result.position.moves.at(-1);
+      const authored = label.replace(/^(?:\d+)?(?:\.{1,3}|…)\s*/, "").replace(/[!?]+$/, "");
+      if (!last || !compatibleMoveSan(authored, last.san)) throw Error("Move label does not match legal SAN");
+      const mover = result.state.pieces[last.pieceId];
+      return { kind, label: last.san, ...last, position: result.position, copyText: result.copyText, evidenceIds, ...engineEvidence, pieceCode: mover.color + mover.type };
+    }
+    if (!square || !/^[a-h][1-8]$/.test(square)) throw Error("Invalid square");
+    if (kind === "square") {
+      if (/^[a-h][1-8]$/.test(label) && label !== square) throw Error("Square label mismatch");
+      return { kind, label: square, displayLabel: label, square, position: result.position, evidenceIds, ...engineEvidence };
+    }
+    const pieceId2 = result.state.squares[square], piece = pieceId2 && result.state.pieces[pieceId2];
+    if (!piece) throw Error("No piece at the scoped square");
+    const canonicalLabel = `${piece.color === "w" ? "White" : "Black"} ${names[piece.type]} on ${square}`;
+    return { kind: "piece", label: canonicalLabel, displayLabel: label, square, pieceId: piece.id, pieceCode: piece.color + piece.type, position: result.position, evidenceIds, ...engineEvidence };
+  };
+  const resolveLabel = (label, target) => {
+    if (!target.startsWith("move:")) return [resolve(label, target)];
+    const [kind, phase, path, ...extra] = target.split(":");
+    if (extra.length || !path || phase !== "before" && phase !== "after") throw Error("Missing exact position");
+    const ucis = path.split(",");
+    try {
+      const labels = [...label.trim().matchAll(/(?:(\d+)?(\.{1,3}|…)\s*)?([^\s.]+)/g)];
+      if (!labels.length || labels.length > ucis.length || labels.map((match) => match[0]).join("").replace(/\s/g, "") !== label.replace(/\s/g, "")) throw Error("Move label does not match legal SAN");
+      const offset = ucis.length - labels.length;
+      return labels.map((match, index) => {
+        const ref = resolve(match[3], `${kind}:${phase}:${ucis.slice(0, offset + index + 1).join(",")}`);
+        if (match[1]) {
+          const prefix = ref.copyText.split(" ")[0];
+          const expected2 = `${Number(match[1])}${match[2] === "." ? "." : "..."}`;
+          if (expected2 !== prefix) throw Error("Move number does not match legal position");
+        }
+        return ref;
+      });
+    } catch (error) {
+      if (ucis.length < 2) throw error;
+      const result = replay(phase, ucis);
+      if (!matchingLines(phase, ucis).length) throw Error("Path not witnessed in acquired evidence");
+      const terminal = result.position.moves.at(-1);
+      const validated = resolve(terminal.san, target);
+      return [{
+        kind: "sequence",
+        label,
+        position: validated.position,
+        evidenceIds: validated.evidenceIds,
+        ...validated.engineEvidence ? { engineEvidence: validated.engineEvidence } : {}
+      }];
+    }
+  };
+  const gaps = [], usedLines = /* @__PURE__ */ new Map();
+  const referenceGapCounts = {
+    version: "simple-reference-gap-counts/1",
+    unboundProseSpans: 0,
+    unboundMentions: 0,
+    unresolvedReferences: 0,
+    unknownCitations: 0,
+    formattingWarnings: 0
+  };
+  let resolved = 0, total = 0;
+  const blocks = answer.split(/\n\s*\n|\n(?=\s*(?:[-*]|\d+\.)\s)/).filter(Boolean).map((raw) => {
+    const cited = [...raw.matchAll(/(?:evidence|recorded-main-line):[\w:-]+/g)].map((match) => match[0]);
+    for (const id of cited) if (!evidence.some((record2) => record2.id === id)) {
+      referenceGapCounts.unknownCitations++;
+      gaps.push(`Unknown citation: ${id}`);
+    }
+    const withoutCitationControls = raw.replace(/\uE200cite[^\uE201]*\uE201/g, "");
+    if (withoutCitationControls !== raw) {
+      referenceGapCounts.formattingWarnings++;
+      gaps.push("Provider citation formatting hidden; raw output remains in the trace.");
+    }
+    const text = historical.annotate(stripSimpleCitationLinks(withoutCitationControls).replace(/\[(?:\s*(?:evidence|recorded-main-line):[\w:-]+\s*[,;]?\s*)+\]/g, "").replace(/(?:evidence|recorded-main-line):[\w:-]+/g, "").replace(/\([\s,;]*\)/g, "").trim());
+    const tokens = [];
+    const plain = (value) => {
+      if (!value) return;
+      const unbound = value.match(/\b(?:[KQRBN](?:[a-h1-8])?x?[a-h][1-8]|[a-h]x[a-h][1-8](?:=[QRBN])?|[a-h][1-8](?:=[QRBN])?|O-O(?:-O)?)[+#]?\b|\b(?:the|White(?:’s|'s)?|Black(?:’s|'s)?) (?:knight|bishop|rook|queen|king|pawn)\b/g) || [];
+      total += unbound.length;
+      if (unbound.length) {
+        referenceGapCounts.unboundProseSpans++;
+        referenceGapCounts.unboundMentions += unbound.length;
+        gaps.push(`Unbound text: ${unbound.join(", ")}`);
+      }
+      tokens.push({ text: value });
+    };
+    let end = 0;
+    for (const match of text.matchAll(/\[([^\]\n]+)\]\(([^)\n]+)\)/g)) {
+      plain(text.slice(end, match.index));
+      const sourceLink = safeSimpleSourceLink(match[2]);
+      if (sourceLink) {
+        tokens.push({ text: match[1], sourceLink });
+        end = match.index + match[0].length;
+        continue;
+      }
+      total++;
+      try {
+        let refs;
+        if (match[2].startsWith("game:")) {
+          const parsed = /^game:(\d+):([a-h1-8qrbn,]+)$/.exec(match[2]);
+          const root = parsed && historical.roots.get(Number(parsed[1]));
+          if (!parsed || !root) throw Error("Unknown recorded position");
+          const path = parsed[2].split(",");
+          const actual = historical.recorded?.slice(Number(parsed[1]), Number(parsed[1]) + path.length);
+          const isActual = actual?.length === path.length && actual.every((uci, i) => uci === path[i]);
+          let v = simpleProseReferences(`[${match[1]}](move:after:${parsed[2]})`, root.context, root.records, void 0, isActual ? path : void 0);
+          let witnessedRefs = v.blocks.flatMap((b) => b.tokens.flatMap((t) => t.reference ? [t.reference] : []));
+          let suffixWitness;
+          if (!witnessedRefs.length || v.gaps.some((g) => !g.startsWith("Unbound"))) {
+            for (const candidate of historical.witnessedSuffixes(Number(parsed[1]), path)) {
+              const board = new Chess11(candidate.root.context.fenAfter);
+              const fullLabel = candidate.path.map((uci) => {
+                const f = board.fen().split(" "), san = board.move({ from: uci.slice(0, 2), to: uci.slice(2, 4), promotion: uci[4] }).san;
+                return `${f[5]}${f[1] === "w" ? "." : "..."}${san}`;
+              }).join(" ");
+              const source = simpleProseReferences(`[${fullLabel}](move:after:${candidate.path.join(",")})`, candidate.root.context, candidate.root.records, void 0, void 0, void 0, INTERNAL_WITNESS);
+              const sourceRefs = source.blocks.flatMap((b) => b.tokens.flatMap((t) => t.reference ? [t.reference] : []));
+              if (source.coverage.resolved !== 1 || source.gaps.some((g) => !g.startsWith("Unbound")) || sourceRefs.length !== candidate.path.length) continue;
+              const evidenceIds = sourceRefs.at(-1)?.evidenceIds ?? [];
+              if (!evidenceIds.length) continue;
+              const sourceLine = source.variations.find((line) => line.ucis.join(",") === candidate.path.join(","));
+              if (!sourceLine) continue;
+              const projected = simpleProseReferences(`[${match[1]}](move:after:${parsed[2]})`, root.context, [], void 0, path);
+              const projectedRefs = projected.blocks.flatMap((b) => b.tokens.flatMap((t) => t.reference ? [t.reference] : []));
+              if (projected.coverage.resolved !== 1 || projected.gaps.some((g) => !g.startsWith("Unbound")) || !projectedRefs.length) continue;
+              suffixWitness = { evidenceIds, authority: sourceLine.authority };
+              v = { ...projected, variations: projected.variations.map((line) => ({
+                ...line,
+                evidenceIds,
+                authority: sourceLine.authority,
+                references: line.references.map((ref) => ({ ...ref, evidenceIds }))
+              })) };
+              witnessedRefs = projectedRefs.map((ref) => ({ ...ref, evidenceIds }));
+              break;
+            }
+          }
+          refs = witnessedRefs.map((ref) => ({ ...ref, position: { ...ref.position, recordedContext: root.context } }));
+          if (!refs.length || v.gaps.some((g) => !g.startsWith("Unbound"))) throw Error("Unwitnessed historical path");
+          let witnessedVariations = v.variations;
+          if (!witnessedVariations.length && path.length > 1) {
+            const board = new Chess11(root.context.fenAfter);
+            const sans = path.map((uci) => board.move({ from: uci.slice(0, 2), to: uci.slice(2, 4), promotion: uci[4] }).san).join(" ");
+            const expanded = simpleProseReferences(`[${sans}](move:after:${parsed[2]})`, root.context, suffixWitness ? [] : root.records, void 0, suffixWitness ? path : isActual ? path : void 0).variations;
+            witnessedVariations = suffixWitness ? expanded.map((line) => ({
+              ...line,
+              evidenceIds: suffixWitness.evidenceIds,
+              authority: suffixWitness.authority,
+              references: line.references.map((ref) => ({ ...ref, evidenceIds: suffixWitness.evidenceIds }))
+            })) : expanded;
+          }
+          for (const line of witnessedVariations) {
+            historicalVariations.push({ ...line, recordedContext: root.context });
+            historicalRefs.set(`${reasoningContextHash(root.context)}:${line.ucis.join(",")}`, line.references.map((r) => ({ ...r, position: { ...r.position, recordedContext: root.context } })));
+          }
+        } else refs = resolveLabel(match[1], canonicalTarget(match[2]));
+        const canonicalLabel = refs.every((ref) => ref.kind === "move") ? canonicalMoveLabel(match[1], refs) : match[1];
+        if (canonicalLabel !== match[1]) notationCorrections.push(`${match[1]} \u2192 ${canonicalLabel} (derived from legal replay)`);
+        onReference?.({ label: match[1], target: match[2], resolved: true, canonicalLabel });
+        resolved++;
+        for (const [index, ref] of refs.entries()) {
+          if (index) tokens.push({ text: " " });
+          tokens.push({ text: ref.label, reference: ref });
+          const ucis = ref.position.moves.map((move) => move.uci);
+          if (!ref.position.recordedContext && ref.kind === "move" && ucis.length) for (const line of matchingLines(ref.position.start, ucis)) {
+            if (ucis.length > 1) {
+              const key2 = `${ref.position.start}:${ucis.join(",")}`, previous = usedLines.get(key2);
+              usedLines.set(key2, {
+                ...line,
+                start: ref.position.start,
+                ucis,
+                evidenceIds: [.../* @__PURE__ */ new Set([...previous?.evidenceIds ?? [], ...line.evidenceIds])],
+                ...previous?.engineEvidence?.length || line.engineEvidence?.length ? {
+                  engineEvidence: [...previous?.engineEvidence ?? [], ...line.engineEvidence ?? []].filter((item, index2, all) => all.findIndex((other) => other.evidenceId === item.evidenceId && other.rootMove === item.rootMove) === index2)
+                } : {},
+                authority: previous?.authority === "Bounded engine line" ? previous.authority : line.authority
+              });
+            }
+          }
+        }
+      } catch (error) {
+        referenceGapCounts.unresolvedReferences++;
+        const gap = `${match[1]}: ${error instanceof Error ? error.message : "Unresolved reference"}`;
+        onReference?.({ label: match[1], target: match[2], resolved: false, reason: gap });
+        gaps.push(gap);
+        tokens.push({ text: match[1], gap });
+      }
+      end = match.index + match[0].length;
+    }
+    plain(text.slice(end));
+    return { tokens, evidenceIds: cited.filter((id) => evidence.some((record2) => record2.id === id)), leadingVariationIndex: void 0 };
+  });
+  const variations = [...usedLines.values(), ...historicalVariations];
+  decorateSimpleVariations(blocks, variations);
+  const visibleVariations = new Set(blocks.flatMap((block) => block.tokens.flatMap((token) => token.variationIndex === void 0 ? [] : [token.variationIndex])));
+  const visibleIndices = [...visibleVariations].sort((a, b) => a - b);
+  for (const block of blocks) for (const token of block.tokens) if (token.variationIndex !== void 0)
+    token.variationIndex = visibleIndices.indexOf(token.variationIndex);
+  for (const block of blocks) if (block.leadingVariationIndex !== void 0)
+    block.leadingVariationIndex = visibleIndices.indexOf(block.leadingVariationIndex);
+  return {
+    blocks,
+    evidence,
+    gaps,
+    notationCorrections,
+    coverage: { resolved, total },
+    ...typeof internalWitness === "object" ? { freshEnginePvAdmission: freshEnginePvAdmission.audit, referenceGapCounts } : {},
+    variations: visibleIndices.map((index) => variations[index]).map((line) => ({
+      ...line,
+      position: line.recordedContext ? historicalRefs.get(`${reasoningContextHash(line.recordedContext)}:${line.ucis.join(",")}`).at(-1).position : replay(line.start, line.ucis).position,
+      references: line.recordedContext ? historicalRefs.get(`${reasoningContextHash(line.recordedContext)}:${line.ucis.join(",")}`) : replay(line.start, line.ucis).position.moves.map((move, index) => resolve(move.san, `move:${line.start}:${line.ucis.slice(0, index + 1).join(",")}`))
+    }))
+  };
+}
+function decorateSimpleVariations(blocks, variations) {
+  const sameRoot = (a, b) => !a && !b || Boolean(a && b && a.historyStartFen === b.historyStartFen && a.moveUci === b.moveUci && a.historyUci.join(",") === b.historyUci.join(","));
+  for (const block of blocks) {
+    block.leadingVariationIndex = void 0;
+    for (const token of block.tokens) {
+      delete token.variationIndex;
+      delete token.variationStart;
+      delete token.variationEnd;
+      delete token.variationPlayFrom;
+      delete token.variationMoveIndices;
+    }
+  }
+  for (const block of blocks) for (let i = 1; i < block.tokens.length - 1; i++) {
+    const token = block.tokens[i], previous = block.tokens[i - 1].reference, next = block.tokens[i + 1].reference;
+    if (token.reference || !/^[\s,;]*(?:\d+\s*(?:\.{1,3}|…)\s*)+$/.test(token.text) || previous?.kind !== "move" || next?.kind !== "move" || !sameRoot(previous.position.recordedContext, next.position.recordedContext) || previous.position.start !== next.position.start || next.position.moves.length !== previous.position.moves.length + 1 || !previous.position.moves.every((move, index) => move.uci === next.position.moves[index].uci)) continue;
+    token.text = " ";
+  }
+  for (const block of blocks) {
+    const mentioned = variations.map((line, variationIndex) => ({
+      line,
+      variationIndex,
+      candidates: block.tokens.filter((token) => token.reference?.kind === "move" && sameRoot(token.reference.position.recordedContext, line.recordedContext) && token.reference.position.start === line.start && token.reference.position.moves.length === line.ucis.length && token.reference.position.moves.every((move, i) => move.uci === line.ucis[i]))
+    })).filter((item) => item.candidates.length);
+    for (const item of mentioned) {
+      if (mentioned.some((other) => sameRoot(other.line.recordedContext, item.line.recordedContext) && other.line.start === item.line.start && other.line.ucis.length > item.line.ucis.length && item.line.ucis.every((uci, i) => other.line.ucis[i] === uci))) continue;
+      const target = item.candidates.find((token) => token.reference?.kind === "move") ?? item.candidates[0];
+      if (target.reference?.kind === "move") {
+        const belongs = (token) => token.reference?.kind === "move" && sameRoot(token.reference.position.recordedContext, item.line.recordedContext) && token.reference.position.start === item.line.start && token.reference.position.moves.length <= item.line.ucis.length && token.reference.position.moves.every((move, i) => move.uci === item.line.ucis[i]);
+        const end = block.tokens.indexOf(target);
+        const mentions = block.tokens.slice(0, end + 1).map((token, index) => ({ token, index })).filter(({ token }) => belongs(token));
+        if (new Set(mentions.map(({ token }) => token.reference.position.moves.length)).size < 2) continue;
+        target.variationIndex = item.variationIndex;
+        const interrupted = mentions.length > 1 && block.tokens.slice(mentions[0].index, end).some((token) => !belongs(token) && (token.reference || !/^[\s,;*]*$/.test(token.text)));
+        if (interrupted) {
+          target.variationMoveIndices = [...new Set(mentions.map(({ token }) => token.reference.position.moves.length - 1))].sort((a, b) => a - b);
+          const distinctMoves = new Set(mentions.map(({ token }) => token.reference.position.moves.length));
+          if (distinctMoves.size > 1 && block.tokens.filter((token) => token.reference?.kind === "move").every(belongs) && !/^\s*(?:#{1,3} |[-*] |\d+\. )/.test(block.tokens[0]?.text || "")) block.leadingVariationIndex = item.variationIndex;
+          continue;
+        }
+        let first = block.tokens.indexOf(target), nextLength = target.reference.position.moves.length;
+        for (let cursor = first - 1; cursor >= 0; cursor--) {
+          const prior = block.tokens[cursor];
+          if (!prior.reference && /^[\s,;]*$/.test(prior.text)) continue;
+          const ref = prior.reference;
+          if (ref?.kind !== "move" || !sameRoot(ref.position.recordedContext, item.line.recordedContext) || ref.position.start !== item.line.start || ref.position.moves.length !== nextLength - 1 || !ref.position.moves.every((move, i) => move.uci === item.line.ucis[i])) break;
+          first = cursor;
+          nextLength--;
+        }
+        if (first !== block.tokens.indexOf(target)) {
+          const prefix = block.tokens[first - 1];
+          if (prefix && !prefix.reference) prefix.text = prefix.text.replace(/\b\d+\s*(?:\.{1,3}|…)\s*$/, "");
+          block.tokens[first].variationStart = true;
+          target.variationEnd = true;
+          target.variationPlayFrom = nextLength - 1;
+        }
+      }
+    }
+  }
+}
+
+// src/ai-request-limits.ts
+var AI_MODEL_CONTEXT_MAX_BYTES = 1e6;
+var AI_RELAY_MAX_REQUEST_BYTES = 2e6;
+
+// src/ai-routing-diagnostics.ts
+var AI_ROUTING_HEADER = "x-knights-eye-ai-routing";
+function readAiRoutingDiagnostics(headers) {
+  try {
+    const raw = headers instanceof Headers ? headers.get(AI_ROUTING_HEADER) : headers?.[AI_ROUTING_HEADER];
+    if (!raw || raw.length > 2048) return void 0;
+    const value = JSON.parse(raw);
+    if (!value || ![null, "flex", "default", "priority"].includes(value.requestedTier) || ![null, "flex", "default", "priority"].includes(value.actualTier) || !["flex_available", "cooldown_active", "storage_unavailable", "unsupported", "user_disabled", "user_standard", "user_fast"].includes(value.reason) || !Number.isFinite(value.elapsedMs) || value.elapsedMs < 0 || !Number.isFinite(value.slowThresholdMs) || value.slowThresholdMs <= 0 || value.cooldownUntil !== null && (!Number.isSafeInteger(value.cooldownUntil) || value.cooldownUntil < 0) || typeof value.cooldownTriggered !== "boolean" || value.timingEligible !== void 0 && typeof value.timingEligible !== "boolean") return void 0;
+    return {
+      requestedTier: value.requestedTier,
+      actualTier: value.actualTier,
+      reason: value.reason,
+      elapsedMs: value.elapsedMs,
+      slowThresholdMs: value.slowThresholdMs,
+      cooldownUntil: value.cooldownUntil,
+      cooldownTriggered: value.cooldownTriggered,
+      ...typeof value.timingEligible === "boolean" ? { timingEligible: value.timingEligible } : {},
+      ...value.persistenceError === true ? { persistenceError: true } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/chess-reasoning/lossless-evidence-sharing.ts
+var EVIDENCE_SHARING_VERSION = "evidence-sharing/1";
+var EVIDENCE_SHARING_INSTRUCTIONS = `Evidence encoding evidence-sharing/1 is lossless and self-contained. Read content with each {"$shared":"sN"} replaced by values.sN in the SAME envelope; dictionary values can themselves contain these references. Then interpret existing engine/metadata encodings normally. All values are already supplied: no tool is needed to expand them. References share identical values only, never authority, position scope, scores or search provenance. Dictionary IDs are not evidence IDs or citations.`;
+var EVIDENCE_SHARING_GUIDANCE_CHARS = 490;
+var object = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
+function shareEvidence(value) {
+  if (object(value) && value.encoding === EVIDENCE_SHARING_VERSION) return value;
+  const counts = /* @__PURE__ */ new Map();
+  const keys = /* @__PURE__ */ new WeakMap();
+  let collision = false;
+  const count = (x) => {
+    if (!x || typeof x !== "object") return;
+    if (Object.hasOwn(x, "$shared")) collision = true;
+    const key2 = JSON.stringify(x);
+    keys.set(x, key2);
+    if (key2.length >= 96) counts.set(key2, (counts.get(key2) ?? 0) + 1);
+    for (const child of Object.values(x)) count(child);
+  };
+  count(value);
+  if (collision) return value;
+  const values = {}, ids = /* @__PURE__ */ new Map();
+  const children = (x) => Array.isArray(x) ? x.map(visit) : object(x) ? Object.fromEntries(Object.entries(x).map(([k, v]) => [k, visit(v)])) : x;
+  const visit = (x) => {
+    if (!x || typeof x !== "object") return x;
+    const key2 = keys.get(x);
+    if ((counts.get(key2) ?? 0) < 2) return children(x);
+    let id = ids.get(key2);
+    if (!id) {
+      id = `s${ids.size}`;
+      ids.set(key2, id);
+      values[id] = children(x);
+    }
+    return { $shared: id };
+  };
+  let content = children(value);
+  const stringCounts = /* @__PURE__ */ new Map();
+  const objectDefinitions = Object.entries(values);
+  const countStrings = (x) => {
+    if (typeof x === "string") {
+      stringCounts.set(x, (stringCounts.get(x) ?? 0) + 1);
+      return;
+    }
+    if (Array.isArray(x)) {
+      x.forEach(countStrings);
+      return;
+    }
+    if (object(x) && !Object.hasOwn(x, "$shared")) Object.values(x).forEach(countStrings);
+  };
+  countStrings(content);
+  for (const [, definition] of objectDefinitions) countStrings(definition);
+  const stringIds = /* @__PURE__ */ new Map();
+  const shareStrings = (x) => {
+    if (typeof x === "string") {
+      const count2 = stringCounts.get(x) ?? 0;
+      let id = stringIds.get(x);
+      if (!id && count2 >= 2) {
+        const nextId = `s${ids.size + stringIds.size}`;
+        const literalLength = JSON.stringify(x).length;
+        const pointerLength = JSON.stringify({ $shared: nextId }).length;
+        const definitionLength = JSON.stringify(nextId).length + 1 + literalLength + 1;
+        if (count2 * literalLength > count2 * pointerLength + definitionLength) {
+          id = nextId;
+          stringIds.set(x, id);
+          values[id] = x;
+        }
+      }
+      return id ? { $shared: id } : x;
+    }
+    if (Array.isArray(x)) return x.map(shareStrings);
+    if (object(x) && !Object.hasOwn(x, "$shared")) return Object.fromEntries(Object.entries(x).map(([k, v]) => [k, shareStrings(v)]));
+    return x;
+  };
+  content = shareStrings(content);
+  for (const [id, definition] of objectDefinitions) values[id] = shareStrings(definition);
+  const result = { encoding: EVIDENCE_SHARING_VERSION, values, content };
+  return (ids.size || stringIds.size) && JSON.stringify(result).length + EVIDENCE_SHARING_GUIDANCE_CHARS + 128 < JSON.stringify(value).length ? result : value;
+}
+function hasSharedEvidence(value) {
+  if (typeof value === "string") {
+    if (!value.startsWith("{") || !value.includes(EVIDENCE_SHARING_VERSION)) return false;
+    try {
+      return hasSharedEvidence(JSON.parse(value));
+    } catch {
+      return false;
+    }
+  }
+  if (Array.isArray(value)) return value.some(hasSharedEvidence);
+  if (!object(value)) return false;
+  if (value.encoding === EVIDENCE_SHARING_VERSION && object(value.values) && Object.hasOwn(value, "content")) return true;
+  return Object.values(value).some(hasSharedEvidence);
+}
+function expandSharedEvidence(value) {
+  if (!object(value) || value.encoding !== EVIDENCE_SHARING_VERSION) return value;
+  if (!object(value.values) || !Object.hasOwn(value, "content")) throw Error("invalid-evidence-sharing");
+  const values = value.values, active = /* @__PURE__ */ new Set(), expanded = /* @__PURE__ */ new Map();
+  const visit = (x) => {
+    if (Array.isArray(x)) return x.map(visit);
+    if (!object(x)) return x;
+    if (Object.hasOwn(x, "$shared")) {
+      const id = x.$shared;
+      if (Object.keys(x).length !== 1 || typeof id !== "string" || !Object.hasOwn(values, id) || active.has(id)) throw Error("invalid-evidence-sharing-reference");
+      if (!expanded.has(id)) {
+        active.add(id);
+        expanded.set(id, visit(values[id]));
+        active.delete(id);
+      }
+      return expanded.get(id);
+    }
+    return Object.fromEntries(Object.entries(x).map(([k, v]) => [k, visit(v)]));
+  };
+  return visit(value.content);
+}
+function shareEvidenceMessages(messages) {
+  return messages.map((message) => {
+    if (message.role === "user" && typeof message.content === "string") {
+      let data;
+      try {
+        data = JSON.parse(message.content);
+      } catch {
+        return message;
+      }
+      if (!object(data) || data.scope !== "CURRENT_QUESTION") return message;
+      const shared = shareEvidence(data);
+      return shared === data ? message : { ...message, content: JSON.stringify(shared) };
+    }
+    if (message.role === "tool") return { ...message, content: message.content.map((part) => {
+      if (part.type !== "tool-result" || part.output.type !== "json") return part;
+      return { ...part, output: { ...part.output, value: shareEvidence(part.output.value) } };
+    }) };
+    return message;
+  });
+}
+
+// src/chess-reasoning/opening-source-credits.ts
+var OPENING_SOURCE_LICENSE_URL = "https://creativecommons.org/licenses/by-sa/4.0/";
+function openingSourceLinks(source) {
+  const title = encodeURIComponent(source.title.replaceAll(" ", "_"));
+  return {
+    revision: `https://en.wikibooks.org/w/index.php?title=${title}&oldid=${source.revisionId}`,
+    history: `https://en.wikibooks.org/w/index.php?title=${title}&action=history`
+  };
+}
+function parseOpeningSourceCredits(value) {
+  if (!Array.isArray(value) || value.length > 512) throw Error("Invalid opening sources.");
+  const result = [], seen = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    if (!item || typeof item !== "object" || typeof item.title !== "string" || !item.title.startsWith("Chess Opening Theory/") || item.title.length > 2e3 || /[\u0000-\u001f\u007f]/.test(item.title) || !Number.isSafeInteger(item.revisionId) || item.revisionId <= 0) throw Error("Invalid opening source.");
+    const key2 = item.title + "@" + item.revisionId;
+    if (!seen.has(key2)) {
+      seen.add(key2);
+      result.push({ title: item.title, revisionId: item.revisionId });
+    }
+  }
+  return result;
+}
+var key = (page) => page.title + "@" + page.revisionId;
+function openingSourcesInMessages(messages, known2) {
+  const found = /* @__PURE__ */ new Map();
+  function visit(value, depth) {
+    if (depth > 30 || value == null) return;
+    if (typeof value === "string") {
+      if (!/^[\s]*[\[{]/.test(value)) return;
+      try {
+        visit(JSON.parse(value), depth + 1);
+      } catch {
+      }
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item, depth + 1);
+      return;
+    }
+    if (typeof value !== "object") return;
+    const record2 = value;
+    if (record2.encoding === EVIDENCE_SHARING_VERSION) {
+      try {
+        visit(expandSharedEvidence(record2), depth + 1);
+      } catch {
+      }
+      return;
+    }
+    if (record2.authority === "untrusted-opening-commentary" && Array.isArray(record2.pages)) for (const page of record2.pages) {
+      const original = page && known2.get(key(page));
+      if (original && typeof page.prose === "string" && page.prose.trim() && page.prose === original.prose) {
+        try {
+          const [credit] = parseOpeningSourceCredits([original]);
+          found.set(key(credit), credit);
+        } catch {
+        }
+      }
+    }
+    for (const item of Object.values(record2)) visit(item, depth + 1);
+  }
+  visit(messages, 0);
+  return [...found.values()];
+}
+var openingSourceKey = key;
+
+// src/chess-reasoning/wikibooks-index.ts
+import { Chess as Chess12 } from "chess.js";
+var ROOT = "Chess Opening Theory";
+function openingTitle(moves) {
+  return ROOT + "/" + moves.map((san, ply) => `${Math.floor(ply / 2) + 1}${ply % 2 ? "..." : ". "}${san.replace(/[+#?!]+$/g, "")}`).join("/");
+}
+function decodeWikibooksIndex(data) {
+  if (data.v !== 1 || !data.at || !Array.isArray(data.entries) || data.entries.length > 2e4) throw Error("Invalid opening catalog");
+  const byPath = /* @__PURE__ */ new Map(), byPosition = /* @__PURE__ */ new Map();
+  for (const row of data.entries) {
+    if (row.length < 2 || row.length > 3 || row.some((x) => typeof x !== "string")) throw Error("Invalid opening catalog row");
+    const moves = row[0].split(" "), canonicalTitle = openingTitle(moves);
+    const entry = { title: row[2] ? ROOT + "/" + row[2] : canonicalTitle, canonicalTitle, positionKey: row[1], plies: moves.length };
+    for (const [map, key2] of [[byPath, canonicalTitle], [byPosition, entry.positionKey]]) {
+      const values = map.get(key2) || [];
+      values.push(entry);
+      map.set(key2, values);
+    }
+  }
+  return { at: data.at, byPath, byPosition };
+}
+function positionKey(fen) {
+  return fen.split(" ").slice(0, 4).join(" ");
+}
+function replayWikibooksTitle(title) {
+  if (title === ROOT) return new Chess12().fen();
+  if (!title.startsWith(ROOT + "/")) return null;
+  const board = new Chess12();
+  try {
+    for (const part of title.slice(ROOT.length + 1).replace(/\/$/, "").split("/")) {
+      const tokens = part.trim().replace(/…/g, "...").replace(/^\d+\s*\.+\s*/, "").split(/\s+/);
+      for (const token of tokens) {
+        const moveText = token.replace(/0/g, "O").replace(/[+#?!]+$/g, "");
+        if (!/^[KQRBN]?[a-h]?[1-8]?x?[a-h][1-8](?:=[QRBN])?$|^O-O(?:-O)?$/.test(moveText)) return null;
+        board.move(moveText);
+      }
+    }
+    return board.fen();
+  } catch {
+    return null;
+  }
+}
+function selectIndexedOpening(index, title, maxAncestorPlies = 2, minSourcePlies = 0) {
+  let ancestor = title;
+  for (let distance = 0; distance <= maxAncestorPlies && ancestor !== ROOT; distance++) {
+    const fen = replayWikibooksTitle(ancestor);
+    if (!fen) return null;
+    const key2 = positionKey(fen), exact = index.byPath.get(ancestor) || [];
+    const candidates = [...exact, ...(index.byPosition.get(key2) || []).filter((e) => !exact.includes(e))];
+    for (const entry of candidates) {
+      const actual = replayWikibooksTitle(entry.title);
+      if (entry.plies >= minSourcePlies && entry.positionKey === key2 && actual && positionKey(actual) === key2)
+        return { entry, requestedTitle: title, ancestorPlies: distance, transposition: entry.canonicalTitle !== ancestor };
+    }
+    ancestor = ancestor.slice(0, ancestor.lastIndexOf("/"));
+  }
+  return null;
+}
+
+// src/ai-request-failure.ts
+var known = /* @__PURE__ */ new Set(["insufficient_credits", "invalid_key", "rate_limited", "model_unavailable", "provider_unavailable", "free_unavailable", "free_funds_exhausted", "ai_request_active", "ai_hourly_limit", "ai_admission_busy", "sign_in_required", "forbidden", "connection_changed", "cancelled", "request_too_large", "request_timeout", "network_error", "response_invalid", "unknown_error", "tool_evidence_contract_failed", "output_truncated", "empty_answer", "no_final_answer", "context_byte_budget"]);
+var expected = /* @__PURE__ */ new Set(["insufficient_credits", "invalid_key", "rate_limited", "model_unavailable", "free_unavailable", "free_funds_exhausted", "ai_hourly_limit", "sign_in_required", "forbidden", "connection_changed", "cancelled"]);
+function aiFailureDetails(code, fields = {}) {
+  code = known.has(code) ? code : "unknown_error";
+  return { ...fields, code, stage: fields.stage || "simple-model", reportable: !expected.has(code) };
+}
+function aiFailureMessage(f, reported = false) {
+  const minutes = Math.max(1, Math.ceil((f.retryAfterSeconds ?? 0) / 60));
+  const wait = f.retryAfterSeconds ? ` Please try again in about ${minutes} ${minutes === 1 ? "minute" : "minutes"}.` : " Please wait a moment and try again.";
+  switch (f.code) {
+    case "ai_request_active":
+      return "Your previous AI request is still processing or being released after it stopped." + wait;
+    case "ai_hourly_limit":
+      return "The hourly AI allowance has been reached." + wait;
+    case "rate_limited":
+      return "Your AI provider is temporarily limiting requests." + wait;
+    case "insufficient_credits":
+      return "Your AI account has insufficient credits or reached its spending limit. Add credits or adjust the limit, then try again.";
+    case "invalid_key":
+    case "connection_changed":
+      return "Your AI connection needs attention. Open your profile and reconnect your AI account.";
+    case "sign_in_required":
+      return "Your session has expired. Please sign in again to ask a question.";
+    case "forbidden":
+      return "You cannot ask questions about this game with the current account. Sign in to the owning account or create your own copy.";
+    case "model_unavailable":
+      return "The selected model is unavailable. Check your AI connection in your profile or try again later.";
+    case "free_unavailable":
+    case "free_funds_exhausted":
+      return "Free AI is temporarily unavailable. Connect your own AI account in your profile, or try again later.";
+    case "cancelled":
+      return "The request was cancelled.";
+    case "network_error":
+      return "We could not reach the AI service. Check your internet connection and try again.";
+    case "request_timeout":
+      return "The AI request took too long. Please try again later. The provider may have charged for this attempt.";
+    case "request_too_large":
+    case "context_byte_budget":
+      return "This question and its context are too large to send. Try a shorter question or start a new chat.";
+    default:
+      return reported ? "Something went wrong. We've received an automatic report and will look into it. Please try again." : "Something went wrong. Please try again. You can also report this problem to us.";
+  }
+}
+function failureFromError(error, code = "unknown_error") {
+  const e = error;
+  if (e?.details) return e.details;
+  if (e?.name === "AbortError") return aiFailureDetails("cancelled");
+  return aiFailureDetails(code);
+}
+
+// src/chess-reasoning/conversation-context.ts
+function priorConversationMessages(history = []) {
+  const retained = [];
+  let bytes = 0;
+  for (let i = history.length - 1; i >= 0; i--) {
+    const item = history[i];
+    if (!item || item.role !== "user" && item.role !== "assistant" || typeof item.content !== "string" || !item.content.trim()) continue;
+    const p = item.position;
+    const position = p && typeof p.fenBefore === "string" && typeof p.fenAfter === "string" && typeof p.moveUci === "string" ? { fenBefore: p.fenBefore, fenAfter: p.fenAfter, moveUci: p.moveUci } : void 0;
+    const text = item.content.replace(/\[([^\]\n]+)\]\((?:move|piece|square|line):[^)\n]+\)/g, "$1").replace(/\[(?:\s*evidence:[\w:-]+\s*[,;]?\s*)+\]/g, "");
+    const content = JSON.stringify({ scope: "previous-conversation", position, text });
+    const size = new TextEncoder().encode(content).length;
+    if (bytes + size > 36e3 || retained.length >= 24) break;
+    bytes += size;
+    retained.unshift({ role: item.role, content });
+  }
+  if (retained[0]?.role === "assistant") retained.shift();
+  return retained.length < history.length ? [{ role: "user", content: "[Conversation history truncated: only the most recent complete exchanges that fit are included.]" }, ...retained] : retained;
+}
+
+// src/chess-reasoning/simple-runtime-version.ts
+var SIMPLE_TOOL_AGENT_VERSION = "simple-native-tool-agent/40";
+
+// src/chess-reasoning/simple-agent-config.ts
+var SIMPLE_MODEL_CATALOGUE = [
+  { id: "anthropic/claude-sonnet-5", label: "Claude Sonnet 5" },
+  { id: "anthropic/claude-haiku-4.5", label: "Claude Haiku 4.5" },
+  { id: "google/gemini-3.1-pro-preview", label: "Gemini 3.1 Pro (Preview)" },
+  { id: "google/gemini-3.5-flash-lite", label: "Gemini 3.5 Flash Lite" },
+  { id: "openai/gpt-5.6-terra-pro", label: "Terra 5.6 Pro" },
+  { id: "openai/gpt-5.6-luna-pro", label: "Luna 5.6 Pro" },
+  { id: "openai/gpt-5.6-sol", label: "Sol" },
+  { id: "anthropic/claude-opus-5", label: "Claude Opus 5" },
+  { id: "openai/gpt-5.6-sol-pro", label: "Sol 5.6 Pro" },
+  { id: "openai/gpt-5.6-terra", label: "Terra" },
+  { id: "openai/gpt-5.6-luna", label: "Luna" },
+  { id: "openai/gpt-6-astra", label: "Astra 6 Standard" },
+  { id: "openai/gpt-6-astra-pro", label: "Astra 6 Pro" },
+  { id: "anthropic/claude-fable-5.1", label: "Claude Fable 5.1" },
+  { id: "google/gemini-3.8-flash", label: "Gemini 3.8 Flash" },
+  { id: "x-ai/grok-4.6", label: "Grok 4.6" },
+  { id: "moonshotai/kimi-k3", label: "Kimi K3" },
+  { id: "z-ai/glm-5.3", label: "GLM 5.3" },
+  { id: "qwen/qwen3.8-max-0902", label: "Qwen3.8 Max 0902" }
+];
+var SIMPLE_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+var EVALUATED_ASTRA_CONFIG = { modelId: "openai/gpt-6-astra", effort: "medium" };
+var DEFAULT_SIMPLE_CONFIG = { ...EVALUATED_ASTRA_CONFIG };
+function simpleEffortsForModel(modelId) {
+  if (!SIMPLE_MODEL_CATALOGUE.some((m) => m.id === modelId)) return [];
+  if (modelId.startsWith("google/") || modelId === "anthropic/claude-haiku-4.5") return ["low", "medium", "high"];
+  if (modelId === "x-ai/grok-4.6" || modelId === "qwen/qwen3.8-max-0902") return ["low", "medium", "high", "xhigh"];
+  if (modelId === "moonshotai/kimi-k3" || modelId === "z-ai/glm-5.3") return ["low", "high", "max"];
+  return SIMPLE_EFFORTS;
+}
+function selectSimpleModel(current, modelId) {
+  const efforts = simpleEffortsForModel(modelId);
+  return validateSimpleAgentConfig({ modelId, effort: efforts.includes(current.effort) ? current.effort : efforts.includes("medium") ? "medium" : "high" });
+}
+function validateSimpleAgentConfig(config) {
+  if (!simpleEffortsForModel(config.modelId).includes(config.effort)) throw new Error("Unsupported simple-agent model/effort");
+  return config;
+}
+var SIMPLE_EXTENSION_CONFIGS = [
+  { modelId: "openai/gpt-5.6-sol-pro", effort: "medium" },
+  { modelId: "openai/gpt-5.6-terra", effort: "xhigh" },
+  { modelId: "openai/gpt-5.6-luna", effort: "max" },
+  { modelId: "openai/gpt-6-astra-pro", effort: "medium" },
+  { modelId: "anthropic/claude-fable-5.1", effort: "medium" }
+];
+var SIMPLE_VENDOR_CONFIGS = [
+  { modelId: "google/gemini-3.8-flash", effort: "medium" },
+  { modelId: "x-ai/grok-4.6", effort: "medium" },
+  { modelId: "moonshotai/kimi-k3", effort: "high" },
+  { modelId: "z-ai/glm-5.3", effort: "high" },
+  { modelId: "qwen/qwen3.8-max-0902", effort: "medium" }
+];
+
+export {
+  QUESTION_ROUTING_VERSION,
+  REVIEW_SUBJECTS,
+  makeQuestionRoutingRequest,
+  parseQuestionRoutingAnswers,
+  moveSectionScope,
+  classifyReviewSubject,
+  classifyQuestionRoutingAnswers,
+  hasMoveClassificationQuestion,
+  classificationTargetAtSelection,
+  savedScorePresentation,
+  materialAtPosition,
+  materialAlongLine,
+  materialForVariations,
+  CHESS_REASONING_SCHEMA_VERSION,
+  CHESS_REASONING_POLICY_VERSION,
+  createIdentityState,
+  forkIdentityState,
+  applyIdentityMove,
+  createPocIdentityTimeline,
+  pieceIdAt,
+  squareForPiece,
+  pieceIdentity,
+  canonicalPieceLabel,
+  moveMechanismFacts,
+  EVIDENCE_LICENSE,
+  evidenceLicenseInput,
+  maximumEvidenceLicenses,
+  validateEvidenceLicenseClaims,
+  effectiveEvidenceLicenses,
+  effectiveLicensesForRecord,
+  withEvidenceLicenses,
+  licensesSemanticChessGrounding,
+  licensesBoundedRouteRelevance,
+  stableHash,
+  stableJson,
+  REASONING_POC_VERSION,
+  REASONING_POC_MAX_OUTPUT_TOKENS,
+  REASONING_POC_MAX_HYPOTHESIS_OUTPUT_TOKENS,
+  REASONING_POC_MAX_CRITIC_OUTPUT_TOKENS,
+  REASONING_POC_MAX_TERMINAL_REVIEW_OUTPUT_TOKENS,
+  REASONING_POC_MAX_RESOLUTION_AUDIT_OUTPUT_TOKENS,
+  REASONING_POC_MAX_PURPOSE_PROBE_OUTPUT_TOKENS,
+  REASONING_POC_MAX_GRAPH_SELECTION_OUTPUT_TOKENS,
+  REASONING_POC_MAX_DISCOURSE_OUTPUT_TOKENS,
+  REASONING_POC_MAX_RENDER_OUTPUT_TOKENS,
+  REASONING_POC_MAX_HYPOTHESIS_BATCHES,
+  REASONING_POC_RESERVED_MANDATORY_STEPS,
+  REASONING_POC_REVISION_EVIDENCE_ALLOWANCE,
+  REASONING_POC_PURPOSE_PROBE_ALLOWANCE,
+  REASONING_POC_CRITIC_CORRECTION_ALLOWANCE,
+  DEFAULT_REASONING_RUN_CONTROLS,
+  REASONING_DISCOURSE_PLAN_VERSION,
+  ModelRuntimeFailure,
+  validateReasoningPositionContext,
+  reasoningContextHash,
+  createQueryContract,
+  createContextEvidence,
+  recordedMainLineResult,
+  MAX_INTERACTIVE_LINE_PLIES,
+  reasoningEvidenceReplayStartPhase,
+  collectReasoningMoveWitnesses,
+  scopePositionAnalysis,
+  toPositionAnalysis,
+  toLegacyPositionAnalysis,
+  toLegacyPositionAnalysisProvider,
+  toPositionAnalysisProvider,
+  historyPositionContext,
+  recordedEvidenceContext,
+  recordedNavigation,
+  recordedDetailsMatch,
+  historicalProseRoots,
+  normalizedEvidenceCitations,
+  MAX_FRESH_ENGINE_WITNESS_ACQUISITIONS,
+  admitFreshEnginePvWitnesses,
+  SIMPLE_REFERENCE_VERSION,
+  safeSimpleSourceLink,
+  stripSimpleMarkdownFences,
+  stripSimpleCitationLinks,
+  repairFrozenCitationLabels,
+  simpleProseReferences,
+  decorateSimpleVariations,
+  AI_MODEL_CONTEXT_MAX_BYTES,
+  AI_RELAY_MAX_REQUEST_BYTES,
+  AI_ROUTING_HEADER,
+  readAiRoutingDiagnostics,
+  EVIDENCE_SHARING_VERSION,
+  EVIDENCE_SHARING_INSTRUCTIONS,
+  EVIDENCE_SHARING_GUIDANCE_CHARS,
+  shareEvidence,
+  hasSharedEvidence,
+  expandSharedEvidence,
+  shareEvidenceMessages,
+  OPENING_SOURCE_LICENSE_URL,
+  openingSourceLinks,
+  parseOpeningSourceCredits,
+  openingSourcesInMessages,
+  openingSourceKey,
+  openingTitle,
+  decodeWikibooksIndex,
+  positionKey,
+  replayWikibooksTitle,
+  selectIndexedOpening,
+  aiFailureDetails,
+  aiFailureMessage,
+  failureFromError,
+  priorConversationMessages,
+  SIMPLE_TOOL_AGENT_VERSION,
+  SIMPLE_MODEL_CATALOGUE,
+  EVALUATED_ASTRA_CONFIG,
+  simpleEffortsForModel,
+  selectSimpleModel,
+  validateSimpleAgentConfig,
+  SIMPLE_EXTENSION_CONFIGS,
+  SIMPLE_VENDOR_CONFIGS
+};