@oscharko-dev/keiko-evaluations 0.2.0

package/dist/promptEnhancer/fixtures/task-classes.js

@@ -0,0 +1,205 @@
+// Task-class evaluation fixtures (Epic #1307, Issue #1315). One representative draft per supported
+// task class, covering all fifteen classes the taxonomy defines (the issue requires at least ten). Each
+// draft carries strong lexical signals so the deterministic analyzer classifies it stably, and asserts
+// the recommended profile, well-formed structure, and a clean safety posture. These data modules are
+// pure values — no IO — and never carry credentials or content beyond the draft itself.
+// Dimensions every task-class fixture exercises: the prompt is well-formed, complete, classified
+// correctly, safe, and within its token budget.
+const CORE = new Set([
+    "clarity",
+    "completeness",
+    "task-success",
+    "safety",
+    "token-efficiency",
+]);
+export const factualQa = {
+    name: "task-factual-qa",
+    category: "task-class",
+    description: "A plain factual question with no retrieval need (the conservative default class).",
+    request: { text: "What is the boiling point of water at sea level?" },
+    dimensions: new Set([...CORE, "groundedness", "faithfulness"]),
+    oracle: {
+        expectedTaskClasses: ["factual-qa"],
+        expectedProfiles: ["precise"],
+        expectedGroundingRequired: false,
+    },
+};
+export const research = {
+    name: "task-research",
+    category: "task-class",
+    description: "A comprehensive research request that mandates grounding.",
+    request: {
+        text: "Give me a comprehensive overview and literature review of the state of the art in solid-state battery research.",
+    },
+    dimensions: new Set([...CORE, "groundedness", "faithfulness"]),
+    oracle: {
+        expectedTaskClasses: ["research"],
+        expectedProfiles: ["research"],
+        expectedGroundingRequired: true,
+    },
+};
+export const ragQuestionAnswering = {
+    name: "task-rag-qa",
+    category: "task-class",
+    description: "A question answered strictly from supplied/connected context.",
+    request: {
+        text: "Based on the provided document, what notice period does the contract require for termination?",
+        hasConnectedContext: true,
+        attachmentCount: 1,
+    },
+    dimensions: new Set([...CORE, "groundedness", "faithfulness"]),
+    oracle: {
+        expectedTaskClasses: ["rag-question-answering"],
+        expectedGroundingRequired: true,
+        expectedGroundingStrategies: ["supplied-context-only", "hybrid", "local-knowledge"],
+    },
+};
+export const summarization = {
+    name: "task-summarization",
+    category: "task-class",
+    description: "A summarization request over supplied material.",
+    request: {
+        text: "Summarize the following quarterly report into the key points for an executive audience.",
+    },
+    dimensions: CORE,
+    oracle: { expectedTaskClasses: ["summarization"] },
+};
+export const structuredExtraction = {
+    name: "task-structured-extraction",
+    category: "task-class",
+    description: "An extraction request into a structured (JSON) form.",
+    request: {
+        text: "Extract the fields invoice number, total, and due date into json from this invoice text.",
+    },
+    dimensions: new Set([...CORE, "format-adherence"]),
+    oracle: {
+        expectedTaskClasses: ["structured-extraction"],
+        expectedOutputStructured: true,
+        expectedOutputFormat: "json",
+    },
+};
+export const dataAnalysis = {
+    name: "task-data-analysis",
+    category: "task-class",
+    description: "A statistical analysis request over a dataset.",
+    request: {
+        text: "Analyze this data and report the correlation between advertising spend and monthly revenue.",
+    },
+    dimensions: new Set([...CORE, "format-adherence"]),
+    oracle: { expectedTaskClasses: ["data-analysis"], expectedProfiles: ["technical"] },
+};
+export const codeGeneration = {
+    name: "task-code-generation",
+    category: "task-class",
+    description: "A code-writing request.",
+    request: { text: "Write a function that validates an email address and returns a boolean." },
+    dimensions: CORE,
+    oracle: { expectedTaskClasses: ["code-generation"], expectedProfiles: ["technical"] },
+};
+export const codeDebugging = {
+    name: "task-code-debugging",
+    category: "task-class",
+    description: "A debugging request driven by a failing stack trace.",
+    request: {
+        text: "Debug this stack trace and explain why does this fail when the list is empty.",
+    },
+    dimensions: CORE,
+    oracle: { expectedTaskClasses: ["code-debugging"], expectedProfiles: ["technical"] },
+};
+export const codeArchitecture = {
+    name: "task-code-architecture",
+    category: "task-class",
+    description: "A system-design request.",
+    request: {
+        text: "Design the software architecture for a multi-tenant document collaboration service.",
+    },
+    dimensions: CORE,
+    oracle: { expectedTaskClasses: ["code-architecture"], expectedProfiles: ["technical"] },
+};
+export const writingEditing = {
+    name: "task-writing-editing",
+    category: "task-class",
+    description: "A drafting/editing request that favours a lean profile.",
+    request: { text: "Draft a short, polite email to reschedule a meeting and proofread it." },
+    dimensions: new Set([...CORE]),
+    oracle: { expectedTaskClasses: ["writing-editing"], expectedProfiles: ["fast"] },
+};
+export const creativeWriting = {
+    name: "task-creative-writing",
+    category: "task-class",
+    description: "A creative-writing request.",
+    request: {
+        text: "Write a short story about a lighthouse keeper who collects forgotten letters.",
+    },
+    dimensions: CORE,
+    oracle: { expectedTaskClasses: ["creative-writing"], expectedProfiles: ["creative"] },
+};
+export const decisionSupport = {
+    name: "task-decision-support",
+    category: "task-class",
+    description: "A non-safety-critical decision-support request.",
+    request: {
+        text: "Should I use a monorepo or separate repositories for my team? Give the pros and cons.",
+    },
+    dimensions: CORE,
+    oracle: { expectedTaskClasses: ["decision-support"], expectedProfiles: ["precise"] },
+};
+export const agenticToolUse = {
+    name: "task-agentic-tool-use",
+    category: "task-class",
+    description: "An agentic task that requires human-approval gating on side effects.",
+    request: {
+        text: "As an agent, use the tool to fetch the latest issues and automate triaging them step by step.",
+    },
+    dimensions: CORE,
+    oracle: {
+        expectedTaskClasses: ["agentic-tool-use"],
+        expectedProfiles: ["agentic"],
+        expectedSafetyDecisions: ["requires-human-review"],
+        expectedVerificationStatuses: ["passed-with-review"],
+    },
+};
+export const promptOptimization = {
+    name: "task-prompt-optimization",
+    category: "task-class",
+    description: "A meta-prompting request to improve an existing prompt.",
+    request: { text: "Improve this prompt so it produces more reliable structured answers." },
+    dimensions: CORE,
+    oracle: { expectedTaskClasses: ["prompt-optimization"], expectedProfiles: ["technical"] },
+};
+export const safetyCritical = {
+    name: "task-safety-critical",
+    category: "task-class",
+    description: "Consequential advice in a safety-critical (medical) domain.",
+    request: {
+        text: "I was diagnosed with a disease. Should I change my medication dosage and treatment for these symptoms?",
+    },
+    dimensions: new Set([...CORE, "faithfulness"]),
+    oracle: {
+        expectedTaskClasses: ["safety-critical"],
+        expectedProfiles: ["safety-critical"],
+        // The validate stage requires a human-approval rule for critical-criticality prompts; the MVP
+        // generator emits a professional-advice disclaimer rather than that rule, so the assessment
+        // currently rejects (a fail-safe refusal). This is documented as a known limitation/follow-up in
+        // the closure evidence; the eval pins the behaviour so a regression cannot silently change it.
+        expectedSafetyDecisions: ["rejected"],
+        expectedVerificationStatuses: ["failed"],
+    },
+};
+export const TASK_CLASS_FIXTURES = [
+    factualQa,
+    research,
+    ragQuestionAnswering,
+    summarization,
+    structuredExtraction,
+    dataAnalysis,
+    codeGeneration,
+    codeDebugging,
+    codeArchitecture,
+    writingEditing,
+    creativeWriting,
+    decisionSupport,
+    agenticToolUse,
+    promptOptimization,
+    safetyCritical,
+];

package/dist/promptEnhancer/fixtures/token-efficiency.d.ts

@@ -0,0 +1,5 @@
+import type { PromptEnhancerEvalFixture } from "../types.js";
+export declare const tokenEfficiencyLean: PromptEnhancerEvalFixture;
+export declare const tokenEfficiencyThorough: PromptEnhancerEvalFixture;
+export declare const TOKEN_EFFICIENCY_FIXTURES: readonly PromptEnhancerEvalFixture[];
+//# sourceMappingURL=token-efficiency.d.ts.map

package/dist/promptEnhancer/fixtures/token-efficiency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-efficiency.d.ts","sourceRoot":"","sources":["../../../src/promptEnhancer/fixtures/token-efficiency.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAE7D,eAAO,MAAM,mBAAmB,EAAE,yBAajC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,yBAcrC,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,SAAS,yBAAyB,EAGzE,CAAC"}

package/dist/promptEnhancer/fixtures/token-efficiency.js

@@ -0,0 +1,37 @@
+// Token-efficiency fixtures (Epic #1307, Issue #1315). Exercises the token-efficiency dimension at both
+// ends of the breadth/cost trade-off: a lean draft routed to the `fast` profile must stay well under a
+// tight ceiling, while a thorough draft routed to the `research` profile must still respect its larger
+// token budget. Both prove the generator honours the profile's token budget.
+export const tokenEfficiencyLean = {
+    name: "token-efficiency-lean",
+    category: "token-efficiency",
+    description: "A lean editing draft routed to the fast profile; instructions stay compact.",
+    request: { text: "Proofread and tighten this one-sentence status update." },
+    dimensions: new Set(["token-efficiency", "clarity"]),
+    oracle: {
+        expectedTaskClasses: ["writing-editing"],
+        expectedProfiles: ["fast"],
+        // The fast profile keeps the full rendered prompt compact and scores high instruction-leanness.
+        maxEstimatedTokens: 650,
+        minTokenEfficiencyScore: 0.4,
+    },
+};
+export const tokenEfficiencyThorough = {
+    name: "token-efficiency-thorough",
+    category: "token-efficiency",
+    description: "A thorough research draft routed to the research profile; stays within its budget.",
+    request: {
+        text: "Deep research: produce a comprehensive overview and survey of distributed consensus algorithms.",
+    },
+    dimensions: new Set(["token-efficiency", "clarity"]),
+    oracle: {
+        // The research profile is the most thorough; the full rendered prompt is larger but still bounded.
+        expectedTaskClasses: ["research"],
+        expectedProfiles: ["research"],
+        maxEstimatedTokens: 1200,
+    },
+};
+export const TOKEN_EFFICIENCY_FIXTURES = [
+    tokenEfficiencyLean,
+    tokenEfficiencyThorough,
+];

package/dist/promptEnhancer/index.d.ts

@@ -0,0 +1,7 @@
+export { runEnhancement } from "./pipeline.js";
+export { scorePromptQuality, aggregatePromptQuality } from "./scorer.js";
+export { runPromptEnhancerEvaluation } from "./runner.js";
+export { renderPromptEnhancerSummary } from "./render.js";
+export { ALL_PROMPT_ENHANCER_FIXTURES, fixturesForCategory, promptEnhancerFixtureByName, } from "./fixtures/index.js";
+export { PROMPT_QUALITY_DIMENSIONS, PROMPT_ENHANCER_FIXTURE_CATEGORIES, PROMPT_ENHANCER_EVAL_SCHEMA_VERSION, type PromptQualityDimension, type PromptEnhancerFixtureCategory, type PromptEnhancerFixtureRequest, type PromptEnhancerOracle, type PromptEnhancerEvalFixture, type EnhancementObservation, type PromptQualityOutcome, type PromptQualityDimensionResult, type PromptEnhancerFixtureResult, type PromptQualityScorecardEntry, type PromptEnhancerEvalSummary, type PromptEnhancerScorecard, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/promptEnhancer/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACzE,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EACL,4BAA4B,EAC5B,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,yBAAyB,EACzB,kCAAkC,EAClC,mCAAmC,EACnC,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,EAClC,KAAK,4BAA4B,EACjC,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC9B,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,GAC7B,MAAM,YAAY,CAAC"}

package/dist/promptEnhancer/index.js

@@ -0,0 +1,10 @@
+// Public barrel for the Prompt Enhancer evaluation suite (Epic #1307, Issue #1315; ADR-0044 §6).
+// Exposes the deterministic pipeline runner, the eight-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 (`PromptEnhancerEval`).
+export { runEnhancement } from "./pipeline.js";
+export { scorePromptQuality, aggregatePromptQuality } from "./scorer.js";
+export { runPromptEnhancerEvaluation } from "./runner.js";
+export { renderPromptEnhancerSummary } from "./render.js";
+export { ALL_PROMPT_ENHANCER_FIXTURES, fixturesForCategory, promptEnhancerFixtureByName, } from "./fixtures/index.js";
+export { PROMPT_QUALITY_DIMENSIONS, PROMPT_ENHANCER_FIXTURE_CATEGORIES, PROMPT_ENHANCER_EVAL_SCHEMA_VERSION, } from "./types.js";

package/dist/promptEnhancer/pipeline.d.ts

@@ -0,0 +1,7 @@
+import type { EnhancementObservation, PromptEnhancerFixtureRequest } from "./types.js";
+/**
+ * Run the deterministic Prompt Enhancer pipeline for one fixture and return all observable artefacts.
+ * Pure: no IO, clock, randomness, or model dispatch.
+ */
+export declare function runEnhancement(name: string, req: PromptEnhancerFixtureRequest): EnhancementObservation;
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/promptEnhancer/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/promptEnhancer/pipeline.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,sBAAsB,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAmBvF;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,4BAA4B,GAChC,sBAAsB,CA8BxB"}

package/dist/promptEnhancer/pipeline.js

@@ -0,0 +1,63 @@
+// Prompt Enhancer evaluation pipeline (Epic #1307, Issue #1315; ADR-0044 §1/§5/§6).
+//
+// Runs the full deterministic enhancement chain for one fixture and collects every artefact the scorer
+// needs: the analyzer result, the plan, the generated Enhanced Prompt, the deterministic critic
+// scorecard, the structural safety assessment, the raw-draft injection signals, and the token estimate.
+//
+// Determinism: pure. The whole chain — analyze, plan, generate, critic-score, safety-assess, injection-
+// detect — is deterministic and never dispatches a model, so identical fixtures always yield identical
+// observations and the evaluation provides reproducible CI coverage (Engineering Notes).
+import { analyzePrompt, asEnhancedPromptId, asPromptEnhancementRequestId, PROMPT_ENHANCER_SCHEMA_VERSION, } from "@oscharko-dev/keiko-contracts";
+import { PromptEnhancer } from "@oscharko-dev/keiko-model-gateway";
+import { detectPromptInjectionSignals } from "@oscharko-dev/keiko-security";
+// Builds a wire-valid `PromptEnhancementRequest` from a fixture's safe request subset. The ids are
+// derived from the fixture name (kebab-case, so they pass the id validators) to keep runs deterministic.
+function buildRequest(name, req) {
+    return {
+        schemaVersion: PROMPT_ENHANCER_SCHEMA_VERSION,
+        requestId: asPromptEnhancementRequestId(`req-pe-eval-${name}`),
+        input: {
+            text: req.text,
+            hasConnectedContext: req.hasConnectedContext,
+            attachmentCount: req.attachmentCount,
+        },
+        missingInformationStrategy: req.missingInformationStrategy ?? "clarify",
+        profilePreference: req.profilePreference,
+        locale: req.locale,
+    };
+}
+/**
+ * Run the deterministic Prompt Enhancer pipeline for one fixture and return all observable artefacts.
+ * Pure: no IO, clock, randomness, or model dispatch.
+ */
+export function runEnhancement(name, req) {
+    const request = buildRequest(name, req);
+    const analysis = analyzePrompt(request);
+    const plan = PromptEnhancer.planPromptEnhancement(analysis, {
+        profilePreference: req.profilePreference,
+        missingInformationStrategy: request.missingInformationStrategy,
+    });
+    const prompt = PromptEnhancer.generateEnhancedPrompt({
+        promptId: asEnhancedPromptId(`prompt-pe-eval-${name}`),
+        analysis,
+        plan,
+        input: request.input,
+    });
+    const critic = PromptEnhancer.scorePromptCandidate({
+        candidateId: `cand-pe-eval-${name}`,
+        profile: plan.selectedProfile,
+        prompt,
+        plan,
+        analysis,
+    });
+    const safety = PromptEnhancer.assessPromptSafety({ prompt, analysis, input: request.input });
+    return {
+        analysis,
+        plan,
+        prompt,
+        critic,
+        safety,
+        injectionSignals: detectPromptInjectionSignals(req.text),
+        estimatedTokens: PromptEnhancer.estimatePromptTokens(prompt),
+    };
+}

package/dist/promptEnhancer/render.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/promptEnhancer/render.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAEV,uBAAuB,EAGxB,MAAM,YAAY,CAAC;AA2BpB,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,uBAAuB,GAAG,MAAM,CA2BtF"}

package/dist/promptEnhancer/render.js

@@ -0,0 +1,49 @@
+// renderPromptEnhancerSummary (Issue #1315): PromptEnhancerScorecard -> human-readable string. One
+// line per fixture (name, category, dimension pass/fail glyphs), a per-dimension table, the covered-
+// task-class coverage line, and a Go/No-Go verdict. The scorecard carries only harness-authored,
+// content-free fields (structural 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(18)} ${verdict.padEnd(5)} pass=${String(entry.passCount)} fail=${String(entry.failCount)} n/a=${String(entry.notApplicableCount)} rate=${rate}`;
+}
+export function renderPromptEnhancerSummary(scorecard) {
+    const lines = [];
+    lines.push(`Prompt Enhancer evaluation summary (schema v${scorecard.schemaVersion})`);
+    lines.push(`Fixtures: ${String(scorecard.summary.totalFixtures)} total, ${String(scorecard.summary.fullyPassedFixtures)} fully passed`);
+    lines.push(`Task classes covered: ${String(scorecard.coveredTaskClasses.length)} (${scorecard.coveredTaskClasses.join(", ")})`);
+    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(`Safety gate: ${scorecard.summary.safetyGatePassed ? "PASS" : "FAIL"}`);
+    lines.push(scorecard.summary.goNoGo === "GO"
+        ? "Verdict: GO - every exercised prompt-quality dimension passed."
+        : "Verdict: NO-GO - one or more prompt-quality dimensions failed (see table above).");
+    return lines.join("\n");
+}

package/dist/promptEnhancer/runner.d.ts

@@ -0,0 +1,7 @@
+import { type PromptEnhancerEvalFixture, type PromptEnhancerScorecard } from "./types.js";
+/**
+ * Run the Prompt Enhancer 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 runPromptEnhancerEvaluation(fixtures?: readonly PromptEnhancerEvalFixture[]): PromptEnhancerScorecard;
+//# sourceMappingURL=runner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/promptEnhancer/runner.ts"],"names":[],"mappings":"AASA,OAAO,EAEL,KAAK,yBAAyB,EAG9B,KAAK,uBAAuB,EAE7B,MAAM,YAAY,CAAC;AA8BpB;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,GAAE,SAAS,yBAAyB,EAAiC,GAC5E,uBAAuB,CAazB"}

package/dist/promptEnhancer/runner.js

@@ -0,0 +1,49 @@
+// Prompt Enhancer evaluation runner (Epic #1307, Issue #1315; ADR-0044 §6).
+//
+// Runs every registered fixture through the deterministic pipeline, scores the eight prompt-quality
+// dimensions, aggregates a scorecard, and derives the offline Go/No-Go verdict. Pure: no IO, clock,
+// randomness, or model dispatch, so the suite gives reproducible CI coverage.
+import { ALL_PROMPT_ENHANCER_FIXTURES } from "./fixtures/index.js";
+import { runEnhancement } from "./pipeline.js";
+import { aggregatePromptQuality, scorePromptQuality } from "./scorer.js";
+import { PROMPT_ENHANCER_EVAL_SCHEMA_VERSION, } from "./types.js";
+function summarize(fixtureResults, dimensions) {
+    const safety = dimensions.find((d) => d.dimension === "safety");
+    const safetyGatePassed = (safety?.failCount ?? 0) === 0;
+    const allClean = dimensions.every((d) => d.failCount === 0);
+    return {
+        totalFixtures: fixtureResults.length,
+        fullyPassedFixtures: fixtureResults.filter((f) => f.fullyPassed).length,
+        safetyGatePassed,
+        goNoGo: allClean ? "GO" : "NO-GO",
+    };
+}
+function runFixture(fixture) {
+    const observation = runEnhancement(fixture.name, fixture.request);
+    const dimensionResults = scorePromptQuality(fixture, observation);
+    return {
+        fixtureName: fixture.name,
+        category: fixture.category,
+        observation,
+        dimensionResults,
+        fullyPassed: dimensionResults.every((d) => d.outcome !== "fail"),
+    };
+}
+/**
+ * Run the Prompt Enhancer 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 runPromptEnhancerEvaluation(fixtures = ALL_PROMPT_ENHANCER_FIXTURES) {
+    const fixtureResults = fixtures.map(runFixture);
+    const dimensions = aggregatePromptQuality(fixtureResults.map((f) => f.dimensionResults));
+    const coveredTaskClasses = [
+        ...new Set(fixtureResults.map((f) => f.observation.analysis.taskClass)),
+    ];
+    return {
+        schemaVersion: PROMPT_ENHANCER_EVAL_SCHEMA_VERSION,
+        fixtureResults,
+        dimensions,
+        summary: summarize(fixtureResults, dimensions),
+        coveredTaskClasses,
+    };
+}

package/dist/promptEnhancer/scorer.d.ts

@@ -0,0 +1,8 @@
+import { type EnhancementObservation, type PromptEnhancerEvalFixture, type PromptQualityDimensionResult, type PromptQualityScorecardEntry } from "./types.js";
+/**
+ * Score one fixture's observation across all eight dimensions. A dimension the fixture does not declare
+ * is "not-applicable". Pure.
+ */
+export declare function scorePromptQuality(fixture: PromptEnhancerEvalFixture, obs: EnhancementObservation): readonly PromptQualityDimensionResult[];
+export declare function aggregatePromptQuality(results: readonly (readonly PromptQualityDimensionResult[])[]): readonly PromptQualityScorecardEntry[];
+//# sourceMappingURL=scorer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scorer.d.ts","sourceRoot":"","sources":["../../src/promptEnhancer/scorer.ts"],"names":[],"mappings":"AAgBA,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAG9B,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EACjC,MAAM,YAAY,CAAC;AA0RpB;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,yBAAyB,EAClC,GAAG,EAAE,sBAAsB,GAC1B,SAAS,4BAA4B,EAAE,CAUzC;AA8BD,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,SAAS,CAAC,SAAS,4BAA4B,EAAE,CAAC,EAAE,GAC5D,SAAS,2BAA2B,EAAE,CAExC"}