@oscharko-dev/keiko-quality-intelligence 0.2.0

package/dist/domain/testQualityRubric.js

@@ -0,0 +1,38 @@
+// Quality Intelligence test-quality rubric domain helpers (Epic #736, Issue #746).
+//
+// Pure functions — no IO, no model calls. Compute aggregate scores and verdict
+// classifications from per-dimension rubric scores.
+/** Threshold below which an overall score is classified as "weak". */
+export 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 function scoreFromDimensions(dimensions) {
+    if (dimensions.length === 0)
+        return 0;
+    let total = 0;
+    for (const d of dimensions) {
+        total += d.score;
+    }
+    return total / dimensions.length;
+}
+/**
+ * Classify an overall score as "weak" or "strong".
+ * Scores strictly below `TEST_QUALITY_WEAK_THRESHOLD` (60) are "weak"; 60 and above are "strong".
+ */
+export function verdictFromScore(score) {
+    return score < TEST_QUALITY_WEAK_THRESHOLD ? "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 function verdictFromDimensions(dimensions) {
+    if (verdictFromScore(scoreFromDimensions(dimensions)) === "weak")
+        return "weak";
+    return dimensions.every((dimension) => dimension.score >= TEST_QUALITY_WEAK_THRESHOLD)
+        ? "strong"
+        : "weak";
+}

package/dist/domain/validation.d.ts

@@ -0,0 +1,7 @@
+import { QualityIntelligence } from "@oscharko-dev/keiko-contracts";
+/**
+ * Validate a list of candidates and return every emitted finding. Pure;
+ * deterministic; no IO. Empty `candidates` returns the empty array.
+ */
+export declare const validateCandidates: (runId: QualityIntelligence.QualityIntelligenceRunId, candidates: readonly QualityIntelligence.QualityIntelligenceTestCaseCandidate[]) => readonly QualityIntelligence.QualityIntelligenceValidationFinding[];
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/domain/validation.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AA+JpE;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,mBAAmB,CAAC,wBAAwB,EACnD,YAAY,SAAS,mBAAmB,CAAC,oCAAoC,EAAE,KAC9E,SAAS,mBAAmB,CAAC,oCAAoC,EAoBnE,CAAC"}

package/dist/domain/validation.js

@@ -0,0 +1,145 @@
+// Quality Intelligence validation (Epic #270, Issue #272).
+//
+// Pure schema/logic validators that emit `QualityIntelligenceValidationFinding`
+// records. NO judge calls in this module — the model-assisted adversarial
+// test-quality judge ships separately (Epic #736, keiko-server judgePort + the
+// workflow judge stage) and augments these deterministic checks.
+//
+// v1 covers four deterministic checks per candidate:
+//   1. schema-completeness — title/steps/expectedResults must be non-empty.
+//   2. consecutive-step-repeat — an adjacent step must not canonically repeat the one before it
+//      (a context-changing step between two identical actions is allowed by design).
+//   3. expected-presence    — at least one expected result must be present.
+//   4. trivial-contradiction — a precondition and an expected result share the
+//      same negation-stripped core but have opposite negation parity (XOR):
+//      exactly one of the two contains a negation word. Both positive or both
+//      negated → consistent; one positive + one negated → contradiction.
+//
+// Structurally inspired by
+// Test Intelligence reference (TI) packages/core-engine/src/
+//   cross-field-invariant-engine.ts and acceptance-criteria.ts — but with
+// the model-judge tier excluded and a Keiko-shaped finding output.
+import { QualityIntelligence } from "@oscharko-dev/keiko-contracts";
+import { sha256Hex } from "@oscharko-dev/keiko-security";
+import { normaliseCandidateText, normaliseText } from "./assertions.js";
+const NEGATION_PATTERN = /\b(not|never|no longer|cannot|isn't|aren't|won't|doesn't|do not)\b/iu;
+const collapseWhitespace = (value) => value.replace(/\s+/gu, " ").trim();
+// Use normaliseCandidateText (NFKC + bidi/zero-width strip + trim) so that two candidates
+// differing only by injected bidi or zero-width spoofing chars produce the same equivalence key.
+const canonicaliseLine = (value) => collapseWhitespace(normaliseCandidateText(value).toLowerCase());
+const stripNegation = (value) => value.replace(NEGATION_PATTERN, " ").replace(/\s+/gu, " ").trim();
+const deriveFindingIdString = (runId, candidateId, kind, ordinal) => {
+    const payload = ["v1", String(runId), candidateId, kind, String(ordinal)].join("");
+    return `qi-finding-${sha256Hex(payload).slice(0, 32)}`;
+};
+const buildLogicDefect = (runId, candidate, ordinal, severity, summary) => {
+    const idString = deriveFindingIdString(runId, String(candidate.id), "logic-defect", ordinal);
+    return Object.freeze({
+        kind: "logic-defect",
+        id: QualityIntelligence.asQualityIntelligenceValidationFindingId(idString),
+        runId,
+        candidateId: candidate.id,
+        severity,
+        summary,
+        evidenceAtomIds: Object.freeze([...candidate.derivedFromAtomIds]),
+    });
+};
+const buildSemanticDefect = (runId, candidate, ordinal, severity, summary) => {
+    const idString = deriveFindingIdString(runId, String(candidate.id), "semantic-defect", ordinal);
+    return Object.freeze({
+        kind: "semantic-defect",
+        id: QualityIntelligence.asQualityIntelligenceValidationFindingId(idString),
+        runId,
+        candidateId: candidate.id,
+        severity,
+        summary,
+        evidenceAtomIds: Object.freeze([...candidate.derivedFromAtomIds]),
+    });
+};
+const checkSchemaCompleteness = (runId, candidate) => {
+    const findings = [];
+    if (normaliseText(candidate.title).length === 0) {
+        findings.push(buildLogicDefect(runId, candidate, 0, "high", "Candidate title is empty after NFKC trim."));
+    }
+    if (candidate.steps.length === 0) {
+        findings.push(buildLogicDefect(runId, candidate, 1, "high", "Candidate has no executable steps."));
+    }
+    return findings;
+};
+const checkExpectedResultsPresence = (runId, candidate) => {
+    if (candidate.expectedResults.length === 0) {
+        return [
+            buildLogicDefect(runId, candidate, 2, "high", "Candidate has no expected results recorded."),
+        ];
+    }
+    return [];
+};
+const checkConsecutiveStepRepeat = (runId, candidate) => {
+    let previousCanonical = "";
+    for (const step of candidate.steps) {
+        const canonical = canonicaliseLine(step);
+        if (canonical.length === 0) {
+            continue;
+        }
+        if (canonical === previousCanonical) {
+            return [
+                buildLogicDefect(runId, candidate, 3, "medium", "Candidate step sequence contains a consecutive canonical-line repeat."),
+            ];
+        }
+        previousCanonical = canonical;
+    }
+    return [];
+};
+const checkTrivialContradictions = (runId, candidate) => {
+    if (candidate.preconditions.length === 0 || candidate.expectedResults.length === 0) {
+        return [];
+    }
+    for (const result of candidate.expectedResults) {
+        const resultCanonical = canonicaliseLine(result);
+        const resultCore = stripNegation(resultCanonical);
+        if (resultCore.length === 0) {
+            continue;
+        }
+        const negatedResult = NEGATION_PATTERN.test(resultCanonical);
+        for (const pre of candidate.preconditions) {
+            const preCanonical = canonicaliseLine(pre);
+            const preCore = stripNegation(preCanonical);
+            if (preCore.length === 0) {
+                continue;
+            }
+            const negatedPre = NEGATION_PATTERN.test(preCanonical);
+            // Contradiction iff cores match AND exactly one side carries a negation (XOR parity).
+            if (preCore === resultCore && negatedPre !== negatedResult) {
+                return [
+                    buildSemanticDefect(runId, candidate, 4, "medium", "Expected result trivially contradicts a precondition (post-negation match)."),
+                ];
+            }
+        }
+    }
+    return [];
+};
+/**
+ * Validate a list of candidates and return every emitted finding. Pure;
+ * deterministic; no IO. Empty `candidates` returns the empty array.
+ */
+export const validateCandidates = (runId, candidates) => {
+    if (candidates.length === 0) {
+        return Object.freeze([]);
+    }
+    const out = [];
+    for (const candidate of candidates) {
+        for (const finding of checkSchemaCompleteness(runId, candidate)) {
+            out.push(finding);
+        }
+        for (const finding of checkExpectedResultsPresence(runId, candidate)) {
+            out.push(finding);
+        }
+        for (const finding of checkConsecutiveStepRepeat(runId, candidate)) {
+            out.push(finding);
+        }
+        for (const finding of checkTrivialContradictions(runId, candidate)) {
+            out.push(finding);
+        }
+    }
+    return Object.freeze(out);
+};

package/dist/export/adapters/alm.d.ts

@@ -0,0 +1,4 @@
+import type { QualityIntelligenceExportBundle, QualityIntelligenceTestCaseCandidate } from "@oscharko-dev/keiko-contracts";
+export declare const ALM_CSV_HEADERS: readonly string[];
+export declare function adaptToAlm(bundle: QualityIntelligenceExportBundle, candidates: readonly QualityIntelligenceTestCaseCandidate[]): string;
+//# sourceMappingURL=alm.d.ts.map

package/dist/export/adapters/alm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alm.d.ts","sourceRoot":"","sources":["../../../src/export/adapters/alm.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,+BAA+B,EAC/B,oCAAoC,EACrC,MAAM,+BAA+B,CAAC;AAIvC,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAS3C,CAAC;AA2CH,wBAAgB,UAAU,CACxB,MAAM,EAAE,+BAA+B,EACvC,UAAU,EAAE,SAAS,oCAAoC,EAAE,GAC1D,MAAM,CAkBR"}

package/dist/export/adapters/alm.js

@@ -0,0 +1,75 @@
+// Micro Focus ALM (Quality Center) CSV export adapter (Epic #270, Issue #283).
+//
+// ALM's Excel-add-in bulk-import shape: Test Name, Description, Type, Designer,
+// Subject, Step Name, Description (step), Expected Result. One row per (test, step)
+// like qTest / Xray.
+//
+// TMS-bound: invariant asserted first. Pure-domain — NO HTTP, NO ALM SDK.
+import { assertExportBundleInvariant } from "@oscharko-dev/keiko-contracts";
+import { encodeSpreadsheetSafeRow } from "./spreadsheetSafeCsv.js";
+export const ALM_CSV_HEADERS = Object.freeze([
+    "TestName",
+    "Description",
+    "Type",
+    "Designer",
+    "Subject",
+    "StepName",
+    "StepDescription",
+    "ExpectedResult",
+]);
+const ALM_DESIGNER = "keiko-quality-intelligence";
+const buildDescription = (candidate) => {
+    if (candidate.preconditions.length === 0) {
+        return "";
+    }
+    return `Preconditions: ${candidate.preconditions.join(" ; ")}`;
+};
+const buildSubject = (candidate) => {
+    return `Subject/${candidate.riskClass}`;
+};
+// Build the ALM rows for a single candidate. One row per (step, expected) pair — the row count is
+// the longer of `steps`/`expectedResults` so a trailing expected result is never dropped (Issue
+// #283); a candidate with neither yields one empty-step row.
+function almRowsFor(candidate) {
+    const head = [
+        candidate.title,
+        buildDescription(candidate),
+        "MANUAL",
+        ALM_DESIGNER,
+        buildSubject(candidate),
+    ];
+    const rowCount = Math.max(candidate.steps.length, candidate.expectedResults.length);
+    if (rowCount === 0) {
+        return encodeSpreadsheetSafeRow([...head, "", "", ""]);
+    }
+    let rows = "";
+    for (let i = 0; i < rowCount; i += 1) {
+        const stepName = i < candidate.steps.length ? `Step ${String(i + 1)}` : "";
+        rows += encodeSpreadsheetSafeRow([
+            ...head,
+            stepName,
+            candidate.steps[i] ?? "",
+            candidate.expectedResults[i] ?? "",
+        ]);
+    }
+    return rows;
+}
+export function adaptToAlm(bundle, candidates) {
+    assertExportBundleInvariant(bundle);
+    const byId = new Map();
+    for (const candidate of candidates) {
+        byId.set(candidate.id, candidate);
+    }
+    const sortedIds = bundle.contents
+        .map((entry) => entry.candidateId)
+        .slice()
+        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    let body = encodeSpreadsheetSafeRow(ALM_CSV_HEADERS);
+    for (const id of sortedIds) {
+        const candidate = byId.get(id);
+        if (candidate !== undefined) {
+            body += almRowsFor(candidate);
+        }
+    }
+    return body;
+}

package/dist/export/adapters/csv.d.ts

@@ -0,0 +1,5 @@
+import type { QualityIntelligenceExportBundle, QualityIntelligenceTestCaseCandidate } from "@oscharko-dev/keiko-contracts";
+/** Schema headers for the Keiko-native CSV format. */
+export declare const CSV_HEADERS: readonly string[];
+export declare function adaptToCsv(bundle: QualityIntelligenceExportBundle, candidates: readonly QualityIntelligenceTestCaseCandidate[]): string;
+//# sourceMappingURL=csv.d.ts.map

package/dist/export/adapters/csv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csv.d.ts","sourceRoot":"","sources":["../../../src/export/adapters/csv.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,+BAA+B,EAC/B,oCAAoC,EACrC,MAAM,+BAA+B,CAAC;AAIvC,sDAAsD;AACtD,eAAO,MAAM,WAAW,EAAE,SAAS,MAAM,EAcvC,CAAC;AAIH,wBAAgB,UAAU,CACxB,MAAM,EAAE,+BAA+B,EACvC,UAAU,EAAE,SAAS,oCAAoC,EAAE,GAC1D,MAAM,CAgCR"}

package/dist/export/adapters/csv.js

@@ -0,0 +1,55 @@
+// Generic Keiko-native CSV export adapter (Epic #270, Issue #283).
+//
+// Pure-domain leaf. Reuses the spreadsheet-safe cell encoder so EVERY CSV
+// adapter (Keiko-native, Jira, qTest, Xray, Polarion, ALM) shares the same
+// formula-injection mitigation — the encoder is the single primitive.
+import { assertExportBundleInvariant } from "@oscharko-dev/keiko-contracts";
+import { encodeSpreadsheetSafeRow } from "./spreadsheetSafeCsv.js";
+/** Schema headers for the Keiko-native CSV format. */
+export const CSV_HEADERS = Object.freeze([
+    "CandidateId",
+    "RunId",
+    "Title",
+    "Priority",
+    "RiskClass",
+    "Status",
+    "Tags",
+    "Preconditions",
+    "Steps",
+    "ExpectedResults",
+    "DerivedFromAtomIds",
+    "CoverageMapRefs",
+    "FindingRefs",
+]);
+const joinSemicolon = (values) => values.join(" ; ");
+export function adaptToCsv(bundle, candidates) {
+    assertExportBundleInvariant(bundle);
+    const byId = new Map();
+    for (const candidate of candidates) {
+        byId.set(candidate.id, candidate);
+    }
+    const sortedEntries = [...bundle.contents].sort((a, b) => a.candidateId < b.candidateId ? -1 : a.candidateId > b.candidateId ? 1 : 0);
+    let body = encodeSpreadsheetSafeRow(CSV_HEADERS);
+    for (const entry of sortedEntries) {
+        const candidate = byId.get(entry.candidateId);
+        if (candidate === undefined) {
+            continue;
+        }
+        body += encodeSpreadsheetSafeRow([
+            candidate.id,
+            candidate.runId,
+            candidate.title,
+            candidate.priority,
+            candidate.riskClass,
+            candidate.status,
+            joinSemicolon(candidate.tags),
+            joinSemicolon(candidate.preconditions),
+            joinSemicolon(candidate.steps),
+            joinSemicolon(candidate.expectedResults),
+            joinSemicolon(candidate.derivedFromAtomIds),
+            joinSemicolon(entry.coverageMapRefs),
+            joinSemicolon(entry.findingRefs),
+        ]);
+    }
+    return body;
+}

package/dist/export/adapters/index.d.ts

@@ -0,0 +1,13 @@
+export { adaptToAlm, ALM_CSV_HEADERS } from "./alm.js";
+export { adaptToCsv, CSV_HEADERS } from "./csv.js";
+export { adaptToJiraIssues, JIRA_CSV_HEADERS } from "./jira.js";
+export { adaptToJson } from "./json.js";
+export { adaptToPolarion, POLARION_CSV_HEADERS } from "./polarion.js";
+export { adaptToQtest, QTEST_CSV_HEADERS } from "./qtest.js";
+export { adaptToSpreadsheetSafeCsv, encodeSpreadsheetSafeCell, encodeSpreadsheetSafeRow, SPREADSHEET_FORMULA_LEAD_CHARS, SPREADSHEET_SAFE_CSV_HEADERS, startsWithFormulaLead, } from "./spreadsheetSafeCsv.js";
+export { adaptToXray, XRAY_CSV_HEADERS } from "./xray.js";
+export { adaptToMarkdown } from "./markdown.js";
+export { adaptToPlainText } from "./plaintext.js";
+export { adaptToQualityCenter } from "./qualityCenter.js";
+export { adaptToTraceabilityCsv, adaptToTraceabilityMarkdown, TRACEABILITY_HEADERS, TRACEABILITY_REVERSE_HEADERS, type QualityIntelligenceTraceabilityDisplayOptions, type QualityIntelligenceTraceabilityRow, } from "./traceability.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/export/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/export/adapters/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EACzB,wBAAwB,EACxB,8BAA8B,EAC9B,4BAA4B,EAC5B,qBAAqB,GACtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EACL,sBAAsB,EACtB,2BAA2B,EAC3B,oBAAoB,EACpB,4BAA4B,EAC5B,KAAK,6CAA6C,EAClD,KAAK,kCAAkC,GACxC,MAAM,mBAAmB,CAAC"}

package/dist/export/adapters/index.js

@@ -0,0 +1,15 @@
+// Public barrel for the Quality Intelligence export adapters (Epic #270, Issue #283).
+// Pure-domain leaf. Re-exports each adapter alongside its column-header constant so
+// downstream consumers and tests have a single import surface.
+export { adaptToAlm, ALM_CSV_HEADERS } from "./alm.js";
+export { adaptToCsv, CSV_HEADERS } from "./csv.js";
+export { adaptToJiraIssues, JIRA_CSV_HEADERS } from "./jira.js";
+export { adaptToJson } from "./json.js";
+export { adaptToPolarion, POLARION_CSV_HEADERS } from "./polarion.js";
+export { adaptToQtest, QTEST_CSV_HEADERS } from "./qtest.js";
+export { adaptToSpreadsheetSafeCsv, encodeSpreadsheetSafeCell, encodeSpreadsheetSafeRow, SPREADSHEET_FORMULA_LEAD_CHARS, SPREADSHEET_SAFE_CSV_HEADERS, startsWithFormulaLead, } from "./spreadsheetSafeCsv.js";
+export { adaptToXray, XRAY_CSV_HEADERS } from "./xray.js";
+export { adaptToMarkdown } from "./markdown.js";
+export { adaptToPlainText } from "./plaintext.js";
+export { adaptToQualityCenter } from "./qualityCenter.js";
+export { adaptToTraceabilityCsv, adaptToTraceabilityMarkdown, TRACEABILITY_HEADERS, TRACEABILITY_REVERSE_HEADERS, } from "./traceability.js";

package/dist/export/adapters/jira.d.ts

@@ -0,0 +1,5 @@
+import type { QualityIntelligenceExportBundle, QualityIntelligenceTestCaseCandidate } from "@oscharko-dev/keiko-contracts";
+/** Jira CSV columns; matches Jira's default "Bulk import" template. */
+export declare const JIRA_CSV_HEADERS: readonly string[];
+export declare function adaptToJiraIssues(bundle: QualityIntelligenceExportBundle, candidates: readonly QualityIntelligenceTestCaseCandidate[]): string;
+//# sourceMappingURL=jira.d.ts.map

package/dist/export/adapters/jira.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jira.d.ts","sourceRoot":"","sources":["../../../src/export/adapters/jira.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,+BAA+B,EAC/B,oCAAoC,EACrC,MAAM,+BAA+B,CAAC;AAIvC,uEAAuE;AACvE,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAM5C,CAAC;AAmCH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,+BAA+B,EACvC,UAAU,EAAE,SAAS,oCAAoC,EAAE,GAC1D,MAAM,CA0BR"}

package/dist/export/adapters/jira.js

@@ -0,0 +1,79 @@
+// Jira Issues CSV export adapter (Epic #270, Issue #283).
+//
+// Produces a Jira CSV in the canonical `Summary, Description, IssueType, Priority,
+// Labels` shape. The output is the byte body only — there is NO HTTP, NO Jira REST
+// SDK import, and NO authentication concern in this leaf. Live publishing of these
+// CSVs to a Jira tenant is deferred to a future issue alongside connector
+// authorisation (#278).
+//
+// TMS-bound adapter: `assertExportBundleInvariant` is invoked first, which enforces
+// `redactionAttested === true` on the bundle. A non-attested bundle throws before
+// any candidate is read.
+//
+// Pure-domain leaf. Reuses the shared spreadsheet-safe cell encoder so all CSV
+// adapters share one formula-injection mitigation primitive.
+import { assertExportBundleInvariant } from "@oscharko-dev/keiko-contracts";
+import { encodeSpreadsheetSafeRow } from "./spreadsheetSafeCsv.js";
+/** Jira CSV columns; matches Jira's default "Bulk import" template. */
+export const JIRA_CSV_HEADERS = Object.freeze([
+    "Summary",
+    "Description",
+    "IssueType",
+    "Priority",
+    "Labels",
+]);
+/** Jira `Issue Type` value used for QI exports. Spec: test cases land as Tests. */
+const JIRA_ISSUE_TYPE = "Test";
+const buildDescription = (candidate) => {
+    const sections = [];
+    if (candidate.preconditions.length > 0) {
+        sections.push(`Preconditions:\n${candidate.preconditions.map((p) => `- ${p}`).join("\n")}`);
+    }
+    if (candidate.steps.length > 0) {
+        sections.push(`Steps:\n${candidate.steps.map((step, i) => `${String(i + 1)}. ${step}`).join("\n")}`);
+    }
+    if (candidate.expectedResults.length > 0) {
+        sections.push(`Expected:\n${candidate.expectedResults.map((e) => `- ${e}`).join("\n")}`);
+    }
+    return sections.join("\n\n");
+};
+const mapPriority = (priority) => {
+    // Jira default priorities: Highest / High / Medium / Low / Lowest.
+    switch (priority) {
+        case "P0":
+            return "Highest";
+        case "P1":
+            return "High";
+        case "P2":
+            return "Medium";
+        case "P3":
+            return "Low";
+    }
+};
+export function adaptToJiraIssues(bundle, candidates) {
+    assertExportBundleInvariant(bundle);
+    const byId = new Map();
+    for (const candidate of candidates) {
+        byId.set(candidate.id, candidate);
+    }
+    const sortedIds = bundle.contents
+        .map((entry) => entry.candidateId)
+        .slice()
+        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    let body = encodeSpreadsheetSafeRow(JIRA_CSV_HEADERS);
+    for (const id of sortedIds) {
+        const candidate = byId.get(id);
+        if (candidate === undefined) {
+            continue;
+        }
+        const labels = [candidate.riskClass, ...candidate.tags].join(" ");
+        body += encodeSpreadsheetSafeRow([
+            candidate.title,
+            buildDescription(candidate),
+            JIRA_ISSUE_TYPE,
+            mapPriority(candidate.priority),
+            labels,
+        ]);
+    }
+    return body;
+}

package/dist/export/adapters/json.d.ts

@@ -0,0 +1,3 @@
+import type { QualityIntelligenceExportBundle, QualityIntelligenceTestCaseCandidate } from "@oscharko-dev/keiko-contracts";
+export declare function adaptToJson(bundle: QualityIntelligenceExportBundle, candidates: readonly QualityIntelligenceTestCaseCandidate[]): string;
+//# sourceMappingURL=json.d.ts.map

package/dist/export/adapters/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../src/export/adapters/json.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EACV,+BAA+B,EAE/B,oCAAoC,EACrC,MAAM,+BAA+B,CAAC;AAmCvC,wBAAgB,WAAW,CACzB,MAAM,EAAE,+BAA+B,EACvC,UAAU,EAAE,SAAS,oCAAoC,EAAE,GAC1D,MAAM,CAwCR"}

package/dist/export/adapters/json.js

@@ -0,0 +1,54 @@
+// Typed JSON export adapter (Epic #270, Issue #283).
+//
+// Produces a deterministic JSON document with stable key ordering and stable
+// candidate ordering. Object keys appear in the order written (V8 insertion
+// order preservation); candidate / entry arrays are sorted by id to keep
+// byte-for-byte determinism across runs.
+//
+// Pure-domain leaf. Reuses `assertExportBundleInvariant`. JSON is a portable
+// target so the redactionAttested invariant fires only when the bundle's
+// adapter is TMS-bound — pure `json` adapter does not require attestation by
+// design (matches the contract-side TMS adapter set).
+import { assertExportBundleInvariant } from "@oscharko-dev/keiko-contracts";
+const byCandidateIdAsc = (a, b) => (a.candidateId < b.candidateId ? -1 : a.candidateId > b.candidateId ? 1 : 0);
+export function adaptToJson(bundle, candidates) {
+    assertExportBundleInvariant(bundle);
+    const byId = new Map();
+    for (const candidate of candidates) {
+        byId.set(candidate.id, candidate);
+    }
+    const sortedEntries = [...bundle.contents].sort(byCandidateIdAsc);
+    const payloadCandidates = [];
+    for (const entry of sortedEntries) {
+        const candidate = byId.get(entry.candidateId);
+        if (candidate === undefined) {
+            continue;
+        }
+        payloadCandidates.push({
+            id: candidate.id,
+            runId: candidate.runId,
+            title: candidate.title,
+            priority: candidate.priority,
+            riskClass: candidate.riskClass,
+            status: candidate.status,
+            tags: candidate.tags,
+            preconditions: candidate.preconditions,
+            steps: candidate.steps,
+            expectedResults: candidate.expectedResults,
+            derivedFromAtomIds: candidate.derivedFromAtomIds,
+            coverageMapRefs: entry.coverageMapRefs,
+            findingRefs: entry.findingRefs,
+        });
+    }
+    const envelope = {
+        schemaVersion: "1",
+        bundleId: bundle.id,
+        runId: bundle.runId,
+        targetAdapter: bundle.targetAdapter,
+        createdAt: bundle.createdAt,
+        integrityHashSha256Hex: bundle.integrityHashSha256Hex,
+        redactionAttested: bundle.redactionAttested,
+        candidates: payloadCandidates,
+    };
+    return JSON.stringify(envelope, null, 2);
+}

package/dist/export/adapters/markdown.d.ts

@@ -0,0 +1,3 @@
+import type { QualityIntelligenceExportBundle, QualityIntelligenceTestCaseCandidate } from "@oscharko-dev/keiko-contracts";
+export declare function adaptToMarkdown(bundle: QualityIntelligenceExportBundle, candidates: readonly QualityIntelligenceTestCaseCandidate[]): string;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/export/adapters/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../src/export/adapters/markdown.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,+BAA+B,EAC/B,oCAAoC,EACrC,MAAM,+BAA+B,CAAC;AAyEvC,wBAAgB,eAAe,CAC7B,MAAM,EAAE,+BAA+B,EACvC,UAAU,EAAE,SAAS,oCAAoC,EAAE,GAC1D,MAAM,CAqBR"}

package/dist/export/adapters/markdown.js

@@ -0,0 +1,88 @@
+// Markdown export adapter (Epic #711).
+//
+// Produces a deterministic Markdown document with one section per candidate,
+// sorted by candidateId ascending. No timestamps, no random content. Pure
+// string output — byte-identical for identical input.
+//
+// Pure-domain leaf. NO IO. NO node:* imports. NO new runtime dependency.
+import { assertExportBundleInvariant } from "@oscharko-dev/keiko-contracts";
+import { inlineField } from "../textSafety.js";
+import { startsWithFormulaLead } from "./spreadsheetSafeCsv.js";
+const byCandidateIdAsc = (a, b) => a.candidateId < b.candidateId ? -1 : a.candidateId > b.candidateId ? 1 : 0;
+// Untrusted candidate free-text rendered into the EXPORTED Markdown artifact must not inject active
+// Markdown structure into an external viewer, nor evaluate as a formula if the .md is pasted into a
+// spreadsheet (Issue #284 AC2 — "Generated artifacts are sanitized before preview or export").
+// `mdText` composes content-preserving (escape-not-strip) steps on top of inlineField:
+//   1. inlineField — fold line breaks so the value stays one logical unit (Epic #711);
+//   2. neutralise a leading spreadsheet formula lead (=,+,-,@, incl. a trimmed leading-whitespace
+//      run) with a single-quote prefix — parity with the CSV adapters / traceability.mdCell;
+//   3. escape the Markdown-active vectors a single-line value can still smuggle — a link or image
+//      (incl. javascript:/data: hrefs) and a fenced-code run — the link/image/fenced subset of the
+//      accepted #278 untrusted-markdown escape set (ingestion/untrustedContentNormalisation). The
+//      literal text is preserved so an auditor still reads the original content.
+// The #278 set's fourth vector — a line-leading `#` heading — is intentionally NOT escaped here: it
+// is already mitigated structurally, not by escaping. Step 1 folds every internal line break to a
+// space, and every field value is rendered behind a fixed prefix (`## ` for the title, `- `/`N. `
+// for list items, `**Tags:** ` etc.), so a leading `#` in untrusted text can never reach a true
+// line-start and open a heading.
+const FENCED_CODE = /```/gu;
+const IMAGE_OPEN = /!\[/gu;
+const LINK_OPEN = /(?<!!)\[([^\]]*)\]\(/gu;
+function mdText(value) {
+    const oneLine = inlineField(value);
+    const formulaSafe = startsWithFormulaLead(oneLine) ? `'${oneLine}` : oneLine;
+    return formulaSafe
+        .replace(FENCED_CODE, "\\`\\`\\`")
+        .replace(IMAGE_OPEN, "\\!\\[")
+        .replace(LINK_OPEN, (_match, inner) => `\\[${inner}\\](`);
+}
+const mdTextList = (items) => items.map(mdText);
+const mdList = (items) => items.length === 0
+    ? "_none_\n"
+    : mdTextList(items)
+        .map((item) => `- ${item}`)
+        .join("\n") + "\n";
+function renderCandidate(candidate, runId) {
+    const lines = [];
+    lines.push(`## ${mdText(candidate.title)}\n`);
+    lines.push(`**ID:** ${candidate.id}  `);
+    lines.push(`**Run:** ${runId}  `);
+    lines.push(`**Priority:** ${candidate.priority}  `);
+    lines.push(`**Risk class:** ${candidate.riskClass}  `);
+    lines.push(`**Status:** ${candidate.status}  `);
+    lines.push(`**Tags:** ${candidate.tags.length > 0 ? mdTextList(candidate.tags).join(", ") : "_none_"}  `);
+    lines.push("");
+    lines.push("### Preconditions\n");
+    lines.push(mdList(candidate.preconditions));
+    lines.push("### Steps\n");
+    lines.push(candidate.steps.length === 0
+        ? "_none_\n"
+        : mdTextList(candidate.steps)
+            .map((s, i) => `${String(i + 1)}. ${s}`)
+            .join("\n") + "\n");
+    lines.push("### Expected results\n");
+    lines.push(mdList(candidate.expectedResults));
+    return lines.join("\n");
+}
+export function adaptToMarkdown(bundle, candidates) {
+    assertExportBundleInvariant(bundle);
+    const byId = new Map();
+    for (const candidate of candidates) {
+        byId.set(candidate.id, candidate);
+    }
+    const sortedEntries = [...bundle.contents].sort(byCandidateIdAsc);
+    const sections = [];
+    sections.push(`# Quality Intelligence Export\n`);
+    sections.push(`**Bundle:** ${bundle.id}  `);
+    sections.push(`**Run:** ${bundle.runId}  `);
+    sections.push(`**Adapter:** ${bundle.targetAdapter}  `);
+    sections.push("");
+    for (const entry of sortedEntries) {
+        const candidate = byId.get(entry.candidateId);
+        if (candidate === undefined) {
+            continue;
+        }
+        sections.push(renderCandidate(candidate, bundle.runId));
+    }
+    return sections.join("\n") + "\n";
+}

package/dist/export/adapters/plaintext.d.ts

@@ -0,0 +1,3 @@
+import type { QualityIntelligenceExportBundle, QualityIntelligenceTestCaseCandidate } from "@oscharko-dev/keiko-contracts";
+export declare function adaptToPlainText(bundle: QualityIntelligenceExportBundle, candidates: readonly QualityIntelligenceTestCaseCandidate[]): string;
+//# sourceMappingURL=plaintext.d.ts.map

package/dist/export/adapters/plaintext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plaintext.d.ts","sourceRoot":"","sources":["../../../src/export/adapters/plaintext.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,+BAA+B,EAC/B,oCAAoC,EACrC,MAAM,+BAA+B,CAAC;AA2CvC,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,+BAA+B,EACvC,UAAU,EAAE,SAAS,oCAAoC,EAAE,GAC1D,MAAM,CA0BR"}