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

package/dist/runtime-closure.json

@@ -0,0 +1,103 @@
+{
+  "runtimeInputs": [
+    "src/ai-request-failure.ts",
+    "src/ai-request-limits.ts",
+    "src/ai-routing-diagnostics.ts",
+    "src/chess-reasoning/ablation-adaptive-evidence-loop.ts",
+    "src/chess-reasoning/ablation-adaptive-runtime.ts",
+    "src/chess-reasoning/ablation-direct-synthesis.ts",
+    "src/chess-reasoning/ablation-evidence-bundle.ts",
+    "src/chess-reasoning/ablation-evidence-capture.ts",
+    "src/chess-reasoning/ablation-lean-direct-runtime.ts",
+    "src/chess-reasoning/ablation-model-facing-evidence.ts",
+    "src/chess-reasoning/ablation-transport-correction.ts",
+    "src/chess-reasoning/ai-sdk-runtime-support.ts",
+    "src/chess-reasoning/answer-model-connector.ts",
+    "src/chess-reasoning/answer-pipeline-exports.ts",
+    "src/chess-reasoning/answer-pipeline.ts",
+    "src/chess-reasoning/answer-reference-validation.ts",
+    "src/chess-reasoning/answer-tool-host.ts",
+    "src/chess-reasoning/branch-expansion-policy.ts",
+    "src/chess-reasoning/branch-expansion.ts",
+    "src/chess-reasoning/causal-claim-checks.ts",
+    "src/chess-reasoning/chess-reference-dictionary.ts",
+    "src/chess-reasoning/classification-question-target.ts",
+    "src/chess-reasoning/classification-reassessment.ts",
+    "src/chess-reasoning/compact-search-preparation.ts",
+    "src/chess-reasoning/concept-registry.ts",
+    "src/chess-reasoning/conversation-context.ts",
+    "src/chess-reasoning/engine-search-failure.ts",
+    "src/chess-reasoning/evidence-citation-normalization.ts",
+    "src/chess-reasoning/evidence-licenses.ts",
+    "src/chess-reasoning/existing-analysis-context.ts",
+    "src/chess-reasoning/fact-observation-provider.ts",
+    "src/chess-reasoning/fact-provider.ts",
+    "src/chess-reasoning/fresh-engine-pv-witnesses.ts",
+    "src/chess-reasoning/historical-prose.ts",
+    "src/chess-reasoning/idea-graph.ts",
+    "src/chess-reasoning/initial-search-plan.ts",
+    "src/chess-reasoning/lossless-evidence-sharing.ts",
+    "src/chess-reasoning/matched-comparison.ts",
+    "src/chess-reasoning/material-accounting.ts",
+    "src/chess-reasoning/material-format.ts",
+    "src/chess-reasoning/mechanical-fact-provider.ts",
+    "src/chess-reasoning/mechanical-ray-facts.ts",
+    "src/chess-reasoning/mechanism-presentation.ts",
+    "src/chess-reasoning/move-mechanism-facts.ts",
+    "src/chess-reasoning/native-answer-connector.ts",
+    "src/chess-reasoning/opening-source-credits.ts",
+    "src/chess-reasoning/opponent-threat-preparation.ts",
+    "src/chess-reasoning/piece-identities.ts",
+    "src/chess-reasoning/poc-contracts.ts",
+    "src/chess-reasoning/poc-hypotheses.ts",
+    "src/chess-reasoning/poc-move-witnesses.ts",
+    "src/chess-reasoning/poc-observations.ts",
+    "src/chess-reasoning/poc-piece-refs.ts",
+    "src/chess-reasoning/poc-plan-model.ts",
+    "src/chess-reasoning/poc-semantic-text.ts",
+    "src/chess-reasoning/poc-tools.ts",
+    "src/chess-reasoning/portable-answer-runtime.ts",
+    "src/chess-reasoning/position-analysis-contracts.ts",
+    "src/chess-reasoning/position-analysis-scope.ts",
+    "src/chess-reasoning/preparation-consolidation.ts",
+    "src/chess-reasoning/production-observation-provider.ts",
+    "src/chess-reasoning/question-routing.ts",
+    "src/chess-reasoning/recorded-main-line.ts",
+    "src/chess-reasoning/recorded-position-tools.ts",
+    "src/chess-reasoning/recorded-reference-context.ts",
+    "src/chess-reasoning/recorded-selected-classification.ts",
+    "src/chess-reasoning/reference-limits.ts",
+    "src/chess-reasoning/research-exports.ts",
+    "src/chess-reasoning/saved-score-presentation.ts",
+    "src/chess-reasoning/score-comparison-notices.ts",
+    "src/chess-reasoning/server-simple-policy.ts",
+    "src/chess-reasoning/simple-agent-config.ts",
+    "src/chess-reasoning/simple-board-analysis.ts",
+    "src/chess-reasoning/simple-compact-evidence.ts",
+    "src/chess-reasoning/simple-completion.ts",
+    "src/chess-reasoning/simple-engine-presentation.ts",
+    "src/chess-reasoning/simple-evidence-preparation.ts",
+    "src/chess-reasoning/simple-evidence-view.ts",
+    "src/chess-reasoning/simple-explanation-coverage.ts",
+    "src/chess-reasoning/simple-fact-delivery.ts",
+    "src/chess-reasoning/simple-fallback-premise.ts",
+    "src/chess-reasoning/simple-prose-references.ts",
+    "src/chess-reasoning/simple-runtime-version.ts",
+    "src/chess-reasoning/stable.ts",
+    "src/chess-reasoning/tool-input-loop-guard.ts",
+    "src/chess-reasoning/types.ts",
+    "src/chess-reasoning/visible-support-lines.ts",
+    "src/chess-reasoning/wikibooks-index.ts",
+    "src/chess-reasoning/wikibooks-tool-context.ts",
+    "src/player-perspective.ts",
+    "src/shared-exports.ts"
+  ],
+  "externalImports": [
+    "chess.js",
+    "ai",
+    "@knights-eye-chess/move-classifier/contracts",
+    "@ai-sdk/provider",
+    "@ai-sdk/provider-utils"
+  ],
+  "runtimeBytes": 969108
+}

package/dist/shared-runtime-closure.json

@@ -0,0 +1,39 @@
+{
+  "runtimeInputs": [
+    "src/ai-request-failure.ts",
+    "src/ai-request-limits.ts",
+    "src/ai-routing-diagnostics.ts",
+    "src/chess-reasoning/classification-question-target.ts",
+    "src/chess-reasoning/conversation-context.ts",
+    "src/chess-reasoning/evidence-citation-normalization.ts",
+    "src/chess-reasoning/evidence-licenses.ts",
+    "src/chess-reasoning/fresh-engine-pv-witnesses.ts",
+    "src/chess-reasoning/historical-prose.ts",
+    "src/chess-reasoning/lossless-evidence-sharing.ts",
+    "src/chess-reasoning/material-accounting.ts",
+    "src/chess-reasoning/move-mechanism-facts.ts",
+    "src/chess-reasoning/opening-source-credits.ts",
+    "src/chess-reasoning/piece-identities.ts",
+    "src/chess-reasoning/poc-contracts.ts",
+    "src/chess-reasoning/poc-move-witnesses.ts",
+    "src/chess-reasoning/poc-piece-refs.ts",
+    "src/chess-reasoning/position-analysis-contracts.ts",
+    "src/chess-reasoning/position-analysis-scope.ts",
+    "src/chess-reasoning/question-routing.ts",
+    "src/chess-reasoning/recorded-main-line.ts",
+    "src/chess-reasoning/recorded-reference-context.ts",
+    "src/chess-reasoning/reference-limits.ts",
+    "src/chess-reasoning/saved-score-presentation.ts",
+    "src/chess-reasoning/simple-agent-config.ts",
+    "src/chess-reasoning/simple-prose-references.ts",
+    "src/chess-reasoning/simple-runtime-version.ts",
+    "src/chess-reasoning/stable.ts",
+    "src/chess-reasoning/types.ts",
+    "src/chess-reasoning/wikibooks-index.ts",
+    "src/player-perspective.ts",
+    "src/shared-exports.ts"
+  ],
+  "externalImports": [
+    "chess.js"
+  ]
+}

package/dist/shared.js

@@ -0,0 +1,152 @@
+import {
+  AI_MODEL_CONTEXT_MAX_BYTES,
+  AI_RELAY_MAX_REQUEST_BYTES,
+  AI_ROUTING_HEADER,
+  DEFAULT_REASONING_RUN_CONTROLS,
+  EVALUATED_ASTRA_CONFIG,
+  EVIDENCE_SHARING_VERSION,
+  MAX_FRESH_ENGINE_WITNESS_ACQUISITIONS,
+  MAX_INTERACTIVE_LINE_PLIES,
+  OPENING_SOURCE_LICENSE_URL,
+  QUESTION_ROUTING_VERSION,
+  REASONING_POC_VERSION,
+  REVIEW_SUBJECTS,
+  SIMPLE_EXTENSION_CONFIGS,
+  SIMPLE_MODEL_CATALOGUE,
+  SIMPLE_REFERENCE_VERSION,
+  SIMPLE_TOOL_AGENT_VERSION,
+  SIMPLE_VENDOR_CONFIGS,
+  admitFreshEnginePvWitnesses,
+  aiFailureDetails,
+  aiFailureMessage,
+  classificationTargetAtSelection,
+  classifyQuestionRoutingAnswers,
+  classifyReviewSubject,
+  createContextEvidence,
+  createQueryContract,
+  decodeWikibooksIndex,
+  decorateSimpleVariations,
+  expandSharedEvidence,
+  failureFromError,
+  hasMoveClassificationQuestion,
+  hasSharedEvidence,
+  historyPositionContext,
+  makeQuestionRoutingRequest,
+  moveSectionScope,
+  openingSourceLinks,
+  openingSourcesInMessages,
+  openingTitle,
+  parseOpeningSourceCredits,
+  parseQuestionRoutingAnswers,
+  positionKey,
+  priorConversationMessages,
+  readAiRoutingDiagnostics,
+  reasoningContextHash,
+  recordedMainLineResult,
+  recordedNavigation,
+  repairFrozenCitationLabels,
+  replayWikibooksTitle,
+  safeSimpleSourceLink,
+  scopePositionAnalysis,
+  selectIndexedOpening,
+  selectSimpleModel,
+  shareEvidence,
+  shareEvidenceMessages,
+  simpleEffortsForModel,
+  simpleProseReferences,
+  stripSimpleCitationLinks,
+  stripSimpleMarkdownFences,
+  toLegacyPositionAnalysis,
+  toLegacyPositionAnalysisProvider,
+  toPositionAnalysis,
+  toPositionAnalysisProvider,
+  validateReasoningPositionContext,
+  validateSimpleAgentConfig
+} from "./chunk-XQDZJOYD.js";
+
+// src/player-perspective.ts
+function normalizedPlayerName(value) {
+  return String(value || "").trim().toLocaleLowerCase();
+}
+function uniquelyMatchedSide(white, black, names) {
+  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";
+}
+function resolvePlayerPerspective(input) {
+  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;
+}
+export {
+  AI_MODEL_CONTEXT_MAX_BYTES,
+  AI_RELAY_MAX_REQUEST_BYTES,
+  AI_ROUTING_HEADER,
+  DEFAULT_REASONING_RUN_CONTROLS,
+  EVALUATED_ASTRA_CONFIG,
+  EVIDENCE_SHARING_VERSION,
+  MAX_FRESH_ENGINE_WITNESS_ACQUISITIONS,
+  MAX_INTERACTIVE_LINE_PLIES,
+  OPENING_SOURCE_LICENSE_URL,
+  QUESTION_ROUTING_VERSION,
+  REASONING_POC_VERSION,
+  REVIEW_SUBJECTS,
+  SIMPLE_EXTENSION_CONFIGS,
+  SIMPLE_MODEL_CATALOGUE,
+  SIMPLE_REFERENCE_VERSION,
+  SIMPLE_TOOL_AGENT_VERSION,
+  SIMPLE_VENDOR_CONFIGS,
+  admitFreshEnginePvWitnesses,
+  aiFailureDetails,
+  aiFailureMessage,
+  classificationTargetAtSelection,
+  classifyQuestionRoutingAnswers,
+  classifyReviewSubject,
+  createContextEvidence,
+  createQueryContract,
+  decodeWikibooksIndex,
+  decorateSimpleVariations,
+  expandSharedEvidence,
+  failureFromError,
+  hasMoveClassificationQuestion,
+  hasSharedEvidence,
+  historyPositionContext,
+  makeQuestionRoutingRequest,
+  moveSectionScope,
+  openingSourceLinks,
+  openingSourcesInMessages,
+  openingTitle,
+  parseOpeningSourceCredits,
+  parseQuestionRoutingAnswers,
+  positionKey,
+  priorConversationMessages,
+  readAiRoutingDiagnostics,
+  reasoningContextHash,
+  recordedMainLineResult,
+  recordedNavigation,
+  repairFrozenCitationLabels,
+  replayWikibooksTitle,
+  resolvePlayerPerspective,
+  safeSimpleSourceLink,
+  scopePositionAnalysis,
+  selectIndexedOpening,
+  selectSimpleModel,
+  shareEvidence,
+  shareEvidenceMessages,
+  simpleEffortsForModel,
+  simpleProseReferences,
+  stripSimpleCitationLinks,
+  stripSimpleMarkdownFences,
+  toLegacyPositionAnalysis,
+  toLegacyPositionAnalysisProvider,
+  toPositionAnalysis,
+  toPositionAnalysisProvider,
+  validateReasoningPositionContext,
+  validateSimpleAgentConfig
+};

package/dist/types/ai-request-failure.d.ts

@@ -0,0 +1,14 @@
+/** Public finite error vocabulary. Never copy arbitrary provider text or transport bodies. */
+export type AiFailureDetails = {
+    code: string;
+    status?: number;
+    retryAfterSeconds?: number;
+    providerDispatched?: boolean;
+    requestId?: string;
+    providerRequestId?: string;
+    stage: string;
+    reportable: boolean;
+};
+export declare function aiFailureDetails(code: string, fields?: Partial<AiFailureDetails>): AiFailureDetails;
+export declare function aiFailureMessage(f: AiFailureDetails, reported?: boolean): string;
+export declare function failureFromError(error: unknown, code?: string): AiFailureDetails;

package/dist/types/ai-request-limits.d.ts

@@ -0,0 +1,4 @@
+/** Byte safety ceilings, not token estimates. Wire encoding, server policy and
+ * opaque provider continuation require headroom beyond model evidence JSON. */
+export declare const AI_MODEL_CONTEXT_MAX_BYTES = 1000000;
+export declare const AI_RELAY_MAX_REQUEST_BYTES = 2000000;

package/dist/types/ai-routing-diagnostics.d.ts

@@ -0,0 +1,14 @@
+/** Public, bounded routing facts only. Never provider text, headers or credentials. */
+export declare const AI_ROUTING_HEADER = "x-knights-eye-ai-routing";
+export type AiRoutingDiagnostics = {
+    requestedTier: 'flex' | 'default' | 'priority' | null;
+    actualTier: 'flex' | 'default' | 'priority' | null;
+    reason: 'flex_available' | 'cooldown_active' | 'storage_unavailable' | 'unsupported' | 'user_disabled' | 'user_standard' | 'user_fast';
+    elapsedMs: number;
+    slowThresholdMs: number;
+    timingEligible?: boolean;
+    cooldownUntil: number | null;
+    cooldownTriggered: boolean;
+    persistenceError?: boolean;
+};
+export declare function readAiRoutingDiagnostics(headers?: Headers | Record<string, string>): AiRoutingDiagnostics | undefined;

package/dist/types/chess-reasoning/ablation-adaptive-evidence-loop.d.ts

@@ -0,0 +1,127 @@
+import { type LanguageModel, type LanguageModelCallOptions } from "ai";
+import type { AdaptiveEvidenceLoop, AdaptiveEvidenceLoopInput, AdaptiveEvidenceLoopResult } from "./ablation-adaptive-runtime.js";
+import { type AblationEvidenceClosureBundle } from "./ablation-evidence-bundle.js";
+import { type ObservableLlmTraceSink } from "./ai-sdk-runtime-support.js";
+import { type ReasoningPositionContext, type ReasoningToolName, type ReasoningToolResult } from "./poc-contracts.js";
+/**
+ * A deliberately transparent evidence adapter for B/B′. Unlike ToolLoopAgent,
+ * it makes one provider request for each decision, so an ablation runner can
+ * put a fresh cache-isolation nonce at the start of every provider request.
+ */
+export declare const ABLATION_ADAPTIVE_EVIDENCE_LOOP_VERSION: "architecture-ablation-adaptive-evidence-loop/2";
+export declare const ADAPTIVE_EVIDENCE_DECISION_SCHEMA: Readonly<{
+    type: "object";
+    additionalProperties: false;
+    required: string[];
+    properties: {
+        schemaVersion: {
+            const: "architecture-ablation-adaptive-evidence-loop/2";
+        };
+        decision: {
+            oneOf: ({
+                type: string;
+                additionalProperties: boolean;
+                required: string[];
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    tool: {
+                        type: string;
+                        minLength: number;
+                        maxLength: number;
+                    };
+                    input: {
+                        type: string;
+                    };
+                    selectionRationale: {
+                        type: string;
+                        minLength: number;
+                        maxLength: number;
+                    };
+                    modelStatedRationale: {
+                        type: string;
+                        minLength: number;
+                        maxLength: number;
+                    };
+                    rationale?: undefined;
+                };
+            } | {
+                type: string;
+                additionalProperties: boolean;
+                required: string[];
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    rationale: {
+                        type: string;
+                        minLength: number;
+                        maxLength: number;
+                    };
+                    modelStatedRationale: {
+                        type: string;
+                        minLength: number;
+                        maxLength: number;
+                    };
+                    tool?: undefined;
+                    input?: undefined;
+                    selectionRationale?: undefined;
+                };
+            })[];
+        };
+    };
+}>;
+export type AdaptiveEvidenceToolExecutorInput = Readonly<{
+    callId: string;
+    requestId: string;
+    tool: ReasoningToolName;
+    input: Record<string, unknown>;
+    context: Readonly<ReasoningPositionContext>;
+    signal?: AbortSignal;
+}>;
+/** Browser and Node hosts adapt their existing exact fact/probe toolset here. */
+export interface AdaptiveEvidenceToolExecutor {
+    execute(input: AdaptiveEvidenceToolExecutorInput): Promise<ReasoningToolResult>;
+}
+export type AdaptiveEvidenceProviderMetadata = Readonly<{
+    cost?: number | null;
+    cacheTokens?: number | null;
+}>;
+export type AdaptiveEvidenceLoopOptions = Readonly<{
+    model: LanguageModel;
+    toolExecutor: AdaptiveEvidenceToolExecutor;
+    maxOutputTokens: number;
+    /** Optional compact, immutable subset; the full source stays local for retrieval. */
+    initialEvidenceView?: Readonly<AblationEvidenceClosureBundle>;
+    discoverRetainedEvidence?: boolean;
+    observableTraceSink?: ObservableLlmTraceSink;
+    reasoning?: NonNullable<LanguageModelCallOptions["reasoning"]>;
+    temperature?: number;
+    /** Optional sanitized relay metadata; never provider bodies or credentials. */
+    consumeProviderMetadata?: () => readonly AdaptiveEvidenceProviderMetadata[];
+}>;
+/** Discovery metadata is not evidence; retrieval preserves the source records verbatim. */
+export declare function retainedEvidenceCatalogue(bundle: Readonly<AblationEvidenceClosureBundle>): {
+    id: string;
+    kind: import("./poc-contracts.js").ReasoningEvidenceKind;
+    source: string;
+    preview: string;
+    previewTruncated: boolean;
+    scope: string | number | true | import("./types.js").SemanticValue[] | {
+        [key: string]: import("./types.js").SemanticValue;
+    };
+    licenses: import("./evidence-licenses.js").EvidenceLicense[] | undefined;
+    observations: {
+        type: string;
+        factKind: string | number | true | import("./types.js").SemanticValue[] | {
+            [key: string]: import("./types.js").SemanticValue;
+        } | null;
+    }[];
+}[];
+/** A browser/Node-neutral implementation of B/B′'s model-owned evidence loop. */
+export declare class ModelOwnedAdaptiveEvidenceLoop implements AdaptiveEvidenceLoop {
+    private readonly options;
+    constructor(options: AdaptiveEvidenceLoopOptions);
+    run(input: AdaptiveEvidenceLoopInput): Promise<AdaptiveEvidenceLoopResult>;
+}

package/dist/types/chess-reasoning/ablation-adaptive-runtime.d.ts

@@ -0,0 +1,178 @@
+import { type LanguageModel, type LanguageModelCallOptions } from "ai";
+import { type DirectSynthesisArtifact, type DirectSynthesisIssue } from "./ablation-direct-synthesis.js";
+import { type AblationEvidenceClosureBundle, type AblationEvidenceClosureCoverage, type AblationProbeTelemetry } from "./ablation-evidence-bundle.js";
+import type { ReasoningObservation, ReasoningToolDescriptor, ReasoningToolName, ReasoningToolResult } from "./poc-contracts.js";
+export { AblationTransportCorrectionError, assertTransportOnlyDirectCorrection } from "./ablation-transport-correction.js";
+/** @deprecated Use AblationTransportCorrectionError from the shared module. */
+export { AblationTransportCorrectionError as AdaptiveTransportCorrectionError } from "./ablation-transport-correction.js";
+/**
+ * Adaptive direct arms remain deliberately outside the staged-C review chain.
+ * The evidence-loop boundary is injectable so the browser and Node adapters can
+ * drive the same episode without giving this experiment its own tool runtime.
+ */
+export declare const ABLATION_ADAPTIVE_RUNTIME_VERSION: "architecture-ablation-adaptive-runtime/2";
+export declare const ABLATION_B_SYSTEM = "You are Knight's Eye in adaptive direct arm B. You may use only the supplied bounded fact and probe tools to acquire evidence about the selected move. Work iteratively, stop as soon as the available evidence is sufficient, and do not infer purpose, safety, forcedness, or a plan merely from a legal move. The verbatim user question is authoritative. You receive no later game history, evaluator answer keys, graph, critic, review, checkpoint, or render state.";
+export declare const ABLATION_B_DIRECT_SYSTEM = "You are Knight's Eye in adaptive direct arm B. Return exactly one object matching the direct-synthesis schema over the frozen evidence closure. This is a pre-checkpoint proposal, not a supported product answer. Cite only allowed evidence and observations. Evidence licenses are strict ceilings: legal sequence evidence establishes legality and identity, and bounded engine evidence establishes only the recorded bounded line, score, comparison, or response coverage. Do not claim intent, a forced plan, or strategic relevance unless the evidence itself licenses the bounded claim.";
+export declare const ABLATION_B_PRIME_CRITIC_SYSTEM = "You are the single bounded semantic reconsideration for Knight's Eye architecture-ablation arm B-prime. You have no tools and may not acquire evidence. Given a frozen direct proposal, explicit generic trigger values, and the same frozen evidence closure, decide whether the proposal can be retained or needs one corrected replacement. A correction may only use existing IDs and evidence licenses; it may narrow, qualify, or remove unsupported meaning but may not add evidence, broaden authority, change the user question, or invoke another critic. Return exactly the required object.";
+export declare const ABLATION_B_PRIME_TRIGGER_VALUES: readonly ["claim.forced-best-unique-safe-winning-principal-purpose", "coverage.requested-defense-or-continuation-incomplete", "evidence.conflict", "claim.sacrifice-or-long-multistep", "plan.legal-affordance-only", "model.high-uncertainty", "validation.semantic-reconsideration-required"];
+export type AblationAdaptiveArm = "B" | "B-prime";
+export type AblationBPrimeTrigger = typeof ABLATION_B_PRIME_TRIGGER_VALUES[number];
+export type AdaptiveCallUsage = {
+    inputTokens: number | null;
+    outputTokens: number | null;
+    latencyMs: number | null;
+    cache: {
+        hits: number;
+        misses: number;
+    };
+    cost: number | null;
+};
+export type AdaptiveEvidenceToolRound = {
+    /** Monotonic across both returned and failed tool executions. */
+    attempt: number;
+    callId: string;
+    requestId: string;
+    tool: ReasoningToolName;
+    input: Record<string, unknown>;
+    selectionRationale: string;
+    modelStatedRationale: string | null;
+    result: ReasoningToolResult;
+    usage: AdaptiveCallUsage;
+};
+/**
+ * A requested tool is still a telemetry event when its host execution fails.
+ * Keep this transport-only record separate from a valid tool result: inventing
+ * a result/evidence record for a failure would make the closure dishonest.
+ */
+export type AdaptiveEvidenceToolFailure = {
+    attempt: number;
+    callId: string;
+    requestId: string;
+    tool: ReasoningToolName;
+    input: Record<string, unknown>;
+    selectionRationale: string;
+    modelStatedRationale: string | null;
+    failureCode: "tool-execution-failed";
+    usage: AdaptiveCallUsage;
+};
+export type AdaptiveEvidenceStoppingReason = "model-finished" | "tool-budget-exhausted" | "probe-budget-exhausted" | "model-decision-budget-exhausted";
+export type AdaptiveEvidenceLoopResult = {
+    /** Only already-executed presemantic fact/probe calls may cross this boundary. */
+    rounds: readonly AdaptiveEvidenceToolRound[];
+    /** Requested executions that started but did not return an admissible result. */
+    failedToolCalls: readonly AdaptiveEvidenceToolFailure[];
+    /** Exact descriptors advertised to the model for this bounded episode. */
+    availableTools: readonly ReasoningToolDescriptor[];
+    /** Fact/probe evidence actually retained by the existing salience policy. */
+    saliencePresentedFactIds: readonly string[];
+    addedObservations?: readonly ReasoningObservation[];
+    coverage: AblationEvidenceClosureCoverage;
+    stopping: {
+        reason: AdaptiveEvidenceStoppingReason;
+        rationale: string;
+        unusedRelevantTools: ReasoningToolName[];
+    };
+    /** Counts provider calls made by the injected model-owned loop. */
+    modelCalls: number;
+    usage: AdaptiveCallUsage & {
+        corrections: number;
+    };
+};
+export type AdaptiveEvidenceLoopInput = {
+    arm: AblationAdaptiveArm;
+    system: string;
+    /** The first provider-visible bytes of every loop call must be this prefix. */
+    firstProviderVisiblePrefix: string;
+    /** Call once for every additional provider attempt/retry after the first. */
+    nextProviderVisiblePrefix: () => string;
+    bundle: Readonly<AblationEvidenceClosureBundle>;
+    tools: readonly ReasoningToolDescriptor[];
+    maxToolCalls: number;
+    maxProbeCalls: number;
+    maxModelSteps: number;
+    signal?: AbortSignal;
+};
+/**
+ * Adapters own tool-call transport and may use ToolLoopAgent. This contract
+ * makes its evidence output auditable while forbidding it from adding semantic
+ * state or bypassing production evidence records.
+ */
+export interface AdaptiveEvidenceLoop {
+    run(input: AdaptiveEvidenceLoopInput): Promise<AdaptiveEvidenceLoopResult>;
+}
+export type AblationAdaptiveCallDiagnostic = {
+    stage: "B-evidence" | "B-direct" | "B-prime-critic" | "B-transport-correction";
+    nonce: string;
+    inputBytes: number;
+    outputBytes: number | null;
+    latencyMs: number | null;
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cacheTokens: number | null;
+    cost: number | null;
+    correctionCount: number;
+    outcome: "succeeded" | "failed" | "skipped" | "aborted";
+    failureCode: string | null;
+};
+export type AblationAdaptiveRuntimeOptions = {
+    model: LanguageModel;
+    /**
+     * Optional isolated B-prime critic transport.  The original adaptive model
+     * and reasoning setting remain the backwards-compatible default for every
+     * stage unless the bounded critic explicitly supplies its own profile.
+     */
+    criticModel?: LanguageModel;
+    evidenceLoop: AdaptiveEvidenceLoop;
+    /** The exact fact/probe descriptor set exposed to the model-owned loop. */
+    evidenceTools: readonly ReasoningToolDescriptor[];
+    /** Fresh, opaque, unique values supplied by the benchmark runner. */
+    benchmarkNonceForCall: (stage: "evidence" | "direct" | "critic" | "transport-correction", ordinal: number) => string;
+    modelName?: string;
+    providerRoute?: string;
+    reasoning?: NonNullable<LanguageModelCallOptions["reasoning"]>;
+    criticReasoning?: NonNullable<LanguageModelCallOptions["reasoning"]>;
+    temperature?: number;
+    maxOutputTokens: number;
+    /** One precommitted wall-time envelope for the complete B/B′ episode. */
+    maxWallTimeMs: number;
+    maxToolCalls: number;
+    maxProbeCalls: number;
+    maxModelSteps: number;
+    triggerPolicy?: (input: AdaptiveTriggerPolicyInput) => readonly AblationBPrimeTrigger[];
+};
+export type AdaptiveTriggerPolicyInput = {
+    bundle: Readonly<AblationEvidenceClosureBundle>;
+    proposal: unknown;
+    artifact: DirectSynthesisArtifact | null;
+    initialIssues: readonly DirectSynthesisIssue[];
+};
+export type AblationAdaptiveFailure = {
+    code: "adaptive-evidence-loop-rejected" | "direct-synthesis-rejected" | "transport-correction-rejected" | "critic-rejected" | "provider-or-structured-output" | "adaptive-timeout" | "adaptive-aborted";
+    issues?: DirectSynthesisIssue[];
+};
+/** B/B′ deliberately start from the frozen initial-exact cell, never a prior enrichment. */
+export declare class AdaptiveAblationPreconditionError extends Error {
+    readonly code: "starting-bundle-must-be-original";
+    constructor();
+}
+export type AblationAdaptiveResult = {
+    arm: AblationAdaptiveArm;
+    ok: boolean;
+    bundle: Readonly<AblationEvidenceClosureBundle>;
+    artifact?: DirectSynthesisArtifact;
+    telemetry: Readonly<AblationProbeTelemetry>;
+    triggers: readonly AblationBPrimeTrigger[];
+    diagnostics: AblationAdaptiveCallDiagnostic[];
+    failure?: AblationAdaptiveFailure;
+};
+export declare function deriveAblationBPrimeTriggers(input: AdaptiveTriggerPolicyInput): AblationBPrimeTrigger[];
+/**
+ * C-plus consumes exactly B's model-owned evidence episode, then hands its
+ * admitted closure to the frozen C chain.  Keeping this adapter here prevents
+ * a second, subtly different evidence-to-bundle conversion in Gate 2.
+ */
+export declare function prepareAblationAdaptiveEvidenceForStagedReference(original: Readonly<AblationEvidenceClosureBundle>, loop: AdaptiveEvidenceLoopResult, evidenceTools: readonly ReasoningToolDescriptor[], limits: Pick<AblationAdaptiveRuntimeOptions, "maxToolCalls" | "maxProbeCalls" | "maxModelSteps">): Readonly<{
+    bundle: Readonly<AblationEvidenceClosureBundle>;
+    telemetry: Readonly<AblationProbeTelemetry>;
+}>;
+export declare function runAblationAdaptiveDirect(options: AblationAdaptiveRuntimeOptions, arm: AblationAdaptiveArm, original: Readonly<AblationEvidenceClosureBundle>, signal?: AbortSignal): Promise<AblationAdaptiveResult>;