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

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

@@ -0,0 +1,185 @@
+import { type ReasoningEvidenceRecord, type ReasoningObservation, type ReasoningPositionContext, type ReasoningToolDescriptor, type ReasoningToolName } from "./poc-contracts.js";
+import { type ReasoningMoveWitness } from "./poc-move-witnesses.js";
+/**
+ * A deliberately pre-semantic snapshot for the architecture ablation.  This
+ * is not a replay/checkpoint format: hypothesis, graph, and disposition
+ * state must remain outside the acquisition/deliberation boundary.
+ */
+export declare const ABLATION_EVIDENCE_BUNDLE_VERSION: "architecture-ablation-evidence-bundle/1";
+export declare const ABLATION_PROBE_TELEMETRY_VERSION: "architecture-ablation-probe-telemetry/2";
+export declare const PRECOMMITTED_PROBE_ATTRIBUTION_CATEGORIES: readonly ["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"];
+export type ProbeAttributionCategory = typeof PRECOMMITTED_PROBE_ATTRIBUTION_CATEGORIES[number];
+export type AblationBundleOmissionReason = "budget" | "not-requested" | "unavailable" | "withheld";
+export type AblationEvidenceClosureCoverage = {
+    complete: boolean;
+    covered: string[];
+    omitted: Array<{
+        domain: "observation" | "evidence" | "tool";
+        id: string;
+        reason: AblationBundleOmissionReason;
+    }>;
+    unavailable: Array<{
+        id: string;
+        reason: string;
+    }>;
+    limitations: string[];
+};
+export type AblationEvidenceReferenceAllowlists = {
+    evidenceIds: string[];
+    observationIds: string[];
+    toolNames: ReasoningToolName[];
+    semanticReferences: Array<{
+        domain: "piece" | "square" | "move";
+        id: string;
+    }>;
+    moveWitnesses: ReasoningMoveWitness[];
+};
+export type AblationEvidenceBundleLineage = {
+    kind: "original";
+} | {
+    kind: "enriched";
+    originalBundleHash: string;
+    acquiredEvidenceIds: string[];
+    acquiredObservationIds: string[];
+};
+export type AblationEvidenceClosureBundle = {
+    schemaVersion: typeof ABLATION_EVIDENCE_BUNDLE_VERSION;
+    contextHash: string;
+    context: ReasoningPositionContext;
+    question: string;
+    observations: ReasoningObservation[];
+    evidence: ReasoningEvidenceRecord[];
+    referenceAllowlists: AblationEvidenceReferenceAllowlists;
+    coverage: AblationEvidenceClosureCoverage;
+    lineage: AblationEvidenceBundleLineage;
+    bundleHash: string;
+};
+export type CreateAblationEvidenceClosureBundleInput = Omit<AblationEvidenceClosureBundle, "schemaVersion" | "contextHash" | "lineage" | "bundleHash">;
+export type EnrichAblationEvidenceClosureBundleInput = {
+    observations: ReasoningObservation[];
+    evidence: ReasoningEvidenceRecord[];
+    referenceAllowlists?: Partial<AblationEvidenceReferenceAllowlists>;
+    coverage: AblationEvidenceClosureCoverage;
+};
+export type AblationAnchorAcquirability = {
+    /** Evaluator metadata only; no evaluator anchor is carried in this value. */
+    telemetryOnly: true;
+    status: "not-applicable" | "acquirable-from-admitted-evidence" | "requires-probe" | "unacquirable-within-budget";
+    basisEvidenceIds: string[];
+    rationale: string;
+};
+export type AblationProbeEffect = "materially-changed" | "supported" | "narrowed" | "rejected" | "no-change" | "failure";
+export type AblationCalledProbe = {
+    callId: string;
+    requestId: string;
+    tool: ReasoningToolName;
+    request: {
+        descriptor: ReasoningToolDescriptor;
+        input: Record<string, unknown>;
+        selectionRationale: string;
+    };
+    target: {
+        fen: string;
+        historyThroughTargetHash: string;
+    };
+    permittedLimits: {
+        maxToolCalls: number;
+        maxProbeCalls: number;
+        engine: {
+            depth: number | null;
+            multiPv: number | null;
+            threads: number | null;
+            rootMoves: string[];
+        } | null;
+    };
+    approval: {
+        approved: boolean;
+        budgetReason: string;
+        remainingToolCalls: number;
+        remainingProbeCalls: number;
+    };
+    status: {
+        started: boolean;
+        finished: "not-started" | "returned" | "failed" | "cancelled";
+    };
+    returned: {
+        lines: number;
+        coverage: {
+            complete: boolean;
+            covered: string[];
+            unresolved: string[];
+        };
+    } | null;
+    admission: {
+        status: "admitted" | "withheld" | "rejected" | "not-produced";
+        reason: string;
+    };
+    admittedEvidence: Array<{
+        evidenceId: string;
+        licenses: string[];
+    }>;
+    presentation: {
+        presentedToModel: boolean;
+        reason: string;
+    };
+    semanticConsumption: {
+        status: "not-reached" | "not-consumed" | "consumed" | "misused";
+        hypothesisIds: string[];
+    };
+    modelStatedRationale: string | null;
+    effect: AblationProbeEffect;
+    hypothesisIds: string[];
+    usage: {
+        inputTokens: number | null;
+        outputTokens: number | null;
+        latencyMs: number | null;
+        cache: {
+            hits: number;
+            misses: number;
+        };
+        cost: number | null;
+        corrections: number;
+    };
+};
+export type AblationProbeTelemetry = {
+    schemaVersion: typeof ABLATION_PROBE_TELEMETRY_VERSION;
+    bundleHash: string;
+    beforeProbeEvidenceIds: string[];
+    postSaliencePresentedFactIds: string[];
+    availableTools: ReasoningToolDescriptor[];
+    calledProbes: AblationCalledProbe[];
+    missedAnchorAttributions: Array<{
+        /** Opaque evaluator-side handle; it never identifies or carries the anchor. */
+        anchorId: string;
+        category: ProbeAttributionCategory;
+        acquirability: AblationAnchorAcquirability;
+        unusedRelevantTools: ReasoningToolName[];
+    }>;
+    stopping: {
+        rationale: string;
+        unusedRelevantTools: ReasoningToolName[];
+    };
+    usage: {
+        modelCalls: number;
+        toolCalls: number;
+        inputTokens: number | null;
+        outputTokens: number | null;
+        latencyMs: number | null;
+        cache: {
+            hits: number;
+            misses: number;
+        };
+        cost: number | null;
+        corrections: number;
+    };
+    telemetryHash: string;
+};
+export type CreateAblationProbeTelemetryInput = Omit<AblationProbeTelemetry, "schemaVersion" | "bundleHash" | "telemetryHash">;
+export declare function ablationHistoryThroughTargetHash(context: ReasoningPositionContext): string;
+export declare function createAblationEvidenceClosureBundle(input: CreateAblationEvidenceClosureBundleInput): Readonly<AblationEvidenceClosureBundle>;
+export declare function enrichAblationEvidenceClosureBundle(original: Readonly<AblationEvidenceClosureBundle>, input: EnrichAblationEvidenceClosureBundleInput): Readonly<AblationEvidenceClosureBundle>;
+export declare function validateAblationEvidenceClosureBundle(value: unknown): asserts value is Readonly<AblationEvidenceClosureBundle>;
+export declare function createAblationProbeTelemetry(bundle: Readonly<AblationEvidenceClosureBundle>, input: CreateAblationProbeTelemetryInput): Readonly<AblationProbeTelemetry>;
+export declare function validateAblationProbeTelemetry(bundle: Readonly<AblationEvidenceClosureBundle>, value: unknown): asserts value is Readonly<AblationProbeTelemetry>;
+/** The fixed category order makes reporting stable and prevents ad-hoc labels. */
+export declare function precommittedProbeAttributionCategories(): readonly ProbeAttributionCategory[];

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

@@ -0,0 +1,37 @@
+import { type AblationEvidenceClosureBundle } from "./ablation-evidence-bundle.js";
+import { type ReasoningObservationSet, type ReasoningPositionContext, type ReasoningRankedObservationSet, type ReasoningToolResult } from "./poc-contracts.js";
+/**
+ * The capture boundary is deliberately narrower than a full reasoning trace:
+ * it accepts only the completed evidence-acquisition phase.  No model-created
+ * hypothesis, review, graph, or answer state can cross this boundary.
+ */
+export declare const ABLATION_EVIDENCE_CAPTURE_VERSION: "architecture-ablation-evidence-capture/1";
+export declare const CAPTURE_RESPONSE_FACT_KIND: "move.capture_response_availability_after";
+export declare const COMPLETED_TOOL_REPLAY_ADMISSION_KEY: "ablationCompletedToolReplayAdmission";
+export type AblationEvidenceCaptureInput = {
+    context: ReasoningPositionContext;
+    question: string;
+    /** Provider output before salience; retained to make membership auditable. */
+    observations: ReasoningObservationSet;
+    /** The exact output of the production salience policy for `observations`. */
+    rankedObservations: ReasoningRankedObservationSet;
+    /** Already completed fact/probe calls from the evidence phase. */
+    admittedToolResults?: readonly ReasoningToolResult[];
+    /**
+     * Retain exact fact records that the supplied salience result explicitly
+     * presents. This is for consumers whose model packet is defined by that
+     * production presentation decision; the original 2x2 baseline remains
+     * response-fact-withheld by default.
+     */
+    retainPresentedExactFacts?: boolean;
+    /** Generic acquisition keeps every admitted record discoverable; frozen 2x2 defaults stay unchanged. */
+    retainAllExactFacts?: boolean;
+};
+/** Freeze the evidence-acquisition state without allowing semantic artifacts across the boundary. */
+export declare function captureAblationOriginalEvidenceBundle(input: AblationEvidenceCaptureInput): Readonly<AblationEvidenceClosureBundle>;
+/**
+ * Derive the opt-in response-availability cell strictly from the immutable
+ * original closure. `null` means that the target/its already-admitted lines
+ * contain no capture, so the 2x2 experiment has no enriched cell to run.
+ */
+export declare function enrichAblationEvidenceBundleWithAdmittedCaptureResponses(original: Readonly<AblationEvidenceClosureBundle>): Readonly<AblationEvidenceClosureBundle> | null;

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

@@ -0,0 +1,193 @@
+import { type LanguageModel, type LanguageModelCallOptions } from "ai";
+import type { LeanDirectEvidenceSelector } from "./evidence-selector-contract.js";
+import { type AblationEvidenceClosureBundle } from "./ablation-evidence-bundle.js";
+import { type ObservableLlmTraceSink } from "./ai-sdk-runtime-support.js";
+/**
+ * A deliberately small development diagnostic. It is not a product stage and
+ * does not create hypotheses, a graph, a checkpoint, or an answer repair
+ * loop. Its purpose is to test whether the model can synthesize a useful,
+ * evidence-cited answer when the evidence transport is not the bottleneck.
+ */
+export declare const ABLATION_LEAN_DIRECT_RUNTIME_VERSION: "architecture-ablation-lean-direct-runtime/8";
+export declare const ABLATION_LEAN_DIRECT_PROPOSAL_VERSION: "architecture-ablation-lean-direct-proposal/3";
+export declare const ABLATION_LEAN_DIRECT_EVIDENCE_VIEW_VERSION: "architecture-ablation-lean-direct-evidence-view/2";
+/**
+ * The direct arm normally sees the production salience projection.  It also
+ * admits at most one already-captured bounded continuation/comparison record,
+ * plus observations that cite it. This is deterministic transport selection,
+ * not an engine call or a chess-purpose heuristic: it prevents a previously
+ * available discriminating witness from being silently withheld before the
+ * sole model call.
+ */
+export type LeanDirectEvidenceView = Readonly<{
+    schemaVersion: typeof ABLATION_LEAN_DIRECT_EVIDENCE_VIEW_VERSION;
+    sourceBundleHash: string;
+    bundle: Readonly<AblationEvidenceClosureBundle>;
+    salienceEvidenceIds: readonly string[];
+    requiredEvidenceIds: readonly string[];
+    supplementalBoundedEvidenceIds: readonly string[];
+    /** Present only for the compact fixture-declared packet, never model-authored semantics. */
+    selectedSelectorIds: readonly string[];
+    viewHash: string;
+}>;
+export declare const ablationLeanDirectSystem = "You are Knight's Eye in a private development diagnostic. Return exactly one object matching the supplied schema. This is one compact synthesis call: there are no tools, hypothesis ledger, critic, graph selection, checkpoint, discourse stage, rendering stage, repair call, or hidden answer key.\n\nAnswer the user's verbatim chess question naturally and concisely. Before drafting, silently compare the evidence-backed causal chains. Lead with the smallest chain that directly answers the question and explains the move's most decision-relevant change to an option, resource, constraint, threat, or comparison. When exact structured evidence gives the mechanism for an unavailable or legal response--for example a blocking occupant or ray, a pin, or a defender constraint--state that mechanism before any incidental attack, square, or material side effect. Then include only the supporting links needed to show why it works, its practical consequence, or a necessary qualification. Deliberately omit exact but incidental facts: do not enumerate records merely because they are available or use them to make the answer look complete. A factual observation is not automatically a strategic explanation: do not invent purpose, force, safety, or a continuation beyond the cited evidence. Bounded engine evidence establishes only its recorded line, comparison, score, or response coverage. Exact legal facts establish only what they state. If the available evidence does not settle a point, say so in limitations instead of guessing.\n\nUse only the supplied evidence IDs. Cite evidence for every claim. Each claim is plain concise prose; do not encode moves, pieces, squares, or other references as structured fields. The answer remains an unvalidated diagnostic proposal, never a supported Knight's Eye result.";
+export declare const LEAN_DIRECT_PROPOSAL_JSON_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["schemaVersion", "claims", "limitations", "coverage"];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly const: "architecture-ablation-lean-direct-proposal/3";
+        };
+        readonly claims: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly maxItems: 4;
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["text", "kind", "evidenceIds"];
+                readonly properties: {
+                    readonly text: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 700;
+                    };
+                    readonly kind: {
+                        readonly enum: readonly ["fact", "interpretation", "consequence", "defense", "uncertainty", "comparison"];
+                    };
+                    readonly evidenceIds: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly maxItems: 8;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly maxLength: 200;
+                        };
+                    };
+                };
+            };
+        };
+        readonly limitations: {
+            readonly type: "array";
+            readonly maxItems: 4;
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 400;
+            };
+        };
+        readonly coverage: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["status", "unresolved"];
+            readonly properties: {
+                readonly status: {
+                    readonly enum: readonly ["complete", "partial", "unavailable"];
+                };
+                readonly unresolved: {
+                    readonly type: "array";
+                    readonly maxItems: 4;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 400;
+                    };
+                };
+            };
+        };
+    };
+};
+export type LeanDirectClaim = {
+    text: string;
+    kind: "fact" | "interpretation" | "consequence" | "defense" | "uncertainty" | "comparison";
+    evidenceIds: string[];
+};
+export type LeanDirectArtifact = {
+    schemaVersion: typeof ABLATION_LEAN_DIRECT_PROPOSAL_VERSION;
+    sourceBundleHash: string;
+    modelFacingEvidenceViewHash: string;
+    claims: LeanDirectClaim[];
+    limitations: string[];
+    coverage: {
+        status: "complete" | "partial" | "unavailable";
+        unresolved: string[];
+    };
+    admission: "diagnostic-proposed";
+    productSupport: "not-a-validated-graph-checkpoint-or-product-result";
+};
+export type LeanDirectFailure = {
+    kind: "provider-or-structured-output" | "lean-contract-rejected" | "aborted" | "wall-time";
+    code: string;
+    issues?: Array<{
+        path: string;
+        code: string;
+    }>;
+};
+export type LeanDirectCallDiagnostic = {
+    stage: "lean-direct" | "lean-acquisition";
+    runtime: typeof ABLATION_LEAN_DIRECT_RUNTIME_VERSION;
+    model: string;
+    route: string;
+    effort: string;
+    temperature: number | null;
+    bundleHash: string;
+    inputBytes: number;
+    schemaBytes: number;
+    outputBytes: number;
+    finishReason: string | null;
+    latencyMs: number | null;
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cost: number | null;
+    cacheTokens: number | null;
+    outcome: "succeeded" | "failed" | "aborted";
+    failureCode: string | null;
+};
+export type LeanDirectRuntimeOptions = {
+    model: LanguageModel;
+    modelName?: string;
+    providerRoute?: string;
+    reasoning?: NonNullable<LanguageModelCallOptions["reasoning"]>;
+    temperature?: number;
+    maxOutputTokens: number;
+    maxWallTimeMs: number;
+    benchmarkNonce?: string | null;
+    /** Deterministically acquired, fixture-scoped evidence that must reach this sole synthesis call. */
+    requiredEvidenceIds?: readonly string[];
+    /**
+     * Fixture-declared fact/observation selectors for a deliberately compact
+     * evidence packet. Absent selectors retain the generic salience projection
+     * used by non-fixture diagnostics.
+     */
+    evidenceSelectors?: readonly LeanDirectEvidenceSelector[];
+    /** Generic acquisition: only records actually presented or retrieved in this episode. */
+    modelEvidenceIds?: readonly string[];
+    episodeCoverage?: AblationEvidenceClosureBundle["coverage"];
+    consumeProviderMetadata?: () => readonly {
+        cost?: number | null;
+        cacheTokens?: number | null;
+        model?: string | null;
+        route?: string | null;
+        effort?: string | null;
+    }[];
+    observableTraceSink?: ObservableLlmTraceSink;
+};
+export type LeanDirectResult = {
+    ok: true;
+    artifact: LeanDirectArtifact;
+    diagnostics: LeanDirectCallDiagnostic[];
+    modelView: LeanDirectEvidenceView;
+} | {
+    ok: false;
+    diagnostics: LeanDirectCallDiagnostic[];
+    failure: LeanDirectFailure;
+    modelView: LeanDirectEvidenceView;
+};
+export declare function projectLeanDirectEvidence(bundle: Readonly<AblationEvidenceClosureBundle>, requiredEvidenceIds?: readonly string[], evidenceSelectors?: readonly LeanDirectEvidenceSelector[]): LeanDirectEvidenceView;
+/** Exact episode membership; no salience reranking or fixture selection at synthesis. */
+export declare function projectLeanEpisodeEvidence(source: Readonly<AblationEvidenceClosureBundle>, ids: readonly string[], coverage?: import("./ablation-evidence-bundle.js").AblationEvidenceClosureCoverage): LeanDirectEvidenceView;
+/** Deterministic admission checks evidence identity and source ceilings; it never interprets generated prose. */
+export declare function materializeLeanDirectProposal(view: LeanDirectEvidenceView, proposal: unknown): LeanDirectArtifact;
+export declare function runLeanDirect(options: LeanDirectRuntimeOptions, bundle: Readonly<AblationEvidenceClosureBundle>, signal?: AbortSignal): Promise<LeanDirectResult>;

package/dist/types/chess-reasoning/ablation-model-facing-evidence.d.ts

@@ -0,0 +1,38 @@
+import { type AblationEvidenceClosureBundle, type AblationEvidenceClosureCoverage } from "./ablation-evidence-bundle.js";
+/**
+ * The closure is deliberately larger than the model view: it retains all
+ * pre-salience records for evaluator audit.  This projection is the one and
+ * only boundary at which that closure becomes provider-visible.
+ */
+export declare const ABLATION_MODEL_FACING_EVIDENCE_VIEW_VERSION: "architecture-ablation-model-facing-evidence/1";
+/** Lean-only transport: evidence is unchanged; observations are an index, not a second copy of its data. */
+export declare function compactLeanEvidencePacket(bundle: Readonly<AblationEvidenceClosureBundle>): {
+    context: import("./poc-contracts.js").ReasoningPositionContext;
+    contextHash: string;
+    question: string;
+    evidence: import("./poc-contracts.js").ReasoningEvidenceRecord[];
+    observations: {
+        id: string;
+        observationType: string;
+        exactness: "exact" | "heuristic";
+        factEvidenceIds: string[];
+    }[];
+    coverage: AblationEvidenceClosureCoverage;
+};
+export type AblationModelFacingEvidenceView = Readonly<{
+    schemaVersion: typeof ABLATION_MODEL_FACING_EVIDENCE_VIEW_VERSION;
+    /** Immutable audit identity of the complete, pre-salience closure. */
+    sourceBundleHash: string;
+    /** A separately validated, non-mutating closure containing only visible material. */
+    bundle: Readonly<AblationEvidenceClosureBundle>;
+    visibleObservationIds: readonly string[];
+    visibleEvidenceIds: readonly string[];
+    viewHash: string;
+}>;
+/**
+ * Project a full ablation closure to material that the relevant arm may see.
+ * Original observations must retain exact ranked presentation metadata. New
+ * acquisition/enrichment records are intentionally visible by lineage, while
+ * an unlinked admitted probe remains available as concrete evidence.
+ */
+export declare function projectAblationEvidenceForModel(source: Readonly<AblationEvidenceClosureBundle>): AblationModelFacingEvidenceView;

package/dist/types/chess-reasoning/ablation-transport-correction.d.ts

@@ -0,0 +1,13 @@
+import type { DirectSynthesisIssue } from "./ablation-direct-synthesis.js";
+/** A narrow transport-only correction is never a second semantic authoring turn. */
+export declare class AblationTransportCorrectionError extends Error {
+    readonly code: "transport-correction-outside-validator-paths";
+    constructor(message: string);
+}
+export declare function isTransportCorrectableDirectSynthesisIssues(issues: readonly DirectSynthesisIssue[]): boolean;
+/**
+ * The model may change only exact validator-named reference leaves. Item
+ * identity/cardinality and every other semantic/evidence association remain
+ * structure-equivalent. This guard is shared by A1 and B/B′ for fairness.
+ */
+export declare function assertTransportOnlyDirectCorrection(originalProposal: unknown, correctedProposal: unknown, issues: readonly DirectSynthesisIssue[]): void;

package/dist/types/chess-reasoning/ai-sdk-runtime-support.d.ts

@@ -0,0 +1,93 @@
+import type { ModelMessage } from "@ai-sdk/provider-utils";
+import type { ReasoningRuntimeDiagnostic } from "./poc-contracts.js";
+export type SanitizedHttpAttempt = {
+    status: number | null;
+    requestId: string | null;
+    latencyMs: number;
+    aborted: boolean;
+    requestBytes?: number | null;
+};
+export type ObservableLlmTraceEvent = {
+    stage: string;
+    direction: "input" | "output" | "error";
+    model: string;
+    providerRoute: string;
+    reasoningEffort: string;
+    payload: Record<string, unknown>;
+    excluded: string[];
+};
+export type ObservableLlmTraceSink = (event: ObservableLlmTraceEvent) => void;
+export declare const AI_SDK_REASONING_RUNTIME = "ai-sdk-tool-loop-agent/99";
+export declare const AI_SDK_HYPOTHESIS_RUNTIME = "ai-sdk-hypothesis-provider/31";
+export declare const AI_SDK_PURPOSE_PROBE_RUNTIME = "ai-sdk-future-purpose-probe/1";
+export declare const AI_SDK_CRITIC_RUNTIME = "ai-sdk-reasoning-critic/32";
+export declare const AI_SDK_TERMINAL_REVIEW_RUNTIME = "ai-sdk-terminal-reasoning-review/7";
+export declare const AI_SDK_RESOLUTION_AUDIT_RUNTIME = "ai-sdk-critic-resolution-audit/4";
+export declare const AI_SDK_GRAPH_SELECTION_RUNTIME = "ai-sdk-graph-selector/8";
+export declare const AI_SDK_ANSWER_OBLIGATION_RUNTIME = "ai-sdk-answer-obligation-audit/4";
+export declare const AI_SDK_GRAPH_PLANNING_RUNTIME = "ai-sdk-answer-obligation-and-graph-selector/3";
+export declare const AI_SDK_DISCOURSE_RUNTIME = "ai-sdk-discourse-planner/3";
+export declare const DETERMINISTIC_DISCOURSE_RUNTIME = "harness-discourse-aggregator/3";
+export declare const AI_SDK_RENDER_RUNTIME = "ai-sdk-checkpoint-render/24";
+export declare const AI_SDK_REPAIR_RUNTIME = "ai-sdk-semantic-draft-repair/13";
+export declare function bytes(value: unknown): number;
+export declare function observableTraceMessages(messages: readonly ModelMessage[]): unknown[];
+export declare function emitObservableTrace(sink: ObservableLlmTraceSink | undefined, event: Omit<ObservableLlmTraceEvent, "excluded">): void;
+export declare function reasoningMetrics(content: readonly unknown[]): {
+    reasoningPartCount: number;
+    reasoningBytes: number;
+    reasoningDetailsPresent: boolean;
+};
+export declare function numericUsage(value: unknown): number | null;
+export declare function requestId(headers?: Record<string, string>, fallback?: string): string | null;
+export declare class ReasoningWorkflowFailure extends Error {
+    readonly code: "continuation-coverage-unavailable" | "response-coverage-unavailable";
+    constructor(code: ReasoningWorkflowFailure["code"]);
+}
+export declare function classifyRuntimeFailure(error: unknown, lastStep?: Pick<ReasoningRuntimeDiagnostic, "finishReason" | "structuredOutputBytes" | "toolCallCount"> & Partial<Pick<ReasoningRuntimeDiagnostic, "lastHarnessPhase" | "sdkRuntime">>): string;
+export declare function deepestError(error: unknown): unknown;
+export declare function abortSource(signal: AbortSignal | undefined, error: unknown): ReasoningRuntimeDiagnostic["abortSource"];
+export type HypothesisRejection = {
+    stage: NonNullable<ReasoningRuntimeDiagnostic["hypothesisRejectionStage"]>;
+    code: NonNullable<ReasoningRuntimeDiagnostic["hypothesisRejectionCode"]>;
+};
+export declare class HypothesisProviderRuntimeFailure extends Error {
+    readonly diagnostics: ReasoningRuntimeDiagnostic[];
+    readonly usage: {
+        inputTokens: number | null;
+        outputTokens: number | null;
+    };
+    constructor(diagnostics: ReasoningRuntimeDiagnostic[], usage: {
+        inputTokens: number | null;
+        outputTokens: number | null;
+    });
+}
+export declare class HypothesisHarnessRejection extends Error {
+    readonly rejection: HypothesisRejection;
+    constructor(rejection: HypothesisRejection);
+}
+export declare class ReasoningCriticHarnessRejection extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare class CriticResolutionAuditHarnessRejection extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare class GraphSelectionHarnessRejection extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare class HypothesisReviewHarnessRejection extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare class TerminalReviewHarnessRejection extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare function classifyProviderHypothesisRejection(error: unknown): HypothesisRejection;
+export declare function classifyHypothesisHarnessRejection(error: unknown): HypothesisRejection;
+export declare function classifyReasoningCriticHarnessRejection(error: unknown): string;
+export declare function classifyGraphSelectionHarnessRejection(error: unknown): string;
+export declare function classifyGraphSelectionRuntimeFailure(error: unknown, lastStep?: Pick<ReasoningRuntimeDiagnostic, "finishReason" | "structuredOutputBytes" | "toolCallCount">): string;

package/dist/types/chess-reasoning/answer-host-contracts.d.ts

@@ -0,0 +1,59 @@
+import type { ReasoningPositionContext } from './poc-contracts.js';
+import type { QuestionRoutingDecision } from './question-routing.js';
+import type { WikibooksContextResult, WikibooksTarget } from './opening-source-contracts.js';
+export type RecordedMoveAnalysis = {
+    version: string;
+    fenBefore: string;
+    fenAfter: string;
+    moveUci: string;
+    engine: string;
+    actualDepth: number;
+    requestedDepth: number;
+    classifierVersion: number;
+    classification: string;
+    beforeCp: number | null;
+    afterCp: number | null;
+    lossCp: number | null;
+    mateBefore: number | null;
+    mateAfter: number | null;
+};
+export type RecordedMainLine = {
+    selectedAtStart?: boolean;
+    startFen: string;
+    moves: Array<{
+        uci: string;
+        san: string;
+        edgeId: string;
+        analysis?: RecordedMoveAnalysis;
+    }>;
+    selectedIndex: number;
+    totalPlies: number;
+    truncated: boolean;
+};
+export type AnswerSelection = {
+    deliveryId: string;
+    selectionKey: string;
+    edgeId: string;
+    context: ReasoningPositionContext;
+    existingAnalysis: unknown;
+};
+export type AnswerRoutingPreparation = {
+    decision: QuestionRoutingDecision;
+    mainLine?: RecordedMainLine;
+    omitSelectedContext: boolean;
+    elapsedMs: number;
+    question: string;
+    selectionKey: string;
+    deliveryId: string;
+};
+export type AnswerHistoryPort = {
+    getMainLine?: (selected: AnswerSelection, signal?: AbortSignal) => Promise<RecordedMainLine>;
+    refreshContext?: (selected: AnswerSelection, signal?: AbortSignal) => Promise<{
+        existingAnalysis: unknown;
+    }>;
+};
+export type AnswerOpeningSession = {
+    initial: (signal?: AbortSignal) => Promise<WikibooksContextResult>;
+    gameReview: (line: RecordedMainLine, signal?: AbortSignal) => Promise<WikibooksContextResult>;
+    lookup: (targets: WikibooksTarget[], signal?: AbortSignal, root?: ReasoningPositionContext) => Promise<WikibooksContextResult>;
+};