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

package/dist/owner-tests/chess-reasoning-compact-search-preparation.test.mjs

@@ -0,0 +1,963 @@
+// test/owner/chess-reasoning-compact-search-preparation.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((line2) => {
+      if (!object2(line2) || !Array.isArray(line2.pv)) return line2;
+      const next = { ...line2 };
+      if (!Object.hasOwn(line2, "rawPvSameAsPv") && Array.isArray(line2.rawPv) && JSON.stringify(line2.rawPv) === JSON.stringify(line2.pv)) {
+        delete next.rawPv;
+        next.rawPvSameAsPv = true;
+        omittedRaw = true;
+      }
+      if (rootFen && object2(line2.pvCompletion) && Array.isArray(line2.pvCompletion.segments)) {
+        const fens = [];
+        try {
+          const chess = new Chess(rootFen);
+          fens.push(chess.fen());
+          for (const move2 of line2.pv) {
+            if (typeof move2 !== "string" || !/^[a-h][1-8][a-h][1-8][qrbn]?$/.test(move2)) break;
+            chess.move({ from: move2.slice(0, 2), to: move2.slice(2, 4), promotion: move2.slice(4) || void 0 });
+            fens.push(chess.fen());
+          }
+        } catch {
+        }
+        next.pvCompletion = { ...line2.pvCompletion, segments: line2.pvCompletion.segments.map((segment2) => {
+          if (!object2(segment2) || !Number.isInteger(segment2.startPly) || segment2.startPly < 0 || typeof segment2.fen !== "string" || fens[segment2.startPly] !== segment2.fen || Object.hasOwn(segment2, "fenFromLinePvPly")) return segment2;
+          const { fen: _fen, ...rest } = segment2;
+          void _fen;
+          referencedFen = true;
+          return { ...rest, fenFromLinePvPly: segment2.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: move2, san, mover, capture, captureGeometry, from: _from, to: _to, promotion: _promotion, givesCheck: _check, ...extra } = x;
+      void _from;
+      void _to;
+      void _promotion;
+      void _check;
+      const row2 = [move2, 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;
+}
+function expandCompactEngineEvidence(value) {
+  if (!object3(value) || value.encoding !== COMPACT_ENGINE_VERSION || !object3(value.pieces)) return value;
+  const pieces = value.pieces;
+  const visit = (x) => {
+    if (Array.isArray(x)) return x.map(visit);
+    if (!object3(x)) return x;
+    if (typeof x.$piece === "string") return { ...pieces[x.$piece], square: x.square };
+    if (object3(x.$table)) {
+      const { columns, rows } = x.$table;
+      return rows.map((row2) => visit(Object.fromEntries(columns.map((key, i) => [key, row2[i]]))));
+    }
+    if (Array.isArray(x.$move)) {
+      const [move2, san, mover, capture = null, geometry = null, extra = {}] = x.$move;
+      return {
+        uci: move2,
+        san,
+        from: move2.slice(0, 2),
+        to: move2.slice(2, 4),
+        mover: visit(mover),
+        capture: visit(capture),
+        ...geometry !== null ? { captureGeometry: visit(geometry) } : {},
+        promotion: move2.slice(4) || null,
+        givesCheck: /[+#]$/.test(san),
+        ...visit(extra)
+      };
+    }
+    return Object.fromEntries(Object.entries(x).map(([k, v]) => [k, visit(v)]));
+  };
+  return visit(value.content);
+}
+
+// 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((entry) => visit(entry, replace)) : Object.fromEntries(Object.entries(item).map(([childKey, entry]) => [childKey, visit(entry, 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((line2) => object4(line2) && line2.rootMove !== playedMove);
+  const mechanismAlternative = details.bestMove && details.bestMove !== playedMove ? details.bestMove : object4(strongestOther) ? strongestOther.rootMove : details.bestMove;
+  const lines = [];
+  for (const line2 of details.lines) {
+    if (!object4(line2) || !known(line2, lineKeys) || !Array.isArray(line2.pv) || !line2.pv.every((move2) => typeof move2 === "string") || typeof line2.rootMove !== "string" || !object4(line2.pvCompletion) || !known(line2.pvCompletion, completionKeys) || !Array.isArray(line2.pvCompletion.segments)) return null;
+    let pvSan;
+    try {
+      const board = new Chess9(details.searchScope.fen);
+      pvSan = line2.pv.map((move2) => {
+        if (!/^[a-h][1-8][a-h][1-8][qrbn]?$/.test(move2)) throw Error("invalid PV move");
+        const replayed = board.move({ from: move2.slice(0, 2), to: move2.slice(2, 4), promotion: move2.slice(4) || void 0 });
+        if (!replayed) throw Error("illegal PV move");
+        return replayed.san;
+      });
+    } catch {
+      return null;
+    }
+    const segments = [];
+    for (const segment2 of line2.pvCompletion.segments) {
+      if (!object4(segment2) || !known(segment2, segmentKeys) || !Array.isArray(segment2.pv) || !Number.isInteger(segment2.startPly)) return null;
+      const start = segment2.startPly;
+      const same = start >= 0 && JSON.stringify(line2.pv.slice(start, start + segment2.pv.length)) === JSON.stringify(segment2.pv);
+      const { pv: _pv, ...remaining } = segment2;
+      void _pv;
+      segments.push(same ? { ...remaining, pvFromLinePly: start, pvLength: segment2.pv.length } : { ...remaining, pv: segment2.pv });
+    }
+    const { segments: _segments, ...completion } = line2.pvCompletion;
+    void _segments;
+    const material2 = object4(line2.material) && object4(line2.material.start) && object4(line2.material.end) ? {
+      authority: line2.material.authority,
+      startBalance: line2.material.start.balance,
+      endBalance: line2.material.end.balance,
+      balanceChangeFromStart: line2.material.balanceChangeFromStart,
+      scope: line2.material.scope
+    } : void 0;
+    const separateRawPv = Array.isArray(line2.rawPv) && JSON.stringify(line2.rawPv) !== JSON.stringify(line2.pv) ? { rawPv: line2.rawPv } : {};
+    const continuation = details.continuationMoveFacts.find((f) => object4(f) && f.rootMove === line2.rootMove);
+    const mechanismRelevant = line2.rootMove === playedMove || line2.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 } : {},
+      ...line2.multipv !== void 0 ? { multipv: line2.multipv } : {},
+      rootMove: line2.rootMove,
+      ...playedMove ? { playedMove: playedMove === line2.rootMove } : {},
+      pv: line2.pv,
+      pvSan,
+      depth: line2.depth,
+      scoreCp: line2.scoreCp,
+      matePly: line2.matePly,
+      scoreScope: line2.scoreScope,
+      ...line2.scoreProvenance ? { scoreProvenance: line2.scoreProvenance } : {},
+      pvCompletion: { ...completion, segments },
+      ...material2 ? { materialSummary: material2 } : {},
+      ...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((line2) => Array.isArray(line2.mechanismFacts)).map((line2) => line2.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);
+}
+
+// test/owner/chess-reasoning-compact-search-preparation.test.mjs
+var fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
+var scope = {
+  fen,
+  requestedDepth: 18,
+  minimumPvPlies: 10,
+  cacheProvenance: "widget-cache",
+  sourceCacheProvenance: "widget-cache",
+  requestedRootMoves: ["e2e4", "d2d4"],
+  requestedMultiPv: null,
+  history: "FEN-root search; prior repetition history not sent to engine"
+};
+var scoreScope = {
+  fen,
+  perspective: "white",
+  positiveMeans: "advantage for perspective color",
+  scoreCpUnit: "centipawns",
+  matePlyUnit: "signed mate-in-moves (legacy field name, not plies)"
+};
+var longPv = ["e2e4", "e7e5", "g1f3", "b8c6"];
+var segment = (pv, startPly, scoreCp) => ({
+  fen,
+  startPly,
+  depth: 18,
+  pv,
+  scoreCp,
+  matePly: null,
+  scoreScope: { ...scoreScope, fen },
+  command: "go depth 18",
+  engine: "Stockfish",
+  engineBuild: "test-build",
+  cacheProvenance: "widget-cache"
+});
+var move = (uci2, san) => ({
+  uci: uci2,
+  san,
+  from: uci2.slice(0, 2),
+  to: uci2.slice(2, 4),
+  mover: { pieceId: `piece-${uci2}`, color: "w", pieceType: "p", square: uci2.slice(0, 2) },
+  capture: null,
+  promotion: null,
+  givesCheck: false,
+  captureGeometry: { attackers: [{ square: "e4" }] }
+});
+var material = {
+  authority: "legal-replay-piece-counts",
+  startFen: fen,
+  plies: 4,
+  start: { balance: "Equal piece counts." },
+  end: { balance: "Equal piece counts." },
+  changes: [{ ply: 1, san: "e4", whiteMinusBlack: { pawn: 0, knight: 0, bishop: 0, rook: 0, queen: 0 }, balance: "Equal piece counts." }],
+  endFen: fen,
+  balanceChangeFromStart: { pawn: 0, knight: 0, bishop: 0, rook: 0, queen: 0 },
+  scope: "Conditional variation."
+};
+var line = (rootMove, pv, scoreCp, matePly = null) => ({
+  rootMove,
+  pv,
+  depth: 18,
+  nodes: 100,
+  scoreCp,
+  matePly,
+  scoreScope,
+  rawPv: pv,
+  pvCompletion: {
+    requestedPlies: 10,
+    actualPlies: pv.length,
+    status: "short-budget",
+    conditional: true,
+    segments: [segment(pv, 0, scoreCp)]
+  },
+  material
+});
+var record = () => ({
+  schemaVersion: "conceptual-explanation-poc/57",
+  id: "evidence:game:test-search",
+  contextHash: "test-hash",
+  kind: "probe",
+  source: "Stockfish/compare_moves",
+  proofStrength: "engine-bounded",
+  summary: "Bounded two-root comparison",
+  data: {
+    recordedPosition: {
+      recordHash: "game-hash",
+      ply: 0,
+      startFen: fen,
+      fen,
+      historyUci: [],
+      rootContextHash: "root-hash",
+      nextRecordedMove: "e4",
+      scope: "position after exactly ply recorded moves"
+    },
+    details: {
+      phase: "after",
+      rootMoves: ["e2e4", "d2d4"],
+      rootSelection: { modelRequested: ["e2e4", "d2d4"], automaticallyAdded: [], scope: "restricted roots" },
+      bestMove: "e2e4",
+      engine: "Stockfish",
+      engineBuild: "test-build",
+      searchScope: scope,
+      rootMoveFacts: [move("e2e4", "e4")],
+      continuationMoveFacts: [{ rootMove: "e2e4", moves: longPv.map((v, i) => move(v, ["e4", "e5", "Nf3", "Nc6"][i])) }],
+      lines: [line("e2e4", longPv, 32), line("d2d4", ["d2d4", "d7d5"], 21)],
+      minimumPvPlies: 10,
+      requestedPvCoverage: { requestedPlies: 10, satisfied: [], short: ["e2e4", "d2d4"] },
+      authority: "bounded-engine"
+    }
+  },
+  coverage: { complete: true, covered: ["e2e4", "d2d4"], unresolved: [] },
+  replay: { fen, command: "go depth 18", linesUci: [longPv, ["d2d4", "d7d5"]] },
+  licenses: ["engine.bounded-score"]
+});
+var search = () => ({
+  schemaVersion: "conceptual-explanation-poc/57",
+  callId: "initial-search-1",
+  tool: "analyze_game_position",
+  contextHash: "test-hash",
+  support: "supported",
+  data: {},
+  evidence: [record()],
+  limitations: [],
+  durationMs: 10
+});
+var decode = (v) => {
+  if (v?.metadata && v?.content) {
+    const expand = (x) => Array.isArray(x) ? x.map(expand) : x && typeof x === "object" ? x.$metadata ? expand(v.metadata[x.$metadata]) : Object.fromEntries(Object.entries(x).map(([k, a]) => [k, expand(a)])) : x;
+    return expandCompactEngineEvidence(expand(v.content));
+  }
+  return expandCompactEngineEvidence(v);
+};
+test("KE-REASON-016/021/024/026: initial search projection preserves both scoped comparisons and all PV moves", () => {
+  const original = search(), copy = structuredClone(original);
+  const projected = decode(compactPreparedSearchResult(original, "d2d4"));
+  assert.deepEqual(original, copy, "the authoritative record remains immutable for retrieval");
+  const e = projected.evidence[0];
+  assert.equal(e.id, original.evidence[0].id);
+  assert.equal(e.data.recordedPosition.ply, 0);
+  assert.equal(e.data.recordedPosition.fen, fen);
+  assert.deepEqual(e.data.details.searchScope, scope);
+  assert.deepEqual(e.data.details.rootSelection, original.evidence[0].data.details.rootSelection);
+  assert.deepEqual(e.data.details.lines.map((x) => x.pv), [longPv, ["d2d4", "d7d5"]]);
+  assert.deepEqual(e.data.details.lines[0].pvSan, ["e4", "e5", "Nf3", "Nc6"]);
+  assert.deepEqual(e.data.details.lines.map((x) => x.playedMove), [false, true]);
+  assert.deepEqual(e.data.details.lines.map((x) => x.scoreCp), [32, 21]);
+  assert.deepEqual(e.data.details.lines.map((x) => x.scoreScope), [scoreScope, scoreScope]);
+  assert.equal(e.data.details.lines[0].pvCompletion.status, "short-budget");
+  assert.equal(e.data.details.lines[0].pvCompletion.conditional, true);
+  assert.equal(e.data.details.lines[0].pvCompletion.segments[0].cacheProvenance, "widget-cache");
+  assert.deepEqual(e.data.details.lines[0].pvCompletion.segments[0].pvFromLinePly, 0);
+  assert.equal(e.data.details.lines[0].pvCompletion.segments[0].pvLength, longPv.length);
+  assert.equal(e.data.details.lines[0].materialSummary.endBalance, "Equal piece counts.");
+  assert.equal(e.data.details.modelPresentation.retrieveFullEvidenceId, e.id);
+  assert.equal(e.data.details.continuationMoveFacts, void 0);
+  assert.equal(e.data.details.rootMoveFacts, void 0);
+  assert.equal(e.replay, null);
+  assert.equal(JSON.stringify(projected).includes("captureGeometry"), true, "retrieval instructions disclose the omitted detail");
+  assert.ok(JSON.stringify(compactPreparedSearchResult(original, "d2d4")).length < JSON.stringify(original).length);
+});
+test("KE-REASON-016/021/024/026: distinct raw or segment PV and mate fields are not mistaken for duplicates", () => {
+  const original = search();
+  const lines = original.evidence[0].data.details.lines;
+  lines[0].rawPv = ["d2d4", "d7d5"];
+  lines[0].matePly = 3;
+  lines[0].scoreCp = null;
+  lines[0].pvCompletion.segments.push(segment(["d2d4"], 1, null));
+  const projected = decode(compactPreparedSearchResult(original, "e2e4"));
+  const a = projected.evidence[0].data.details.lines[0];
+  assert.deepEqual(a.rawPv, ["d2d4", "d7d5"]);
+  assert.equal(a.matePly, 3);
+  assert.equal(a.scoreCp, null);
+  assert.deepEqual(a.pvCompletion.segments[1].pv, ["d2d4"]);
+  assert.equal(a.playedMove, true);
+});
+test("KE-REASON-016/021/024/026: unfamiliar engine evidence stays complete", () => {
+  const original = search();
+  original.evidence[0].data.details.lines[0].newEngineData = { future: "keep" };
+  const projected = decode(compactPreparedSearchResult(original, "e2e4"));
+  const standard = decode(compactSimpleEngineResult({ contextHash: original.contextHash, evidence: original.evidence, limitations: original.limitations }));
+  assert.deepEqual(projected.evidence[0].data.details.lines[0].newEngineData, { future: "keep" });
+  assert.deepEqual(
+    projected.evidence[0].data.details.continuationMoveFacts,
+    standard.evidence[0].data.details.continuationMoveFacts
+  );
+});
+test("KE-REASON-016/026: unknown played move is not represented as a negative match", () => {
+  const projected = decode(compactPreparedSearchResult(search()));
+  assert.ok(projected.evidence[0].data.details.lines.every((line2) => !Object.hasOwn(line2, "playedMove")));
+});
+test("KE-REASON-016/021/026: compact preparation retains line and continuation score origins", () => {
+  const original = search(), line2 = original.evidence[0].data.details.lines[0];
+  line2.scoreProvenance = { kind: "legacy-unknown", originatingDepth: null, reportedDepth: 18 };
+  line2.pvCompletion.segments[0].scoreProvenance = { kind: "root-search", fen, originatingDepth: 22 };
+  const output = decode(compactPreparedSearchResult(original, "d2d4")).evidence[0].data.details;
+  assert.ok(output.modelPresentation, "recognized provenance does not force full geometry presentation");
+  assert.deepEqual(output.lines[0].scoreProvenance, line2.scoreProvenance);
+  assert.deepEqual(output.lines[0].pvCompletion.segments[0].scoreProvenance, line2.pvCompletion.segments[0].scoreProvenance);
+});