@oscharko-dev/keiko-evidence 0.2.0

package/dist/promptEnhancement/store.js

@@ -0,0 +1,409 @@
+// Local-state store for Prompt Enhancement runs (Epic #1307, Issue #1313; ADR-0044 §1/§5).
+//
+// Extends the existing `keiko-evidence` JSON-on-disk discipline (ADR-0023 D7 "extend, don't fork"),
+// mirroring the Quality Intelligence store: each run is persisted as one schema-validated JSON file
+// `<runId>.pe.json` under a `pe/` subdirectory of the evidence base dir, kept separate from the
+// run-level evidence manifests and the QI sub-manifests.
+//
+// The record path is record → redact → hash → validate → write:
+//   1. every free-text leaf is passed through the security redactor (redaction by construction);
+//   2. per-group SHA-256 integrity hashes are computed over the redacted groups;
+//   3. the (totals, collection-length) invariant is asserted;
+//   4. the manifest is written atomically (O_EXCL temp + rename) inside a realpath-contained base dir.
+// On read the schema gate, the totals invariant, and the integrity hashes are all re-checked, so a
+// tampered or corrupt manifest fails closed.
+import { randomUUID } from "node:crypto";
+import { chmodSync, lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { join, resolve } from "node:path";
+import { resolveWithinWorkspace } from "@oscharko-dev/keiko-workspace";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+import { assertValidRunId, sha256Hex } from "@oscharko-dev/keiko-security";
+import { EvidenceReadError, EvidenceWriteError } from "../errors.js";
+import { PROMPT_ENHANCEMENT_EVIDENCE_SCHEMA_VERSION, validatePromptEnhancementEvidenceManifest, } from "./manifestSchema.js";
+import { redactPromptEnhancementEvidence, } from "./redaction.js";
+// `pe/` subdir of the evidence base; chosen so `listEvidence()` and the QI `list()` never see Prompt
+// Enhancement manifests by accident — different layer, different shape.
+export const PE_SUBDIR = "pe";
+const PE_MANIFEST_SUFFIX = ".pe.json";
+const PE_DIR_MODE = 0o700;
+const DEFAULT_INPUT_EXCERPT_MAX_CHARS = 2_000;
+function sha256OfJson(value) {
+    return sha256Hex(JSON.stringify(value));
+}
+function buildIntegrityHashes(enhancedOutput, appliedRules, candidateScores, record) {
+    return {
+        enhancedOutput: sha256OfJson(enhancedOutput),
+        appliedRules: sha256OfJson(appliedRules),
+        candidateScores: sha256OfJson(candidateScores),
+        record: sha256OfJson(record),
+    };
+}
+function buildManifestIntegrityHashes(manifest) {
+    return buildIntegrityHashes({
+        enhancedPromptId: manifest.enhancedPromptId,
+        enhancedPromptTextRedacted: manifest.enhancedPromptTextRedacted,
+    }, {
+        appliedSafetyRules: manifest.appliedSafetyRules,
+        appliedGroundingDirectives: manifest.appliedGroundingDirectives,
+        assumptions: manifest.assumptions,
+    }, manifest.candidateScores, manifest);
+}
+function withoutIntegrityHashes(manifest) {
+    const record = { ...manifest };
+    delete record.integrityHashes;
+    return record;
+}
+function withRecomputedIntegrityHashes(manifest) {
+    return { ...manifest, integrityHashes: buildManifestIntegrityHashes(manifest) };
+}
+function truncate(value, max) {
+    return value.length <= max ? value : value.slice(0, max);
+}
+function assembleManifest(input, redacted, summary, inputRedactedFingerprintSha256) {
+    const manifestWithoutHashes = {
+        peEvidenceSchemaVersion: PROMPT_ENHANCEMENT_EVIDENCE_SCHEMA_VERSION,
+        runId: input.runId,
+        recordedAt: input.recordedAt,
+        requestId: input.requestId,
+        status: input.status,
+        inputRedactedFingerprintSha256,
+        inputExcerptRedacted: redacted.inputExcerptRedacted,
+        enhancedPromptId: input.enhancedPromptId,
+        enhancedPromptTextRedacted: redacted.enhancedPromptTextRedacted,
+        appliedSafetyRules: redacted.appliedSafetyRules,
+        appliedGroundingDirectives: input.appliedGroundingDirectives,
+        assumptions: redacted.assumptions,
+        candidateScores: input.candidateScores,
+        safety: input.safety,
+        modelMetadata: redacted.modelMetadata,
+        redactionSummary: summary,
+        totals: {
+            candidateScores: input.candidateScores.length,
+            appliedSafetyRules: redacted.appliedSafetyRules.length,
+            assumptions: redacted.assumptions.length,
+            safetyFindings: input.safety.findingCodes.length,
+        },
+    };
+    return withRecomputedIntegrityHashes(manifestWithoutHashes);
+}
+export function buildPromptEnhancementEvidenceManifest(input, redaction = {}) {
+    assertValidRunId(input.runId);
+    const excerptMax = input.inputExcerptMaxChars ?? DEFAULT_INPUT_EXCERPT_MAX_CHARS;
+    // Redact every free-text leaf BEFORE assembly or hashing (redaction by construction). Ids, enums,
+    // and numbers (runId, requestId, candidate ids/profiles, scores, finding codes) carry no free text
+    // and stay outside the redactor — matching the QI store's redaction scope.
+    const { redacted, summary } = redactPromptEnhancementEvidence({
+        originalInputRedacted: input.originalInput,
+        inputExcerptRedacted: "",
+        enhancedPromptTextRedacted: input.enhancedPromptText,
+        appliedSafetyRules: input.appliedSafetyRules,
+        assumptions: input.assumptions,
+        modelMetadata: input.modelMetadata,
+    }, redaction);
+    const inputExcerptRedacted = truncate(redacted.originalInputRedacted, excerptMax);
+    const inputRedactedFingerprintSha256 = sha256Hex(redacted.originalInputRedacted);
+    const manifest = assembleManifest(input, { ...redacted, inputExcerptRedacted }, summary, inputRedactedFingerprintSha256);
+    assertManifestWriteReady(manifest);
+    return { manifest };
+}
+function foldRedactionSummary(base, add) {
+    const patternsMatched = { ...base.patternsMatched };
+    for (const [key, count] of Object.entries(add.patternsMatched)) {
+        patternsMatched[key] = (patternsMatched[key] ?? 0) + count;
+    }
+    return {
+        totalStringsScanned: base.totalStringsScanned + add.totalStringsScanned,
+        stringsRedacted: base.stringsRedacted + add.stringsRedacted,
+        patternsMatched,
+    };
+}
+function assertManifestWriteReady(manifest) {
+    const validation = validatePromptEnhancementEvidenceManifest(manifest);
+    if (!validation.ok) {
+        throw new EvidenceWriteError(`PE manifest schema invalid: ${validation.reason ?? "unknown"}`);
+    }
+    try {
+        assertManifestIntegrity(manifest);
+    }
+    catch (error) {
+        throw new EvidenceWriteError(error instanceof Error ? error.message : "PE manifest integrity invalid");
+    }
+}
+function sanitizeManifestForPersistence(manifest) {
+    assertValidRunId(manifest.runId);
+    const { redacted, summary } = redactPromptEnhancementEvidence(withoutIntegrityHashes(manifest));
+    const redactionSummary = summary.stringsRedacted > 0
+        ? foldRedactionSummary(redacted.redactionSummary, summary)
+        : redacted.redactionSummary;
+    const sanitized = withRecomputedIntegrityHashes({ ...redacted, redactionSummary });
+    assertManifestWriteReady(sanitized);
+    return sanitized;
+}
+// ─── In-memory store (tests + future port-injected callers) ─────────────────────────
+export function createInMemoryPromptEnhancementLocalStore() {
+    const data = new Map();
+    return {
+        record: (manifest) => {
+            const sanitized = sanitizeManifestForPersistence(manifest);
+            data.set(sanitized.runId, sanitized);
+            return `${sanitized.runId}${PE_MANIFEST_SUFFIX}`;
+        },
+        load: (runId) => {
+            assertValidRunId(runId);
+            const manifest = data.get(runId);
+            return manifest === undefined
+                ? undefined
+                : parseAndValidateManifest(JSON.stringify(manifest));
+        },
+        list: () => [...data.keys()].sort(),
+        location: (runId) => {
+            assertValidRunId(runId);
+            return `${runId}${PE_MANIFEST_SUFFIX}`;
+        },
+        delete: (runId) => {
+            assertValidRunId(runId);
+            return data.delete(runId);
+        },
+    };
+}
+// ─── Integrity assertions (on read) ──────────────────────────────────────────────────
+function assertHashMatches(label, expected, stored) {
+    if (expected !== stored) {
+        throw new EvidenceReadError(`PE manifest ${label} integrity hash mismatch`);
+    }
+}
+function assertManifestIntegrity(manifest) {
+    const expectations = [
+        ["candidateScores", manifest.totals.candidateScores, manifest.candidateScores.length],
+        ["appliedSafetyRules", manifest.totals.appliedSafetyRules, manifest.appliedSafetyRules.length],
+        ["assumptions", manifest.totals.assumptions, manifest.assumptions.length],
+        ["safetyFindings", manifest.totals.safetyFindings, manifest.safety.findingCodes.length],
+    ];
+    for (const [label, total, length] of expectations) {
+        if (total !== length) {
+            throw new EvidenceReadError(`PE manifest totals.${label} (${String(total)}) does not match collection length (${String(length)})`);
+        }
+    }
+    const expected = buildManifestIntegrityHashes(withoutIntegrityHashes(manifest));
+    assertHashMatches("enhancedOutput", expected.enhancedOutput, manifest.integrityHashes.enhancedOutput);
+    assertHashMatches("appliedRules", expected.appliedRules, manifest.integrityHashes.appliedRules);
+    assertHashMatches("candidateScores", expected.candidateScores, manifest.integrityHashes.candidateScores);
+    assertHashMatches("record", expected.record, manifest.integrityHashes.record);
+}
+function parseAndValidateManifest(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch (error) {
+        throw new EvidenceReadError(`PE manifest is not valid JSON: ${error instanceof Error ? error.message : "unknown"}`);
+    }
+    const validation = validatePromptEnhancementEvidenceManifest(parsed);
+    if (!validation.ok) {
+        throw new EvidenceReadError(`PE manifest schema invalid: ${validation.reason ?? "unknown"}`);
+    }
+    const manifest = parsed;
+    assertManifestIntegrity(manifest);
+    return manifest;
+}
+// ─── Node adapter ──────────────────────────────────────────────────────────────────
+function prepareBaseDir(baseDir, fs) {
+    try {
+        mkdirSync(baseDir, { recursive: true, mode: PE_DIR_MODE });
+        return fs.realPath(baseDir);
+    }
+    catch (error) {
+        throw new EvidenceWriteError(`cannot create PE evidence directory: ${error instanceof Error ? error.message : "unknown"}`);
+    }
+}
+function existingBaseDir(baseDir, fs) {
+    if (!fs.exists(baseDir)) {
+        return undefined;
+    }
+    try {
+        return fs.realPath(baseDir);
+    }
+    catch (error) {
+        throw new EvidenceReadError(`cannot read PE evidence directory: ${error instanceof Error ? error.message : "unknown"}`);
+    }
+}
+function lexicalManifestPath(runId, realBase) {
+    assertValidRunId(runId);
+    return resolveWithinWorkspace(realBase, `${runId}${PE_MANIFEST_SUFFIX}`);
+}
+function isManifestName(name) {
+    if (!name.endsWith(PE_MANIFEST_SUFFIX)) {
+        return false;
+    }
+    const runId = name.slice(0, name.length - PE_MANIFEST_SUFFIX.length);
+    try {
+        assertValidRunId(runId);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isSingleLinkRegularFile(path, fs) {
+    try {
+        const stat = fs.stat(path);
+        return stat.isFile && (stat.hardLinkCount ?? 1) <= 1;
+    }
+    catch (error) {
+        throw new EvidenceReadError(`cannot inspect PE manifest: ${error instanceof Error ? error.message : "unknown"}`);
+    }
+}
+function assertWritableManifestEntry(target, fs) {
+    const entry = lstatSync(target, { throwIfNoEntry: false });
+    if (entry === undefined)
+        return;
+    if (!entry.isFile() || !isSingleLinkRegularFile(target, fs)) {
+        throw new EvidenceWriteError("cannot overwrite a non-ledger PE manifest");
+    }
+}
+function listRunIds(realBase, fs) {
+    const runIds = [];
+    try {
+        for (const entry of readdirSync(realBase, { withFileTypes: true })) {
+            if (entry.isSymbolicLink() ||
+                !entry.isFile() ||
+                !isManifestName(entry.name) ||
+                !isSingleLinkRegularFile(join(realBase, entry.name), fs)) {
+                continue;
+            }
+            runIds.push(entry.name.slice(0, entry.name.length - PE_MANIFEST_SUFFIX.length));
+        }
+    }
+    catch (error) {
+        throw new EvidenceReadError(`cannot list PE manifests: ${error instanceof Error ? error.message : "unknown"}`);
+    }
+    return runIds.sort();
+}
+function atomicWriteManifest(target, json, randomSuffix) {
+    const temp = `${target}.${randomSuffix()}.tmp`;
+    try {
+        writeFileSync(temp, json, { encoding: "utf8", flag: "wx" });
+        try {
+            chmodSync(temp, 0o600);
+        }
+        catch {
+            // ignore; not all filesystems support chmod (e.g. Windows)
+        }
+        renameSync(temp, target);
+    }
+    catch (error) {
+        rmSync(temp, { force: true });
+        throw new EvidenceWriteError(`PE manifest write failed: ${error instanceof Error ? error.message : "unknown"}`);
+    }
+}
+function recordManifest(baseDir, fs, randomSuffix, manifest) {
+    const sanitized = sanitizeManifestForPersistence(manifest);
+    const realBase = prepareBaseDir(baseDir, fs);
+    const target = lexicalManifestPath(sanitized.runId, realBase);
+    assertWritableManifestEntry(target, fs);
+    atomicWriteManifest(target, JSON.stringify(sanitized), randomSuffix);
+    return target;
+}
+function loadManifest(baseDir, fs, runId) {
+    assertValidRunId(runId);
+    const realBase = existingBaseDir(baseDir, fs);
+    if (realBase === undefined) {
+        return undefined;
+    }
+    const target = join(realBase, `${runId}${PE_MANIFEST_SUFFIX}`);
+    try {
+        if (lstatSync(target, { throwIfNoEntry: false })?.isFile() !== true) {
+            return undefined;
+        }
+        if (!isSingleLinkRegularFile(target, fs)) {
+            return undefined;
+        }
+        return parseAndValidateManifest(readFileSync(target, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof EvidenceReadError) {
+            throw error;
+        }
+        throw new EvidenceReadError(`cannot read PE manifest: ${error instanceof Error ? error.message : "unknown"}`);
+    }
+}
+function deleteManifest(baseDir, fs, runId) {
+    assertValidRunId(runId);
+    const realBase = existingBaseDir(baseDir, fs);
+    if (realBase === undefined) {
+        return false;
+    }
+    const target = lexicalManifestPath(runId, realBase);
+    if (lstatSync(target, { throwIfNoEntry: false })?.isFile() !== true) {
+        return false;
+    }
+    if (!isSingleLinkRegularFile(target, fs)) {
+        return false;
+    }
+    rmSync(target, { force: true });
+    return true;
+}
+/**
+ * Build a Prompt Enhancement store that writes under `<evidenceDir>/pe/`. The caller passes the SAME
+ * evidence dir it would pass to `createNodeEvidenceStore`; the store layers the `pe/` subdir itself.
+ */
+export function createNodePromptEnhancementLocalStore(evidenceDir, options = {}) {
+    const baseDir = join(evidenceDir, PE_SUBDIR);
+    const fs = options.fs ?? nodeWorkspaceFs;
+    const randomSuffix = options.randomSuffix ?? randomUUID;
+    return {
+        record: (manifest) => recordManifest(baseDir, fs, randomSuffix, manifest),
+        load: (runId) => loadManifest(baseDir, fs, runId),
+        list: () => {
+            const realBase = existingBaseDir(baseDir, fs);
+            return realBase === undefined ? [] : listRunIds(realBase, fs);
+        },
+        location: (runId) => {
+            assertValidRunId(runId);
+            const realBase = existingBaseDir(baseDir, fs);
+            return realBase === undefined
+                ? join(resolve(baseDir), `${runId}${PE_MANIFEST_SUFFIX}`)
+                : lexicalManifestPath(runId, realBase);
+        },
+        delete: (runId) => deleteManifest(baseDir, fs, runId),
+    };
+}
+// ─── Public CRUD API ───────────────────────────────────────────────────────────────
+function resolveStore(options) {
+    if (options.store !== undefined) {
+        return options.store;
+    }
+    if (options.evidenceDir !== undefined) {
+        return createNodePromptEnhancementLocalStore(options.evidenceDir);
+    }
+    return undefined;
+}
+/**
+ * Build and persist a Prompt Enhancement run record. Redacts every free-text leaf, hashes the redacted
+ * groups, validates the totals invariant, then writes the manifest through the resolved store. The
+ * store is supplied via `options.store` (explicit, e.g. in-memory for tests) or `options.evidenceDir`
+ * (resolve to a node adapter); one MUST be provided.
+ */
+export function recordPromptEnhancementRun(input, options = {}) {
+    const store = resolveStore(options);
+    if (store === undefined) {
+        throw new EvidenceWriteError("recordPromptEnhancementRun requires options.store or options.evidenceDir");
+    }
+    const { manifest } = buildPromptEnhancementEvidenceManifest(input, options.redaction ?? {});
+    return { manifest, location: store.record(manifest) };
+}
+function resolveLoadStore(options) {
+    if (options.store !== undefined) {
+        return options.store;
+    }
+    if (options.evidenceDir !== undefined) {
+        return createNodePromptEnhancementLocalStore(options.evidenceDir);
+    }
+    throw new EvidenceReadError("PE load/list requires options.store or options.evidenceDir");
+}
+export function loadPromptEnhancementRun(runId, options = {}) {
+    return resolveLoadStore(options).load(runId);
+}
+export function listPromptEnhancementRuns(options = {}) {
+    return resolveLoadStore(options).list();
+}

package/dist/qualityIntelligence/candidatesArtifact.d.ts

@@ -0,0 +1,74 @@
+import { QualityIntelligence } from "@oscharko-dev/keiko-contracts";
+export declare const QUALITY_INTELLIGENCE_CANDIDATES_SCHEMA_VERSION: 1;
+export declare const CANDIDATES_SUFFIX = ".candidates.json";
+export interface QualityIntelligenceCandidateRow {
+    readonly id: string;
+    readonly title: string;
+    readonly preconditions: readonly string[];
+    readonly steps: readonly string[];
+    readonly expectedResults: readonly string[];
+    readonly priority: QualityIntelligence.QualityIntelligencePriority;
+    readonly riskClass: QualityIntelligence.QualityIntelligenceRiskClass;
+    readonly tags: readonly string[];
+    readonly status: QualityIntelligence.QualityIntelligenceTestCaseStatus;
+    readonly derivedFromAtomIds: readonly string[];
+    readonly qualityVerdict?: QualityIntelligenceCandidateQualityVerdict;
+}
+export interface QualityIntelligenceCandidateQualityVerdict {
+    readonly verdict: QualityIntelligence.TestQualityJudgeVerdict["verdict"];
+    readonly score: number;
+    readonly dimensions: readonly QualityIntelligence.TestQualityRubricDimension[];
+    readonly overallRationale: string;
+}
+export interface QualityIntelligenceCandidatesArtifact {
+    readonly qiCandidatesSchemaVersion: typeof QUALITY_INTELLIGENCE_CANDIDATES_SCHEMA_VERSION;
+    readonly runId: string;
+    readonly generatedAt: string;
+    readonly candidates: readonly QualityIntelligenceCandidateRow[];
+    readonly editedRevisions?: readonly QualityIntelligence.QualityIntelligenceCandidateEditedRevision[];
+}
+export interface QualityIntelligenceCandidatesStoreOptions {
+    readonly evidenceDir: string;
+}
+export interface RecordQualityIntelligenceCandidatesInput {
+    readonly runId: string;
+    readonly generatedAt: string;
+    readonly candidates: readonly QualityIntelligence.QualityIntelligenceTestCaseCandidate[];
+    readonly editedRevisions?: readonly QualityIntelligence.QualityIntelligenceCandidateEditedRevision[] | undefined;
+    readonly evidenceDir: string;
+    /**
+     * Required defence-in-depth redactor applied to every string leaf before persist. The server
+     * passes the live audit redactor (`deps.redactor`); tests pass an explicit identity. Making it
+     * mandatory keeps a forgetful caller from writing an unredacted candidate body to disk (#284).
+     */
+    readonly redact: (value: unknown) => unknown;
+}
+/**
+ * Persist the generated candidate bodies for a run. Redacts every string leaf first, then writes
+ * the companion artifact atomically. Returns the on-disk location.
+ */
+export declare const recordQualityIntelligenceCandidates: (input: RecordQualityIntelligenceCandidatesInput) => string;
+export declare const loadQualityIntelligenceCandidates: (runId: string, options: QualityIntelligenceCandidatesStoreOptions) => QualityIntelligenceCandidatesArtifact | undefined;
+export declare const deleteQualityIntelligenceCandidates: (runId: string, options: QualityIntelligenceCandidatesStoreOptions) => boolean;
+type EditableFields = QualityIntelligence.QualityIntelligenceCandidateEditableFields;
+type EditProvenance = QualityIntelligence.QualityIntelligenceCandidateEditProvenance;
+export type QualityIntelligenceCandidateEditErrorReason = "artifact-not-found" | "candidate-not-found" | "no-edited-fields";
+export type ApplyQualityIntelligenceCandidateEditResult = {
+    readonly ok: true;
+    readonly candidate: QualityIntelligenceCandidateRow;
+    readonly changed: boolean;
+} | {
+    readonly ok: false;
+    readonly reason: QualityIntelligenceCandidateEditErrorReason;
+};
+export interface ApplyQualityIntelligenceCandidateEditInput {
+    readonly runId: string;
+    readonly candidateId: string;
+    readonly editedFields: EditableFields;
+    readonly provenance: EditProvenance;
+    readonly evidenceDir: string;
+    readonly redact: (value: unknown) => unknown;
+}
+export declare const applyQualityIntelligenceCandidateEdit: (input: ApplyQualityIntelligenceCandidateEditInput) => ApplyQualityIntelligenceCandidateEditResult;
+export {};
+//# sourceMappingURL=candidatesArtifact.d.ts.map

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

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