@oscharko-dev/keiko-quality-intelligence 0.2.0

package/dist/domain/staleness.js

@@ -0,0 +1,313 @@
+// Source-fingerprint drift detection and per-test staleness model (Epic #735, Issue #742).
+//
+// Pure function, no IO, deterministic. Compares persisted envelope fingerprints from a previous
+// QI run against current source fingerprints to classify each test-case candidate as fresh or
+// stale. A candidate is stale on ANY of its source envelopes changing (hash differs → "source-changed")
+// or disappearing from the current scan (envelope absent → "source-removed"). The removed case takes
+// precedence over changed. Candidates with no resolvable envelope (unknown atoms) are treated as
+// stale to prevent silently keeping invalid tests.
+/** Build a map from atomId → envelopeId from the manifest evidenceRefs. */
+function buildAtomToEnvelopeMap(evidenceRefs) {
+    const map = new Map();
+    for (const ref of evidenceRefs) {
+        map.set(ref.atomId, ref.envelopeId);
+    }
+    return map;
+}
+/** Build a map from envelopeId → hash for a fingerprint array. */
+function buildFingerprintMap(fingerprints) {
+    const map = new Map();
+    for (const fp of fingerprints) {
+        map.set(fp.envelopeId, fp.integrityHashSha256Hex);
+    }
+    return map;
+}
+/** Distinct envelopeIds in first-seen evidenceRefs order (deterministic tie-breaking). */
+function envelopeOrderOf(evidenceRefs) {
+    const order = [];
+    const seen = new Set();
+    for (const ref of evidenceRefs) {
+        if (!seen.has(ref.envelopeId)) {
+            order.push(ref.envelopeId);
+            seen.add(ref.envelopeId);
+        }
+    }
+    return order;
+}
+const UNKNOWN_ENVELOPE = "unknown";
+const REQUIREMENTS_ENVELOPE_PREFIX = "qi-src-req-";
+const ALIGN_INSERT_DELETE_COST = 3;
+const ALIGN_SUBSTITUTE_COST = 4;
+const ALIGN_CROSS_OLD_ATOM_COST = 10;
+const staleReason = (candidateId, reason, envelopeId) => ({ candidateId, reason, envelopeId });
+function buildAtomFingerprintMap(fingerprints) {
+    const map = new Map();
+    for (const fp of fingerprints ?? []) {
+        map.set(fp.atomId, {
+            envelopeId: fp.envelopeId,
+            canonicalHashSha256Hex: fp.canonicalHashSha256Hex,
+            ...(fp.replacementGroupId !== undefined ? { replacementGroupId: fp.replacementGroupId } : {}),
+            ...(fp.replacementOrdinal !== undefined ? { replacementOrdinal: fp.replacementOrdinal } : {}),
+        });
+    }
+    return map;
+}
+function replacementEntriesByGroup(fingerprints) {
+    const groups = new Map();
+    for (const fp of fingerprints ?? []) {
+        if (fp.replacementGroupId === undefined || fp.replacementOrdinal === undefined)
+            continue;
+        const entry = {
+            atomId: fp.atomId,
+            canonicalHashSha256Hex: fp.canonicalHashSha256Hex,
+            replacementGroupId: fp.replacementGroupId,
+            replacementOrdinal: fp.replacementOrdinal,
+        };
+        const group = groups.get(fp.replacementGroupId);
+        if (group === undefined) {
+            groups.set(fp.replacementGroupId, [entry]);
+        }
+        else {
+            group.push(entry);
+        }
+    }
+    for (const group of groups.values()) {
+        group.sort((a, b) => a.replacementOrdinal - b.replacementOrdinal);
+    }
+    return groups;
+}
+function alignmentPairCost(oldEntry, currentEntry, oldAtomIds) {
+    if (oldEntry.atomId === currentEntry.atomId)
+        return 0;
+    if (currentEntry.canonicalHashSha256Hex === oldEntry.canonicalHashSha256Hex)
+        return 0;
+    return oldAtomIds.has(currentEntry.atomId) ? ALIGN_CROSS_OLD_ATOM_COST : ALIGN_SUBSTITUTE_COST;
+}
+function replacementEntryAt(entries, index) {
+    const entry = entries[index];
+    if (entry === undefined)
+        throw new Error("Replacement alignment index out of bounds.");
+    return entry;
+}
+function matrixValue(matrix, row, col) {
+    const value = matrix[row]?.[col];
+    if (value === undefined)
+        throw new Error("Replacement alignment matrix index out of bounds.");
+    return value;
+}
+function setMatrixValue(matrix, row, col, value) {
+    const rowValues = matrix[row];
+    if (rowValues === undefined) {
+        throw new Error("Replacement alignment matrix index out of bounds.");
+    }
+    rowValues[col] = value;
+}
+function buildAlignmentCostMatrix(oldEntries, currentEntries, oldAtomIds) {
+    const matrix = Array.from({ length: oldEntries.length + 1 }, () => Array.from({ length: currentEntries.length + 1 }, () => 0));
+    for (let oldIndex = 1; oldIndex <= oldEntries.length; oldIndex += 1) {
+        setMatrixValue(matrix, oldIndex, 0, oldIndex * ALIGN_INSERT_DELETE_COST);
+    }
+    for (let currentIndex = 1; currentIndex <= currentEntries.length; currentIndex += 1) {
+        setMatrixValue(matrix, 0, currentIndex, currentIndex * ALIGN_INSERT_DELETE_COST);
+    }
+    for (let oldIndex = 1; oldIndex <= oldEntries.length; oldIndex += 1) {
+        for (let currentIndex = 1; currentIndex <= currentEntries.length; currentIndex += 1) {
+            const pairCost = alignmentPairCost(replacementEntryAt(oldEntries, oldIndex - 1), replacementEntryAt(currentEntries, currentIndex - 1), oldAtomIds);
+            const pair = matrixValue(matrix, oldIndex - 1, currentIndex - 1) + pairCost;
+            const deletion = matrixValue(matrix, oldIndex - 1, currentIndex) + ALIGN_INSERT_DELETE_COST;
+            const insertion = matrixValue(matrix, oldIndex, currentIndex - 1) + ALIGN_INSERT_DELETE_COST;
+            setMatrixValue(matrix, oldIndex, currentIndex, Math.min(pair, deletion, insertion));
+        }
+    }
+    return matrix;
+}
+function alignReplacementEntries(oldEntries, currentEntries) {
+    const mapping = new Map();
+    const oldAtomIds = new Set(oldEntries.map((entry) => entry.atomId));
+    const costs = buildAlignmentCostMatrix(oldEntries, currentEntries, oldAtomIds);
+    let oldIndex = oldEntries.length;
+    let currentIndex = currentEntries.length;
+    while (oldIndex > 0 && currentIndex > 0) {
+        const oldEntry = replacementEntryAt(oldEntries, oldIndex - 1);
+        const currentEntry = replacementEntryAt(currentEntries, currentIndex - 1);
+        const pairCost = alignmentPairCost(oldEntry, currentEntry, oldAtomIds);
+        const currentCost = matrixValue(costs, oldIndex, currentIndex);
+        const pair = matrixValue(costs, oldIndex - 1, currentIndex - 1) + pairCost;
+        const deletion = matrixValue(costs, oldIndex - 1, currentIndex) + ALIGN_INSERT_DELETE_COST;
+        const insertion = matrixValue(costs, oldIndex, currentIndex - 1) + ALIGN_INSERT_DELETE_COST;
+        if (pairCost === 0 && currentCost === pair) {
+            mapping.set(oldEntry.atomId, currentEntry.atomId);
+            oldIndex -= 1;
+            currentIndex -= 1;
+        }
+        else if (currentCost === insertion) {
+            currentIndex -= 1;
+        }
+        else if (currentCost === deletion) {
+            oldIndex -= 1;
+        }
+        else {
+            mapping.set(oldEntry.atomId, currentEntry.atomId);
+            oldIndex -= 1;
+            currentIndex -= 1;
+        }
+    }
+    return mapping;
+}
+function buildReplacementAtomMap(oldFingerprints, currentFingerprints) {
+    const oldGroups = replacementEntriesByGroup(oldFingerprints);
+    const currentGroups = replacementEntriesByGroup(currentFingerprints);
+    const mapping = new Map();
+    for (const [groupId, oldEntries] of oldGroups) {
+        const currentEntries = currentGroups.get(groupId);
+        if (currentEntries === undefined)
+            continue;
+        for (const [oldAtomId, currentAtomId] of alignReplacementEntries(oldEntries, currentEntries)) {
+            mapping.set(oldAtomId, currentAtomId);
+        }
+    }
+    return mapping;
+}
+function buildAtomIdsByEnvelope(fingerprints) {
+    const map = new Map();
+    for (const fp of fingerprints ?? []) {
+        const current = map.get(fp.envelopeId);
+        if (current === undefined) {
+            map.set(fp.envelopeId, [fp.atomId]);
+        }
+        else {
+            current.push(fp.atomId);
+        }
+    }
+    return map;
+}
+function replacementAtomIdForMissingCurrentAtom(atomId, ctx) {
+    return ctx.currentReplacementAtomIdsByOldAtomId.get(atomId);
+}
+function positionalRequirementReplacementAtomId(atomId, envelopeId, ctx) {
+    const oldAtomIds = ctx.oldAtomIdsByEnvelope.get(envelopeId) ?? [];
+    const currentAtomIds = ctx.currentAtomIdsByEnvelope.get(envelopeId) ?? [];
+    const oldIndex = oldAtomIds.indexOf(atomId);
+    return oldIndex >= 0 ? currentAtomIds[oldIndex] : undefined;
+}
+function classifyMissingCurrentAtom(candidateId, atomId, envelopeId, ctx) {
+    if (!ctx.currentMap.has(envelopeId)) {
+        return staleReason(candidateId, "source-removed", envelopeId);
+    }
+    const replacementAtomId = replacementAtomIdForMissingCurrentAtom(atomId, ctx);
+    if (replacementAtomId !== undefined && !ctx.oldAtoms.has(replacementAtomId)) {
+        return staleReason(candidateId, "source-changed", envelopeId);
+    }
+    if (!envelopeId.startsWith(REQUIREMENTS_ENVELOPE_PREFIX)) {
+        return staleReason(candidateId, "source-removed", envelopeId);
+    }
+    const currentAtomAtSamePosition = positionalRequirementReplacementAtomId(atomId, envelopeId, ctx);
+    if (currentAtomAtSamePosition !== undefined && !ctx.oldAtoms.has(currentAtomAtSamePosition)) {
+        return staleReason(candidateId, "source-changed", envelopeId);
+    }
+    return staleReason(candidateId, "source-removed", envelopeId);
+}
+function classifyCandidateWithAtomFingerprints(candidate, ctx) {
+    if (candidate.derivedFromAtomIds.length === 0) {
+        return staleReason(candidate.id, "source-removed", UNKNOWN_ENVELOPE);
+    }
+    let changedEnvelopeId;
+    for (const atomId of candidate.derivedFromAtomIds) {
+        const oldAtom = ctx.oldAtoms.get(atomId);
+        if (oldAtom === undefined) {
+            return staleReason(candidate.id, "source-changed", UNKNOWN_ENVELOPE);
+        }
+        const currentAtom = ctx.currentAtoms.get(atomId);
+        if (currentAtom !== undefined) {
+            if (currentAtom.canonicalHashSha256Hex !== oldAtom.canonicalHashSha256Hex) {
+                changedEnvelopeId ??= oldAtom.envelopeId;
+            }
+            continue;
+        }
+        const missingCurrentAtomReason = classifyMissingCurrentAtom(candidate.id, atomId, oldAtom.envelopeId, ctx);
+        if (missingCurrentAtomReason.reason === "source-changed") {
+            changedEnvelopeId ??= oldAtom.envelopeId;
+            continue;
+        }
+        return missingCurrentAtomReason;
+    }
+    return changedEnvelopeId === undefined
+        ? null
+        : staleReason(candidate.id, "source-changed", changedEnvelopeId);
+}
+function orderedCandidateEnvelopeIds(candidate, ctx) {
+    const envelopeIds = new Set();
+    for (const atomId of candidate.derivedFromAtomIds) {
+        const envelopeId = ctx.atomToEnvelope.get(atomId);
+        if (envelopeId !== undefined)
+            envelopeIds.add(envelopeId);
+    }
+    return ctx.envelopeOrder.filter((envelopeId) => envelopeIds.has(envelopeId));
+}
+function classifyEnvelopeLevelCandidate(candidateId, orderedEnvelopeIds, ctx) {
+    for (const envelopeId of orderedEnvelopeIds) {
+        if (!ctx.currentMap.has(envelopeId)) {
+            return staleReason(candidateId, "source-removed", envelopeId);
+        }
+    }
+    for (const envelopeId of orderedEnvelopeIds) {
+        const oldHash = ctx.oldMap.get(envelopeId);
+        const currentHash = ctx.currentMap.get(envelopeId);
+        if (currentHash !== undefined && oldHash !== currentHash) {
+            return staleReason(candidateId, "source-changed", envelopeId);
+        }
+    }
+    return null;
+}
+/**
+ * Classify ONE candidate. Returns the dominant staleness reason, or null when fresh.
+ * Removed (envelope gone from the current scan) takes precedence over changed (hash differs);
+ * an unresolvable atom is treated as changed so an invalid test is never silently kept fresh.
+ */
+function classifyCandidate(candidate, ctx) {
+    const hasAtomMetadata = ctx.oldAtoms.size > 0 &&
+        candidate.derivedFromAtomIds.every((atomId) => ctx.oldAtoms.has(atomId));
+    if (hasAtomMetadata) {
+        return classifyCandidateWithAtomFingerprints(candidate, ctx);
+    }
+    if (candidate.derivedFromAtomIds.length === 0) {
+        return staleReason(candidate.id, "source-removed", UNKNOWN_ENVELOPE);
+    }
+    if (candidate.derivedFromAtomIds.some((atomId) => !ctx.atomToEnvelope.has(atomId))) {
+        return staleReason(candidate.id, "source-changed", UNKNOWN_ENVELOPE);
+    }
+    return classifyEnvelopeLevelCandidate(candidate.id, orderedCandidateEnvelopeIds(candidate, ctx), ctx);
+}
+/**
+ * Classify each candidate as fresh or stale based on whether their source envelopes have changed
+ * since the run was persisted. Pure, deterministic; candidate input order is preserved.
+ */
+export function compareStaleness(args) {
+    const ctx = {
+        atomToEnvelope: buildAtomToEnvelopeMap(args.evidenceRefs),
+        oldMap: buildFingerprintMap(args.oldFingerprints),
+        currentMap: buildFingerprintMap(args.currentFingerprints),
+        envelopeOrder: envelopeOrderOf(args.evidenceRefs),
+        oldAtoms: buildAtomFingerprintMap(args.oldAtomFingerprints),
+        currentAtoms: buildAtomFingerprintMap(args.currentAtomFingerprints),
+        currentReplacementAtomIdsByOldAtomId: buildReplacementAtomMap(args.oldAtomFingerprints, args.currentAtomFingerprints),
+        oldAtomIdsByEnvelope: buildAtomIdsByEnvelope(args.oldAtomFingerprints),
+        currentAtomIdsByEnvelope: buildAtomIdsByEnvelope(args.currentAtomFingerprints),
+    };
+    const fresh = [];
+    const changedStale = [];
+    const orphanedStale = [];
+    for (const candidate of args.candidates) {
+        const reason = classifyCandidate(candidate, ctx);
+        if (reason === null) {
+            fresh.push(candidate.id);
+        }
+        else if (reason.reason === "source-removed") {
+            orphanedStale.push(reason);
+        }
+        else {
+            changedStale.push(reason);
+        }
+    }
+    return { fresh, changedStale, orphanedStale };
+}

package/dist/domain/testDesignModel.d.ts

@@ -0,0 +1,38 @@
+import { QualityIntelligence } from "@oscharko-dev/keiko-contracts";
+import type { IntentSummary } from "./intentDerivation.js";
+import type { PolicyProfile } from "./policyProfile.js";
+export interface DesignTestCaseCandidatesInput {
+    readonly runId: QualityIntelligence.QualityIntelligenceRunId;
+    readonly intent: IntentSummary;
+    readonly atoms: readonly QualityIntelligence.QualityIntelligenceEvidenceAtom[];
+    /**
+     * Optional canonical source text by atom id. Evidence atoms intentionally carry only hashes in the
+     * public contract, but live ingestion has the canonical text available server-side. Supplying it
+     * lets the deterministic baseline produce usable, source-specific tests instead of atom-id stubs.
+     */
+    readonly atomTextById?: ReadonlyMap<string, string>;
+    readonly profile?: PolicyProfile;
+}
+/**
+ * Stable provenance discriminator carried by every deterministic-baseline candidate.
+ *
+ * The model-delta builder (`parseGeneratedCandidates`) never emits this tag, so it is a reliable
+ * "this is a generic determinism-floor stub, not a judged model candidate" marker — unlike a null
+ * `qualityVerdict`, which is also null whenever the judge stage is skipped entirely. Render-layer
+ * consumers sort baseline-tagged candidates to the end so judged candidates lead the deliverable;
+ * the persisted manifest order stays `[...baseline, ...delta]` (Issue #763 contract). The tag is
+ * additive and feeds no candidate id (`sha256(v2<atomHash><index>)`), dedup signature, or manifest
+ * hash, so it is determinism-safe.
+ */
+export declare const DETERMINISTIC_BASELINE_PROVENANCE_TAG = "source:deterministic-baseline";
+/**
+ * Produce deterministic draft candidates from the intent summary + atoms.
+ * Returns the empty array when the atom list is empty. Atoms are first
+ * sorted by canonical hash so input ordering does not affect IDs.
+ *
+ * Candidate IDs are derived as
+ * `qi-candidate-<32-hex-of-sha256(v2<atomHash><index>)>` — collision-resistant,
+ * run-independent, and round-trip-stable for the same evidence.
+ */
+export declare const designTestCaseCandidates: (input: DesignTestCaseCandidatesInput) => readonly QualityIntelligence.QualityIntelligenceTestCaseCandidate[];
+//# sourceMappingURL=testDesignModel.d.ts.map

package/dist/domain/testDesignModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testDesignModel.d.ts","sourceRoot":"","sources":["../../src/domain/testDesignModel.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAKpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAC,wBAAwB,CAAC;IAC7D,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,SAAS,mBAAmB,CAAC,+BAA+B,EAAE,CAAC;IAC/E;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpD,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;CAClC;AAoHD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qCAAqC,kCAAkC,CAAC;AA2IrF;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,GACnC,OAAO,6BAA6B,KACnC,SAAS,mBAAmB,CAAC,oCAAoC,EA4CnE,CAAC"}

package/dist/domain/testDesignModel.js

@@ -0,0 +1,264 @@
+// Quality Intelligence test-design model (Epic #270, Issue #272).
+//
+// Converts an `IntentSummary` plus the evidence atoms it was derived from
+// into a deterministic list of draft `QualityIntelligenceTestCaseCandidate`
+// records. NO model calls; NO randomness; ID derivation is content-hash +
+// position based, so the same evidence always produces the same candidate IDs
+// regardless of the enclosing run id.
+//
+// Structurally inspired by
+// Test Intelligence reference (TI) packages/core-engine/src/intent-derivation.ts
+// (the IR → candidate translation phase). The TI reference produces richer
+// UI-oriented candidates with screen/route metadata; our Keiko port stays
+// envelope/atom-shaped and policy-driven.
+import { QualityIntelligence } from "@oscharko-dev/keiko-contracts";
+import { sha256Hex } from "@oscharko-dev/keiko-security";
+import { isKnownPriority, normaliseCandidateText } from "./assertions.js";
+import { STRUCTURAL_BASELINE_MARKER } from "./figma/screenIrTestBaseline.js";
+import { regressionDefault } from "./policyProfile.js";
+const compareString = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+const stableSortAtoms = (atoms) => {
+    return [...atoms].sort((left, right) => compareString(left.canonicalHashSha256Hex, right.canonicalHashSha256Hex));
+};
+const deriveRiskClass = (atom, profile) => {
+    if (atom.kind === "design-fragment") {
+        return "visual";
+    }
+    if (atom.kind === "requirement") {
+        return profile.defaultRiskClass === "visual" ? "functional" : profile.defaultRiskClass;
+    }
+    return profile.defaultRiskClass;
+};
+const derivePriority = (intent, profile) => {
+    if (intent.priorityHint !== "unknown" && isKnownPriority(intent.priorityHint)) {
+        return intent.priorityHint;
+    }
+    return profile.defaultPriority;
+};
+const buildTitle = (atom, intent, index, atomText) => {
+    const indexLabel = `#${String(index + 1).padStart(3, "0")}`;
+    const sourceSubject = atomText === undefined ? undefined : conciseText(atomText, 90);
+    if (sourceSubject !== undefined) {
+        return `${indexLabel} Prüfe ${sourceSubject}`;
+    }
+    const themes = intent.themes.slice(0, 2).join(" / ");
+    const subject = themes.length > 0 ? themes : atom.kind;
+    return `${indexLabel} ${subject} — ${atom.kind}`;
+};
+const buildPreconditions = (intent, atomText) => {
+    const preconditions = [];
+    if (atomText !== undefined) {
+        const sourceRequirement = conciseText(atomText, 220);
+        if (sourceRequirement !== undefined) {
+            preconditions.push(`Quellanforderung: ${sourceRequirement}`);
+        }
+    }
+    if (intent.requirementCandidates.length === 0) {
+        return Object.freeze(preconditions);
+    }
+    preconditions.push(...intent.requirementCandidates.slice(0, atomText === undefined ? 3 : 2));
+    return Object.freeze(preconditions);
+};
+const buildSteps = (atom, intent, atomText) => {
+    const steps = [];
+    const theme = intent.themes[0];
+    const requirement = atomText === undefined ? undefined : conciseText(atomText, 180);
+    if (theme !== undefined) {
+        steps.push(`Öffne den ${theme}-Ablauf oder Servicepfad zu dieser Anforderung.`);
+    }
+    else {
+        steps.push("Öffne den Zielablauf oder Servicepfad zu dieser Anforderung.");
+    }
+    if (requirement !== undefined) {
+        steps.push(`Bereite das Szenario vor, das hier beschrieben ist: ${requirement}`);
+    }
+    steps.push("Führe die fachliche Aktion, Validierungsregel oder Entscheidungsstrecke aus.");
+    steps.push(`Dokumentiere Ergebnis, persistierten Zustand, Meldungen und Audit-Evidenz für Atom ${atom.id}.`);
+    return Object.freeze(steps);
+};
+const buildExpectedResults = (atom, intent, atomText) => {
+    const results = [];
+    if (atomText !== undefined) {
+        const expectedRequirement = conciseText(atomText, 220);
+        if (expectedRequirement !== undefined) {
+            results.push(`Das beobachtete Verhalten erfüllt: ${expectedRequirement}`);
+        }
+    }
+    else if (intent.requirementCandidates.length > 0) {
+        results.push(`Der Ablauf erfüllt: ${intent.requirementCandidates[0] ?? ""}`);
+    }
+    else {
+        results.push("Der Ablauf wird ohne Fehler abgeschlossen.");
+    }
+    results.push("Widersprüchliche Ergebnisse, fehlende Validierung und stiller Datenverlust sind nicht akzeptabel.");
+    results.push(`Evidenz-Atom ${atom.canonicalHashSha256Hex.slice(0, 12)} bleibt kanonisch.`);
+    return Object.freeze(results);
+};
+/**
+ * Stable provenance discriminator carried by every deterministic-baseline candidate.
+ *
+ * The model-delta builder (`parseGeneratedCandidates`) never emits this tag, so it is a reliable
+ * "this is a generic determinism-floor stub, not a judged model candidate" marker — unlike a null
+ * `qualityVerdict`, which is also null whenever the judge stage is skipped entirely. Render-layer
+ * consumers sort baseline-tagged candidates to the end so judged candidates lead the deliverable;
+ * the persisted manifest order stays `[...baseline, ...delta]` (Issue #763 contract). The tag is
+ * additive and feeds no candidate id (`sha256(v2<atomHash><index>)`), dedup signature, or manifest
+ * hash, so it is determinism-safe.
+ */
+export const DETERMINISTIC_BASELINE_PROVENANCE_TAG = "source:deterministic-baseline";
+const buildTags = (intent, riskClass) => {
+    const tags = new Set();
+    for (const theme of intent.themes) {
+        tags.add(`theme:${theme}`);
+    }
+    for (const risk of intent.riskHints) {
+        tags.add(`risk-hint:${risk}`);
+    }
+    tags.add(`risk-class:${riskClass}`);
+    tags.add(DETERMINISTIC_BASELINE_PROVENANCE_TAG);
+    return Object.freeze(Array.from(tags).sort(compareString));
+};
+const deriveCandidateIdString = (atom, index) => {
+    const payload = ["v2", atom.canonicalHashSha256Hex, String(index)].join("");
+    const digest = sha256Hex(payload).slice(0, 32);
+    return `qi-candidate-${digest}`;
+};
+// Sanitise an ordered fragment list for a persisted candidate field: NFKC-normalise,
+// strip unsafe bidi / zero-width / C0/C1/DEL code points (via normaliseCandidateText),
+// and drop fragments that become empty. Order-preserving, no dedup. The deterministic
+// builder receives untrusted text only through `intent` (derived from source display
+// labels, which sanitiseLabel does NOT strip bidi/zero-width from), so without this the
+// deterministic candidates persist and export those spoofing code points — the
+// deterministic-path twin of the model-path chokepoint in parseGeneratedCandidates
+// (Epic #711 / Issue #724 residual). Clean fragments are byte-identical (strip is a
+// no-op and the fragments are already trimmed), so candidate IDs — derived from
+// atomHash/index, never from text — stay stable.
+const sanitiseFragmentList = (values) => Object.freeze(values.map((value) => normaliseCandidateText(value)).filter((value) => value.length > 0));
+// Sanitise + canonicalise a tag list: strip unsafe code points, drop empties, dedup,
+// and sort — preserving the Set+sort semantics of buildTags on the post-strip values so
+// a zero-width-spoofed theme cannot smuggle a visually-duplicate tag into the export.
+const canonicaliseCandidateTags = (values) => {
+    const seen = new Set();
+    for (const value of values) {
+        const cleaned = normaliseCandidateText(value);
+        if (cleaned.length > 0) {
+            seen.add(cleaned);
+        }
+    }
+    return Object.freeze(Array.from(seen).sort(compareString));
+};
+const COLLAPSED_WHITESPACE = /\s+/gu;
+function conciseText(value, maxLength) {
+    const cleaned = normaliseCandidateText(value).replace(COLLAPSED_WHITESPACE, " ").trim();
+    if (cleaned.length === 0)
+        return undefined;
+    if (cleaned.length <= maxLength)
+        return cleaned;
+    return `${cleaned.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+function atomTextFor(atom, atomTextById) {
+    return atomTextById === undefined
+        ? undefined
+        : conciseText(atomTextById.get(String(atom.id)) ?? "", 320);
+}
+// ─── Figma screen-baseline candidate (clean structural floor) ────────────────────────────────────
+//
+// A Figma screen atom's canonical text is a Screen-IR STRUCTURAL BASELINE (render / field / control /
+// navigation / a11y items), NOT a prose requirement. Run through the generic requirement template
+// above, it degenerates into an atom-id/hash-laden stub ("#001 Prüfe <baseline dump> … Öffne den
+// <name-suffix>-Ablauf … für Atom <id> … Evidenz-Atom <hash> bleibt kanonisch"). Detect it by its
+// stable marker and emit a clean, screen-scoped structural floor test instead. Marker-gated, so every
+// NON-figma source kind's deterministic candidate stays byte-identical (no cross-source regression);
+// the model path (parseGeneratedCandidates) is unaffected and still produces the per-element tests.
+const FIGMA_SCREEN_HEADER = /^Screen:\s+(.+?)\s+\[[^\]]+\]$/u;
+function figmaScreenNameFromAtomText(rawText) {
+    if (rawText?.includes(STRUCTURAL_BASELINE_MARKER) !== true)
+        return undefined;
+    for (const line of rawText.split("\n")) {
+        const match = FIGMA_SCREEN_HEADER.exec(line.trim());
+        const name = match?.[1]?.trim();
+        if (name !== undefined && name.length > 0)
+            return name;
+    }
+    return undefined;
+}
+function figmaBaselineCandidateBody(index, screenName) {
+    const indexLabel = `#${String(index + 1).padStart(3, "0")}`;
+    const subject = conciseText(screenName, 90) ?? screenName;
+    return {
+        title: `${indexLabel} Strukturelle Baseline-Prüfung: ${subject}`,
+        preconditions: [`Die Anwendung ist gestartet.`, `Der Screen "${subject}" ist geöffnet.`],
+        steps: [
+            `Prüfe, dass der Screen "${subject}" ohne Darstellungsfehler vollständig rendert.`,
+            "Prüfe die im Screen-IR-Baseline erfassten strukturellen Prüfpunkte: vorhandene Felder und " +
+                "Eingaben, Bedienelemente und ihre Aktionen, Navigationsziele sowie Accessibility-Kriterien " +
+                "(Kontrast, Fokusreihenfolge, Zielgröße).",
+            "Halte jede Abweichung je strukturellem Prüfpunkt einzeln fest.",
+        ],
+        expectedResults: [
+            `Der Screen "${subject}" rendert korrekt und vollständig.`,
+            "Die strukturellen Prüfpunkte (Felder, Bedienelemente, Navigation, Accessibility) des " +
+                "Screen-IR-Baselines sind erfüllt.",
+            "Es treten keine fehlenden Elemente, Renderfehler oder verletzten Accessibility-Kriterien auf.",
+        ],
+    };
+}
+function genericCandidateBody(atom, intent, index, atomText) {
+    return {
+        title: buildTitle(atom, intent, index, atomText),
+        preconditions: buildPreconditions(intent, atomText),
+        steps: buildSteps(atom, intent, atomText),
+        expectedResults: buildExpectedResults(atom, intent, atomText),
+    };
+}
+/**
+ * Produce deterministic draft candidates from the intent summary + atoms.
+ * Returns the empty array when the atom list is empty. Atoms are first
+ * sorted by canonical hash so input ordering does not affect IDs.
+ *
+ * Candidate IDs are derived as
+ * `qi-candidate-<32-hex-of-sha256(v2<atomHash><index>)>` — collision-resistant,
+ * run-independent, and round-trip-stable for the same evidence.
+ */
+export const designTestCaseCandidates = (input) => {
+    const { runId, intent, atoms, atomTextById } = input;
+    const profile = input.profile ?? regressionDefault;
+    if (atoms.length === 0) {
+        return Object.freeze([]);
+    }
+    const sorted = stableSortAtoms(atoms);
+    const priority = derivePriority(intent, profile);
+    const candidates = [];
+    for (let index = 0; index < sorted.length; index += 1) {
+        const atom = sorted[index];
+        if (atom === undefined) {
+            continue;
+        }
+        const idString = deriveCandidateIdString(atom, index);
+        const id = QualityIntelligence.asQualityIntelligenceTestCaseId(idString);
+        const riskClass = deriveRiskClass(atom, profile);
+        const atomText = atomTextFor(atom, atomTextById);
+        // A Figma screen atom carries a structural baseline, not a prose requirement — give it a clean
+        // screen-scoped structural candidate. Detection reads the FULL canonical text (not the truncated
+        // `atomText`) so the marker + screen-name header survive the per-title length cap.
+        const figmaScreenName = figmaScreenNameFromAtomText(atomTextById?.get(String(atom.id)));
+        const body = figmaScreenName !== undefined
+            ? figmaBaselineCandidateBody(index, figmaScreenName)
+            : genericCandidateBody(atom, intent, index, atomText);
+        const candidate = {
+            id,
+            runId,
+            derivedFromAtomIds: Object.freeze([atom.id]),
+            title: normaliseCandidateText(body.title),
+            preconditions: sanitiseFragmentList(body.preconditions),
+            steps: sanitiseFragmentList(body.steps),
+            expectedResults: sanitiseFragmentList(body.expectedResults),
+            priority,
+            riskClass,
+            tags: canonicaliseCandidateTags(buildTags(intent, riskClass)),
+            status: "proposed",
+        };
+        candidates.push(Object.freeze(candidate));
+    }
+    return Object.freeze(candidates);
+};

package/dist/domain/testQualityRubric.d.ts

@@ -0,0 +1,20 @@
+import type { TestQualityRubricDimension } from "@oscharko-dev/keiko-contracts";
+/** Threshold below which an overall score is classified as "weak". */
+export declare const TEST_QUALITY_WEAK_THRESHOLD = 60;
+/**
+ * Compute the mean score across all dimensions. Returns 0 when `dimensions` is empty.
+ * Deterministic: iteration order of `dimensions` does not affect the result.
+ */
+export declare function scoreFromDimensions(dimensions: readonly TestQualityRubricDimension[]): number;
+/**
+ * Classify an overall score as "weak" or "strong".
+ * Scores strictly below `TEST_QUALITY_WEAK_THRESHOLD` (60) are "weak"; 60 and above are "strong".
+ */
+export declare function verdictFromScore(score: number): "weak" | "strong";
+/**
+ * Classify a full rubric verdict. A candidate is only strong when the aggregate score and every
+ * mandatory rubric dimension meet the threshold; one weak dimension is enough to keep the finding
+ * visible instead of hiding it behind a passing average.
+ */
+export declare function verdictFromDimensions(dimensions: readonly TestQualityRubricDimension[]): "weak" | "strong";
+//# sourceMappingURL=testQualityRubric.d.ts.map

package/dist/domain/testQualityRubric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testQualityRubric.d.ts","sourceRoot":"","sources":["../../src/domain/testQualityRubric.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAEhF,sEAAsE;AACtE,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAE9C;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,SAAS,0BAA0B,EAAE,GAAG,MAAM,CAO7F;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,CAEjE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,SAAS,0BAA0B,EAAE,GAChD,MAAM,GAAG,QAAQ,CAKnB"}