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

package/dist/owner-tests/preparation-consolidation.test.mjs

@@ -0,0 +1,1052 @@
+// test/owner/preparation-consolidation.test.mjs
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// src/chess-reasoning/mechanism-presentation.ts
+var object = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var COLUMNS = {
+  mover: ["pieceId", "pieceIdAfter", "fromSquare", "toSquare", "color", "pieceTypeBefore", "pieceTypeAfter", "attackersBefore", "attackersAfter"],
+  unmoved: ["pieceId", "square", "pieceType", "attackersBefore", "attackersAfter"],
+  rays: ["pieceId", "fromSquare", "color", "pieceType", "direction", "gainedSquares", "lostSquares"],
+  control: ["square", "color", "attackersBefore", "attackersAfter"]
+};
+function exactKeys(value, columns) {
+  return object(value) && Object.keys(value).length === columns.length && columns.every((column) => Object.hasOwn(value, column));
+}
+function encodeRows(value, columns) {
+  return columns.map((column) => value[column]);
+}
+function compactMechanism(value, targetSquares) {
+  if (!object(value) || !Array.isArray(value.controlDelta)) return value;
+  const targets = [...new Set(targetSquares)].filter((s) => /^[a-h][1-8]$/.test(s));
+  const controlDelta = value.controlDelta.filter((d) => object(d) && targets.includes(String(d.square)));
+  const rays = Array.isArray(value.stationarySliderRays) ? value.stationarySliderRays.map((ray) => {
+    if (!object(ray)) return ray;
+    const { beforeSquares: _before, afterSquares: _after, ...changes } = ray;
+    void _before;
+    void _after;
+    return changes;
+  }) : value.stationarySliderRays;
+  const projected = {
+    ...value,
+    stationarySliderRays: rays,
+    controlDelta,
+    presentation: {
+      controlSquares: targets,
+      omittedControlDeltaCount: value.controlDelta.length - controlDelta.length,
+      scope: "All changed stationary rays and mover/unmoved attack measurements retained. Control deltas shown only for controlSquares; an omitted square is not checked-negative in this view. Full ray extents and all control deltas are retrievable."
+    }
+  };
+  if (!exactKeys(value, ["mover", "attackedUnmovedFriendlyPieces", "stationarySliderRays", "controlDelta", "checksRun", "scope"]) || !exactKeys(projected.mover, COLUMNS.mover) || !Array.isArray(projected.attackedUnmovedFriendlyPieces) || !projected.attackedUnmovedFriendlyPieces.every((item) => exactKeys(item, COLUMNS.unmoved)) || !Array.isArray(rays) || !rays.every((item) => exactKeys(item, COLUMNS.rays)) || !controlDelta.every((item) => exactKeys(item, COLUMNS.control))) return projected;
+  return {
+    encoding: "move-mechanism/1",
+    columns: COLUMNS,
+    rows: {
+      mover: encodeRows(projected.mover, COLUMNS.mover),
+      unmoved: projected.attackedUnmovedFriendlyPieces.map((item) => encodeRows(item, COLUMNS.unmoved)),
+      rays: rays.map((item) => encodeRows(item, COLUMNS.rays)),
+      control: controlDelta.map((item) => encodeRows(item, COLUMNS.control))
+    },
+    checksRun: projected.checksRun,
+    scope: projected.scope,
+    presentation: projected.presentation
+  };
+}
+function presentMoveMechanisms(moves, inspectPlies = [], inspectSquares = []) {
+  return moves.flatMap((fact, index) => {
+    if (!object(fact) || !object(fact.mechanism)) return [];
+    if (index >= 2 && !inspectPlies.includes(index + 1) && !inspectSquares.includes(String(fact.to))) return [];
+    const targets = [...inspectSquares, ...moves.slice(index, index + 3).flatMap((m) => object(m) && typeof m.to === "string" ? [m.to] : [])];
+    return [{ ply: index + 1, uci: fact.uci, san: fact.san, mechanism: compactMechanism(fact.mechanism, targets) }];
+  });
+}
+
+// src/chess-reasoning/compact-search-preparation.ts
+import { Chess as Chess9 } from "chess.js";
+
+// src/chess-reasoning/simple-engine-presentation.ts
+import { Chess } from "chess.js";
+var object2 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function projectEnginePresentation(value, fullGeometry = false) {
+  const visit = (v) => {
+    if (Array.isArray(v)) return v.map(visit);
+    if (!object2(v)) return v;
+    if (typeof v.id !== "string" || !object2(v.data)) {
+      return Object.fromEntries(Object.entries(v).map(([k, child]) => [k, visit(child)]));
+    }
+    const nested = object2(v.data.details) && (Array.isArray(v.data.details.lines) || Array.isArray(v.data.details.moveFacts));
+    const d = nested ? v.data.details : v.data;
+    if (Object.hasOwn(d, "modelPresentation")) return v;
+    if (object2(d.selectedMoveMechanism) && Array.isArray(d.selectedMoveMechanism.controlDelta) && !fullGeometry) {
+      const squares = d.selectedMoveMechanism.controlDelta.flatMap((delta) => object2(delta) && typeof delta.square === "string" ? [delta.square] : []);
+      const projected2 = { ...d, selectedMoveMechanism: compactMechanism(d.selectedMoveMechanism, squares) };
+      return { ...v, data: nested ? { ...v.data, details: projected2 } : projected2 };
+    }
+    if (Array.isArray(d.moveFacts) && !fullGeometry) {
+      const inspection = object2(d.mechanismInspection) ? d.mechanismInspection : {};
+      const { moveFacts, ...rest } = d;
+      const projected2 = {
+        ...rest,
+        mechanismFacts: presentMoveMechanisms(
+          moveFacts,
+          Array.isArray(inspection.inspectPlies) ? inspection.inspectPlies : [],
+          Array.isArray(inspection.inspectSquares) ? inspection.inspectSquares : []
+        ),
+        modelPresentation: {
+          mechanismThroughPly: 2,
+          explicitInspection: inspection,
+          retrieveFullEvidenceId: v.id,
+          geometryNotice: "Mechanisms shown for first two plies, explicit inspectPlies and moves landing on inspectSquares. Other plies omitted, not absent; retrieve full evidence for all replayed move facts."
+        }
+      };
+      return { ...v, data: nested ? { ...v.data, details: projected2 } : projected2 };
+    }
+    if (!Array.isArray(d.lines)) return v;
+    const rootFen = object2(d.searchScope) && typeof d.searchScope.fen === "string" ? d.searchScope.fen : void 0;
+    let omittedGeometry = 0, omittedRaw = false, referencedFen = false;
+    const lines = d.lines.map((line) => {
+      if (!object2(line) || !Array.isArray(line.pv)) return line;
+      const next = { ...line };
+      if (!Object.hasOwn(line, "rawPvSameAsPv") && Array.isArray(line.rawPv) && JSON.stringify(line.rawPv) === JSON.stringify(line.pv)) {
+        delete next.rawPv;
+        next.rawPvSameAsPv = true;
+        omittedRaw = true;
+      }
+      if (rootFen && object2(line.pvCompletion) && Array.isArray(line.pvCompletion.segments)) {
+        const fens = [];
+        try {
+          const chess = new Chess(rootFen);
+          fens.push(chess.fen());
+          for (const move of line.pv) {
+            if (typeof move !== "string" || !/^[a-h][1-8][a-h][1-8][qrbn]?$/.test(move)) break;
+            chess.move({ from: move.slice(0, 2), to: move.slice(2, 4), promotion: move.slice(4) || void 0 });
+            fens.push(chess.fen());
+          }
+        } catch {
+        }
+        next.pvCompletion = { ...line.pvCompletion, segments: line.pvCompletion.segments.map((segment) => {
+          if (!object2(segment) || !Number.isInteger(segment.startPly) || segment.startPly < 0 || typeof segment.fen !== "string" || fens[segment.startPly] !== segment.fen || Object.hasOwn(segment, "fenFromLinePvPly")) return segment;
+          const { fen: _fen, ...rest } = segment;
+          void _fen;
+          referencedFen = true;
+          return { ...rest, fenFromLinePvPly: segment.startPly };
+        }) };
+      }
+      return next;
+    });
+    const continuations = !fullGeometry && Array.isArray(d.continuationMoveFacts) ? d.continuationMoveFacts.map((c) => {
+      if (!object2(c) || !Array.isArray(c.moves)) return c;
+      const compact = presentMoveMechanisms(c.moves);
+      return { ...c, moves: c.moves.map((m, i) => {
+        if (!object2(m)) return m;
+        const next = { ...m };
+        if (i >= 2 && Object.hasOwn(next, "captureGeometry")) {
+          delete next.captureGeometry;
+          omittedGeometry++;
+        }
+        if (Object.hasOwn(next, "mechanism")) {
+          const delivered = compact.find((f) => object2(f) && f.ply === i + 1);
+          if (object2(delivered)) next.mechanism = delivered.mechanism;
+          else {
+            delete next.mechanism;
+            omittedGeometry++;
+          }
+        }
+        return next;
+      }) };
+    }) : d.continuationMoveFacts;
+    const roots = !fullGeometry && Array.isArray(d.rootMoveFacts) ? d.rootMoveFacts.map((f) => !object2(f) || !f.mechanism ? f : { ...f, mechanism: compactMechanism(f.mechanism, [String(f.to)]) }) : d.rootMoveFacts;
+    if (!omittedGeometry && !omittedRaw && !referencedFen && !Array.isArray(d.rootMoveFacts)) return v;
+    const projected = {
+      ...d,
+      lines,
+      ...roots !== void 0 ? { rootMoveFacts: roots } : {},
+      ...d.continuationMoveFacts !== void 0 ? { continuationMoveFacts: continuations } : {},
+      modelPresentation: {
+        ...omittedGeometry ? {
+          captureGeometryThroughPly: 2,
+          omittedCaptureGeometry: omittedGeometry,
+          retrieveFullEvidenceId: v.id,
+          geometryNotice: "Deeper capture and mechanism geometry omitted, not absent. Retrieve this evidence ID for full geometry; basic move and capture facts remain complete."
+        } : {},
+        ...referencedFen ? { segmentFenReference: "fenFromLinePvPly=N is the exact position after N moves of this line.pv, legally replayed from this engine result\u2019s searchScope.fen. Segment scores, depth and search provenance still apply only to that segment." } : {}
+      }
+    };
+    return { ...v, data: nested ? { ...v.data, details: projected } : projected };
+  };
+  return visit(value);
+}
+
+// src/chess-reasoning/material-format.ts
+var DEFAULT_MATERIAL_FORMAT = "hybrid";
+var order = ["pawn", "knight", "bishop", "rook", "queen"];
+var obj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var keys = (v, expected) => Object.keys(v).every((k) => expected.includes(k));
+var counts = (v) => obj(v) && keys(v, [...order]) && order.every((k) => Number.isInteger(v[k]));
+var snapshot = (v) => obj(v) && keys(v, ["white", "black", "whiteMinusBlack", "balance"]) && counts(v.white) && counts(v.black) && counts(v.whiteMinusBlack) && typeof v.balance === "string";
+var row = (v) => order.map((k) => v[k]);
+var inventory = (v) => order.map((k) => `${v[k]} ${k}${v[k] === 1 ? "" : "s"}`).join(", ");
+var textSnapshot = (v) => `White: ${inventory(v.white)}. Black: ${inventory(v.black)}. ${v.balance}`;
+var hybridSnapshot = (v) => ({ white: row(v.white), black: row(v.black), balance: v.balance });
+function formattedMaterial(v, format) {
+  if (snapshot(v)) return format === "text" ? { encoding: "material-text/1", position: textSnapshot(v) } : { encoding: "material-table/1", pieceOrder: order.join(" "), ...hybridSnapshot(v) };
+  if (!obj(v) || v.authority !== "legal-replay-piece-counts" || !keys(v, ["authority", "startFen", "plies", "start", "changes", "endFen", "end", "balanceChangeFromStart", "scope"]) || typeof v.startFen !== "string" || typeof v.endFen !== "string" || !Number.isInteger(v.plies) || !snapshot(v.start) || !snapshot(v.end) || !counts(v.balanceChangeFromStart) || typeof v.scope !== "string" || !Array.isArray(v.changes) || v.changes.some((c) => !obj(c) || !keys(c, ["ply", "san", "whiteMinusBlack", "balance"]) || !Number.isInteger(c.ply) || typeof c.san !== "string" || !counts(c.whiteMinusBlack) || typeof c.balance !== "string")) return v;
+  const balanceChangeFromStart = v.balanceChangeFromStart;
+  const shared = { authority: v.authority, startFen: v.startFen, plies: v.plies, endFen: v.endFen, scope: v.scope };
+  if (format === "hybrid") return {
+    encoding: "material-table/1",
+    ...shared,
+    pieceOrder: order.join(" "),
+    start: hybridSnapshot(v.start),
+    checkpointColumns: "ply san pawn knight bishop rook queen; absolute White minus Black",
+    checkpoints: v.changes.map((c) => [c.ply, c.san, ...row(c.whiteMinusBlack)]),
+    end: hybridSnapshot(v.end),
+    balanceChangeFromStart: row(v.balanceChangeFromStart)
+  };
+  return {
+    encoding: "material-text/1",
+    ...shared,
+    convention: "Balances list all differences; unmentioned piece types have equal counts.",
+    start: textSnapshot(v.start),
+    checkpoints: Object.fromEntries(v.changes.map((c) => [`After ply ${c.ply} (${c.san})`, c.balance])),
+    end: textSnapshot(v.end),
+    balanceChangeFromStart: `Change only, White minus Black: ${order.map((k) => `${k} ${balanceChangeFromStart[k] >= 0 ? "+" : ""}${balanceChangeFromStart[k]}`).join(", ")}.`
+  };
+}
+function projectMaterial(value, format = DEFAULT_MATERIAL_FORMAT) {
+  if (!["raw", "hybrid", "text"].includes(format)) throw Error("invalid-material-format");
+  if (format === "raw") return value;
+  const visit = (v) => Array.isArray(v) ? v.map(visit) : obj(v) ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, k === "material" ? formattedMaterial(x, format) : visit(x)])) : v;
+  return visit(value);
+}
+
+// src/chess-reasoning/material-accounting.ts
+import { Chess as Chess2 } from "chess.js";
+
+// src/chess-reasoning/simple-evidence-view.ts
+import { Chess as Chess8 } from "chess.js";
+
+// src/chess-reasoning/poc-contracts.ts
+import { Chess as Chess6 } from "chess.js";
+
+// src/chess-reasoning/poc-piece-refs.ts
+import { Chess as Chess4, SQUARES as SQUARES2 } from "chess.js";
+
+// src/chess-reasoning/piece-identities.ts
+import { Chess as Chess3, SQUARES } from "chess.js";
+
+// src/chess-reasoning/move-mechanism-facts.ts
+import { Chess as Chess5, SQUARES as SQUARES3 } from "chess.js";
+
+// 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));
+
+// src/chess-reasoning/poc-contracts.ts
+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
+});
+
+// src/chess-reasoning/ablation-adaptive-evidence-loop.ts
+import { Output, generateText, jsonSchema } from "ai";
+
+// src/chess-reasoning/concept-registry.ts
+var ENTITY_TYPES = {
+  IDEA: "idea",
+  PLAN: "plan",
+  ROLE: "role-assignment",
+  CONDITION: "condition",
+  TRANSFORMATION: "transformation",
+  OUTCOME: "outcome"
+};
+var PARTICIPANT_ROLES = {
+  ACTOR: "actor",
+  SUBJECT: "subject",
+  TARGET: "target",
+  GOAL: "goal",
+  RESOURCE: "resource",
+  DEFENDER: "defender",
+  DESTINATION: "destination"
+};
+var CONCEPT_KEYS = {
+  OFFER: "material.offer",
+  MATERIAL_CLAIM: "material.claim",
+  FORK: "tactic.fork",
+  TRAPPED_TARGET: "tactic.trapped-target",
+  PROMOTION: "tactic.promotion",
+  MATING_ATTACK: "attack.mating",
+  PERPETUAL_CHECK: "attack.perpetual-check",
+  POSITIONAL_CLAIM: "position.claim",
+  KING_ATTACK_PLAN: "plan.king-attack",
+  PIECE_ROLE: "role.piece-function",
+  CHANGED_CONSTRAINT: "condition.changed-constraint",
+  POSITIONAL_TRANSFORMATION: "position.transformation"
+};
+var COMMON_TERMINAL_STATES = ["converted", "refuted", "abandoned", "expired"];
+function claimLifecycle(capturedBy) {
+  return {
+    initialState: "created",
+    retainedState: "retained",
+    terminalStates: [...COMMON_TERMINAL_STATES],
+    trackedParticipantRole: PARTICIPANT_ROLES.TARGET,
+    expireWhenTrackedUnavailable: true,
+    onTrackedCapture: {
+      capturedBy,
+      matchingState: "converted",
+      matchingAnnotation: "converted",
+      otherState: "refuted",
+      otherAnnotation: "refuted"
+    }
+  };
+}
+function createConceptRegistry(definitions) {
+  const registry = {};
+  for (const definition of definitions) {
+    if (!definition.key.trim()) throw new Error("Concept keys must not be empty");
+    if (registry[definition.key]) throw new Error(`Duplicate concept key: ${definition.key}`);
+    registry[definition.key] = Object.freeze({
+      ...definition,
+      lifecycle: definition.lifecycle ? Object.freeze({
+        ...definition.lifecycle,
+        terminalStates: Object.freeze([...definition.lifecycle.terminalStates]),
+        onTrackedCapture: definition.lifecycle.onTrackedCapture ? Object.freeze({ ...definition.lifecycle.onTrackedCapture }) : void 0
+      }) : void 0
+    });
+  }
+  return Object.freeze(registry);
+}
+var DEFAULT_CONCEPT_REGISTRY = createConceptRegistry([
+  {
+    key: CONCEPT_KEYS.OFFER,
+    label: "Material offer",
+    category: "tactical",
+    description: "A material liability the opponent may choose to accept.",
+    defaultEntityType: ENTITY_TYPES.IDEA,
+    acceptancePolicy: "material-offer-liability/1",
+    lifecycle: claimLifecycle("opponent")
+  },
+  {
+    key: CONCEPT_KEYS.MATERIAL_CLAIM,
+    label: "Material claim",
+    category: "tactical",
+    description: "An evidence-backed entitlement to win material.",
+    defaultEntityType: ENTITY_TYPES.IDEA,
+    lifecycle: claimLifecycle("owner")
+  },
+  {
+    key: CONCEPT_KEYS.FORK,
+    label: "Fork",
+    category: "tactical",
+    description: "One resource attacks multiple targets.",
+    defaultEntityType: ENTITY_TYPES.IDEA,
+    lifecycle: claimLifecycle("owner")
+  },
+  {
+    key: CONCEPT_KEYS.TRAPPED_TARGET,
+    label: "Trapped target",
+    category: "tactical",
+    description: "A target lacks an adequate escape or defensive resource.",
+    defaultEntityType: ENTITY_TYPES.IDEA,
+    lifecycle: claimLifecycle("owner")
+  },
+  {
+    key: CONCEPT_KEYS.PROMOTION,
+    label: "Promotion",
+    category: "tactical",
+    description: "A promotion event or promotion claim.",
+    defaultEntityType: ENTITY_TYPES.IDEA
+  },
+  {
+    key: CONCEPT_KEYS.MATING_ATTACK,
+    label: "Mating attack",
+    category: "tactical",
+    description: "A coordinated plan whose concrete target is mate.",
+    defaultEntityType: ENTITY_TYPES.PLAN
+  },
+  {
+    key: CONCEPT_KEYS.PERPETUAL_CHECK,
+    label: "Perpetual check",
+    category: "tactical",
+    description: "A claim to a repeatable checking sequence.",
+    defaultEntityType: ENTITY_TYPES.IDEA
+  },
+  {
+    key: CONCEPT_KEYS.POSITIONAL_CLAIM,
+    label: "Positional claim",
+    category: "positional",
+    description: "A measured, evidence-bounded positional interpretation.",
+    defaultEntityType: ENTITY_TYPES.IDEA
+  },
+  {
+    key: CONCEPT_KEYS.KING_ATTACK_PLAN,
+    label: "King attack plan",
+    category: "plan",
+    description: "A goal-directed sequence intended to attack the king.",
+    defaultEntityType: ENTITY_TYPES.PLAN
+  },
+  {
+    key: CONCEPT_KEYS.PIECE_ROLE,
+    label: "Piece role",
+    category: "role",
+    description: "A context-dependent function performed by a piece.",
+    defaultEntityType: ENTITY_TYPES.ROLE
+  },
+  {
+    key: CONCEPT_KEYS.CHANGED_CONSTRAINT,
+    label: "Changed constraint",
+    category: "condition",
+    description: "A condition whose importance changed after a move or sequence.",
+    defaultEntityType: ENTITY_TYPES.CONDITION
+  },
+  {
+    key: CONCEPT_KEYS.POSITIONAL_TRANSFORMATION,
+    label: "Positional transformation",
+    category: "transformation",
+    description: "A causal change in the meaning of a positional feature.",
+    defaultEntityType: ENTITY_TYPES.TRANSFORMATION
+  }
+]);
+
+// src/chess-reasoning/poc-move-witnesses.ts
+import { Chess as Chess7 } from "chess.js";
+
+// src/chess-reasoning/ablation-evidence-bundle.ts
+import { SQUARES as SQUARES4 } from "chess.js";
+var PRECOMMITTED_PROBE_ATTRIBUTION_CATEGORIES = Object.freeze([
+  "fact-unavailable",
+  "fact-available-not-presented",
+  "fact-presented-ignored",
+  "fact-recognized-not-probed",
+  "hypothesis-formed-later-discarded",
+  "correct-graph-poor-rendering",
+  "unsupported-claim-admitted",
+  "safe-fail-closed-termination"
+]);
+
+// src/chess-reasoning/ai-sdk-runtime-support.ts
+import { NoOutputGeneratedError, RetryError } from "ai";
+import { APICallError, EmptyResponseBodyError, NoContentGeneratedError } from "@ai-sdk/provider";
+var encoder = new TextEncoder();
+var OBSERVABLE_TRACE_EXCLUSIONS = Object.freeze([
+  "provider credentials and authorization headers",
+  "raw HTTP request and response bodies",
+  "hidden chain-of-thought and provider reasoning details"
+]);
+
+// src/chess-reasoning/ablation-adaptive-evidence-loop.ts
+var ABLATION_ADAPTIVE_EVIDENCE_LOOP_VERSION = "architecture-ablation-adaptive-evidence-loop/2";
+var ADAPTIVE_EVIDENCE_DECISION_SCHEMA = Object.freeze({
+  type: "object",
+  additionalProperties: false,
+  required: ["schemaVersion", "decision"],
+  properties: {
+    schemaVersion: { const: ABLATION_ADAPTIVE_EVIDENCE_LOOP_VERSION },
+    decision: {
+      oneOf: [
+        {
+          type: "object",
+          additionalProperties: false,
+          required: ["type", "tool", "input", "selectionRationale", "modelStatedRationale"],
+          properties: {
+            type: { const: "tool" },
+            tool: { type: "string", minLength: 1, maxLength: 120 },
+            input: { type: "object" },
+            selectionRationale: { type: "string", minLength: 1, maxLength: 1e3 },
+            modelStatedRationale: { type: "string", minLength: 1, maxLength: 1e3 }
+          }
+        },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: ["type", "rationale", "modelStatedRationale"],
+          properties: {
+            type: { const: "finish" },
+            rationale: { type: "string", minLength: 1, maxLength: 1e3 },
+            modelStatedRationale: { type: "string", minLength: 1, maxLength: 1e3 }
+          }
+        }
+      ]
+    }
+  }
+});
+
+// src/chess-reasoning/simple-compact-evidence.ts
+var COMPACT_ENGINE_VERSION = "simple-engine-evidence/1";
+var object3 = (x) => !!x && typeof x === "object" && !Array.isArray(x);
+var uci = /^[a-h][1-8][a-h][1-8][qrbn]?$/;
+function projectCompactEngineEvidence(value) {
+  const pieces = {}, pieceIds = /* @__PURE__ */ new Map();
+  let changed = false;
+  const visit = (x) => {
+    if (Array.isArray(x)) {
+      const entries = x.map(visit);
+      if (entries.length >= 3 && entries.every(object3)) {
+        const columns = Object.keys(entries[0]);
+        if (columns.length >= 2 && entries.every((e) => JSON.stringify(Object.keys(e)) === JSON.stringify(columns) && columns.every((k) => e[k] !== void 0))) {
+          const table = { $table: { columns, rows: entries.map((e) => columns.map((k) => e[k])) } };
+          if (JSON.stringify(table).length < JSON.stringify(entries).length) {
+            changed = true;
+            return table;
+          }
+        }
+      }
+      return entries;
+    }
+    if (!object3(x)) return x;
+    if (typeof x.pieceId === "string" && typeof x.square === "string" && typeof x.color === "string" && typeof x.pieceType === "string") {
+      const { square, ...identity } = x;
+      const key = JSON.stringify(identity);
+      let id = pieceIds.get(key);
+      if (!id) {
+        id = `p${pieceIds.size}`;
+        pieceIds.set(key, id);
+        pieces[id] = identity;
+      }
+      changed = true;
+      return { $piece: id, square };
+    }
+    if (typeof x.uci === "string" && uci.test(x.uci) && typeof x.san === "string" && x.mover && x.from === x.uci.slice(0, 2) && x.to === x.uci.slice(2, 4) && x.capture !== void 0 && x.captureGeometry !== null && x.promotion === (x.uci.slice(4) || null) && x.givesCheck === /[+#]$/.test(x.san)) {
+      const { uci: move, san, mover, capture, captureGeometry, from: _from, to: _to, promotion: _promotion, givesCheck: _check, ...extra } = x;
+      void _from;
+      void _to;
+      void _promotion;
+      void _check;
+      const row2 = [move, san, visit(mover), visit(capture)];
+      if (captureGeometry !== void 0 || Object.keys(extra).length) row2.push(visit(captureGeometry ?? null));
+      if (Object.keys(extra).length) row2.push(visit(extra));
+      while (row2.length > 3 && row2.at(-1) === null) row2.pop();
+      changed = true;
+      return { $move: row2 };
+    }
+    return Object.fromEntries(Object.entries(x).map(([k, v]) => [k, visit(v)]));
+  };
+  const reserved = (x) => Array.isArray(x) ? x.some(reserved) : object3(x) ? Object.keys(x).some((k) => ["$piece", "$move", "$table"].includes(k)) || Object.values(x).some(reserved) : false;
+  if (reserved(value)) return value;
+  const content = visit(value);
+  return changed ? { encoding: COMPACT_ENGINE_VERSION, pieces, content } : value;
+}
+
+// src/chess-reasoning/simple-evidence-view.ts
+function compactSimpleEngineResult(value, format = DEFAULT_MATERIAL_FORMAT, fullGeometry = false) {
+  value = projectMaterial(projectEnginePresentation(value, fullGeometry), format);
+  const baseline = compactSimpleToolResult(value);
+  const candidate = compactSimpleToolResult(projectCompactEngineEvidence(value));
+  return JSON.stringify(candidate).length < JSON.stringify(baseline).length ? candidate : baseline;
+}
+function compactSimpleToolResult(value) {
+  const counts2 = /* @__PURE__ */ new Map();
+  let reservedKeyPresent = false;
+  const visit = (item, replace) => {
+    if (!item || typeof item !== "object") return item;
+    const encoded = JSON.stringify(item);
+    if (Object.hasOwn(item, "$metadata")) reservedKeyPresent = true;
+    if (encoded.length >= 80) {
+      if (!replace) counts2.set(encoded, (counts2.get(encoded) || 0) + 1);
+      else if ((counts2.get(encoded) || 0) > 1) {
+        let id = ids.get(encoded);
+        if (!id) {
+          id = `m${ids.size}`;
+          ids.set(encoded, id);
+          metadata[id] = item;
+        }
+        return { $metadata: id };
+      }
+    }
+    return Array.isArray(item) ? item.map((entry2) => visit(entry2, replace)) : Object.fromEntries(Object.entries(item).map(([childKey, entry2]) => [childKey, visit(entry2, replace)]));
+  };
+  const ids = /* @__PURE__ */ new Map(), metadata = {};
+  visit(value, false);
+  if (reservedKeyPresent) return value;
+  const content = visit(value, true);
+  const compact = { metadata, content };
+  return ids.size && JSON.stringify(compact).length < JSON.stringify(value).length ? compact : value;
+}
+
+// src/chess-reasoning/compact-search-preparation.ts
+var object4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var known = (value, keys2) => Object.keys(value).every((key) => keys2.includes(key));
+var detailsKeys = [
+  "phase",
+  "rootMoves",
+  "rootSelection",
+  "bestMove",
+  "engine",
+  "engineBuild",
+  "searchScope",
+  "rootMoveFacts",
+  "continuationMoveFacts",
+  "lines",
+  "minimumPvPlies",
+  "requestedPvCoverage",
+  "authority",
+  "branchExpansion"
+];
+var lineKeys = [
+  "multipv",
+  "rootMove",
+  "pv",
+  "depth",
+  "nodes",
+  "scoreCp",
+  "matePly",
+  "scoreScope",
+  "scoreProvenance",
+  "rawPv",
+  "pvCompletion",
+  "material"
+];
+var completionKeys = ["requestedPlies", "actualPlies", "status", "conditional", "segments"];
+var segmentKeys = [
+  "fen",
+  "startPly",
+  "depth",
+  "pv",
+  "scoreCp",
+  "matePly",
+  "scoreScope",
+  "scoreProvenance",
+  "command",
+  "engine",
+  "engineBuild",
+  "cacheProvenance"
+];
+function compactSearchRecord(record2, playedMove) {
+  const data = record2.data;
+  if (!known(data, ["recordedPosition", "details"]) || !object4(data.recordedPosition) || !object4(data.details)) return null;
+  const recordedPosition = data.recordedPosition;
+  const details = data.details;
+  if (!known(details, detailsKeys) || !object4(details.searchScope) || typeof details.searchScope.fen !== "string" || !Array.isArray(details.lines) || !details.lines.length || !Array.isArray(details.continuationMoveFacts)) return null;
+  const positionKeys = ["recordHash", "ply", "startFen", "fen", "historyUci", "rootContextHash", "nextRecordedMove", "scope"];
+  if (!known(recordedPosition, positionKeys) || !Number.isInteger(recordedPosition.ply) || typeof recordedPosition.fen !== "string") return null;
+  const strongestOther = details.lines.find((line) => object4(line) && line.rootMove !== playedMove);
+  const mechanismAlternative = details.bestMove && details.bestMove !== playedMove ? details.bestMove : object4(strongestOther) ? strongestOther.rootMove : details.bestMove;
+  const lines = [];
+  for (const line of details.lines) {
+    if (!object4(line) || !known(line, lineKeys) || !Array.isArray(line.pv) || !line.pv.every((move) => typeof move === "string") || typeof line.rootMove !== "string" || !object4(line.pvCompletion) || !known(line.pvCompletion, completionKeys) || !Array.isArray(line.pvCompletion.segments)) return null;
+    let pvSan;
+    try {
+      const board = new Chess9(details.searchScope.fen);
+      pvSan = line.pv.map((move) => {
+        if (!/^[a-h][1-8][a-h][1-8][qrbn]?$/.test(move)) throw Error("invalid PV move");
+        const replayed = board.move({ from: move.slice(0, 2), to: move.slice(2, 4), promotion: move.slice(4) || void 0 });
+        if (!replayed) throw Error("illegal PV move");
+        return replayed.san;
+      });
+    } catch {
+      return null;
+    }
+    const segments = [];
+    for (const segment of line.pvCompletion.segments) {
+      if (!object4(segment) || !known(segment, segmentKeys) || !Array.isArray(segment.pv) || !Number.isInteger(segment.startPly)) return null;
+      const start = segment.startPly;
+      const same = start >= 0 && JSON.stringify(line.pv.slice(start, start + segment.pv.length)) === JSON.stringify(segment.pv);
+      const { pv: _pv, ...remaining } = segment;
+      void _pv;
+      segments.push(same ? { ...remaining, pvFromLinePly: start, pvLength: segment.pv.length } : { ...remaining, pv: segment.pv });
+    }
+    const { segments: _segments, ...completion } = line.pvCompletion;
+    void _segments;
+    const material = object4(line.material) && object4(line.material.start) && object4(line.material.end) ? {
+      authority: line.material.authority,
+      startBalance: line.material.start.balance,
+      endBalance: line.material.end.balance,
+      balanceChangeFromStart: line.material.balanceChangeFromStart,
+      scope: line.material.scope
+    } : void 0;
+    const separateRawPv = Array.isArray(line.rawPv) && JSON.stringify(line.rawPv) !== JSON.stringify(line.pv) ? { rawPv: line.rawPv } : {};
+    const continuation = details.continuationMoveFacts.find((f) => object4(f) && f.rootMove === line.rootMove);
+    const mechanismRelevant = line.rootMove === playedMove || line.rootMove === mechanismAlternative || !mechanismAlternative && lines.length === 0;
+    const mechanismFacts = mechanismRelevant && object4(continuation) && Array.isArray(continuation.moves) ? presentMoveMechanisms(continuation.moves) : [];
+    lines.push({
+      ...object4(continuation) && Array.isArray(continuation.moves) ? { mechanismAvailablePlies: continuation.moves.length } : {},
+      ...mechanismFacts.length ? { mechanismFacts } : {},
+      ...line.multipv !== void 0 ? { multipv: line.multipv } : {},
+      rootMove: line.rootMove,
+      ...playedMove ? { playedMove: playedMove === line.rootMove } : {},
+      pv: line.pv,
+      pvSan,
+      depth: line.depth,
+      scoreCp: line.scoreCp,
+      matePly: line.matePly,
+      scoreScope: line.scoreScope,
+      ...line.scoreProvenance ? { scoreProvenance: line.scoreProvenance } : {},
+      pvCompletion: { ...completion, segments },
+      ...material ? { materialSummary: material } : {},
+      ...separateRawPv
+    });
+  }
+  const { historyUci: _historyUci, ...root } = recordedPosition;
+  void _historyUci;
+  const { rootMoveFacts: _rootMoveFacts, continuationMoveFacts: _continuationMoveFacts, lines: _lines, ...search2 } = details;
+  void _rootMoveFacts;
+  void _continuationMoveFacts;
+  void _lines;
+  const projection = {
+    ...record2,
+    data: { recordedPosition: root, details: {
+      ...search2,
+      lines,
+      modelPresentation: {
+        scope: "compact initial preparation only; supplied PVs are complete, mechanismFacts cover first two plies for played and strongest roots with scoped control targets; deeper geometry remains retrievable",
+        mechanismRoots: lines.filter((line) => Array.isArray(line.mechanismFacts)).map((line) => line.rootMove),
+        omitted: ["otherRootMechanisms", "rootMoveFacts", "continuationMoveFacts", "captureGeometry", "materialCheckpoints", "duplicatePvSegmentMoves"],
+        retrieveFullEvidenceId: record2.id,
+        segmentPvReference: "A segment with pvFromLinePly=N and pvLength=L repeats exactly L moves of that line.pv starting at zero-based index N; its own depth, score, FEN, command and cache provenance remain specific to that segment.",
+        instruction: "For deeper or omitted geometry, other control squares, piece identities or material checkpoints, call retrieve_evidence with this evidence ID. This reuses the acquired record without another engine search. mechanismAvailablePlies states the retained geometry horizon; inspect later moves with test_game_line/inspectPlies."
+      }
+    } },
+    // replay duplicates the full PV arrays. The PVs above remain available for
+    // game links, while the immutable replay stays in the authoritative record.
+    replay: null
+  };
+  return projection;
+}
+function compactPreparedSearchResult(result, playedMove, format) {
+  const packet = {
+    contextHash: result.contextHash,
+    evidence: result.evidence.map((record2) => compactSearchRecord(record2, playedMove) ?? record2),
+    limitations: [
+      ...result.limitations,
+      "Initial preparation shows complete supplied PV moves and bounded scores, with first-two-ply mechanism measurements for played/strongest roots, but omits deeper geometry and material checkpoints. retrieve_evidence(evidenceIds) returns the already acquired full records without a new search."
+    ]
+  };
+  return compactSimpleEngineResult(packet, format);
+}
+
+// src/chess-reasoning/matched-comparison.ts
+import { Chess as Chess10 } from "chess.js";
+function matchedRootComparison(result, fen2, requiredRoots = []) {
+  const lines = Array.isArray(result.lines) ? result.lines : [];
+  const rootMoves = lines.flatMap((line) => line && typeof line.rootMove === "string" ? [line.rootMove] : []);
+  const unmatched = (reason) => ({ status: "unmatched", actualDepth: null, rootMoves, reason });
+  if ((result.sourceCacheProvenance ?? result.cacheProvenance) !== "engine") return unmatched("Common engine search identity is unavailable.");
+  if (rootMoves.length !== lines.length) return unmatched("A compared root is malformed.");
+  if (lines.length < 2 || new Set(rootMoves).size !== rootMoves.length || requiredRoots.some((root) => !rootMoves.includes(root))) return unmatched("The search does not cover all compared moves.");
+  try {
+    const legal = new Set(new Chess10(fen2).moves({ verbose: true }).map((move) => move.from + move.to + (move.promotion || "")));
+    if (rootMoves.some((root) => !legal.has(root))) return unmatched("A compared move is not legal at this root.");
+  } catch {
+    return unmatched("The comparison root is invalid.");
+  }
+  const depth = lines[0].depth, perspective = fen2.split(" ")[1] === "w" ? "white" : fen2.split(" ")[1] === "b" ? "black" : null;
+  if (!perspective || !Number.isSafeInteger(depth) || depth < 1 || lines.some((line) => line.depth !== depth)) return unmatched("The moves have no common achieved depth.");
+  for (const line of lines) {
+    if (line.scoreScope?.fen !== fen2 || line.scoreScope.perspective !== perspective || line.scoreScope.positiveMeans !== "advantage for perspective color") return unmatched("The score roots or perspectives differ.");
+    if (line.matePly == null ? !Number.isFinite(line.scoreCp) || Math.abs(line.scoreCp) >= 1e5 : !Number.isFinite(line.matePly)) return unmatched("A compared score is unavailable.");
+    if (line.matePly == null ? line.scoreScope.scoreCpUnit !== "centipawns" : line.scoreScope.matePlyUnit !== "signed mate-in-moves (legacy field name, not plies)") return unmatched("The score units are unknown.");
+    const origin = line.scoreProvenance;
+    if (origin && (origin.kind !== "root-search" || origin.fen !== fen2 || origin.originatingDepth !== depth)) return unmatched("A score is not a matching root-search measurement.");
+    if (origin?.engineBuild != null && origin.engineBuild !== result.engineBuild) return unmatched("The engine builds differ.");
+    if (origin?.command != null && result.command && origin.command !== result.command) return unmatched("The search commands differ.");
+  }
+  if (new Set(lines.flatMap((line) => typeof line.scoreProvenance?.command === "string" ? [line.scoreProvenance.command] : [])).size > 1) return unmatched("The search commands differ.");
+  return { status: "matched", actualDepth: depth, rootMoves, reason: "These root scores came from one engine search at a common achieved depth." };
+}
+
+// src/chess-reasoning/preparation-consolidation.ts
+var object5 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var strings = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
+var finite = (v) => typeof v === "number" && Number.isFinite(v);
+var equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function search(record2) {
+  const data = record2.data;
+  if (!object5(data.recordedPosition) || !object5(data.details)) return;
+  const root = data.recordedPosition, details = data.details;
+  if (!object5(details.searchScope) || !Array.isArray(details.lines) || !details.lines.length || !details.lines.every(object5)) return;
+  const scope = details.searchScope, lines = details.lines;
+  const perspective = typeof root.fen === "string" && root.fen.split(" ")[1] === "w" ? "white" : "black";
+  if (typeof root.fen !== "string" || scope.fen !== root.fen || !Number.isInteger(root.ply) || !strings(scope.requestedRootMoves) || new Set(lines.map((l) => l.rootMove)).size !== lines.length) return;
+  for (const line of lines) {
+    if (typeof line.rootMove !== "string" || !strings(line.pv) || line.pv[0] !== line.rootMove || !finite(line.depth) || !object5(line.scoreScope) || line.scoreScope.fen !== root.fen || line.scoreScope.perspective !== perspective || line.scoreScope.positiveMeans !== "advantage for perspective color") return;
+    if (finite(line.matePly)) {
+      if (line.scoreScope.matePlyUnit !== "signed mate-in-moves (legacy field name, not plies)") return;
+    } else if (line.matePly != null || !finite(line.scoreCp) || Math.abs(line.scoreCp) >= 1e5 || line.scoreScope.scoreCpUnit !== "centipawns") return;
+  }
+  return { root, details, scope, lines, requestedRootMoves: scope.requestedRootMoves };
+}
+function consolidatePreparedSearches(entries) {
+  const replacements = /* @__PURE__ */ new Map(), omitted = /* @__PURE__ */ new Set();
+  const dependencies = [];
+  for (const primary of entries) {
+    if (!primary.discoveryCallId) continue;
+    const discovery = entries.find((e) => e.callId === primary.discoveryCallId);
+    const dependency = {
+      relation: "candidate-selection",
+      discoveryCallId: primary.discoveryCallId,
+      comparisonCallId: primary.callId,
+      discoveryEvidenceIds: discovery?.records.map((r) => r.id) ?? [],
+      comparisonEvidenceIds: primary.records.map((r) => r.id),
+      presentation: "separate",
+      reason: "Comparison is not a complete compatible replacement."
+    };
+    dependencies.push(dependency);
+    if (!discovery || discovery.modelRun.status !== "completed" || primary.modelRun.status !== "completed" || discovery.records.length !== 1 || primary.records.length !== 1 || omitted.has(discovery.callId)) continue;
+    const original = discovery.records[0], comparison = primary.records[0], a = search(original), b = search(comparison);
+    if (!a || !b || !original.source.endsWith("/explore-continuations") || !comparison.source.endsWith("/compare_moves") || original.contextHash !== comparison.contextHash || !equal(a.root, b.root) || a.requestedRootMoves.length || comparison.coverage?.complete !== true || !primary.playedMove || !b.lines.some((l) => l.rootMove === primary.playedMove) || new Set(b.lines.map((l) => l.depth)).size !== 1) continue;
+    if (matchedRootComparison({ ...b.details, command: b.scope.command, cacheProvenance: b.scope.cacheProvenance, sourceCacheProvenance: b.scope.sourceCacheProvenance }, String(b.root.fen), b.requestedRootMoves).status !== "matched") continue;
+    const roots = a.lines.map((l) => String(l.rootMove)), compared = b.requestedRootMoves;
+    if (![...roots, primary.playedMove, ...compared].every((move) => compared.includes(move) && comparison.coverage.covered.includes(move) && b.lines.some((l) => l.rootMove === move))) continue;
+    if (!compactSearchRecord(original, primary.playedMove) || !compactSearchRecord(comparison, primary.playedMove)) continue;
+    const commonComparisonOrder = b.lines.map((l) => String(l.rootMove)).filter((move) => roots.includes(move));
+    const differentContinuations = a.lines.filter((line) => {
+      const other = b.lines.find((l) => l.rootMove === line.rootMove);
+      return !equal(line.pv, other.pv) || !equal(line.pvCompletion, other.pvCompletion);
+    }).map((l) => l.rootMove);
+    const discoverySummary = {
+      callId: discovery.callId,
+      evidenceId: original.id,
+      source: original.source,
+      engine: a.details.engine,
+      engineBuild: a.details.engineBuild,
+      searchScope: a.scope,
+      coverage: original.coverage,
+      summary: original.summary,
+      limitations: discovery.limitations ?? [],
+      scores: a.lines.map((l) => ({
+        rootMove: l.rootMove,
+        depth: l.depth,
+        scoreCp: l.scoreCp,
+        matePly: l.matePly,
+        scoreScope: l.scoreScope,
+        ...l.scoreProvenance ? { scoreProvenance: l.scoreProvenance } : {},
+        ...object5(l.pvCompletion) ? { continuation: { status: l.pvCompletion.status, conditional: l.pvCompletion.conditional, actualPlies: l.pvCompletion.actualPlies, requestedPlies: l.pvCompletion.requestedPlies } } : {}
+      })),
+      discoveryOrder: roots,
+      comparisonOrderForDiscoveredMoves: commonComparisonOrder,
+      reportedOrderChanged: !equal(roots, commonComparisonOrder),
+      distinctContinuationRootMoves: differentContinuations,
+      retrieveFullEvidenceId: original.id,
+      interpretation: "Discovery supplied candidates for this comparison. Its scores and reported ordering belong to the discovery search, not the primary comparison. Reported order changes may include tied moves. Full discovery continuations and details remain retrievable; use retrieve_evidence before relying on an omitted discovery line. Score disagreements remain in scoreComparisonNotices. This dependency does not establish that the answering model used or cited either record."
+    };
+    const result = discovery.modelRun.result;
+    const discoveryOpeningSourceContext = object5(result) ? result.openingSourceContext : void 0;
+    replacements.set(primary.callId, {
+      ...primary.modelRun,
+      discovery: discoverySummary,
+      ...discoveryOpeningSourceContext ? { discoveryOpeningSourceContext } : {}
+    });
+    omitted.add(discovery.callId);
+    Object.assign(dependency, {
+      presentation: "comparison-with-discovery-summary",
+      reason: "Complete same-root comparison covers discovered alternatives and played move.",
+      primaryEvidenceId: comparison.id,
+      reportedOrderChanged: discoverySummary.reportedOrderChanged,
+      distinctContinuationRootMoves: differentContinuations
+    });
+  }
+  return {
+    results: entries.filter((e) => !omitted.has(e.callId)).map((e) => replacements.get(e.callId) ?? e.modelRun),
+    diagnostics: {
+      version: "preparation-consolidation/1",
+      searchCount: entries.length,
+      primaryEntryCount: entries.length - omitted.size,
+      summarizedDiscoveryCount: omitted.size,
+      dependencies,
+      interpretation: "Candidate-selection and presentation decisions are observable. They do not establish whether uncited records influenced the answer. All authoritative records remain available for retrieval."
+    }
+  };
+}
+
+// src/chess-reasoning/score-comparison-notices.ts
+var object6 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+var finite2 = (value) => typeof value === "number" && Number.isFinite(value);
+var strings2 = (value) => Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+function disagreementKind(observations) {
+  const mates = observations.filter((observation) => observation.score.unit === "mate-in-moves").map((observation) => observation.score.value);
+  if (mates.length !== observations.length) return mates.length ? "mate-status-disagreement" : "centipawn-variation";
+  if (mates.some((value) => value > 0) && mates.some((value) => value < 0)) return "opposite-mate-sign";
+  return "mate-distance-variation";
+}
+var sharedInterpretation = "Different search results for the same root move; equal requested depth does not make their search scope, actual depth, cache or search history equivalent. Preserve each scoped score. For relative move comparisons prefer alternatives covered together at the same actual depth in the identified comparison records; this supports a relative claim within that search, not independent confirmation or rejection of a mate result. Do not combine scores from separate searches into a move-loss estimate. This notice alone does not require another search.";
+var interpretationFor = (kind) => {
+  const qualification = kind === "mate-status-disagreement" ? "Mate status differs: a centipawn score in another search does not refute its mating continuation, and mate distances cannot be converted to centipawns. " : kind === "opposite-mate-sign" ? "The mate signs oppose, indicating different reported mating sides; retain each search scope and inspect the underlying continuations. " : kind === "mate-distance-variation" ? "The searches report different mate distances; mate distances are not centipawns. " : "The searches report different centipawn evaluations. ";
+  return qualification + sharedInterpretation;
+};
+function originatingRootDepth(line, search2, fen2) {
+  const provenance = object6(line.scoreProvenance);
+  if (provenance) return provenance.kind === "root-search" && provenance.fen === fen2 && finite2(provenance.originatingDepth) && Number.isInteger(provenance.originatingDepth) && provenance.originatingDepth > 0 && provenance.originatingDepth === line.depth ? provenance.originatingDepth : null;
+  const source = search2.sourceCacheProvenance ?? search2.cacheProvenance;
+  return source === "engine" && finite2(line.depth) && Number.isInteger(line.depth) && line.depth > 0 ? line.depth : null;
+}
+function scoreComparisonNotices(records) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const record2 of records) {
+    const wrapper = object6(record2.data);
+    const data = object6(wrapper?.details) ?? wrapper;
+    const search2 = object6(data?.searchScope);
+    if (!data || !search2 || typeof search2.fen !== "string" || !Array.isArray(data.lines)) continue;
+    const fen2 = search2.fen;
+    const perspective = fen2.split(" ")[1] === "w" ? "white" : fen2.split(" ")[1] === "b" ? "black" : null;
+    if (!perspective) continue;
+    const roots = strings2(search2.requestedRootMoves);
+    const lines = data.lines.map(object6).filter((line) => !!line);
+    const scoped = (line) => {
+      const scope = object6(line.scoreScope);
+      return scope?.fen === fen2 && scope.perspective === perspective && scope.positiveMeans === "advantage for perspective color";
+    };
+    const comparedRoots = roots.length ? roots : lines.map((line) => String(line.rootMove));
+    const matched = (!roots.length || record2.coverage?.complete === true && roots.every((root) => record2.coverage.covered.includes(root))) && matchedRootComparison({ ...data, command: search2.command, cacheProvenance: search2.cacheProvenance, sourceCacheProvenance: search2.sourceCacheProvenance }, fen2, comparedRoots).status === "matched";
+    for (const line of lines) {
+      if (typeof line.rootMove !== "string" || !scoped(line)) continue;
+      const scope = object6(line.scoreScope);
+      let score;
+      if (finite2(line.matePly) && scope.matePlyUnit === "signed mate-in-moves (legacy field name, not plies)") {
+        score = { unit: "mate-in-moves", value: line.matePly };
+      } else if (line.matePly == null && finite2(line.scoreCp) && Math.abs(line.scoreCp) < 1e5 && scope.scoreCpUnit === "centipawns") {
+        score = { unit: "centipawns", value: line.scoreCp };
+      } else continue;
+      const key = JSON.stringify([fen2, line.rootMove, perspective]);
+      let group = groups.get(key);
+      if (!group) {
+        group = { fen: fen2, rootMove: line.rootMove, perspective, observations: [], matched: /* @__PURE__ */ new Set() };
+        groups.set(key, group);
+      }
+      if (group.observations.some((observation) => observation.evidenceId === record2.id)) continue;
+      group.observations.push({
+        evidenceId: record2.id,
+        source: record2.source,
+        score,
+        reportedDepth: finite2(line.depth) ? line.depth : null,
+        actualDepth: originatingRootDepth(line, search2, fen2),
+        requestedDepth: finite2(search2.requestedDepth) ? search2.requestedDepth : null,
+        requestedMultiPv: finite2(search2.requestedMultiPv) ? search2.requestedMultiPv : null,
+        rootScope: roots.length ? "restricted" : "unrestricted",
+        requestedRootMoves: roots,
+        cacheProvenance: typeof search2.cacheProvenance === "string" ? search2.cacheProvenance : "unreported",
+        sourceCacheProvenance: typeof search2.sourceCacheProvenance === "string" ? search2.sourceCacheProvenance : "unreported",
+        engine: typeof data.engine === "string" ? data.engine : null,
+        engineBuild: typeof data.engineBuild === "string" ? data.engineBuild : null,
+        ...object6(line.scoreProvenance) ? { scoreProvenance: line.scoreProvenance } : {}
+      });
+      if (matched && comparedRoots.includes(line.rootMove)) group.matched.add(record2.id);
+    }
+  }
+  return [...groups.values()].filter((group) => new Set(group.observations.map((observation) => JSON.stringify(observation.score))).size > 1).map((group) => {
+    const kind = disagreementKind(group.observations);
+    return {
+      fen: group.fen,
+      rootMove: group.rootMove,
+      perspective: group.perspective,
+      disagreementKind: kind,
+      observations: group.observations,
+      preferredWithinSearchComparisonEvidenceIds: [...group.matched],
+      interpretation: interpretationFor(kind)
+    };
+  });
+}
+
+// test/owner/preparation-consolidation.test.mjs
+var fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
+var scoreScope = { fen, perspective: "white", positiveMeans: "advantage for perspective color", scoreCpUnit: "centipawns", matePlyUnit: "signed mate-in-moves (legacy field name, not plies)" };
+function record(id, restricted = false) {
+  const roots = restricted ? ["d2d4", "e2e4", "b1c3"] : ["e2e4", "d2d4"];
+  return {
+    id,
+    contextHash: "game",
+    source: "Stockfish/" + (restricted ? "compare_moves" : "explore-continuations"),
+    data: { recordedPosition: { recordHash: "record", ply: 0, startFen: fen, fen, historyUci: [], rootContextHash: "root" }, details: { phase: "after", engine: "Stockfish", engineBuild: "test", searchScope: { fen, requestedDepth: 18, requestedMultiPv: restricted ? null : 2, requestedRootMoves: restricted ? roots : [], cacheProvenance: "engine" }, rootMoveFacts: [], continuationMoveFacts: [], lines: roots.map((rootMove, i) => ({ rootMove, pv: [rootMove], depth: 18, scoreCp: 50 - i * 10, matePly: null, scoreScope, pvCompletion: { requestedPlies: 1, actualPlies: 1, status: "complete", conditional: false, segments: [] } })) } },
+    coverage: { complete: restricted, covered: roots, unresolved: [] },
+    licenses: ["engine.bounded-comparison"],
+    replay: { fen, linesUci: roots.map((x) => [x]) }
+  };
+}
+function entry(callId, record2, discoveryCallId) {
+  const result = compactPreparedSearchResult({ contextHash: "game", evidence: [record2], limitations: [] }, "b1c3");
+  return { callId, records: [record2], playedMove: "b1c3", discoveryCallId, modelRun: { callId, status: "completed", result } };
+}
+var pair = () => [entry("discovery", record("evidence:discovery")), entry("comparison", record("evidence:comparison", true), "discovery")];
+test("KE-REASON-016/021/026: one primary comparison keeps original scores, order changes, dependency and retrieval identity", () => {
+  const input = pair(), copy = structuredClone(input), notices = scoreComparisonNotices(input.flatMap((x) => x.records));
+  const out = consolidatePreparedSearches(input);
+  assert.equal(out.results.length, 1);
+  assert.deepEqual(out.results[0].result, input[1].modelRun.result);
+  assert.equal(out.results[0].discovery.evidenceId, "evidence:discovery");
+  assert.equal(out.results[0].discovery.retrieveFullEvidenceId, "evidence:discovery");
+  assert.deepEqual(out.results[0].discovery.scores.map((x) => [x.rootMove, x.scoreCp]), [["e2e4", 50], ["d2d4", 40]]);
+  assert.deepEqual(out.results[0].discovery.comparisonOrderForDiscoveredMoves, ["d2d4", "e2e4"]);
+  assert.equal(out.results[0].discovery.reportedOrderChanged, true);
+  assert.equal(out.diagnostics.dependencies[0].relation, "candidate-selection");
+  assert.equal(out.diagnostics.dependencies[0].primaryEvidenceId, "evidence:comparison");
+  assert.deepEqual(scoreComparisonNotices(input.flatMap((x) => x.records)), notices);
+  assert.equal(notices.length, 2);
+  assert.deepEqual(input, copy);
+});
+test("KE-REASON-016/021/026: distinct PVs and conditional segments remain explicitly discoverable by original ID", () => {
+  const input = pair();
+  const line = input[0].records[0].data.details.lines[0];
+  line.pv.push("e7e5");
+  line.pvCompletion.conditional = true;
+  input[0].modelRun.result = compactPreparedSearchResult({ contextHash: "game", evidence: input[0].records, limitations: [] }, "b1c3");
+  const out = consolidatePreparedSearches(input);
+  assert.deepEqual(out.results[0].discovery.distinctContinuationRootMoves, ["e2e4"]);
+  assert.deepEqual(input[0].records[0].data.details.lines[0].pv, ["e2e4", "e7e5"]);
+});
+test("KE-REASON-023/026: discovery-only delivered opening commentary survives consolidation", () => {
+  const input = pair(), source = { pages: [{ title: "source", prose: "opening", matchedTargets: ["original"] }] };
+  input[0].modelRun.result = { chessResult: input[0].modelRun.result, openingSourceContext: source };
+  assert.deepEqual(consolidatePreparedSearches(input).results[0].discoveryOpeningSourceContext, source);
+});
+test("KE-REASON-016/026: no omission for incomplete, failed, foreign, unrecognized, mixed-depth or unrelated results", () => {
+  const changes = [
+    (a) => a[1].modelRun.status = "failed",
+    (a) => a[1].records[0].coverage.complete = false,
+    (a) => a[1].records[0].coverage.covered.pop(),
+    (a) => a[1].records[0].data.details.lines.pop(),
+    (a) => a[1].records[0].data.recordedPosition.ply = 1,
+    (a) => a[1].records[0].contextHash = "foreign",
+    (a) => a[1].records[0].data.details.lines[0].depth = 19,
+    (a) => a[1].records[0].data.details.lines[0].scoreScope = { ...scoreScope, perspective: "black" },
+    (a) => a[0].records[0].data.details.newProducerField = "retain",
+    (a) => a[1].discoveryCallId = void 0,
+    (a) => a[1].playedMove = void 0,
+    (a) => a[0].records[0].data.details.lines[0].pv.push("a1a8")
+  ];
+  for (const change of changes) {
+    const input = pair();
+    change(input);
+    const out = consolidatePreparedSearches(input);
+    assert.deepEqual(out.results, input.map((e) => e.modelRun));
+    assert.equal(out.diagnostics.summarizedDiscoveryCount, 0);
+  }
+  const only = [pair()[0]];
+  assert.deepEqual(consolidatePreparedSearches(only).results, only.map((e) => e.modelRun));
+});
+test("KE-REASON-016/021/026: unverified cached comparison depth cannot authorize consolidation", () => {
+  const input = pair();
+  input[1].records[0].data.details.searchScope.sourceCacheProvenance = "widget-analysis-cache";
+  assert.equal(consolidatePreparedSearches(input).results.length, 2);
+  for (const line of input[1].records[0].data.details.lines) line.scoreProvenance = { kind: "root-search", fen, originatingDepth: 18 };
+  input[0].records[0].data.details.lines[0].scoreProvenance = { kind: "legacy-unknown", originatingDepth: null, reportedDepth: 18 };
+  assert.equal(consolidatePreparedSearches(input).results.length, 2, "known origins alone do not establish one search");
+  input[1].records[0].data.details.searchScope.sourceCacheProvenance = "engine";
+  const out = consolidatePreparedSearches(input);
+  assert.equal(out.results.length, 1);
+  assert.equal(out.results[0].discovery.scores[0].scoreProvenance.kind, "legacy-unknown");
+});
+test("KE-REASON-026: the original command remains authoritative when origins share a different command", () => {
+  const input = pair(), details = input[1].records[0].data.details;
+  details.searchScope.command = "go depth 18 searchmoves d2d4 e2e4 b1c3";
+  for (const line of details.lines) line.scoreProvenance = { kind: "root-search", fen, originatingDepth: 18, command: "go depth 26" };
+  assert.equal(consolidatePreparedSearches(input).results.length, 2);
+});