@oscharko-dev/keiko-evaluations 0.2.8 → 0.2.9

package/dist/discussion/fixtures/correction.d.ts

@@ -0,0 +1,5 @@
+import type { DiscussionEvalFixture } from "../types.js";
+export declare const evidenceCheckCorrection: DiscussionEvalFixture;
+export declare const voiceEvidenceCheckCorrection: DiscussionEvalFixture;
+export declare const CORRECTION_FIXTURES: readonly DiscussionEvalFixture[];
+//# sourceMappingURL=correction.d.ts.map

package/dist/discussion/fixtures/correction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correction.d.ts","sourceRoot":"","sources":["../../../src/discussion/fixtures/correction.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD,eAAO,MAAM,uBAAuB,EAAE,qBAuBrC,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,qBAuB1C,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,SAAS,qBAAqB,EAG/D,CAAC"}

package/dist/discussion/fixtures/correction.js

@@ -0,0 +1,53 @@
+// Correction / contradiction-handling discussion fixtures (Epic #491, Issue #502; AC3). These pin the
+// evidence-check mode's strict citation discipline and the disclose-and-defer contradiction policy that
+// governs how Keiko handles an unresolved contradiction (defer to the user). Pure value modules.
+export const evidenceCheckCorrection = {
+    name: "evidence-check-correction",
+    category: "correction",
+    description: "Evidence-check mode in the `none` profile; strict citation discipline and disclose-and-defer on contradiction.",
+    profile: "none",
+    mode: "evidence-check",
+    topicId: "topic-evidence-check",
+    dimensions: new Set([
+        "mode-appropriateness",
+        "disagreement-completeness",
+        "uncertainty-discipline",
+        "evidence-citation-discipline",
+        "correction-handling",
+        "capability-gating",
+    ]),
+    oracle: {
+        expectedMandatedFacets: ["evidence", "assumptions", "uncertainty"],
+        expectedGatingAllowed: false,
+        expectedUncertaintyDisclosure: true,
+        expectedDecisionRecommendation: false,
+        expectedContradictionPolicies: ["disclose-and-defer"],
+    },
+};
+export const voiceEvidenceCheckCorrection = {
+    name: "voice-evidence-check-correction",
+    category: "correction",
+    description: "Evidence-check mode under a speech-to-text profile; same correction handling reached via voice.",
+    profile: "speech-to-text",
+    mode: "evidence-check",
+    topicId: "topic-evidence-check-stt",
+    dimensions: new Set([
+        "mode-appropriateness",
+        "disagreement-completeness",
+        "uncertainty-discipline",
+        "evidence-citation-discipline",
+        "correction-handling",
+        "capability-gating",
+    ]),
+    oracle: {
+        expectedMandatedFacets: ["evidence", "assumptions", "uncertainty"],
+        expectedGatingAllowed: true,
+        expectedUncertaintyDisclosure: true,
+        expectedDecisionRecommendation: false,
+        expectedContradictionPolicies: ["disclose-and-defer"],
+    },
+};
+export const CORRECTION_FIXTURES = [
+    evidenceCheckCorrection,
+    voiceEvidenceCheckCorrection,
+];

package/dist/discussion/fixtures/index.d.ts

@@ -0,0 +1,5 @@
+import type { DiscussionEvalFixture, DiscussionFixtureCategory } from "../types.js";
+export declare const ALL_DISCUSSION_FIXTURES: readonly DiscussionEvalFixture[];
+export declare function discussionFixturesForCategory(category: DiscussionFixtureCategory): readonly DiscussionEvalFixture[];
+export declare function discussionFixtureByName(name: string): DiscussionEvalFixture | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/discussion/fixtures/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/discussion/fixtures/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAEpF,eAAO,MAAM,uBAAuB,EAAE,SAAS,qBAAqB,EAInE,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,yBAAyB,GAClC,SAAS,qBAAqB,EAAE,CAElC;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS,CAEvF"}

package/dist/discussion/fixtures/index.js

@@ -0,0 +1,17 @@
+// Discussion Intelligence fixture registry (Epic #491, Issue #502). ALL_DISCUSSION_FIXTURES is the
+// canonical list the runner and suite tests consume; the selectors resolve a category or a fixture name
+// against it. Mirrors the Prompt Enhancer fixtures/index.ts layout.
+import { NO_VOICE_FIXTURES } from "./no-voice.js";
+import { VOICE_FIXTURES } from "./voice.js";
+import { CORRECTION_FIXTURES } from "./correction.js";
+export const ALL_DISCUSSION_FIXTURES = [
+    ...NO_VOICE_FIXTURES,
+    ...VOICE_FIXTURES,
+    ...CORRECTION_FIXTURES,
+];
+export function discussionFixturesForCategory(category) {
+    return ALL_DISCUSSION_FIXTURES.filter((f) => f.category === category);
+}
+export function discussionFixtureByName(name) {
+    return ALL_DISCUSSION_FIXTURES.find((f) => f.name === name);
+}

package/dist/discussion/fixtures/no-voice.d.ts

@@ -0,0 +1,6 @@
+import type { DiscussionEvalFixture } from "../types.js";
+export declare const noVoiceChallenge: DiscussionEvalFixture;
+export declare const noVoiceDecide: DiscussionEvalFixture;
+export declare const noVoiceBrainstorm: DiscussionEvalFixture;
+export declare const NO_VOICE_FIXTURES: readonly DiscussionEvalFixture[];
+//# sourceMappingURL=no-voice.d.ts.map

package/dist/discussion/fixtures/no-voice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-voice.d.ts","sourceRoot":"","sources":["../../../src/discussion/fixtures/no-voice.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD,eAAO,MAAM,gBAAgB,EAAE,qBAuB9B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,qBAsB3B,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,qBAyB/B,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,SAAS,qBAAqB,EAI7D,CAAC"}

package/dist/discussion/fixtures/no-voice.js

@@ -0,0 +1,79 @@
+// No-voice (text-first) discussion fixtures (Epic #491, Issue #502; AC1/AC6). These exercise the
+// discussion scaffold in the `none` voice profile, proving every mode works text-first and that
+// capability gating denies spoken turns for a profile with no capture capability. Pure value modules.
+export const noVoiceChallenge = {
+    name: "no-voice-challenge",
+    category: "no-voice",
+    description: "Challenge mode in the text-first `none` profile; full disagreement structure mandated.",
+    profile: "none",
+    mode: "challenge",
+    topicId: "topic-challenge-text",
+    dimensions: new Set([
+        "mode-appropriateness",
+        "disagreement-completeness",
+        "uncertainty-discipline",
+        "evidence-citation-discipline",
+        "correction-handling",
+        "capability-gating",
+    ]),
+    oracle: {
+        expectedMandatedFacets: ["evidence", "assumptions", "uncertainty"],
+        expectedGatingAllowed: false,
+        expectedUncertaintyDisclosure: true,
+        expectedDecisionRecommendation: false,
+        expectedContradictionPolicies: ["disclose-and-defer"],
+    },
+};
+export const noVoiceDecide = {
+    name: "no-voice-decide",
+    category: "no-voice",
+    description: "Decide mode in the text-first `none` profile; produces a decision recommendation.",
+    profile: "none",
+    mode: "decide",
+    topicId: "topic-decide-text",
+    dimensions: new Set([
+        "mode-appropriateness",
+        "disagreement-completeness",
+        "uncertainty-discipline",
+        "evidence-citation-discipline",
+        "correction-handling",
+        "capability-gating",
+    ]),
+    oracle: {
+        expectedMandatedFacets: ["evidence", "assumptions", "uncertainty"],
+        expectedGatingAllowed: false,
+        expectedUncertaintyDisclosure: true,
+        expectedDecisionRecommendation: true,
+        expectedContradictionPolicies: ["disclose-and-defer"],
+    },
+};
+export const noVoiceBrainstorm = {
+    name: "no-voice-brainstorm",
+    category: "no-voice",
+    description: "Brainstorm mode in the `none` profile; relaxes uncertainty disclosure and expands options.",
+    profile: "none",
+    mode: "brainstorm",
+    topicId: "topic-brainstorm-text",
+    dimensions: new Set([
+        "mode-appropriateness",
+        "disagreement-completeness",
+        "uncertainty-discipline",
+        "evidence-citation-discipline",
+        "correction-handling",
+        "capability-gating",
+    ]),
+    oracle: {
+        // Brainstorm relaxes the disagreement structure: it mandates evidence + assumptions but NOT
+        // uncertainty, so the facet set is a strict subset of the full three.
+        expectedMandatedFacets: ["evidence", "assumptions"],
+        expectedGatingAllowed: false,
+        expectedUncertaintyDisclosure: false,
+        expectedDecisionRecommendation: false,
+        expectedContradictionPolicies: ["synthesize-with-caveats"],
+    },
+};
+export const NO_VOICE_FIXTURES = [
+    noVoiceChallenge,
+    noVoiceDecide,
+    noVoiceBrainstorm,
+];

package/dist/discussion/fixtures/voice.d.ts

@@ -0,0 +1,5 @@
+import type { DiscussionEvalFixture } from "../types.js";
+export declare const voiceSttReview: DiscussionEvalFixture;
+export declare const voiceRealtimeBargeInRecovery: DiscussionEvalFixture;
+export declare const VOICE_FIXTURES: readonly DiscussionEvalFixture[];
+//# sourceMappingURL=voice.d.ts.map

package/dist/discussion/fixtures/voice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voice.d.ts","sourceRoot":"","sources":["../../../src/discussion/fixtures/voice.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD,eAAO,MAAM,cAAc,EAAE,qBAuB5B,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,qBA0B1C,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,SAAS,qBAAqB,EAG1D,CAAC"}

package/dist/discussion/fixtures/voice.js

@@ -0,0 +1,57 @@
+// Voice-enabled discussion fixtures (Epic #491, Issue #502; AC2/AC4/AC6). These exercise the SAME
+// discussion scaffold under voice-capable profiles (`speech-to-text`, `full-realtime`), proving voice
+// reuses the intelligence (no parallel stack) and that an interrupted spoken turn recovers without
+// losing the active mode/topicId/turnIndex. Pure value modules.
+export const voiceSttReview = {
+    name: "voice-stt-review",
+    category: "voice",
+    description: "Review mode under a speech-to-text profile; voice may drive the same intelligence (no parallel stack).",
+    profile: "speech-to-text",
+    mode: "review",
+    topicId: "topic-review-stt",
+    dimensions: new Set([
+        "mode-appropriateness",
+        "disagreement-completeness",
+        "uncertainty-discipline",
+        "evidence-citation-discipline",
+        "correction-handling",
+        "capability-gating",
+    ]),
+    oracle: {
+        expectedMandatedFacets: ["evidence", "assumptions", "uncertainty"],
+        expectedGatingAllowed: true,
+        expectedUncertaintyDisclosure: true,
+        expectedDecisionRecommendation: false,
+        expectedContradictionPolicies: ["disclose-and-defer"],
+    },
+};
+export const voiceRealtimeBargeInRecovery = {
+    name: "voice-realtime-barge-in-recovery",
+    category: "voice",
+    description: "Decide mode under full-realtime voice with a barge-in interruption; recovery must preserve context (AC4).",
+    profile: "full-realtime",
+    mode: "decide",
+    topicId: "topic-decide-realtime",
+    interruption: true,
+    dimensions: new Set([
+        "mode-appropriateness",
+        "disagreement-completeness",
+        "uncertainty-discipline",
+        "evidence-citation-discipline",
+        "correction-handling",
+        "interruption-recovery",
+        "capability-gating",
+    ]),
+    oracle: {
+        expectedMandatedFacets: ["evidence", "assumptions", "uncertainty"],
+        expectedGatingAllowed: true,
+        expectedUncertaintyDisclosure: true,
+        expectedDecisionRecommendation: true,
+        expectedContradictionPolicies: ["disclose-and-defer"],
+        expectsRecoveredContext: true,
+    },
+};
+export const VOICE_FIXTURES = [
+    voiceSttReview,
+    voiceRealtimeBargeInRecovery,
+];

package/dist/discussion/index.d.ts

@@ -0,0 +1,6 @@
+export { deriveDiscussionObservation, runDiscussionEvaluation } from "./runner.js";
+export { scoreDiscussionQuality, aggregateDiscussionQuality } from "./scorer.js";
+export { renderDiscussionSummary } from "./render.js";
+export { ALL_DISCUSSION_FIXTURES, discussionFixturesForCategory, discussionFixtureByName, } from "./fixtures/index.js";
+export { DISCUSSION_QUALITY_DIMENSIONS, DISCUSSION_FIXTURE_CATEGORIES, DISCUSSION_EVAL_SCHEMA_VERSION, type DiscussionQualityDimension, type DiscussionFixtureCategory, type DiscussionOracle, type DiscussionEvalFixture, type DiscussionRecoveryTrajectory, type DiscussionObservation, type DiscussionQualityOutcome, type DiscussionDimensionResult, type DiscussionFixtureResult, type DiscussionScorecardEntry, type DiscussionEvalSummary, type DiscussionScorecard, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/discussion/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/discussion/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,2BAA2B,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACnF,OAAO,EAAE,sBAAsB,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AACjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EACL,uBAAuB,EACvB,6BAA6B,EAC7B,uBAAuB,GACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,6BAA6B,EAC7B,6BAA6B,EAC7B,8BAA8B,EAC9B,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC9B,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,4BAA4B,EACjC,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,GACzB,MAAM,YAAY,CAAC"}

package/dist/discussion/index.js

@@ -0,0 +1,9 @@
+// Public barrel for the Discussion Intelligence evaluation suite (Epic #491, Issue #502; ADR-0065).
+// Exposes the deterministic observation derivation, the seven-dimension scorer, the suite runner, the
+// scorecard renderer, the fixture registry, and the result/fixture types. Re-exported from the package
+// barrel as a single auditable namespace (`DiscussionEval`), mirroring `PromptEnhancerEval`.
+export { deriveDiscussionObservation, runDiscussionEvaluation } from "./runner.js";
+export { scoreDiscussionQuality, aggregateDiscussionQuality } from "./scorer.js";
+export { renderDiscussionSummary } from "./render.js";
+export { ALL_DISCUSSION_FIXTURES, discussionFixturesForCategory, discussionFixtureByName, } from "./fixtures/index.js";
+export { DISCUSSION_QUALITY_DIMENSIONS, DISCUSSION_FIXTURE_CATEGORIES, DISCUSSION_EVAL_SCHEMA_VERSION, } from "./types.js";

package/dist/discussion/render.d.ts

@@ -0,0 +1,3 @@
+import type { DiscussionScorecard } from "./types.js";
+export declare function renderDiscussionSummary(scorecard: DiscussionScorecard): string;
+//# sourceMappingURL=render.d.ts.map

package/dist/discussion/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/discussion/render.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAGV,mBAAmB,EAEpB,MAAM,YAAY,CAAC;AA2BpB,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,mBAAmB,GAAG,MAAM,CA6B9E"}

package/dist/discussion/render.js

@@ -0,0 +1,49 @@
+// renderDiscussionSummary (Issue #502): DiscussionScorecard -> human-readable string. One line per
+// fixture (name, category, dimension pass/fail glyphs), a per-dimension table, the covered-mode line,
+// the AC6 no-voice / voice coverage line, and a Go/No-Go verdict. The scorecard carries only
+// harness-authored, content-free fields (counts, closed-vocabulary labels, numeric scores), so this
+// renderer performs no redaction — it only formats fields that are safe to print.
+function glyph(result) {
+    if (result.outcome === "pass") {
+        return "PASS";
+    }
+    if (result.outcome === "fail") {
+        return "FAIL";
+    }
+    return "n/a";
+}
+function fixtureLine(fixture) {
+    const dims = fixture.dimensionResults
+        .filter((d) => d.outcome !== "not-applicable")
+        .map((d) => `${d.dimension}=${glyph(d)}`)
+        .join(" ");
+    const verdict = fixture.fullyPassed ? "OK" : "FAIL";
+    return `- ${fixture.fixtureName} [${fixture.category}] ${verdict} ${dims}`.trimEnd();
+}
+function dimensionLine(entry) {
+    const rate = entry.passRate === null ? "n/a" : `${(entry.passRate * 100).toFixed(0)}%`;
+    const verdict = entry.failCount > 0 ? "FAIL" : entry.passCount > 0 ? "PASS" : "n/a";
+    return `  ${entry.dimension.padEnd(28)} ${verdict.padEnd(5)} pass=${String(entry.passCount)} fail=${String(entry.failCount)} n/a=${String(entry.notApplicableCount)} rate=${rate}`;
+}
+export function renderDiscussionSummary(scorecard) {
+    const lines = [];
+    lines.push(`Discussion Intelligence evaluation summary (schema v${scorecard.schemaVersion})`);
+    lines.push(`Fixtures: ${String(scorecard.summary.totalFixtures)} total, ${String(scorecard.summary.fullyPassedFixtures)} fully passed`);
+    lines.push(`Modes covered: ${String(scorecard.coveredModes.length)} (${scorecard.coveredModes.join(", ")})`);
+    lines.push(`Profile coverage: no-voice=${scorecard.summary.coversNoVoiceProfile ? "yes" : "no"} voice=${scorecard.summary.coversVoiceProfile ? "yes" : "no"}`);
+    lines.push("");
+    lines.push("Fixtures:");
+    for (const fixture of scorecard.fixtureResults) {
+        lines.push(fixtureLine(fixture));
+    }
+    lines.push("");
+    lines.push("Dimensions:");
+    for (const entry of scorecard.dimensions) {
+        lines.push(dimensionLine(entry));
+    }
+    lines.push("");
+    lines.push(scorecard.summary.goNoGo === "GO"
+        ? "Verdict: GO - every exercised discussion-quality dimension passed across no-voice and voice profiles."
+        : "Verdict: NO-GO - a dimension failed or a profile coverage gate was unmet (see table above).");
+    return lines.join("\n");
+}

package/dist/discussion/runner.d.ts

@@ -0,0 +1,13 @@
+import { type DiscussionEvalFixture, type DiscussionObservation, type DiscussionScorecard } from "./types.js";
+/**
+ * Derive the deterministic observation for one fixture: the mode plan, its directive templates rendered
+ * verbatim, the voice-gating verdict, and (when the fixture declares one) the interruption-recovery
+ * trajectory. Pure data derivation over the frozen contract tables.
+ */
+export declare function deriveDiscussionObservation(fixture: DiscussionEvalFixture): DiscussionObservation;
+/**
+ * Run the Discussion Intelligence evaluation suite and return a fully aggregated scorecard. Pure and
+ * deterministic. Pass an explicit fixture list to scope the run (the suite tests use the default set).
+ */
+export declare function runDiscussionEvaluation(fixtures?: readonly DiscussionEvalFixture[]): DiscussionScorecard;
+//# sourceMappingURL=runner.d.ts.map

package/dist/discussion/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/discussion/runner.ts"],"names":[],"mappings":"AAiBA,OAAO,EAEL,KAAK,qBAAqB,EAG1B,KAAK,qBAAqB,EAE1B,KAAK,mBAAmB,EAEzB,MAAM,YAAY,CAAC;AAkBpB;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,qBAAqB,GAAG,qBAAqB,CAejG;AA8BD;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,GAAE,SAAS,qBAAqB,EAA4B,GACnE,mBAAmB,CAarB"}

package/dist/discussion/runner.js

@@ -0,0 +1,80 @@
+// Discussion Intelligence evaluation runner (Epic #491, Issue #502; ADR-0065).
+//
+// Derives a deterministic observation for each fixture from the frozen keiko-contracts tables and the
+// pure recovery helpers, scores the seven discussion-quality dimensions, aggregates a scorecard, and
+// derives the offline Go/No-Go verdict. Pure: no IO, clock, randomness, or model dispatch.
+import { DISCUSSION_DIRECTIVE_TEMPLATES, applyDiscussionInterruption, applyDiscussionRecovery, beginDiscussionTurn, discussionModePlan, voiceCanDriveDiscussion, } from "@oscharko-dev/keiko-contracts";
+import { ALL_DISCUSSION_FIXTURES } from "./fixtures/index.js";
+import { aggregateDiscussionQuality, scoreDiscussionQuality } from "./scorer.js";
+import { DISCUSSION_EVAL_SCHEMA_VERSION, } from "./types.js";
+// The fixed turn index every fixture seeds. Recovery's load-bearing property is that this value is
+// preserved across interrupt -> recover, not its magnitude, so a single constant suffices.
+const FIXTURE_TURN_INDEX = 0;
+// Begin a turn, interrupt it (active -> interrupted), then recover it (interrupted -> recovered). The
+// contract helpers preserve mode/topicId/turnIndex; the scorer asserts that preservation (AC4).
+function deriveRecoveryTrajectory(mode, topicId) {
+    const initial = beginDiscussionTurn(mode, topicId, FIXTURE_TURN_INDEX);
+    const interrupted = applyDiscussionInterruption(initial);
+    const recovered = applyDiscussionRecovery(interrupted);
+    return { initial, interrupted, recovered };
+}
+/**
+ * Derive the deterministic observation for one fixture: the mode plan, its directive templates rendered
+ * verbatim, the voice-gating verdict, and (when the fixture declares one) the interruption-recovery
+ * trajectory. Pure data derivation over the frozen contract tables.
+ */
+export function deriveDiscussionObservation(fixture) {
+    const plan = discussionModePlan(fixture.mode);
+    const renderedDirectives = plan.directives.map((directive) => DISCUSSION_DIRECTIVE_TEMPLATES[directive]);
+    const gatingAllowed = voiceCanDriveDiscussion(fixture.profile);
+    if (fixture.interruption !== true) {
+        return { plan, renderedDirectives, gatingAllowed };
+    }
+    return {
+        plan,
+        renderedDirectives,
+        gatingAllowed,
+        recovery: deriveRecoveryTrajectory(fixture.mode, fixture.topicId),
+    };
+}
+function runFixture(fixture) {
+    const observation = deriveDiscussionObservation(fixture);
+    const dimensionResults = scoreDiscussionQuality(fixture, observation);
+    return {
+        fixtureName: fixture.name,
+        category: fixture.category,
+        observation,
+        dimensionResults,
+        fullyPassed: dimensionResults.every((d) => d.outcome !== "fail"),
+    };
+}
+function summarize(fixtureResults, dimensions) {
+    const allClean = dimensions.every((d) => d.failCount === 0);
+    const coversNoVoiceProfile = fixtureResults.some((f) => f.category === "no-voice");
+    const coversVoiceProfile = fixtureResults.some((f) => f.observation.gatingAllowed);
+    return {
+        totalFixtures: fixtureResults.length,
+        fullyPassedFixtures: fixtureResults.filter((f) => f.fullyPassed).length,
+        coversNoVoiceProfile,
+        coversVoiceProfile,
+        goNoGo: allClean && coversNoVoiceProfile && coversVoiceProfile ? "GO" : "NO-GO",
+    };
+}
+/**
+ * Run the Discussion Intelligence evaluation suite and return a fully aggregated scorecard. Pure and
+ * deterministic. Pass an explicit fixture list to scope the run (the suite tests use the default set).
+ */
+export function runDiscussionEvaluation(fixtures = ALL_DISCUSSION_FIXTURES) {
+    const fixtureResults = fixtures.map(runFixture);
+    const dimensions = aggregateDiscussionQuality(fixtureResults.map((f) => f.dimensionResults));
+    const coveredModes = [
+        ...new Set(fixtureResults.map((f) => f.observation.plan.mode)),
+    ];
+    return {
+        schemaVersion: DISCUSSION_EVAL_SCHEMA_VERSION,
+        fixtureResults,
+        dimensions,
+        summary: summarize(fixtureResults, dimensions),
+        coveredModes,
+    };
+}

package/dist/discussion/scorer.d.ts

@@ -0,0 +1,8 @@
+import { type DiscussionDimensionResult, type DiscussionEvalFixture, type DiscussionObservation, type DiscussionScorecardEntry } from "./types.js";
+/**
+ * Score one fixture's observation across all seven dimensions. A dimension the fixture does not declare
+ * is "not-applicable". Pure.
+ */
+export declare function scoreDiscussionQuality(fixture: DiscussionEvalFixture, obs: DiscussionObservation): readonly DiscussionDimensionResult[];
+export declare function aggregateDiscussionQuality(results: readonly (readonly DiscussionDimensionResult[])[]): readonly DiscussionScorecardEntry[];
+//# sourceMappingURL=scorer.d.ts.map

package/dist/discussion/scorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scorer.d.ts","sourceRoot":"","sources":["../../src/discussion/scorer.ts"],"names":[],"mappings":"AAuBA,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAG1B,KAAK,wBAAwB,EAC9B,MAAM,YAAY,CAAC;AAyNpB;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,qBAAqB,EAC9B,GAAG,EAAE,qBAAqB,GACzB,SAAS,yBAAyB,EAAE,CAUtC;AA8BD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,SAAS,CAAC,SAAS,yBAAyB,EAAE,CAAC,EAAE,GACzD,SAAS,wBAAwB,EAAE,CAErC"}