@oscharko-dev/keiko-evaluations 0.2.8 → 0.2.9

package/dist/voice-twin/scorer.js

@@ -0,0 +1,323 @@
+// Voice Digital Twin scorer (Epic #491, Issue #505; ADR-0068).
+//
+// Pure per-dimension scoring + suite aggregation across the eleven capstone dimensions. Each dimension is a
+// pure function over the fixture + its derived observation. A dimension a fixture does not declare is
+// `not-applicable` and excluded from aggregation. Each dimension combines a STRUCTURAL gate (the contract
+// fact the cell / metric must satisfy) with the fixture oracle, so weakening a capability table, leaking a
+// forbidden message kind into the STT profile, dropping the loopback control plane, letting an unapproved
+// egress through, or breaking a metric flips the corresponding dimension to FAIL. Rationales are
+// harness-authored and content-free (counts, closed-vocabulary labels, numbers).
+import { VOICE_CONTROL_TRANSPORTS, } from "@oscharko-dev/keiko-contracts";
+import { VOICE_TWIN_REPLAY_CAPACITY } from "./metrics.js";
+import { VOICE_TWIN_DIMENSIONS, } from "./types.js";
+// The control-message kinds STT-only must NEVER permit (AC3): WebRTC media signalling, media-track state,
+// playback, and barge-in interruption all belong to the full-realtime / speech-output paths.
+const STT_FORBIDDEN_KINDS = [
+    "signal.sdp.offer",
+    "signal.sdp.answer",
+    "signal.ice.candidate",
+    "media.track.state",
+    "playback.state",
+    "control.interrupt",
+];
+// The kinds full-realtime MUST permit (AC4): WebRTC SDP signalling and media-track state.
+const REALTIME_REQUIRED_KINDS = [
+    "signal.sdp.offer",
+    "signal.sdp.answer",
+    "media.track.state",
+];
+function gate(dimension, checks) {
+    const failed = checks.filter((c) => !c.ok);
+    if (failed.length === 0) {
+        return {
+            dimension,
+            outcome: "pass",
+            rationale: `${String(checks.length)}/${String(checks.length)} structural checks met.`,
+        };
+    }
+    return {
+        dimension,
+        outcome: "fail",
+        rationale: `failed: ${failed.map((c) => c.label).join("; ")}.`,
+    };
+}
+// ─── Capability-matrix consistency ───────────────────────────────────────────────────
+function scoreCapabilityMatrix(fixture, obs) {
+    const cell = obs.cell;
+    return gate("capability-matrix-consistency", [
+        {
+            label: "effective profile matches the oracle expectation",
+            ok: cell.effectiveProfile === fixture.oracle.expectedEffectiveProfile,
+        },
+        {
+            label: "control plane is loopback",
+            ok: cell.controlPlaneIsLoopback,
+        },
+        {
+            // `none` egresses nowhere; any active capability egresses only to the configured model endpoint.
+            label: "egress class matches the effective profile",
+            ok: cell.effectiveProfile === "none"
+                ? cell.egressClass === "none"
+                : cell.egressClass === "configured-model-endpoint",
+        },
+    ]);
+}
+// ─── No-voice dormancy (AC1 / AC2) ───────────────────────────────────────────────────
+function scoreNoVoiceDormancy(obs) {
+    const cell = obs.cell;
+    return gate("no-voice-dormancy", [
+        { label: "effective profile is none", ok: cell.effectiveProfile === "none" },
+        { label: "no allowed control message kinds", ok: cell.allowedKinds.length === 0 },
+        { label: "media transport is none", ok: cell.mediaTransport === "none" },
+        { label: "negotiation is disabled", ok: cell.negotiation === "disabled" },
+        { label: "egress class is none", ok: cell.egressClass === "none" },
+    ]);
+}
+// ─── STT affordance bounding (AC3) ───────────────────────────────────────────────────
+function scoreSttAffordanceBounding(obs) {
+    const cell = obs.cell;
+    const allowed = cell.allowedKinds;
+    const excludesForbidden = STT_FORBIDDEN_KINDS.every((kind) => !allowed.includes(kind));
+    return gate("stt-affordance-bounding", [
+        {
+            label: "effective profile is speech-to-text",
+            ok: cell.effectiveProfile === "speech-to-text",
+        },
+        { label: "transcript dictation kinds permitted", ok: allowed.includes("transcript.committed") },
+        { label: "WebRTC / media / playback / interrupt kinds excluded", ok: excludesForbidden },
+        {
+            label: "media transport is gateway-batch not webrtc",
+            ok: cell.mediaTransport === "gateway-batch",
+        },
+        { label: "negotiation is disabled", ok: cell.negotiation === "disabled" },
+    ]);
+}
+// ─── Transport plane separation (AC4) ────────────────────────────────────────────────
+function scoreTransportPlaneSeparation(obs) {
+    const cell = obs.cell;
+    const allowed = cell.allowedKinds;
+    const includesRealtimeKinds = REALTIME_REQUIRED_KINDS.every((kind) => allowed.includes(kind));
+    return gate("transport-plane-separation", [
+        { label: "effective profile is full-realtime", ok: cell.effectiveProfile === "full-realtime" },
+        { label: "media transport is webrtc", ok: cell.mediaTransport === "webrtc" },
+        { label: "negotiation is proxied-sdp", ok: cell.negotiation === "proxied-sdp" },
+        { label: "SDP / media-track signalling kinds present", ok: includesRealtimeKinds },
+        {
+            label: "control plane is loopback (loopback-websocket available)",
+            ok: cell.controlPlaneIsLoopback && VOICE_CONTROL_TRANSPORTS.includes("loopback-websocket"),
+        },
+    ]);
+}
+// ─── External-destination privacy (AC5) ──────────────────────────────────────────────
+function scoreExternalDestinationPrivacy(fixture, obs) {
+    return gate("external-destination-privacy", [
+        {
+            // The dimension PASSES when the auditor's verdict matches the fixture oracle: a positive fixture
+            // audits approved, a privacy-negative fixture is correctly caught (approved=false).
+            label: "egress audit verdict matches oracle expectation",
+            ok: obs.egressAudit.approved === fixture.oracle.expectedEgressApproved,
+        },
+        {
+            label: "manifest scan verdict matches oracle expectation",
+            ok: obs.manifestScan.clean === fixture.oracle.expectedManifestsClean,
+        },
+        {
+            // An approved-expected fixture must carry zero unapproved destinations; a negative one must carry at
+            // least one (so the teeth are exercised, not merely asserted).
+            label: "unapproved-destination count agrees with the verdict",
+            ok: fixture.oracle.expectedEgressApproved
+                ? obs.egressAudit.unapprovedCount === 0
+                : obs.egressAudit.unapprovedCount > 0,
+        },
+    ]);
+}
+// ─── AC6 metric dimensions ───────────────────────────────────────────────────────────
+function scoreInterruptionMetric(obs) {
+    const metric = obs.metrics.interruption;
+    if (metric === undefined) {
+        return missingMetric("interruption-metric");
+    }
+    return gate("interruption-metric", [
+        { label: "interrupt allowed for the capable profile", ok: metric.interruptAllowed },
+        { label: "speaking -> interrupted is reachable", ok: metric.interruptedPhaseReachable },
+    ]);
+}
+function scoreEndOfTurnMetric(obs) {
+    const metric = obs.metrics.endOfTurn;
+    if (metric === undefined) {
+        return missingMetric("end-of-turn-metric");
+    }
+    return gate("end-of-turn-metric", [
+        { label: "transcript.committed permitted for the profile", ok: metric.committedKindAllowed },
+        { label: "transcript capture permitted for the profile", ok: metric.captureAllowed },
+        { label: "committed projection is non-empty", ok: metric.committedSegmentCount > 0 },
+        { label: "committed projection excludes partial / stable", ok: metric.excludesUncommitted },
+    ]);
+}
+function scoreTranscriptCorrectionMetric(obs) {
+    const metric = obs.metrics.transcriptCorrection;
+    if (metric === undefined) {
+        return missingMetric("transcript-correction-metric");
+    }
+    return gate("transcript-correction-metric", [
+        { label: "stable -> corrected transition allowed", ok: metric.stableToCorrectedAllowed },
+        { label: "committed -> corrected transition allowed", ok: metric.committedToCorrectedAllowed },
+        { label: "corrected is a consumable state", ok: metric.correctedIsConsumable },
+        {
+            label: "superseded committed text dropped from projection",
+            ok: metric.supersededTextDropped,
+        },
+    ]);
+}
+function scoreProviderFailureRecoveryMetric(obs) {
+    const metric = obs.metrics.providerFailureRecovery;
+    if (metric === undefined) {
+        return missingMetric("provider-failure-recovery-metric");
+    }
+    return gate("provider-failure-recovery-metric", [
+        { label: "provider-error is a transcript state", ok: metric.providerErrorIsState },
+        { label: "provider-error is not consumable", ok: metric.providerErrorNotConsumable },
+        { label: "playback failed is a settled phase", ok: metric.playbackFailedIsSettled },
+        { label: "a recovery transition exists out of failure", ok: metric.recoveryTransitionExists },
+    ]);
+}
+function scoreBufferBoundednessMetric(obs) {
+    const metric = obs.metrics.bufferBoundedness;
+    if (metric === undefined) {
+        return missingMetric("buffer-boundedness-metric");
+    }
+    return gate("buffer-boundedness-metric", [
+        {
+            label: "capacity equals the documented ring size",
+            ok: metric.capacity === VOICE_TWIN_REPLAY_CAPACITY,
+        },
+        {
+            // Under overflow the ring fills EXACTLY to capacity (not merely ≤): a self-referential ≤capacity
+            // check would pass even at a trivial capacity that never evicted, so we require equality whenever
+            // eviction occurred and ≤capacity only in the no-overflow case.
+            label: "ring fills exactly to capacity under overflow",
+            ok: metric.evictedOldestOnOverflow
+                ? metric.maxObservedLength === metric.capacity
+                : metric.maxObservedLength <= metric.capacity,
+        },
+        { label: "no ephemeral kind ever buffered", ok: !metric.ephemeralBuffered },
+        { label: "overflow evicts the oldest entry", ok: metric.evictedOldestOnOverflow },
+        { label: "at least one replay-eligible kind admitted", ok: metric.admittedCount > 0 },
+    ]);
+}
+// The latency POSTURE class each media transport must map to. A total map so a new transport added to the
+// contract is a compile error here, keeping the scorer's expectation in lock-step with the derivation.
+const EXPECTED_LATENCY_CLASS = {
+    none: "none",
+    "gateway-batch": "batch",
+    webrtc: "interactive-realtime",
+};
+function scoreLatencyClassMetric(obs) {
+    const metric = obs.metrics.latencyClass;
+    if (metric === undefined) {
+        return missingMetric("latency-class-metric");
+    }
+    const expectedClass = EXPECTED_LATENCY_CLASS[metric.mediaTransport];
+    return gate("latency-class-metric", [
+        {
+            label: "latency class matches the media-transport mapping",
+            ok: metric.latencyClass === expectedClass,
+        },
+        {
+            // A `webrtc` (full-realtime) transport is interactive; every batch / none transport is not.
+            label: "isInteractive agrees with an interactive-realtime class",
+            ok: metric.isInteractive === (metric.latencyClass === "interactive-realtime"),
+        },
+        {
+            label: "webrtc is interactive while batch / none are not",
+            ok: metric.mediaTransport === "webrtc" ? metric.isInteractive : !metric.isInteractive,
+        },
+    ]);
+}
+function missingMetric(dimension) {
+    return {
+        dimension,
+        outcome: "fail",
+        rationale: `failed: ${dimension} declared but no metric record was derived.`,
+    };
+}
+// ─── Dispatch ─────────────────────────────────────────────────────────────────────────
+// The metric dimensions (the five AC6 metrics plus the latency-posture class) are dispatched separately so
+// neither dispatcher exceeds the cyclomatic complexity ceiling. `undefined` means the dimension is not a
+// metric dimension.
+function scoreMetricDimension(dimension, obs) {
+    switch (dimension) {
+        case "interruption-metric":
+            return scoreInterruptionMetric(obs);
+        case "end-of-turn-metric":
+            return scoreEndOfTurnMetric(obs);
+        case "transcript-correction-metric":
+            return scoreTranscriptCorrectionMetric(obs);
+        case "provider-failure-recovery-metric":
+            return scoreProviderFailureRecoveryMetric(obs);
+        case "buffer-boundedness-metric":
+            return scoreBufferBoundednessMetric(obs);
+        case "latency-class-metric":
+            return scoreLatencyClassMetric(obs);
+        default:
+            return undefined;
+    }
+}
+function scoreDimension(dimension, fixture, obs) {
+    switch (dimension) {
+        case "capability-matrix-consistency":
+            return scoreCapabilityMatrix(fixture, obs);
+        case "no-voice-dormancy":
+            return scoreNoVoiceDormancy(obs);
+        case "stt-affordance-bounding":
+            return scoreSttAffordanceBounding(obs);
+        case "transport-plane-separation":
+            return scoreTransportPlaneSeparation(obs);
+        case "external-destination-privacy":
+            return scoreExternalDestinationPrivacy(fixture, obs);
+        default:
+            return scoreMetricDimension(dimension, obs) ?? missingMetric(dimension);
+    }
+}
+/**
+ * Score one fixture's observation across all eleven dimensions. A dimension the fixture does not declare is
+ * `not-applicable`. Pure.
+ */
+export function scoreVoiceTwinQuality(fixture, obs) {
+    return VOICE_TWIN_DIMENSIONS.map((dimension) => fixture.dimensions.has(dimension)
+        ? scoreDimension(dimension, fixture, obs)
+        : {
+            dimension,
+            outcome: "not-applicable",
+            rationale: "not exercised by this fixture.",
+        });
+}
+// ─── Suite aggregation ─────────────────────────────────────────────────────────────────
+function aggregateDimension(dimension, results) {
+    let passCount = 0;
+    let failCount = 0;
+    let notApplicableCount = 0;
+    for (const dims of results) {
+        const outcome = dims.find((d) => d.dimension === dimension)?.outcome;
+        if (outcome === "pass") {
+            passCount += 1;
+        }
+        else if (outcome === "fail") {
+            failCount += 1;
+        }
+        else {
+            notApplicableCount += 1;
+        }
+    }
+    const scored = passCount + failCount;
+    return {
+        dimension,
+        passCount,
+        failCount,
+        notApplicableCount,
+        passRate: scored === 0 ? null : passCount / scored,
+    };
+}
+export function aggregateVoiceTwinQuality(results) {
+    return VOICE_TWIN_DIMENSIONS.map((dimension) => aggregateDimension(dimension, results));
+}

package/dist/voice-twin/types.d.ts

@@ -0,0 +1,149 @@
+import type { VoiceControlMessageKind, VoiceMediaTransport, VoiceNegotiationMode, VoiceProfile } from "@oscharko-dev/keiko-contracts";
+export declare const VOICE_TWIN_EVAL_SCHEMA_VERSION: "1";
+export type VoiceTwinDimension = "capability-matrix-consistency" | "no-voice-dormancy" | "stt-affordance-bounding" | "transport-plane-separation" | "external-destination-privacy" | "interruption-metric" | "end-of-turn-metric" | "transcript-correction-metric" | "provider-failure-recovery-metric" | "buffer-boundedness-metric" | "latency-class-metric";
+export declare const VOICE_TWIN_DIMENSIONS: readonly VoiceTwinDimension[];
+export type VoiceEnvironmentProfile = "azure-foundry" | "customer-hosted" | "no-voice-env";
+export declare const VOICE_ENVIRONMENT_PROFILES: readonly VoiceEnvironmentProfile[];
+export type EgressDestinationClass = "none" | "configured-model-endpoint" | "unapproved-external";
+export type VoiceTwinFixtureCategory = "no-voice" | "stt-only" | "speech-output" | "full-realtime" | "privacy";
+export declare const VOICE_TWIN_FIXTURE_CATEGORIES: readonly VoiceTwinFixtureCategory[];
+export interface VoiceTwinOracle {
+    readonly expectedEffectiveProfile: VoiceProfile;
+    readonly expectedEgressApproved: boolean;
+    readonly expectedManifestsClean: boolean;
+}
+export interface VoiceTwinManifestFixture {
+    readonly packageName: string;
+    readonly dependencyNames: readonly string[];
+}
+export interface VoiceTwinEgressDestination {
+    readonly class: EgressDestinationClass;
+}
+export interface VoiceTwinFixture {
+    readonly name: string;
+    readonly category: VoiceTwinFixtureCategory;
+    readonly description: string;
+    readonly environment: VoiceEnvironmentProfile;
+    readonly advertisedProfile: VoiceProfile;
+    readonly egressLedger: readonly VoiceTwinEgressDestination[];
+    readonly manifests: readonly VoiceTwinManifestFixture[];
+    readonly dimensions: ReadonlySet<VoiceTwinDimension>;
+    readonly oracle: VoiceTwinOracle;
+}
+export interface VoiceTwinCapabilityCell {
+    readonly effectiveProfile: VoiceProfile;
+    readonly allowedKinds: readonly VoiceControlMessageKind[];
+    readonly mediaTransport: VoiceMediaTransport;
+    readonly negotiation: VoiceNegotiationMode;
+    readonly controlPlaneIsLoopback: boolean;
+    readonly mediaPlaneId: "media";
+    readonly egressClass: EgressDestinationClass;
+}
+export interface InterruptionMetricRecord {
+    readonly interruptAllowed: boolean;
+    readonly interruptedPhaseReachable: boolean;
+}
+export interface EndOfTurnMetricRecord {
+    readonly committedKindAllowed: boolean;
+    readonly captureAllowed: boolean;
+    readonly committedSegmentCount: number;
+    readonly excludesUncommitted: boolean;
+}
+export interface TranscriptCorrectionMetricRecord {
+    readonly stableToCorrectedAllowed: boolean;
+    readonly committedToCorrectedAllowed: boolean;
+    readonly correctedIsConsumable: boolean;
+    readonly supersededTextDropped: boolean;
+}
+export interface ProviderFailureRecoveryMetricRecord {
+    readonly providerErrorIsState: boolean;
+    readonly providerErrorNotConsumable: boolean;
+    readonly playbackFailedIsSettled: boolean;
+    readonly recoveryTransitionExists: boolean;
+}
+export interface BufferBoundednessMetricRecord {
+    readonly capacity: number;
+    readonly maxObservedLength: number;
+    readonly admittedCount: number;
+    readonly ephemeralBuffered: boolean;
+    readonly evictedOldestOnOverflow: boolean;
+}
+export interface LatencyClassMetricRecord {
+    readonly mediaTransport: VoiceMediaTransport;
+    readonly latencyClass: "none" | "batch" | "interactive-realtime";
+    readonly isInteractive: boolean;
+}
+export interface VoiceTwinMetricBundle {
+    readonly interruption?: InterruptionMetricRecord;
+    readonly endOfTurn?: EndOfTurnMetricRecord;
+    readonly transcriptCorrection?: TranscriptCorrectionMetricRecord;
+    readonly providerFailureRecovery?: ProviderFailureRecoveryMetricRecord;
+    readonly bufferBoundedness?: BufferBoundednessMetricRecord;
+    readonly latencyClass?: LatencyClassMetricRecord;
+}
+export interface VoiceTwinEgressAudit {
+    readonly approved: boolean;
+    readonly unapprovedCount: number;
+}
+export interface VoiceTwinDeniedManifestHit {
+    readonly packageName: string;
+    readonly deniedPackage: string;
+}
+export interface VoiceTwinManifestScan {
+    readonly clean: boolean;
+    readonly found: readonly VoiceTwinDeniedManifestHit[];
+}
+export interface VoiceTwinObservation {
+    readonly environment: VoiceEnvironmentProfile;
+    readonly advertisedProfile: VoiceProfile;
+    readonly cell: VoiceTwinCapabilityCell;
+    readonly egressAudit: VoiceTwinEgressAudit;
+    readonly manifestScan: VoiceTwinManifestScan;
+    readonly metrics: VoiceTwinMetricBundle;
+}
+export type VoiceTwinOutcome = "pass" | "fail" | "not-applicable";
+export interface VoiceTwinDimensionResult {
+    readonly dimension: VoiceTwinDimension;
+    readonly outcome: VoiceTwinOutcome;
+    readonly rationale: string;
+}
+export interface VoiceTwinFixtureResult {
+    readonly fixtureName: string;
+    readonly category: VoiceTwinFixtureCategory;
+    readonly environment: VoiceEnvironmentProfile;
+    readonly effectiveProfile: VoiceProfile;
+    readonly observation: VoiceTwinObservation;
+    readonly dimensionResults: readonly VoiceTwinDimensionResult[];
+    readonly fullyPassed: boolean;
+}
+export interface VoiceTwinScorecardEntry {
+    readonly dimension: VoiceTwinDimension;
+    readonly passCount: number;
+    readonly failCount: number;
+    readonly notApplicableCount: number;
+    readonly passRate: number | null;
+}
+export interface VoiceTwinMatrixCell {
+    readonly environment: VoiceEnvironmentProfile;
+    readonly effectiveProfile: VoiceProfile;
+}
+export interface VoiceTwinEvalSummary {
+    readonly totalFixtures: number;
+    readonly fullyPassedFixtures: number;
+    readonly coversNoVoice: boolean;
+    readonly coversSttOnly: boolean;
+    readonly coversSpeechOutput: boolean;
+    readonly coversFullRealtime: boolean;
+    readonly coversAzureFoundry: boolean;
+    readonly coversCustomerHosted: boolean;
+    readonly coversPrivacyNegative: boolean;
+    readonly goNoGo: "GO" | "NO-GO";
+}
+export interface VoiceTwinScorecard {
+    readonly schemaVersion: typeof VOICE_TWIN_EVAL_SCHEMA_VERSION;
+    readonly fixtureResults: readonly VoiceTwinFixtureResult[];
+    readonly dimensions: readonly VoiceTwinScorecardEntry[];
+    readonly summary: VoiceTwinEvalSummary;
+    readonly coveredMatrixCells: readonly VoiceTwinMatrixCell[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/voice-twin/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/voice-twin/types.ts"],"names":[],"mappings":"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"}

package/dist/voice-twin/types.js

@@ -0,0 +1,45 @@
+// Voice Digital Twin evaluation types (Epic #491, Issue #505 — the capstone; ADR-0068).
+//
+// This subpackage is the PROOF MECHANISM for the whole Voice Digital Twin: that it is high quality when
+// available and harmless when unavailable. It scores the deterministic capability / privacy / metric
+// facts derivable from the keiko-contracts voice leaf modules (`voice-protocol`, `voice-transcript`,
+// `voice-playback`) across the profile × environment matrix from
+// `docs/voice/deployment-profile-matrix.md` §3. It is NOT the agent-trajectory harness (`../types.ts`):
+// the capstone is judged on its own closed set of eleven dimensions, mirroring the Voice Action
+// (`../voice-action/`) and Discussion (`../discussion/`) subpackages.
+//
+// Import boundary (ADR-0019 rule 3l): keiko-evaluations may import ONLY keiko-contracts (and node fs in
+// .test.ts for the repo manifest scan). All voice RUNTIME mechanics (timing engine, turn manager,
+// transcript reducer, playback controller) live in keiko-ui and are OFF LIMITS — every metric is modelled
+// against keiko-contracts importable APIs and the repo manifests.
+//
+// Determinism: every observation is pure data derivation over the frozen contract — no model call, clock
+// read, randomness, or network. Every observation / metric / rationale field is content-free: counts,
+// closed-vocabulary enum labels, booleans, integers. No raw transcript text, SDP, ICE, audio, or a
+// fixture's opaque topic / segment id ever enters the scorecard.
+export const VOICE_TWIN_EVAL_SCHEMA_VERSION = "1";
+export const VOICE_TWIN_DIMENSIONS = [
+    "capability-matrix-consistency",
+    "no-voice-dormancy",
+    "stt-affordance-bounding",
+    "transport-plane-separation",
+    "external-destination-privacy",
+    "interruption-metric",
+    "end-of-turn-metric",
+    "transcript-correction-metric",
+    "provider-failure-recovery-metric",
+    "buffer-boundedness-metric",
+    "latency-class-metric",
+];
+export const VOICE_ENVIRONMENT_PROFILES = [
+    "azure-foundry",
+    "customer-hosted",
+    "no-voice-env",
+];
+export const VOICE_TWIN_FIXTURE_CATEGORIES = [
+    "no-voice",
+    "stt-only",
+    "speech-output",
+    "full-realtime",
+    "privacy",
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oscharko-dev/keiko-evaluations",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Internal evaluations package: deterministic evaluation harness — scripted ModelPort fixtures, six scored dimensions, surface-parity check, scorecard renderer, and the offline-vs-live model provider selector (ADR-0012, ADR-0019). Not published independently.",
@@ -26,13 +26,13 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@oscharko-dev/keiko-contracts": "0.2.8",
-    "@oscharko-dev/keiko-evidence": "0.2.8",
-    "@oscharko-dev/keiko-harness": "0.2.8",
-    "@oscharko-dev/keiko-model-gateway": "0.2.8",
-    "@oscharko-dev/keiko-security": "0.2.8",
-    "@oscharko-dev/keiko-tools": "0.2.8",
-    "@oscharko-dev/keiko-workflows": "0.2.8",
-    "@oscharko-dev/keiko-workspace": "0.2.8"
+    "@oscharko-dev/keiko-contracts": "0.2.9",
+    "@oscharko-dev/keiko-evidence": "0.2.9",
+    "@oscharko-dev/keiko-harness": "0.2.9",
+    "@oscharko-dev/keiko-model-gateway": "0.2.9",
+    "@oscharko-dev/keiko-security": "0.2.9",
+    "@oscharko-dev/keiko-tools": "0.2.9",
+    "@oscharko-dev/keiko-workflows": "0.2.9",
+    "@oscharko-dev/keiko-workspace": "0.2.9"
   }
 }