@oscharko-dev/keiko-evidence 0.2.0

package/dist/qualityIntelligence/retention.js

@@ -0,0 +1,287 @@
+// QI retention + deletion + restart-recovery semantics (Issue #274, ADR-0023 D8).
+//
+// Pure decision function (`applyQualityIntelligenceRetention`) consumed by the orchestrator with
+// the current store snapshot; the orchestrator does the side effects. Idempotent deletion
+// (`deleteQualityIntelligenceRun`) removes the manifest AND its companion artifacts
+// (`.candidates.json` plus any caller-supplied server-owned suffixes) so a deleted run leaves no
+// orphaned customer-derived content, and emits a typed deletion-receipt audit event without
+// throwing on a missing run.
+//
+// Restart recovery is enforced at the WRITE seam: every persist is atomic O_EXCL temp + rename,
+// so an unclean shutdown leaves at most one `.tmp` (or nothing). The list/load surfaces filter on
+// the `.qi.json` suffix, so a half-written run is never surfaced. There is no recovery procedure
+// to call — recovery IS the absence of a code path that surfaces partials.
+import { lstatSync, realpathSync, renameSync, rmSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+import { assertValidRunId } from "@oscharko-dev/keiko-security";
+import { CANDIDATES_SUFFIX } from "./candidatesArtifact.js";
+import { deleteQualityIntelligenceCompanionArtifact } from "./companionStore.js";
+import { getQualityIntelligenceRetentionProfile, } from "./retentionPolicy.js";
+import { createNodeQualityIntelligenceLocalStore, QI_SUBDIR, } from "./store.js";
+// Companion artifacts that `keiko-evidence` OWNS and writes alongside the run manifest under
+// `qi/`, keyed by `<runId>`. They are swept by default on deletion so a "deleted" run never leaves
+// customer-derived generated content (`.candidates.json`) orphaned on disk (Issue #274 AC4).
+// Higher layers that own their own companions (e.g. keiko-server's `.review.json`, the figma
+// route companions) pass their suffixes via `QualityIntelligenceDeleteOptions.companionSuffixes`;
+// keiko-evidence MUST NOT hard-code suffixes it does not own (layering). The figma-snapshot
+// companion + its `figma-snapshots/<runId>/` side-files are deliberately EXCLUDED here — they have
+// their own retention seam (`enforceFigmaSnapshotRetention`) and are cleaned by that subsystem.
+const QI_EVIDENCE_OWNED_COMPANION_SUFFIXES = Object.freeze([CANDIDATES_SUFFIX]);
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+function profileForEntry(entry) {
+    return { entry, profile: getQualityIntelligenceRetentionProfile(entry.retentionPolicyId) };
+}
+// Bucket snapshot entries by their retention-policy id so each profile is enforced
+// independently. Entries with an unknown profile id are retained (forward-compat: a future schema
+// migration may introduce a profile a current binary does not know).
+function bucketByProfile(snapshot) {
+    const buckets = new Map();
+    for (const entry of snapshot) {
+        const profiled = profileForEntry(entry);
+        const list = buckets.get(entry.retentionPolicyId) ?? [];
+        list.push(profiled);
+        buckets.set(entry.retentionPolicyId, list);
+    }
+    return buckets;
+}
+function decideOneBucket(bucket, now) {
+    // The first bucket entry's profile is the bucket's profile (all entries share the same
+    // retentionPolicyId by construction). Empty bucket → no decisions.
+    const head = bucket[0];
+    if (head === undefined) {
+        return [];
+    }
+    const profile = head.profile;
+    if (profile === undefined) {
+        // Unknown profile id: retain everything (forward-compat).
+        return [];
+    }
+    // Newest-first ordering so the "always keep newest N" guarantee is the bucket head.
+    const sorted = [...bucket].sort((a, b) => b.entry.recordedAt - a.entry.recordedAt);
+    const decisions = [];
+    const maxAgeMs = profile.retainedDays * MS_PER_DAY;
+    for (let i = 0; i < sorted.length; i += 1) {
+        const slot = sorted[i];
+        if (slot === undefined) {
+            continue;
+        }
+        const { entry } = slot;
+        if (i >= profile.maxRunArtifacts) {
+            decisions.push({ runId: entry.runId, reason: "count-exceeded" });
+            continue;
+        }
+        if (now - entry.recordedAt > maxAgeMs) {
+            decisions.push({ runId: entry.runId, reason: "age-exceeded" });
+        }
+    }
+    return decisions;
+}
+// Pure retention decision. Returns the set of run ids to expire under each entry's configured
+// policy. Always keeps the newest N runs per policy (count-exceeded only fires for runs at index
+// >= N when sorted newest-first); age decisions are evaluated against the entry's own profile.
+export function applyQualityIntelligenceRetention(input) {
+    const buckets = bucketByProfile(input.snapshot);
+    const decisions = [];
+    for (const bucket of buckets.values()) {
+        decisions.push(...decideOneBucket(bucket, input.now));
+    }
+    const expired = new Set(decisions.map((d) => d.runId));
+    const expiredRunIds = [...expired].sort();
+    const retainedRunIds = input.snapshot
+        .map((entry) => entry.runId)
+        .filter((runId) => !expired.has(runId))
+        .sort();
+    return { expiredRunIds, retainedRunIds, decisions };
+}
+function resolveDeleteStore(options) {
+    if (options.store !== undefined) {
+        return options.store;
+    }
+    if (options.evidenceDir !== undefined) {
+        return createNodeQualityIntelligenceLocalStore(options.evidenceDir);
+    }
+    throw new Error("deleteQualityIntelligenceRun requires options.store or options.evidenceDir");
+}
+function containedPath(path, root) {
+    return path === root || path.startsWith(root + sep);
+}
+function realDirectoryForDeletion(path, label) {
+    const lexical = resolve(path);
+    const stat = lstatSync(lexical, { throwIfNoEntry: false });
+    if (stat === undefined) {
+        return undefined;
+    }
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        throw new Error(`${label} is not a real directory, refusing to delete: ${lexical}`);
+    }
+    return realpathSync(lexical);
+}
+function realEvidenceRootForContainment(evidenceDir) {
+    try {
+        return realpathSync(resolve(evidenceDir));
+    }
+    catch {
+        return undefined;
+    }
+}
+// Recursively removes a per-run side-file directory if it exists. Missing dir → no-op. Symlinked
+// side-file roots or run dirs are refused before the manifest is deleted so retention cannot rm
+// outside the evidence tree or emit a false successful deletion receipt. The evidence root itself
+// may be a workspace-approved symlink; canonicalize it for containment instead of rejecting it.
+function removeSideFileDirIfPresent(runId, sideFileRoot, evidenceDir) {
+    const root = realDirectoryForDeletion(sideFileRoot, "QI side-file root");
+    if (root === undefined) {
+        return;
+    }
+    if (evidenceDir !== undefined) {
+        const evidenceRoot = realEvidenceRootForContainment(evidenceDir);
+        if (evidenceRoot === undefined || !containedPath(root, evidenceRoot)) {
+            throw new Error(`QI side-file root escapes the evidence directory, refusing to delete: ${root}`);
+        }
+    }
+    const runDir = join(root, runId);
+    // Defence-in-depth: runId is already `assertValidRunId`-checked (no separators, no `..`, no
+    // leading dot) before this is reached. Assert containment against the canonical side-file root so
+    // symlinked roots or future validation drift cannot redirect recursive deletion outside evidence.
+    if (!containedPath(runDir, root)) {
+        throw new Error(`QI side-file dir escapes the side-file root, refusing to delete: ${runDir}`);
+    }
+    const stat = lstatSync(runDir, { throwIfNoEntry: false });
+    if (stat === undefined) {
+        return;
+    }
+    if (stat.isSymbolicLink()) {
+        throw new Error(`QI side-file dir is a symlink, refusing to delete: ${runDir}`);
+    }
+    if (!stat.isDirectory()) {
+        throw new Error(`QI side-file dir is not a real directory, refusing to delete: ${runDir}`);
+    }
+    rmSync(runDir, { recursive: true, force: true });
+}
+// Sweep the run's companion artifacts (evidence-owned + caller-supplied) from the contained `qi/`
+// dir. Exact-suffix, idempotent: a companion that does not exist is skipped. Returns the suffixes
+// that were actually removed so the deletion receipt/audit event can attest completeness.
+function removeRunCompanions(evidenceDir, runId, extraSuffixes) {
+    const suffixes = [
+        ...new Set([...QI_EVIDENCE_OWNED_COMPANION_SUFFIXES, ...(extraSuffixes ?? [])]),
+    ];
+    const removed = [];
+    for (const suffix of suffixes) {
+        if (deleteQualityIntelligenceCompanionArtifact(evidenceDir, runId, suffix)) {
+            removed.push(suffix);
+        }
+    }
+    return removed.sort();
+}
+// Idempotent removal of a single QI run's local state. Returns a structured receipt rather than
+// throwing on a missing run — callers (UI, retention orchestrator) need to distinguish "deleted"
+// from "absent" without try/catch noise. When options.sideFileRoot is set, also removes
+// `<sideFileRoot>/<runId>/` so binary side-files written by future export adapters are cleaned
+// up alongside the manifest.
+export function deleteQualityIntelligenceRun(runId, options = {}) {
+    assertValidRunId(runId);
+    const store = resolveDeleteStore(options);
+    if (options.sideFileRoot !== undefined) {
+        removeSideFileDirIfPresent(runId, options.sideFileRoot, options.evidenceDir);
+    }
+    const removed = store.delete(runId);
+    // Sweep companion artifacts so a deleted run leaves no orphaned customer-derived content on disk
+    // (Issue #274 AC4). On-disk only — skipped when just an in-memory store is supplied.
+    const removedCompanionSuffixes = options.evidenceDir === undefined
+        ? []
+        : removeRunCompanions(options.evidenceDir, runId, options.companionSuffixes);
+    const at = new Date(options.now?.() ?? Date.now()).toISOString();
+    const status = removed ? "deleted" : "absent";
+    return {
+        runId,
+        status,
+        removedCompanionSuffixes,
+        auditEvent: { type: "qi:run:deleted", runId, status, removedCompanionSuffixes, at },
+    };
+}
+// Load one run's manifest and project it onto a retention snapshot entry. Returns undefined when the
+// run MUST be skipped: load returned absent/corrupt (undefined or EvidenceReadError) or the
+// manifest's `completedAt ?? planAt` is not a parseable timestamp. Skipping means the run never
+// reaches the decision and is therefore never purged — the destructive-path fail-safe.
+function snapshotEntryForRun(store, runId) {
+    let manifest;
+    try {
+        manifest = store.load(runId);
+    }
+    catch {
+        // A corrupt / tampered / unreadable manifest fails closed: skip, never delete.
+        return undefined;
+    }
+    if (manifest === undefined) {
+        return undefined;
+    }
+    const recordedAt = Date.parse(manifest.completedAt ?? manifest.planAt);
+    if (Number.isNaN(recordedAt)) {
+        // No usable timestamp → cannot age the run out safely → retain.
+        return undefined;
+    }
+    return { runId, recordedAt, retentionPolicyId: manifest.retentionPolicyId };
+}
+function buildRetentionSnapshot(store) {
+    const snapshot = [];
+    for (const runId of store.list()) {
+        const entry = snapshotEntryForRun(store, runId);
+        if (entry !== undefined) {
+            snapshot.push(entry);
+        }
+    }
+    return snapshot;
+}
+export function enforceQualityIntelligenceRetentionPolicy(options) {
+    const store = createNodeQualityIntelligenceLocalStore(options.evidenceDir);
+    const snapshot = buildRetentionSnapshot(store);
+    const result = applyQualityIntelligenceRetention({
+        snapshot,
+        now: options.now?.() ?? Date.now(),
+    });
+    const receipts = [];
+    const failures = [];
+    for (const runId of result.expiredRunIds) {
+        try {
+            receipts.push(deleteQualityIntelligenceRun(runId, {
+                evidenceDir: options.evidenceDir,
+                now: options.now,
+                companionSuffixes: options.companionSuffixes,
+                sideFileRoot: options.sideFileRoot,
+            }));
+        }
+        catch (error) {
+            failures.push({
+                runId,
+                message: error instanceof Error ? error.message : "unknown deletion failure",
+            });
+        }
+    }
+    return { receipts, failures, result };
+}
+export function quarantineCorruptQualityIntelligenceManifest(evidenceDir, runId, options = {}) {
+    assertValidRunId(runId);
+    const baseDir = join(evidenceDir, QI_SUBDIR);
+    const originalPath = join(baseDir, `${runId}.qi.json`);
+    const stat = lstatSync(originalPath, { throwIfNoEntry: false });
+    if (!stat?.isFile()) {
+        return { originalPath, quarantinedPath: originalPath, status: "absent" };
+    }
+    const ts = new Date(options.now?.() ?? Date.now()).toISOString();
+    const quarantinedPath = `${originalPath}.corrupt.${ts}`;
+    renameSync(originalPath, quarantinedPath);
+    return { originalPath, quarantinedPath, status: "quarantined" };
+}
+export function snapshotQualityIntelligenceRunsForRecovery(store) {
+    const loaded = [];
+    const skipped = [];
+    for (const runId of store.list()) {
+        const manifest = store.load(runId);
+        if (manifest === undefined) {
+            skipped.push(runId);
+            continue;
+        }
+        loaded.push(runId);
+    }
+    return { loadedRunIds: loaded.sort(), skippedRunIds: skipped.sort() };
+}

package/dist/qualityIntelligence/retentionPolicy.d.ts

@@ -0,0 +1,10 @@
+export interface QualityIntelligenceRetentionProfile {
+    readonly id: string;
+    readonly description: string;
+    readonly retainedDays: number;
+    readonly maxRunArtifacts: number;
+}
+export declare const QUALITY_INTELLIGENCE_RETENTION_PROFILES: Readonly<Record<string, QualityIntelligenceRetentionProfile>>;
+export declare const QUALITY_INTELLIGENCE_DEFAULT_RETENTION_PROFILE_ID: "qi:short-30d";
+export declare function getQualityIntelligenceRetentionProfile(profileId: string): QualityIntelligenceRetentionProfile | undefined;
+//# sourceMappingURL=retentionPolicy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retentionPolicy.d.ts","sourceRoot":"","sources":["../../src/qualityIntelligence/retentionPolicy.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,mCAAmC;IAClD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AA4BD,eAAO,MAAM,uCAAuC,EAAE,QAAQ,CAC5D,MAAM,CAAC,MAAM,EAAE,mCAAmC,CAAC,CACL,CAAC;AAEjD,eAAO,MAAM,iDAAiD,EAAG,cAAuB,CAAC;AAKzF,wBAAgB,sCAAsC,CACpD,SAAS,EAAE,MAAM,GAChB,mCAAmC,GAAG,SAAS,CAEjD"}

package/dist/qualityIntelligence/retentionPolicy.js

@@ -0,0 +1,38 @@
+// QI retention profiles (Issue #274, ADR-0023 D8).
+//
+// Frozen, typed constants describing how long a QI run's evidence record persists locally before
+// it becomes a candidate for `applyQualityIntelligenceRetention`. The profile is a pure
+// description; the decision function is in `./retention.ts`.
+// Three pre-shipped profiles. New profiles are added by extending this map; the IDs are
+// referenced by string on the manifest, so renaming a profile is a manifest-schema breaking
+// change (bump `QUALITY_INTELLIGENCE_EVIDENCE_SCHEMA_VERSION`).
+const QI_RETENTION_PROFILES_MUTABLE = {
+    "qi:short-30d": Object.freeze({
+        id: "qi:short-30d",
+        description: "Short retention: 30 days, up to 100 runs.",
+        retainedDays: 30,
+        maxRunArtifacts: 100,
+    }),
+    "qi:standard-90d": Object.freeze({
+        id: "qi:standard-90d",
+        description: "Standard retention: 90 days, up to 500 runs.",
+        retainedDays: 90,
+        maxRunArtifacts: 500,
+    }),
+    "qi:long-365d": Object.freeze({
+        id: "qi:long-365d",
+        description: "Long retention: 365 days, up to 2000 runs.",
+        retainedDays: 365,
+        maxRunArtifacts: 2000,
+    }),
+};
+// The exposed table is a frozen view; mutating it (or any contained profile) throws in strict
+// mode and is a no-op otherwise. Tests assert frozenness as a regression guard.
+export const QUALITY_INTELLIGENCE_RETENTION_PROFILES = Object.freeze(QI_RETENTION_PROFILES_MUTABLE);
+export const QUALITY_INTELLIGENCE_DEFAULT_RETENTION_PROFILE_ID = "qi:short-30d";
+// Looks up a profile by id, returning undefined for unknown ids. Callers MUST not throw on
+// unknown — a future schema migration may introduce a profile a current binary does not know,
+// and the local-state contract requires graceful read-back.
+export function getQualityIntelligenceRetentionProfile(profileId) {
+    return QUALITY_INTELLIGENCE_RETENTION_PROFILES[profileId];
+}

package/dist/qualityIntelligence/store.d.ts

@@ -0,0 +1,95 @@
+import { type WorkspaceFs } from "@oscharko-dev/keiko-workspace";
+import { type QualityIntelligenceEvidenceManifest, type QualityIntelligenceAtomFingerprintRow, type QualityIntelligenceSourceFingerprintRow } from "./manifestSchema.js";
+import { type QualityIntelligenceRedactionOptions } from "./redaction.js";
+export declare const QI_SUBDIR = "qi";
+export interface QualityIntelligenceLocalStore {
+    readonly record: (manifest: QualityIntelligenceEvidenceManifest) => string;
+    readonly load: (runId: string) => QualityIntelligenceEvidenceManifest | undefined;
+    readonly list: () => readonly string[];
+    readonly location: (runId: string) => string;
+    readonly delete: (runId: string) => boolean;
+}
+export declare function createInMemoryQualityIntelligenceLocalStore(): QualityIntelligenceLocalStore;
+export interface QualityIntelligenceNodeStoreOptions {
+    readonly fs?: WorkspaceFs;
+    readonly randomSuffix?: () => string;
+}
+export declare function createNodeQualityIntelligenceLocalStore(evidenceDir: string, options?: QualityIntelligenceNodeStoreOptions): QualityIntelligenceLocalStore;
+export interface QualityIntelligenceRecordInput {
+    readonly runId: string;
+    readonly planAt: string;
+    readonly completedAt: string | undefined;
+    readonly status: QualityIntelligenceEvidenceManifest["status"];
+    readonly policyProfileIds: readonly string[];
+    readonly retentionPolicyId: string;
+    readonly modelGatewayCallCount: number;
+    readonly totals: QualityIntelligenceEvidenceManifest["totals"];
+    readonly findings: QualityIntelligenceEvidenceManifest["findings"];
+    readonly exports: QualityIntelligenceEvidenceManifest["exports"];
+    readonly evidenceRefs: QualityIntelligenceEvidenceManifest["evidenceRefs"];
+    readonly provenanceRefs: QualityIntelligenceEvidenceManifest["provenanceRefs"];
+    /** Optional coverage matrix (per-atom status, refs only). Added in #738. */
+    readonly coverageMatrix?: QualityIntelligenceEvidenceManifest["coverageMatrix"];
+    /** Optional run quality score — percent of candidates with a strong judge outcome [0-100]; null when judge was skipped. Added in #736. */
+    readonly qualityScore?: QualityIntelligenceEvidenceManifest["qualityScore"];
+    /** Optional per-envelope content fingerprints for drift detection (Epic #735). */
+    readonly sourceFingerprints?: readonly QualityIntelligenceSourceFingerprintRow[];
+    /** Optional per-atom content fingerprints for atom-aware drift detection (#798/#799). */
+    readonly atomFingerprints?: readonly QualityIntelligenceAtomFingerprintRow[];
+    /** Optional model id that generated the candidates (Epic #761). */
+    readonly modelId?: string;
+    /** Optional redaction-safe request parameter scalars (Epic #761). */
+    readonly modelParameters?: Record<string, unknown>;
+    /** Optional seed used for deterministic sampling (Epic #761). */
+    readonly seedUsed?: number | null;
+}
+export interface QualityIntelligenceRecordOptions {
+    readonly store?: QualityIntelligenceLocalStore | undefined;
+    readonly evidenceDir?: string | undefined;
+    readonly redaction?: QualityIntelligenceRedactionOptions | undefined;
+}
+export interface QualityIntelligenceRecordResult {
+    readonly manifest: QualityIntelligenceEvidenceManifest;
+    readonly location: string;
+}
+export declare function recordQualityIntelligenceRun(input: QualityIntelligenceRecordInput, options?: QualityIntelligenceRecordOptions): QualityIntelligenceRecordResult;
+export interface QualityIntelligenceExportEvidenceInput {
+    readonly runId: string;
+    /** The export row to append: target adapter, artifact id, integrity hash, attestation, mode. */
+    readonly export: QualityIntelligenceEvidenceManifest["exports"][number];
+}
+/**
+ * Append one export-evidence row to an already-recorded run manifest (Issue #283, AC4 — "export
+ * evidence records target type, artifact IDs, mapping profile, and result without leaking secrets";
+ * Audit Addendum — "audit evidence for every export action").
+ *
+ * Every QI export action — a local serialisation download, a binary PDF/ZIP bundle, or a dry-run
+ * preview — emits one audit row recording WHAT was exported (`targetAdapter`), the artifact id, its
+ * integrity hash, the redaction attestation, and whether it was a dry-run. The disabled external-TMS
+ * write path produces no artifact and therefore records nothing.
+ *
+ * Rows are deduplicated by `(id, dryRun)` so re-exporting the same adapter in the same mode is
+ * idempotent — the audit captures each distinct (artifact, mode) once rather than once per click,
+ * which also bounds manifest growth.
+ *
+ * Invariants preserved (mirrors {@link recordQualityIntelligenceRun}):
+ *  - the new row's string leaves pass the persist redactor before assembly (the row carries only
+ *    ids / an enum / a sha-256 hash / booleans, so this is a no-op in practice, but the persist
+ *    redactor is applied unconditionally to keep the fail-closed contract uniform);
+ *  - `integrityHashes.exports` is recomputed over the full new collection; the other hash groups are
+ *    carried over unchanged because their collections did not change;
+ *  - `totals.exports` stays equal to `exports.length` (asserted on read);
+ *  - the counts-only `redactionSummary` folds in the new row's scan;
+ *  - the manifest is rewritten through the same atomic O_EXCL temp + rename path.
+ *
+ * Throws `EvidenceReadError` when the run manifest does not exist (an export cannot precede its run)
+ * and `EvidenceWriteError` when neither `store` nor `evidenceDir` is supplied or the write fails.
+ */
+export declare function appendQualityIntelligenceExportRow(input: QualityIntelligenceExportEvidenceInput, options?: QualityIntelligenceRecordOptions): QualityIntelligenceRecordResult;
+export interface QualityIntelligenceLoadOptions {
+    readonly store?: QualityIntelligenceLocalStore | undefined;
+    readonly evidenceDir?: string | undefined;
+}
+export declare function loadQualityIntelligenceRun(runId: string, options?: QualityIntelligenceLoadOptions): QualityIntelligenceEvidenceManifest | undefined;
+export declare function listQualityIntelligenceRuns(options?: QualityIntelligenceLoadOptions): readonly string[];
+//# sourceMappingURL=store.d.ts.map

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

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