@oscharko-dev/keiko-workflows 0.2.0

package/dist/qualityIntelligence/runEntries.d.ts.map

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

package/dist/qualityIntelligence/runEntries.js

@@ -0,0 +1,243 @@
+// Quality Intelligence deterministic ("scripted") workflow run entries (Epic #270, Issue #273,
+// ADR-0023 D6).
+//
+// Pure orchestration over the seams shipped in #272 (pure-domain QI logic), #279 (model gateway QI
+// dispatcher), and #274 (QI evidence persistence). Shares the run-lifecycle runtime with the
+// model-routed entry via `runtimeCommon.ts`. NO new scheduler, NO event bus, NO duplicated
+// checkpoint store.
+//
+// Structurally inspired by Test Intelligence reference (TI) workflow runners, but rewritten
+// end-to-end against the Keiko contracts surface; no TI runtime, no TI IR.
+import { QualityIntelligence as QI, } from "@oscharko-dev/keiko-contracts";
+import { deduplicateCandidates, deriveIntent, designTestCaseCandidates, validateCandidates, } from "@oscharko-dev/keiko-quality-intelligence";
+import {} from "@oscharko-dev/keiko-model-gateway";
+import {} from "@oscharko-dev/keiko-evidence";
+import { QI_ARTIFACT_REFINEMENT_WORKFLOW_DESCRIPTOR, QI_COVERAGE_REVIEW_WORKFLOW_DESCRIPTOR, QI_TEST_DESIGN_WORKFLOW_DESCRIPTOR, QI_VALIDATION_WORKFLOW_DESCRIPTOR, } from "./descriptors.js";
+import { emit, emitCandidateProposed, emitFindingsRecorded, emitQueuedAndStarted, coverageMatrixFor, finaliseFailureOrCancellation, makeContext, persistRun, truncateCandidates, truncateFindings, withStage, } from "./runtimeCommon.js";
+function contextFor(descriptor, plan, deps) {
+    return makeContext({
+        descriptor,
+        plan,
+        sink: deps.sink,
+        clock: deps.clock,
+        limits: deps.limits,
+        policyProfile: deps.policyProfile,
+        signal: deps.signal,
+    });
+}
+// ─── qi:test-design (scripted) ─────────────────────────────────────────────────
+// The orchestrator follows a strict 6-stage QI lifecycle (queued → started → 4 stages →
+// succeeded); extracting per-stage helpers would obscure the event-emission audit trail.
+// eslint-disable-next-line max-lines-per-function
+export async function runQualityIntelligenceTestDesign(input, deps) {
+    const ctx = contextFor(QI_TEST_DESIGN_WORKFLOW_DESCRIPTOR, input.plan, deps);
+    emitQueuedAndStarted(ctx);
+    try {
+        await withStage(ctx, "plan", async () => Promise.resolve());
+        // Intent derivation is a deterministic sub-step of candidate design, not a separately surfaced
+        // stage. The shared qi:test-design descriptor declares the model-routed lifecycle
+        // (plan, candidates, judge, coverage, validate, finalize); emitting an undeclared "intent"
+        // stage here threw via assertStageRegistered and made this scripted entry impossible to
+        // succeed. Derive intent inside the declared "candidates" stage so the scripted entry stays a
+        // strict subset of the descriptor's stage set.
+        const rawCandidates = await withStage(ctx, "candidates", async () => {
+            const intent = deriveIntent(input.envelopes, ctx.profile);
+            return Promise.resolve(designTestCaseCandidates({
+                runId: input.plan.id,
+                intent,
+                atoms: input.atoms,
+                profile: ctx.profile,
+            }));
+        });
+        const candidates = truncateCandidates(rawCandidates, ctx.limits.maxCandidatesPerRun);
+        emitCandidateProposed(ctx, candidates);
+        const coverageMatrix = await withStage(ctx, "coverage", async () => Promise.resolve(coverageMatrixFor(input.plan.id, input.atoms, candidates)));
+        const rawFindings = await withStage(ctx, "validate", async () => Promise.resolve(validateCandidates(input.plan.id, candidates)));
+        const findings = truncateFindings(rawFindings, ctx.limits.maxFindingsPerRun);
+        emitFindingsRecorded(ctx, findings);
+        const evidence = await withStage(ctx, "finalize", async () => Promise.resolve(persistRun({
+            ctx,
+            status: "succeeded",
+            candidatesCount: candidates.length,
+            findings,
+            provenanceRefs: input.provenanceRefs,
+            completedAt: ctx.clock.nowIso(),
+            evidenceStore: deps.evidenceStore,
+            coverageMatrix,
+        })));
+        emit(ctx, { kind: "run:succeeded" });
+        return Object.freeze({
+            runId: input.plan.id,
+            workflowId: ctx.descriptor.workflowId,
+            status: "succeeded",
+            eventsEmitted: ctx.sequence,
+            modelGatewayCallCount: ctx.modelGatewayCallCount,
+            evidence,
+        });
+    }
+    catch (caught) {
+        return finaliseFailureOrCancellation(ctx, caught, {
+            candidatesCount: 0,
+            findings: Object.freeze([]),
+            provenanceRefs: input.provenanceRefs,
+            evidenceStore: deps.evidenceStore,
+        });
+    }
+}
+// ─── qi:coverage-review ──────────────────────────────────────────────────────
+export async function runQualityIntelligenceCoverageReview(input, deps) {
+    const ctx = contextFor(QI_COVERAGE_REVIEW_WORKFLOW_DESCRIPTOR, input.plan, deps);
+    emitQueuedAndStarted(ctx);
+    try {
+        await withStage(ctx, "plan", async () => Promise.resolve());
+        const coverageMatrix = await withStage(ctx, "analyse", async () => Promise.resolve(coverageMatrixFor(input.plan.id, input.atoms, input.candidates)));
+        const evidence = await withStage(ctx, "report", async () => Promise.resolve(persistRun({
+            ctx,
+            status: "succeeded",
+            candidatesCount: input.candidates.length,
+            findings: Object.freeze([]),
+            provenanceRefs: input.provenanceRefs,
+            completedAt: ctx.clock.nowIso(),
+            evidenceStore: deps.evidenceStore,
+            coverageMatrix,
+        })));
+        emit(ctx, { kind: "run:succeeded" });
+        return Object.freeze({
+            runId: input.plan.id,
+            workflowId: ctx.descriptor.workflowId,
+            status: "succeeded",
+            eventsEmitted: ctx.sequence,
+            modelGatewayCallCount: ctx.modelGatewayCallCount,
+            evidence,
+        });
+    }
+    catch (caught) {
+        return finaliseFailureOrCancellation(ctx, caught, {
+            candidatesCount: input.candidates.length,
+            findings: Object.freeze([]),
+            provenanceRefs: input.provenanceRefs,
+            evidenceStore: deps.evidenceStore,
+        });
+    }
+}
+// ─── qi:validation ───────────────────────────────────────────────────────────
+// Minimal stand-in for the qi:judge-logic profile so this module does not have to plumb a profile
+// id through every caller. The profile lookup itself stays the dispatcher's responsibility.
+const QI_JUDGE_LOGIC_PROFILE = Object.freeze({
+    id: "qi:judge-logic",
+    requiredCapabilities: Object.freeze(["text"]),
+    tokenBudgetHint: 1024,
+    timeoutMsHint: 30_000,
+    retriesMax: 1,
+    cacheable: false,
+    temperatureHint: 0,
+});
+async function maybeRunJudges(ctx, candidates, modelRouted) {
+    if (modelRouted === undefined) {
+        return undefined;
+    }
+    if (candidates.length === 0) {
+        return modelRouted.initialBudget;
+    }
+    let budget = modelRouted.initialBudget;
+    if (ctx.modelGatewayCallCount >= ctx.limits.maxModelCallsPerRun) {
+        return budget;
+    }
+    const evidence = candidates.slice(0, 4).map((c) => ({
+        kind: "normalised-text",
+        value: `candidate:${String(c.id)}`,
+    }));
+    const result = await modelRouted.dispatch.dispatch({
+        profile: QI_JUDGE_LOGIC_PROFILE,
+        instruction: "Evaluate the listed candidates for logic defects (Keiko QI judge).",
+        evidence,
+        model: modelRouted.model,
+        providerConfig: modelRouted.providerConfig,
+        port: modelRouted.port,
+        cache: modelRouted.cache,
+        budget,
+        signal: ctx.signal,
+    });
+    ctx.modelGatewayCallCount += 1;
+    budget = result.budget;
+    return budget;
+}
+export async function runQualityIntelligenceValidation(input, deps) {
+    const ctx = contextFor(QI_VALIDATION_WORKFLOW_DESCRIPTOR, input.plan, deps);
+    emitQueuedAndStarted(ctx);
+    try {
+        await withStage(ctx, "plan", async () => Promise.resolve());
+        await withStage(ctx, "run-judges", async () => {
+            await maybeRunJudges(ctx, input.candidates, deps.modelRouted);
+        });
+        const rawFindings = await withStage(ctx, "reconcile", async () => Promise.resolve(validateCandidates(input.plan.id, input.candidates)));
+        const findings = truncateFindings(rawFindings, ctx.limits.maxFindingsPerRun);
+        emitFindingsRecorded(ctx, findings);
+        const evidence = await withStage(ctx, "report", async () => Promise.resolve(persistRun({
+            ctx,
+            status: "succeeded",
+            candidatesCount: input.candidates.length,
+            findings,
+            provenanceRefs: input.provenanceRefs,
+            completedAt: ctx.clock.nowIso(),
+            evidenceStore: deps.evidenceStore,
+        })));
+        emit(ctx, { kind: "run:succeeded" });
+        return Object.freeze({
+            runId: input.plan.id,
+            workflowId: ctx.descriptor.workflowId,
+            status: "succeeded",
+            eventsEmitted: ctx.sequence,
+            modelGatewayCallCount: ctx.modelGatewayCallCount,
+            evidence,
+        });
+    }
+    catch (caught) {
+        return finaliseFailureOrCancellation(ctx, caught, {
+            candidatesCount: input.candidates.length,
+            findings: Object.freeze([]),
+            provenanceRefs: input.provenanceRefs,
+            evidenceStore: deps.evidenceStore,
+        });
+    }
+}
+// ─── qi:artifact-refinement ──────────────────────────────────────────────────
+export async function runQualityIntelligenceArtifactRefinement(input, deps) {
+    const ctx = contextFor(QI_ARTIFACT_REFINEMENT_WORKFLOW_DESCRIPTOR, input.plan, deps);
+    emitQueuedAndStarted(ctx);
+    try {
+        await withStage(ctx, "plan", async () => Promise.resolve());
+        const refinedRaw = await withStage(ctx, "refine", async () => Promise.resolve(deduplicateCandidates(input.candidates)));
+        const refined = truncateCandidates(refinedRaw, ctx.limits.maxCandidatesPerRun);
+        emitCandidateProposed(ctx, refined);
+        const rawFindings = await withStage(ctx, "validate", async () => Promise.resolve(validateCandidates(input.plan.id, refined)));
+        const findings = truncateFindings(rawFindings, ctx.limits.maxFindingsPerRun);
+        emitFindingsRecorded(ctx, findings);
+        const evidence = await withStage(ctx, "report", async () => Promise.resolve(persistRun({
+            ctx,
+            status: "succeeded",
+            candidatesCount: refined.length,
+            findings,
+            provenanceRefs: input.provenanceRefs,
+            completedAt: ctx.clock.nowIso(),
+            evidenceStore: deps.evidenceStore,
+        })));
+        emit(ctx, { kind: "run:succeeded" });
+        return Object.freeze({
+            runId: input.plan.id,
+            workflowId: ctx.descriptor.workflowId,
+            status: "succeeded",
+            eventsEmitted: ctx.sequence,
+            modelGatewayCallCount: ctx.modelGatewayCallCount,
+            evidence,
+        });
+    }
+    catch (caught) {
+        return finaliseFailureOrCancellation(ctx, caught, {
+            candidatesCount: input.candidates.length,
+            findings: Object.freeze([]),
+            provenanceRefs: input.provenanceRefs,
+            evidenceStore: deps.evidenceStore,
+        });
+    }
+}

package/dist/qualityIntelligence/runtimeCommon.d.ts

@@ -0,0 +1,106 @@
+import { QualityIntelligence as QI } from "@oscharko-dev/keiko-contracts";
+import { type QualityIntelligenceCoverageMatrixRow, type QualityIntelligenceLocalStore, type QualityIntelligenceRecordInput, type QualityIntelligenceRecordOptions, type QualityIntelligenceRecordResult } from "@oscharko-dev/keiko-evidence";
+import { type AtomCoverageStatus, type PolicyProfile } from "@oscharko-dev/keiko-quality-intelligence";
+import type { QualityIntelligenceWorkflowDescriptor, QualityIntelligenceWorkflowLimits } from "./descriptors.js";
+/** Sink for QI run events. Mirrors the harness EventSink shape but typed for the QI envelope. */
+export interface QualityIntelligenceRunEventSink {
+    readonly emit: (event: QI.QualityIntelligenceRunEvent) => void;
+}
+/** Wall-clock port. Defaults to `Date.now`; injected for deterministic tests. */
+export interface QualityIntelligenceClock {
+    readonly nowIso: () => string;
+}
+export declare const DEFAULT_CLOCK: QualityIntelligenceClock;
+export type QualityIntelligenceProvenanceRefs = QualityIntelligenceRecordInput["provenanceRefs"];
+export type QualityIntelligenceRunStatus = "succeeded" | "failed" | "cancelled";
+export interface QualityIntelligenceRunSummary {
+    readonly runId: QI.QualityIntelligenceRunId;
+    readonly workflowId: QualityIntelligenceWorkflowDescriptor["workflowId"];
+    readonly status: QualityIntelligenceRunStatus;
+    readonly eventsEmitted: number;
+    readonly modelGatewayCallCount: number;
+    readonly evidence?: QualityIntelligenceRecordResult | undefined;
+    readonly reasonSummary?: string | undefined;
+    /**
+     * Run quality score: the percentage of candidates with a strong judge outcome [0-100] (Epic #736).
+     * Null only when the judge stage was skipped/unavailable or there were no candidates to judge.
+     */
+    readonly qualityScore?: number | null;
+}
+export interface RunContext {
+    readonly descriptor: QualityIntelligenceWorkflowDescriptor;
+    readonly plan: QI.QualityIntelligenceRunPlan;
+    readonly sink: QualityIntelligenceRunEventSink;
+    readonly clock: QualityIntelligenceClock;
+    readonly limits: QualityIntelligenceWorkflowLimits;
+    readonly profile: PolicyProfile;
+    readonly signal: AbortSignal | undefined;
+    sequence: number;
+    modelGatewayCallCount: number;
+}
+export interface RunContextInit {
+    readonly descriptor: QualityIntelligenceWorkflowDescriptor;
+    readonly plan: QI.QualityIntelligenceRunPlan;
+    readonly sink: QualityIntelligenceRunEventSink;
+    readonly clock?: QualityIntelligenceClock | undefined;
+    readonly limits?: QualityIntelligenceWorkflowLimits | undefined;
+    readonly policyProfile?: PolicyProfile | undefined;
+    readonly signal?: AbortSignal | undefined;
+}
+export declare function makeContext(init: RunContextInit): RunContext;
+export declare function emit(ctx: RunContext, payload: QI.QualityIntelligenceRunEventPayload): void;
+export declare function emitQueuedAndStarted(ctx: RunContext): void;
+export declare class StageCancelledError extends Error {
+    constructor();
+}
+export declare function checkCancelled(ctx: RunContext): void;
+export declare function safeReasonSummary(error: unknown): string;
+export declare function withStage<T>(ctx: RunContext, stageName: string, body: () => Promise<T>): Promise<T>;
+export declare function truncateCandidates(candidates: readonly QI.QualityIntelligenceTestCaseCandidate[], limit: number): readonly QI.QualityIntelligenceTestCaseCandidate[];
+export declare function truncateFindings(findings: readonly QI.QualityIntelligenceValidationFinding[], limit: number): readonly QI.QualityIntelligenceValidationFinding[];
+/**
+ * Project per-atom coverage statuses into persistable matrix rows (Epic #734). When the caller
+ * supplies `excerptByAtomId` (atom id -> already-redacted excerpt, see `buildRequirementExcerpt`),
+ * each row additionally carries `requirementExcerptRedacted` so coverage/traceability surfaces are
+ * auditor-readable (#790); rows without a map entry stay refs-only.
+ */
+export declare function toCoverageMatrixRows(statuses: readonly AtomCoverageStatus[], excerptByAtomId?: ReadonlyMap<string, string>): readonly QualityIntelligenceCoverageMatrixRow[];
+/**
+ * Build the persistable coverage matrix for a run from its atoms + candidates. Used by every run
+ * path so coverage is persisted consistently (the scripted paths previously discarded it).
+ */
+export declare function coverageMatrixFor(runId: QI.QualityIntelligenceRunId, atoms: readonly QI.QualityIntelligenceEvidenceAtom[], candidates: readonly QI.QualityIntelligenceTestCaseCandidate[], excerptByAtomId?: ReadonlyMap<string, string>): readonly QualityIntelligenceCoverageMatrixRow[];
+export declare function emitCandidateProposed(ctx: RunContext, candidates: readonly QI.QualityIntelligenceTestCaseCandidate[]): void;
+export declare function emitFindingsRecorded(ctx: RunContext, findings: readonly QI.QualityIntelligenceValidationFinding[]): void;
+export type EvidenceStatus = "running" | "succeeded" | "failed" | "cancelled";
+export interface PersistArgs {
+    readonly ctx: RunContext;
+    readonly status: EvidenceStatus;
+    readonly candidatesCount: number;
+    readonly findings: readonly QI.QualityIntelligenceValidationFinding[];
+    readonly evidenceRefs?: QualityIntelligenceRecordInput["evidenceRefs"] | undefined;
+    readonly provenanceRefs: QualityIntelligenceProvenanceRefs;
+    readonly completedAt: string | undefined;
+    readonly evidenceStore: QualityIntelligenceLocalStore;
+    readonly coverageMatrix?: QualityIntelligenceRecordInput["coverageMatrix"];
+    readonly qualityScore?: number | null;
+    readonly redaction?: QualityIntelligenceRecordOptions["redaction"];
+    readonly sourceFingerprints?: QualityIntelligenceRecordInput["sourceFingerprints"];
+    readonly atomFingerprints?: QualityIntelligenceRecordInput["atomFingerprints"];
+    /** Model id that generated the candidates (Epic #761). */
+    readonly modelId?: string;
+    /** Redaction-safe request parameter scalars (Epic #761). */
+    readonly modelParameters?: Record<string, unknown>;
+    /** Seed used for deterministic sampling (Epic #761). */
+    readonly seedUsed?: number | null;
+}
+export declare function persistRun(args: PersistArgs): QualityIntelligenceRecordResult;
+export interface FinaliseArgs {
+    readonly candidatesCount: number;
+    readonly findings: readonly QI.QualityIntelligenceValidationFinding[];
+    readonly evidenceRefs?: QualityIntelligenceRecordInput["evidenceRefs"] | undefined;
+    readonly provenanceRefs: QualityIntelligenceProvenanceRefs;
+    readonly evidenceStore: QualityIntelligenceLocalStore;
+}
+export declare function finaliseFailureOrCancellation(ctx: RunContext, caught: unknown, args: FinaliseArgs): QualityIntelligenceRunSummary;
+//# sourceMappingURL=runtimeCommon.d.ts.map

package/dist/qualityIntelligence/runtimeCommon.d.ts.map

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

package/dist/qualityIntelligence/runtimeCommon.js

@@ -0,0 +1,258 @@
+// Shared Quality Intelligence run-lifecycle runtime (Epic #270, Issue #273, ADR-0023 D6).
+//
+// Behaviour-preserving extraction of the run-event emission, stage tracking, cancellation, and
+// evidence-persistence helpers shared by every QI run entry (the deterministic test-design /
+// coverage / validation / refinement entries in `runEntries.ts` and the model-routed test-design
+// entry in `modelRoutedTestDesign.ts`). NO new scheduler, NO event bus: this composes the existing
+// Harness world and emits the versioned QI run-event envelope from `@oscharko-dev/keiko-contracts`.
+import { QualityIntelligence as QI } from "@oscharko-dev/keiko-contracts";
+import { recordQualityIntelligenceRun, } from "@oscharko-dev/keiko-evidence";
+import { QualityIntelligenceSafeErrorException } from "@oscharko-dev/keiko-model-gateway";
+import { buildAtomCoverageStatuses, buildCoverageMap, regressionDefault, } from "@oscharko-dev/keiko-quality-intelligence";
+import { QUALITY_INTELLIGENCE_DEFAULT_RETENTION_PROFILE_ID } from "@oscharko-dev/keiko-evidence";
+import { composeStageCancellation, isCancelled } from "./cancellation.js";
+export const DEFAULT_CLOCK = Object.freeze({
+    nowIso: () => new Date().toISOString(),
+});
+export function makeContext(init) {
+    return {
+        descriptor: init.descriptor,
+        plan: init.plan,
+        sink: init.sink,
+        clock: init.clock ?? DEFAULT_CLOCK,
+        limits: init.limits ?? init.descriptor.defaultLimits,
+        profile: init.policyProfile ?? regressionDefault,
+        signal: init.signal,
+        sequence: 0,
+        modelGatewayCallCount: 0,
+    };
+}
+function nextSequence(ctx) {
+    const value = ctx.sequence;
+    ctx.sequence = value + 1;
+    return value;
+}
+export function emit(ctx, payload) {
+    const event = Object.freeze({
+        eventSchemaVersion: QI.QUALITY_INTELLIGENCE_EVENT_SCHEMA_VERSION,
+        runId: ctx.plan.id,
+        sequence: nextSequence(ctx),
+        timestamp: ctx.clock.nowIso(),
+        payload: Object.freeze(payload),
+    });
+    ctx.sink.emit(event);
+}
+export function emitQueuedAndStarted(ctx) {
+    emit(ctx, { kind: "run:queued" });
+    emit(ctx, { kind: "run:started" });
+}
+function assertStageRegistered(descriptor, stageName) {
+    if (!descriptor.stageNames.includes(stageName)) {
+        throw new Error(`Stage "${stageName}" is not declared by descriptor ${descriptor.workflowId}`);
+    }
+}
+export class StageCancelledError extends Error {
+    constructor() {
+        super("Quality Intelligence run cancelled before completion");
+        this.name = "StageCancelledError";
+    }
+}
+export function checkCancelled(ctx) {
+    if (isCancelled(ctx.signal)) {
+        throw new StageCancelledError();
+    }
+}
+// Error names raised inside the QI server/workflow layers whose identity (and, for coded errors,
+// whose `QI_*` code) is authored, static, and secret-free — safe to surface so a failed run stays
+// actionable. Matched by name rather than `instanceof` because the coded server errors
+// (QiGenerationError / QiIngestionError) live in a higher layer this package must not import.
+const SAFE_QI_ERROR_NAMES = new Set([
+    "EmptyEvidenceError",
+    "UnparseableModelOutputError",
+    "QiGenerationError",
+    "QiIngestionError",
+]);
+const QI_ERROR_CODE_PATTERN = /^QI_[A-Z0-9_]+$/;
+// Derive a redaction-safe, statically-bounded failure summary for a run/stage event (#279 AC3).
+//
+// FAIL-CLOSED: the raw `.message` of an arbitrary error is NEVER echoed. A productive model call
+// rejects through the Keiko Model Gateway with a `GatewayError` whose message can carry the
+// provider base URL, a deployment endpoint, or a credential-shaped substring (see
+// keiko-server `conversation-audit.test.ts`); that string must not reach the SSE `reasonSummary`
+// or any persisted field. Only three shapes produce a non-generic summary:
+//   1. a QI safe-error exception          -> its `qi/*` code (already secret-free by construction);
+//   2. an allow-listed in-repo QI error   -> its `QI_*` code when present, else its error name;
+//   3. everything else (gateway/provider/unexpected) -> a fixed generic code, no message.
+export function safeReasonSummary(error) {
+    if (error instanceof QualityIntelligenceSafeErrorException) {
+        return `qi-safe-error: ${error.safe.code}`;
+    }
+    if (error instanceof Error && SAFE_QI_ERROR_NAMES.has(error.name)) {
+        const code = error.code;
+        if (typeof code === "string" && QI_ERROR_CODE_PATTERN.test(code)) {
+            return `qi-error: ${code}`;
+        }
+        return `qi-error: ${error.name}`;
+    }
+    return "qi-run-error";
+}
+export async function withStage(ctx, stageName, body) {
+    assertStageRegistered(ctx.descriptor, stageName);
+    checkCancelled(ctx);
+    emit(ctx, { kind: "stage:started", stageName });
+    const handle = composeStageCancellation(ctx.signal);
+    try {
+        const result = await body();
+        checkCancelled(ctx);
+        emit(ctx, { kind: "stage:completed", stageName });
+        return result;
+    }
+    catch (caught) {
+        if (caught instanceof StageCancelledError) {
+            throw caught;
+        }
+        if (isCancelled(ctx.signal)) {
+            // The stage work threw because the run was cancelled mid-flight (e.g. the model call's
+            // AbortSignal fired and the gateway rejected). That is a cancellation, not a stage failure:
+            // do not emit stage:failed, and let the finaliser classify the run as "cancelled".
+            throw new StageCancelledError();
+        }
+        emit(ctx, { kind: "stage:failed", stageName, reasonSummary: safeReasonSummary(caught) });
+        throw caught;
+    }
+    finally {
+        handle.dispose();
+    }
+}
+// ─── Candidate / finding helpers ─────────────────────────────────────────────
+export function truncateCandidates(candidates, limit) {
+    return candidates.length <= limit ? candidates : Object.freeze(candidates.slice(0, limit));
+}
+export function truncateFindings(findings, limit) {
+    return findings.length <= limit ? findings : Object.freeze(findings.slice(0, limit));
+}
+/**
+ * Project per-atom coverage statuses into persistable matrix rows (Epic #734). When the caller
+ * supplies `excerptByAtomId` (atom id -> already-redacted excerpt, see `buildRequirementExcerpt`),
+ * each row additionally carries `requirementExcerptRedacted` so coverage/traceability surfaces are
+ * auditor-readable (#790); rows without a map entry stay refs-only.
+ */
+export function toCoverageMatrixRows(statuses, excerptByAtomId) {
+    return Object.freeze(statuses.map((s) => {
+        const excerpt = excerptByAtomId?.get(String(s.atomId));
+        return Object.freeze({
+            atomId: String(s.atomId),
+            status: s.status,
+            confidence: s.confidence,
+            coveringCandidateIds: Object.freeze(s.coveringCandidateIds.map(String)),
+            ...(excerpt !== undefined ? { requirementExcerptRedacted: excerpt } : {}),
+        });
+    }));
+}
+/**
+ * Build the persistable coverage matrix for a run from its atoms + candidates. Used by every run
+ * path so coverage is persisted consistently (the scripted paths previously discarded it).
+ */
+export function coverageMatrixFor(runId, atoms, candidates, excerptByAtomId) {
+    const coverageMap = buildCoverageMap({ runId, atoms, candidates });
+    return toCoverageMatrixRows(buildAtomCoverageStatuses(atoms, coverageMap), excerptByAtomId);
+}
+export function emitCandidateProposed(ctx, candidates) {
+    for (const candidate of candidates) {
+        emit(ctx, {
+            kind: "candidate:proposed",
+            candidateId: candidate.id,
+            derivedFromAtomIds: candidate.derivedFromAtomIds,
+        });
+    }
+}
+export function emitFindingsRecorded(ctx, findings) {
+    for (const finding of findings) {
+        emit(ctx, { kind: "finding:recorded", findingId: finding.id });
+    }
+}
+function mapFindingsToRows(findings) {
+    return Object.freeze(findings.map((f) => Object.freeze({
+        id: String(f.id),
+        kind: f.kind,
+        severity: f.severity,
+        summaryRedacted: f.summary,
+        ...(f.candidateId !== undefined ? { candidateId: String(f.candidateId) } : {}),
+    })));
+}
+export function persistRun(args) {
+    const findingRows = mapFindingsToRows(args.findings);
+    const evidenceRefs = args.evidenceRefs ?? Object.freeze([]);
+    const input = {
+        runId: String(args.ctx.plan.id),
+        planAt: args.ctx.plan.requestedAt,
+        completedAt: args.completedAt,
+        status: args.status,
+        policyProfileIds: Object.freeze([args.ctx.profile.id]),
+        retentionPolicyId: QUALITY_INTELLIGENCE_DEFAULT_RETENTION_PROFILE_ID,
+        modelGatewayCallCount: args.ctx.modelGatewayCallCount,
+        totals: Object.freeze({
+            candidates: args.candidatesCount,
+            findings: findingRows.length,
+            exports: 0,
+        }),
+        findings: findingRows,
+        exports: Object.freeze([]),
+        evidenceRefs,
+        provenanceRefs: args.provenanceRefs,
+        coverageMatrix: args.coverageMatrix,
+        ...(args.qualityScore !== undefined ? { qualityScore: args.qualityScore } : {}),
+        ...(args.sourceFingerprints !== undefined
+            ? { sourceFingerprints: args.sourceFingerprints }
+            : {}),
+        ...(args.atomFingerprints !== undefined ? { atomFingerprints: args.atomFingerprints } : {}),
+        ...(args.modelId !== undefined ? { modelId: args.modelId } : {}),
+        ...(args.modelParameters !== undefined ? { modelParameters: args.modelParameters } : {}),
+        ...(args.seedUsed !== undefined ? { seedUsed: args.seedUsed } : {}),
+    };
+    return recordQualityIntelligenceRun(input, {
+        store: args.evidenceStore,
+        ...(args.redaction !== undefined ? { redaction: args.redaction } : {}),
+    });
+}
+export function finaliseFailureOrCancellation(ctx, caught, args) {
+    // A StageCancelledError, or any error raised while the run signal is aborted, is a cancellation
+    // (defense-in-depth: an abort-induced rejection that bypassed withStage must not look like a failure).
+    if (caught instanceof StageCancelledError || isCancelled(ctx.signal)) {
+        emit(ctx, { kind: "run:cancelled" });
+        return Object.freeze({
+            runId: ctx.plan.id,
+            workflowId: ctx.descriptor.workflowId,
+            status: "cancelled",
+            eventsEmitted: ctx.sequence,
+            modelGatewayCallCount: ctx.modelGatewayCallCount,
+        });
+    }
+    const reasonSummary = safeReasonSummary(caught);
+    emit(ctx, { kind: "run:failed", reasonSummary });
+    let evidence;
+    try {
+        evidence = persistRun({
+            ctx,
+            status: "failed",
+            candidatesCount: args.candidatesCount,
+            findings: args.findings,
+            evidenceRefs: args.evidenceRefs,
+            provenanceRefs: args.provenanceRefs,
+            completedAt: ctx.clock.nowIso(),
+            evidenceStore: args.evidenceStore,
+        });
+    }
+    catch {
+        evidence = undefined;
+    }
+    return Object.freeze({
+        runId: ctx.plan.id,
+        workflowId: ctx.descriptor.workflowId,
+        status: "failed",
+        eventsEmitted: ctx.sequence,
+        modelGatewayCallCount: ctx.modelGatewayCallCount,
+        evidence,
+        reasonSummary,
+    });
+}

package/dist/qualityIntelligence/scopedRegeneration.d.ts

@@ -0,0 +1,26 @@
+import { QualityIntelligence as QI } from "@oscharko-dev/keiko-contracts";
+import type { QualityIntelligenceModelRoutedTestDesignDeps } from "./modelRoutedTestDesign.js";
+import type { QualityIntelligenceIngestedAtom } from "./modelRoutedTestDesign.js";
+import type { QualityIntelligenceRunSummary, QualityIntelligenceProvenanceRefs } from "./runtimeCommon.js";
+export interface ScopedRegenerationInput {
+    /** Fresh run id for the regenerated run (must be different from the original). */
+    readonly newRunId: string;
+    readonly requestedAt: string;
+    /** All envelopes from re-ingesting the current sources. */
+    readonly envelopes: readonly QI.QualityIntelligenceSourceEnvelope[];
+    /** NARROWED to atoms belonging to stale candidates only. */
+    readonly ingestedAtoms: readonly QualityIntelligenceIngestedAtom[];
+    readonly provenanceRefs: QualityIntelligenceProvenanceRefs;
+}
+export interface ScopedRegenerationResult {
+    readonly summary: QualityIntelligenceRunSummary;
+    /** Number of atoms that were submitted for regeneration. */
+    readonly narrowedAtomCount: number;
+}
+/**
+ * Run the model-routed test-design workflow scoped to a narrowed set of atoms. Returns the full run
+ * summary plus a count of narrowed atoms for caller bookkeeping. The caller is responsible for
+ * merging the regenerated candidates with preserved-fresh candidates from the original run.
+ */
+export declare function runScopedRegeneration(input: ScopedRegenerationInput, deps: QualityIntelligenceModelRoutedTestDesignDeps): Promise<ScopedRegenerationResult>;
+//# sourceMappingURL=scopedRegeneration.d.ts.map

package/dist/qualityIntelligence/scopedRegeneration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scopedRegeneration.d.ts","sourceRoot":"","sources":["../../src/qualityIntelligence/scopedRegeneration.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,mBAAmB,IAAI,EAAE,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,KAAK,EAAE,4CAA4C,EAAE,MAAM,4BAA4B,CAAC;AAE/F,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,4BAA4B,CAAC;AAClF,OAAO,KAAK,EACV,6BAA6B,EAC7B,iCAAiC,EAClC,MAAM,oBAAoB,CAAC;AAW5B,MAAM,WAAW,uBAAuB;IACtC,kFAAkF;IAClF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,EAAE,SAAS,EAAE,CAAC,iCAAiC,EAAE,CAAC;IACpE,4DAA4D;IAC5D,QAAQ,CAAC,aAAa,EAAE,SAAS,+BAA+B,EAAE,CAAC;IACnE,QAAQ,CAAC,cAAc,EAAE,iCAAiC,CAAC;CAC5D;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,OAAO,EAAE,6BAA6B,CAAC;IAChD,4DAA4D;IAC5D,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,uBAAuB,EAC9B,IAAI,EAAE,4CAA4C,GACjD,OAAO,CAAC,wBAAwB,CAAC,CAmBnC"}