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

package/src/chess-reasoning/types.ts

@@ -0,0 +1,195 @@
+import type { Color, PieceSymbol, Square } from "chess.js";
+
+export const CHESS_REASONING_SCHEMA_VERSION = "0.2.0" as const;
+export const CHESS_REASONING_POLICY_VERSION = "shadow-2" as const;
+
+export type BranchId = string;
+export type PieceId = string;
+export type EntityId = string;
+export type EvidenceId = string;
+export type CandidateId = string;
+export type ConceptKey = string;
+export type RegistryKey = string;
+export type ProofStrength = "observed" | "supported" | "forced";
+export type CandidateDisposition = "accepted" | "rejected" | "unsupported";
+export type ConceptCoverage = "evaluated" | "partial" | "unsupported";
+
+export type SemanticScalar = string | number | boolean | null;
+export type SemanticValue = SemanticScalar | SemanticValue[] | { [key: string]: SemanticValue };
+export type SemanticAttributes = Record<string, SemanticValue>;
+
+export type SemanticReference = {
+  domain: RegistryKey;
+  id: string;
+};
+
+export type SemanticParticipant = {
+  role: RegistryKey;
+  ref: SemanticReference;
+};
+
+export type PieceIdentity = {
+  id: PieceId;
+  color: Color;
+  type: PieceSymbol;
+  originSquare: Square;
+  createdPly: number;
+  promotedFrom: PieceId | null;
+  capturedAtPly: number | null;
+  retiredAtPly: number | null;
+};
+
+export type IdentityState = {
+  schemaVersion: typeof CHESS_REASONING_SCHEMA_VERSION;
+  branchId: BranchId;
+  fen: string;
+  ply: number;
+  pieces: Record<PieceId, PieceIdentity>;
+  squares: Partial<Record<Square, PieceId>>;
+  promotionSequence: number;
+};
+
+export type MoveIdentityDelta = {
+  branchId: BranchId;
+  ply: number;
+  uci: string;
+  san: string;
+  mover: PieceId;
+  captured: PieceId | null;
+  promoted: PieceId | null;
+  rookMoved: PieceId | null;
+  beforeFen: string;
+  afterFen: string;
+};
+
+export type ProposalReason = {
+  code: RegistryKey;
+  detail: string;
+};
+
+/**
+ * Candidates and persisted entities deliberately share generic semantic
+ * building blocks. Chess concepts are registry values in `concepts`; they do
+ * not add flags, fields, or concept-specific entity subclasses.
+ */
+export type SemanticCandidate = {
+  schemaVersion: typeof CHESS_REASONING_SCHEMA_VERSION;
+  id: CandidateId;
+  branchId: BranchId;
+  ply: number;
+  uci: string;
+  san: string;
+  entityType: RegistryKey;
+  concepts: ConceptKey[];
+  owner: Color | null;
+  participants: SemanticParticipant[];
+  attributes: SemanticAttributes;
+  proposalReasons: ProposalReason[];
+  verification: "not-requested";
+};
+
+export type CandidateGenerationReport = {
+  schemaVersion: typeof CHESS_REASONING_SCHEMA_VERSION;
+  branchId: BranchId;
+  ply: number;
+  move: MoveIdentityDelta;
+  candidates: SemanticCandidate[];
+  conceptCoverage: Record<ConceptKey, ConceptCoverage>;
+  skipped: Array<{ concept: ConceptKey; reason: string }>;
+};
+
+export type ProbeBudget = {
+  depth: number | null;
+  nodes: number | null;
+  timeMs: number | null;
+};
+
+export type EvidenceRecord = {
+  schemaVersion: typeof CHESS_REASONING_SCHEMA_VERSION;
+  id: EvidenceId;
+  candidateId: CandidateId;
+  disposition: CandidateDisposition;
+  proofStrength: ProofStrength | null;
+  summary: string;
+  engine: string;
+  engineBuild: string;
+  budget: ProbeBudget;
+  rootMovesCovered: string[];
+  unresolvedMoves: string[];
+  principalVariations: string[][];
+  scoreCp: number | null;
+  matePly: number | null;
+  replay: {
+    fen: string;
+    command: string;
+  } | null;
+};
+
+export type SemanticTransition = {
+  ply: number;
+  uci: string;
+  state: RegistryKey;
+  annotation: RegistryKey;
+  evidence: EvidenceId[];
+};
+
+export type SemanticEntity = {
+  schemaVersion: typeof CHESS_REASONING_SCHEMA_VERSION;
+  id: EntityId;
+  branchId: BranchId;
+  entityType: RegistryKey;
+  concepts: ConceptKey[];
+  owner: Color | null;
+  createdByPly: number;
+  createdByUci: string;
+  participants: SemanticParticipant[];
+  attributes: SemanticAttributes;
+  proofStrength: ProofStrength | null;
+  state: RegistryKey;
+  evidence: EvidenceId[];
+  transitions: SemanticTransition[];
+};
+
+export type SemanticRelation = {
+  id: string;
+  branchId: BranchId;
+  relationType: RegistryKey;
+  from: EntityId;
+  to: EntityId;
+  createdAtPly: number;
+  attributes: SemanticAttributes;
+  evidence: EvidenceId[];
+};
+
+export type IdeaGraph = {
+  schemaVersion: typeof CHESS_REASONING_SCHEMA_VERSION;
+  policyVersion: typeof CHESS_REASONING_POLICY_VERSION;
+  branchId: BranchId;
+  ply: number;
+  inputHash: string;
+  entities: SemanticEntity[];
+  relations: SemanticRelation[];
+  candidateOutcomes: Array<{
+    candidateId: CandidateId;
+    disposition: CandidateDisposition;
+    evidence: EvidenceId[];
+  }>;
+};
+
+export type SemanticMoveRecord = {
+  schemaVersion: typeof CHESS_REASONING_SCHEMA_VERSION;
+  identity: IdentityState;
+  generation: CandidateGenerationReport;
+  evidence: EvidenceRecord[];
+  graph: IdeaGraph;
+};
+
+export type ToolSupport = "supported" | "insufficient-evidence" | "unsupported-concept";
+
+export type ReasoningToolResponse<T> = {
+  schemaVersion: typeof CHESS_REASONING_SCHEMA_VERSION;
+  support: ToolSupport;
+  answer: T | null;
+  evidence: EvidenceId[];
+  limitations: string[];
+};

package/src/chess-reasoning/visible-support-lines.ts

@@ -0,0 +1,44 @@
+import { Chess } from 'chess.js';
+import { historicalProseRoots, type RecordedReferenceLine } from './historical-prose';
+import { simpleProseReferences, type SimpleReference } from './simple-prose-references';
+import { reasoningContextHash, type ReasoningPositionContext, type ReasoningEvidenceRecord } from './poc-contracts';
+
+/** Expose only a path the answer already explicitly referenced and admission verified. */
+export function visibleSupportLines(answer: string, context: ReasoningPositionContext,
+  records: readonly ReasoningEvidenceRecord[], recordedLine?: RecordedReferenceLine) {
+  const view = simpleProseReferences(answer, context, records, recordedLine);
+  const historical = historicalProseRoots(context, records, recordedLine);
+  const refs = view.blocks.flatMap(block => block.tokens.flatMap(token => token.reference ? [token.reference] : []));
+  const rootKey = (r: SimpleReference) => JSON.stringify([reasoningContextHash(r.position.recordedContext ?? context), r.position.start]);
+  const path = (r: SimpleReference) => r.position.moves.map(m => m.uci);
+  const isPrefix = (a: string[], b: string[]) => a.length <= b.length && a.every((m,i) => m === b[i]);
+  const candidates = refs.filter(r => path(r).length > 1);
+  const maximal = candidates.filter((r,i) => !candidates.some((other,j) => rootKey(r) === rootKey(other)
+    && isPrefix(path(r),path(other)) && (path(r).length < path(other).length || j < i)));
+  const additions: Array<{target:string;label:string;evidenceIds:string[];authority:string}> = [];
+  for (const ref of maximal) {
+    const moves = path(ref);
+    const visible = new Set(refs.filter(r => r.kind === 'move' && rootKey(r) === rootKey(ref)
+      && isPrefix(path(r),moves)).map(r => path(r).length));
+    if (moves.every((_,i) => visible.has(i+1))) continue;
+    const rootContext = ref.position.recordedContext ?? context;
+    let target = `move:${ref.position.start}:${moves.join(',')}`;
+    if (ref.position.recordedContext) {
+      const root = [...historical.roots].find(([,value]) => reasoningContextHash(value.context) === reasoningContextHash(rootContext));
+      if (!root) continue;
+      target = `game:${root[0]}:${moves.join(',')}`;
+    }
+    const board = new Chess(ref.position.start === 'before' ? rootContext.fenBefore : rootContext.fenAfter);
+    const label = moves.map(uci => {
+      const [,turn,,,,number] = board.fen().split(' ');
+      const san = board.move({from:uci.slice(0,2),to:uci.slice(2,4),promotion:uci[4]}).san;
+      return `${number}${turn === 'w' ? '.' : '...'}${san}`;
+    }).join(' ');
+    const line = `[${label}](${target})`;
+    // Square/piece admission alone must never broaden move-path authority.
+    const checked = simpleProseReferences(line,context,records,recordedLine);
+    if (checked.coverage.resolved !== 1 || checked.gaps.some(g => !g.startsWith('Unbound text:'))) continue;
+    additions.push({target,label,evidenceIds:ref.evidenceIds,authority:'Existing admitted reference path; not proof of best play, force or purpose.'});
+  }
+  return {answer: answer + additions.map(a => `\n\nReferenced line: [${a.label}](${a.target}).`).join(''), additions};
+}

package/src/chess-reasoning/wikibooks-index.ts

@@ -0,0 +1,56 @@
+import { Chess } from 'chess.js';
+const ROOT = 'Chess Opening Theory';
+export type WikibooksIndexData = { v: number; at: string; run: string; extractor: string; entries: string[][] };
+export type IndexedOpening = { title: string; canonicalTitle: string; positionKey: string; plies: number };
+export type WikibooksIndex = { at: string; byPath: Map<string, IndexedOpening[]>; byPosition: Map<string, IndexedOpening[]> };
+export function openingTitle(moves: string[]): string {
+  return ROOT + '/' + moves.map((san, ply) => `${Math.floor(ply / 2) + 1}${ply % 2 ? '...' : '. '}${san.replace(/[+#?!]+$/g, '')}`).join('/');
+}
+export function decodeWikibooksIndex(data: WikibooksIndexData): WikibooksIndex {
+  if (data.v !== 1 || !data.at || !Array.isArray(data.entries) || data.entries.length > 20_000) throw Error('Invalid opening catalog');
+  const byPath = new Map<string, IndexedOpening[]>(), byPosition = new Map<string, IndexedOpening[]>();
+  for (const row of data.entries) {
+    if (row.length < 2 || row.length > 3 || row.some(x => typeof x !== 'string')) throw Error('Invalid opening catalog row');
+    const moves = row[0].split(' '), canonicalTitle = openingTitle(moves);
+    const entry = {title: row[2] ? ROOT + '/' + row[2] : canonicalTitle, canonicalTitle, positionKey: row[1], plies: moves.length};
+    for (const [map, key] of [[byPath, canonicalTitle], [byPosition, entry.positionKey]] as const) {
+      const values = map.get(key) || []; values.push(entry); map.set(key, values);
+    }
+  }
+  return {at: data.at, byPath, byPosition};
+}
+export function positionKey(fen: string): string { return fen.split(' ').slice(0, 4).join(' '); }
+/** Normalize only title notation; every move must replay legally with its actual side/number. */
+export function replayWikibooksTitle(title: string): string | null {
+  if (title === ROOT) return new Chess().fen();
+  if (!title.startsWith(ROOT + '/')) return null;
+  const board = new Chess();
+  try {
+    for (const part of title.slice(ROOT.length + 1).replace(/\/$/, '').split('/')) {
+      const tokens = part.trim().replace(/…/g, '...').replace(/^\d+\s*\.+\s*/, '').split(/\s+/);
+      for (const token of tokens) {
+        const moveText = token.replace(/0/g, 'O').replace(/[+#?!]+$/g, '');
+        if (!/^[KQRBN]?[a-h]?[1-8]?x?[a-h][1-8](?:=[QRBN])?$|^O-O(?:-O)?$/.test(moveText)) return null;
+        board.move(moveText);
+      }
+    }
+    return board.fen();
+  } catch { return null; }
+}
+export type IndexedSelection = { entry: IndexedOpening; requestedTitle: string; ancestorPlies: number; transposition: boolean };
+export function selectIndexedOpening(index: WikibooksIndex, title: string, maxAncestorPlies = 2, minSourcePlies = 0): IndexedSelection | null {
+  let ancestor = title;
+  for (let distance = 0; distance <= maxAncestorPlies && ancestor !== ROOT; distance++) {
+    const fen = replayWikibooksTitle(ancestor);
+    if (!fen) return null;
+    const key = positionKey(fen), exact = index.byPath.get(ancestor) || [];
+    const candidates = [...exact, ...(index.byPosition.get(key) || []).filter(e => !exact.includes(e))];
+    for (const entry of candidates) {
+      const actual = replayWikibooksTitle(entry.title);
+      if (entry.plies >= minSourcePlies && entry.positionKey === key && actual && positionKey(actual) === key)
+        return {entry, requestedTitle: title, ancestorPlies: distance, transposition: entry.canonicalTitle !== ancestor};
+    }
+    ancestor = ancestor.slice(0, ancestor.lastIndexOf('/'));
+  }
+  return null;
+}

package/src/chess-reasoning/wikibooks-tool-context.ts

@@ -0,0 +1,91 @@
+import { openingTitle, positionKey, type WikibooksIndex } from './wikibooks-index';
+import { recordedEvidenceContext, recordedDetailsMatch } from './recorded-reference-context';
+import { Chess } from 'chess.js';
+import { reasoningContextHash, validateReasoningPositionContext, type ReasoningPositionContext, type ReasoningToolResult } from './poc-contracts';
+import { type WikibooksTarget } from './opening-source-contracts';
+
+const object = (value: unknown): Record<string, unknown> => value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+const ucis = (value: unknown): string[] | null => Array.isArray(value) && value.every(v => typeof v === 'string' && /^[a-h][1-8][a-h][1-8][qrbn]?$/.test(v)) ? value : null;
+
+/** Legacy unfiltered planner; production uses the indexed entrypoint below. */
+export function wikibooksTargetsForTool(context: ReasoningPositionContext, name: string, args: Record<string, unknown>, result: ReasoningToolResult): WikibooksTarget[] {
+  return targetsForTool(context,name,args,result).targets;
+}
+export function wikibooksTargetsForToolIndexed(context: ReasoningPositionContext, name: string, args: Record<string, unknown>, result: ReasoningToolResult, catalog: WikibooksIndex) {
+  return targetsForTool(context,name,args,result,catalog);
+}
+
+/** Check board positions before allocating possibly long page-address strings.
+ * Ancestors follow the actual replayed path, including tool continuations. */
+function targetsForTool(context: ReasoningPositionContext, name: string, args: Record<string, unknown>, result: ReasoningToolResult, catalog?: WikibooksIndex): {targets:WikibooksTarget[];positionChecks:number;candidateCount:number} {
+  const empty = () => ({targets:[] as WikibooksTarget[],positionChecks:0,candidateCount:0});
+  if (result.contextHash !== reasoningContextHash(context) || result.tool !== name) return empty();
+  if (name === 'analyze_game_position' || name === 'test_game_line') {
+    try {
+      const root = recordedEvidenceContext(context,result.data.recordedPosition), details = object(result.data.details);
+      if (Number(args.ply) !== Number(object(result.data.recordedPosition).ply) || !recordedDetailsMatch(root,details)) return empty();
+      const mapped = name === 'test_game_line' ? 'test_line' : args.rootMoves ? 'compare_moves' : 'explore_continuations';
+      return targetsForTool(root,mapped,{...args,phase:'after',...(args.rootMoves?{movesUci:args.rootMoves}:{})},
+        {...result,tool:mapped,contextHash:reasoningContextHash(root),data:details as ReasoningToolResult['data']},catalog);
+    } catch { return empty(); }
+  }
+  if (!['analyze_move','inspect_position','compare_moves','enumerate_defenses','explore_continuations','test_line'].includes(name)) return empty();
+  try {
+    validateReasoningPositionContext(context);
+    const board = new Chess();
+    if (context.historyStartFen && new Chess(context.historyStartFen).fen() !== board.fen()) return empty();
+    const sans:string[] = [], fens = [board.fen()];
+    for (const uci of [...context.historyUci,...(context.kind === 'position'?[]:[context.moveUci])]) {
+      sans.push(board.move({from:uci.slice(0,2),to:uci.slice(2,4),promotion:uci[4]}).san); fens.push(board.fen());
+    }
+    if (board.fen() !== new Chess(context.fenAfter).fen()) return empty();
+    const targets = new Map<string,WikibooksTarget>(), seen = new Set<string>();
+    let positionChecks=0,candidateCount=0;
+    const add = (moves:string[],positions:string[],relation:WikibooksTarget['relation']) => {
+      const key=moves.join(' ');
+      if (seen.has(key)) return;
+      seen.add(key); candidateCount++;
+      if (!catalog) {const title=moves.length?openingTitle(moves):'Chess Opening Theory';targets.set(title,{title,relation});return;}
+      for (let distance=0;distance<=2 && moves.length-distance>0;distance++) {
+        positionChecks++;
+        if (!catalog.byPosition.has(positionKey(positions[moves.length-distance]))) continue;
+        const title=openingTitle(moves);
+        if (!targets.has(title)) targets.set(title,{title,relation});
+        break;
+      }
+    };
+    const beforeLength=context.kind === 'position'?sans.length:sans.length-1;
+    if (name === 'analyze_move') {
+      if(context.kind !== 'position')add(sans.slice(0,beforeLength),fens.slice(0,beforeLength+1),'before');
+      add(sans,fens,'current'); return {targets:[...targets.values()],positionChecks,candidateCount};
+    }
+    const phase=name === 'enumerate_defenses'?'after':args.phase??'after';
+    if (phase !== 'before' && phase !== 'after') return empty();
+    const length=phase === 'before'?beforeLength:sans.length, baseSans=sans.slice(0,length), baseFens=fens.slice(0,length+1), fen=baseFens.at(-1)!;
+    const data=object(result.data),scope=object(data.searchScope);
+    if (data.phase !== undefined && data.phase !== phase || name !== 'test_line' && scope.fen !== undefined && scope.fen !== fen) return empty();
+    add(baseSans,baseFens,phase === 'before' && context.kind !== 'position'?'before':'current');
+    const path=(moves:string[],expectedFen?:string) => {
+      const branch=new Chess(fen), branchSans=[...baseSans],branchFens=[...baseFens];
+      try {
+        for(const uci of moves){branchSans.push(branch.move({from:uci.slice(0,2),to:uci.slice(2,4),promotion:uci[4]}).san);branchFens.push(branch.fen());}
+        if(expectedFen && branch.fen()!==expectedFen)return false;
+        for(let end=baseSans.length+1;end<=branchSans.length;end++)add(branchSans.slice(0,end),branchFens.slice(0,end+1),'continuation');
+        return true;
+      } catch {return false;}
+    };
+    if(name === 'compare_moves' || name === 'enumerate_defenses'){
+      const requested=ucis(name === 'compare_moves'?args.movesUci:args.rootMoves)??[],returned=ucis(data.rootMoves)??[];
+      for(const move of new Set([...requested,...returned]))path([move]);
+    } else if(name === 'test_line'){
+      const moves=ucis(args.movesUci);
+      if(!moves || moves.length>32 || typeof data.finalFen!=='string' || !path(moves,data.finalFen))return empty();
+      if(scope.fen===data.finalFen && Array.isArray(data.lines))for(const candidate of data.lines){
+        const line=object(candidate),pv=ucis(line.pv);if(pv?.length && line.rootMove===pv[0])path([...moves,...pv].slice(0,32));
+      }
+    } else if(name === 'explore_continuations' && scope.fen===fen && Array.isArray(data.lines))for(const candidate of data.lines){
+      const line=object(candidate),pv=ucis(line.pv);if(pv?.length && line.rootMove===pv[0])path(pv.slice(0,32));
+    }
+    return {targets:[...targets.values()],positionChecks,candidateCount};
+  } catch {return empty();}
+}

package/src/player-perspective.ts

@@ -0,0 +1,41 @@
+export type PlayerPerspective = Readonly<{
+  side: "white" | "black";
+  basis: "linked-lichess-identity" | "chesscom-lookup-handle";
+}>;
+
+export type PlayerPerspectiveIdentity = Readonly<{
+  provider: string;
+  providerUserId: string;
+  displayName: string;
+}>;
+
+function normalizedPlayerName(value: unknown) {
+  return String(value || "").trim().toLocaleLowerCase();
+}
+
+function uniquelyMatchedSide(white: string, black: string, names: readonly string[]): PlayerPerspective["side"] | null {
+  const candidates = new Set(names.map(normalizedPlayerName).filter(Boolean));
+  if (!candidates.size) return null;
+  const whiteMatch = candidates.has(normalizedPlayerName(white));
+  const blackMatch = candidates.has(normalizedPlayerName(black));
+  return whiteMatch === blackMatch ? null : whiteMatch ? "white" : "black";
+}
+
+/** Resolve the current viewer's side without using board orientation or stored game data. */
+export function resolvePlayerPerspective(input: {
+  white: string;
+  black: string;
+  providerIdentities?: readonly PlayerPerspectiveIdentity[];
+  chessComLookupHandle?: string;
+}): PlayerPerspective | null {
+  const lichessNames = (input.providerIdentities || [])
+    .filter((identity) => identity.provider === "lichess")
+    .flatMap((identity) => [identity.providerUserId, identity.displayName]);
+  const lichessSide = uniquelyMatchedSide(input.white, input.black, lichessNames);
+  const chessComSide = uniquelyMatchedSide(input.white, input.black, [input.chessComLookupHandle || ""]);
+  if (lichessSide && chessComSide && lichessSide !== chessComSide) return null;
+  if (lichessSide) return { side: lichessSide, basis: "linked-lichess-identity" };
+  if (chessComSide) return { side: chessComSide, basis: "chesscom-lookup-handle" };
+  return null;
+}
+

package/src/shared-exports.ts

@@ -0,0 +1,23 @@
+/** Pure host protocol, presentation and error helpers; no model connector or answer loop. */
+export * from './ai-request-failure';
+export * from './ai-request-limits';
+export * from './ai-routing-diagnostics';
+export * from './player-perspective';
+export {validateReasoningPositionContext,reasoningContextHash,createContextEvidence,createQueryContract,DEFAULT_REASONING_RUN_CONTROLS,REASONING_POC_VERSION} from './chess-reasoning/poc-contracts';
+export {toPositionAnalysis,toLegacyPositionAnalysis,toPositionAnalysisProvider,toLegacyPositionAnalysisProvider} from './chess-reasoning/position-analysis-contracts';
+export {simpleProseReferences,SIMPLE_REFERENCE_VERSION,safeSimpleSourceLink,decorateSimpleVariations,repairFrozenCitationLabels,stripSimpleMarkdownFences,stripSimpleCitationLinks} from './chess-reasoning/simple-prose-references';
+export {admitFreshEnginePvWitnesses,MAX_FRESH_ENGINE_WITNESS_ACQUISITIONS} from './chess-reasoning/fresh-engine-pv-witnesses';
+export {MAX_INTERACTIVE_LINE_PLIES} from './chess-reasoning/reference-limits';
+export {recordedMainLineResult} from './chess-reasoning/recorded-main-line';
+export {recordedNavigation,historyPositionContext} from './chess-reasoning/recorded-reference-context';
+export {classificationTargetAtSelection} from './chess-reasoning/classification-question-target';
+export {scopePositionAnalysis} from './chess-reasoning/position-analysis-scope';
+export {priorConversationMessages} from './chess-reasoning/conversation-context';
+export {parseOpeningSourceCredits,openingSourceLinks,OPENING_SOURCE_LICENSE_URL,openingSourcesInMessages} from './chess-reasoning/opening-source-credits';
+export {openingTitle,positionKey,replayWikibooksTitle,selectIndexedOpening,decodeWikibooksIndex} from './chess-reasoning/wikibooks-index';
+export {QUESTION_ROUTING_VERSION,classifyQuestionRoutingAnswers,classifyReviewSubject,makeQuestionRoutingRequest,parseQuestionRoutingAnswers,hasMoveClassificationQuestion,moveSectionScope,REVIEW_SUBJECTS} from './chess-reasoning/question-routing';
+export {SIMPLE_TOOL_AGENT_VERSION} from './chess-reasoning/simple-runtime-version';
+export {SIMPLE_MODEL_CATALOGUE,simpleEffortsForModel,validateSimpleAgentConfig,selectSimpleModel,SIMPLE_EXTENSION_CONFIGS,SIMPLE_VENDOR_CONFIGS,EVALUATED_ASTRA_CONFIG} from './chess-reasoning/simple-agent-config';
+export {hasSharedEvidence,expandSharedEvidence,EVIDENCE_SHARING_VERSION,shareEvidence,shareEvidenceMessages} from './chess-reasoning/lossless-evidence-sharing';
+// Public types are erased and do not bring the pipeline into a browser runtime.
+export type * from './chess-reasoning/answer-pipeline-exports';