@oscharko-dev/keiko 0.1.6 → 0.1.7

package/node_modules/@oscharko-dev/keiko-evidence/dist/index-api.js

@@ -0,0 +1,131 @@
+// Evidence index/list API (ADR-0010 D5). listEvidence enumerates and loadEvidence loads past runs
+// reading ONLY the contained base dir via the EvidenceStore — never scanning arbitrary workspace
+// files. Because the persisted JSON is redacted by construction (D3), the loaded data is
+// redacted-by-construction: there is no un-redaction path. A manifest whose evidenceSchemaVersion is
+// not a recognised version is reported with a typed error (D5), not silently coerced. This is the
+// #13 UI seam.
+import { EvidenceReadError, EvidenceSchemaError } from "./errors.js";
+import { EVIDENCE_SCHEMA_VERSION } from "./types.js";
+// Parses raw JSON and verifies the schema version before trusting the shape. We narrow on the
+// version discriminant exactly as harness consumers narrow on the event schemaVersion (D2).
+// JSON.parse can throw a raw SyntaxError on a truncated/hand-edited manifest; the parse is a system
+// boundary (reading developer-writable files), so catching it and re-throwing a typed AuditError is
+// correct — the CLI maps AuditError to an exit code instead of leaking an unhandled stack (C1).
+function parseJson(json, runId) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        throw new EvidenceReadError(`evidence manifest is not valid JSON: ${runId}`);
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireRecord(parent, key, runId) {
+    const value = parent[key];
+    if (!isRecord(value)) {
+        throw new EvidenceSchemaError(`evidence manifest is missing object field ${key}: ${runId}`, "1");
+    }
+    return value;
+}
+function requireArray(parent, key, runId) {
+    if (!Array.isArray(parent[key])) {
+        throw new EvidenceSchemaError(`evidence manifest is missing array field ${key}: ${runId}`, "1");
+    }
+}
+function requireString(parent, key, runId) {
+    if (typeof parent[key] !== "string") {
+        throw new EvidenceSchemaError(`evidence manifest is missing string field ${key}: ${runId}`, "1");
+    }
+}
+function requireNumber(parent, key, runId) {
+    if (typeof parent[key] !== "number" || !Number.isFinite(parent[key])) {
+        throw new EvidenceSchemaError(`evidence manifest is missing numeric field ${key}: ${runId}`, "1");
+    }
+}
+function requireOptionalRecord(parent, key, runId) {
+    const value = parent[key];
+    if (value !== undefined && !isRecord(value)) {
+        throw new EvidenceSchemaError(`evidence manifest has invalid object field ${key}: ${runId}`, "1");
+    }
+}
+function requireOptionalArray(parent, key, runId) {
+    const value = parent[key];
+    if (value !== undefined && !Array.isArray(value)) {
+        throw new EvidenceSchemaError(`evidence manifest has invalid array field ${key}: ${runId}`, "1");
+    }
+}
+function validateManifestShape(parsed, runId) {
+    const run = requireRecord(parsed, "run", runId);
+    requireString(run, "runId", runId);
+    requireString(run, "fingerprint", runId);
+    requireString(run, "harnessVersion", runId);
+    requireString(run, "taskType", runId);
+    requireString(run, "outcome", runId);
+    requireNumber(run, "startedAt", runId);
+    requireNumber(run, "finishedAt", runId);
+    requireNumber(run, "durationMs", runId);
+    const model = requireRecord(parsed, "model", runId);
+    requireString(model, "modelId", runId);
+    requireString(model, "costClass", runId);
+    const usage = requireRecord(parsed, "usageTotals", runId);
+    requireNumber(usage, "promptTokens", runId);
+    requireNumber(usage, "completionTokens", runId);
+    requireNumber(usage, "requestCount", runId);
+    requireNumber(usage, "totalLatencyMs", runId);
+    requireArray(parsed, "stateTransitions", runId);
+    requireArray(parsed, "toolCalls", runId);
+    requireArray(parsed, "commandExecutions", runId);
+    requireOptionalArray(parsed, "sandboxConfigurations", runId);
+    requireOptionalArray(parsed, "verificationResults", runId);
+    requireOptionalArray(parsed, "reasoning", runId);
+    requireOptionalRecord(parsed, "context", runId);
+    requireOptionalRecord(parsed, "patch", runId);
+    requireOptionalRecord(parsed, "verification", runId);
+    requireOptionalRecord(parsed, "failure", runId);
+    requireOptionalRecord(parsed, "browser", runId);
+}
+function parseManifest(json, runId) {
+    const parsed = parseJson(json, runId);
+    if (!isRecord(parsed)) {
+        throw new EvidenceSchemaError(`evidence manifest is not an object: ${runId}`, "none");
+    }
+    const version = parsed.evidenceSchemaVersion;
+    if (version !== EVIDENCE_SCHEMA_VERSION) {
+        throw new EvidenceSchemaError(`unrecognised evidence schema version for ${runId}`, typeof version === "string" ? version : "none");
+    }
+    validateManifestShape(parsed, runId);
+    return parsed;
+}
+function toListEntry(manifest) {
+    return {
+        runId: manifest.run.runId,
+        taskType: manifest.run.taskType,
+        outcome: manifest.run.outcome,
+        startedAt: manifest.run.startedAt,
+        finishedAt: manifest.run.finishedAt,
+        modelId: manifest.model.modelId,
+        ...(manifest.context?.workspaceRoot === undefined
+            ? {}
+            : { workspaceRoot: manifest.context.workspaceRoot }),
+    };
+}
+export function listEvidence(store) {
+    const entries = [];
+    for (const runId of store.list()) {
+        const json = store.get(runId);
+        if (json === undefined) {
+            continue;
+        }
+        entries.push(toListEntry(parseManifest(json, runId)));
+    }
+    return entries;
+}
+export function loadEvidence(store, runId) {
+    const json = store.get(runId);
+    if (json === undefined) {
+        return undefined;
+    }
+    return parseManifest(json, runId);
+}

package/node_modules/@oscharko-dev/keiko-evidence/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { KEIKO_EVIDENCE_VERSION } from "./version.js";
+export { buildEvidenceManifest } from "./build.js";
+export { persistEvidence, type PersistResult } from "./persist.js";
+export { createAuditRedactor, deepRedactStrings } from "./redaction.js";
+export { aggregateUsage } from "./aggregate.js";
+export { listEvidence, loadEvidence, type EvidenceListEntry } from "./index-api.js";
+export { applyRetention } from "./retention.js";
+export { buildEvidenceReport, renderEvidenceReport, type EvidenceReport } from "./report.js";
+export { assertValidRunId } from "./runid.js";
+export { buildWorkflowManifest, foldWorkflowUsage, persistWorkflowEvidence, type EvidencePersistContext, type WorkflowEventLike, type WorkflowRunIdentity, type WorkflowRunKind, type WorkflowTerminalStatus, } from "./workflow-evidence.js";
+export { createInMemoryEvidenceStore, createNodeEvidenceStore, DEFAULT_EVIDENCE_DIR, resolveEvidenceDir, type EvidenceStore, } from "./store.js";
+export { writeSideFile, type SideFileWriteResult, type SideFileWriterOptions, } from "./side-file.js";
+export { AUDIT_CODES, AuditError, EvidenceReadError, EvidenceSchemaError, EvidenceWriteError, InvalidRunIdError, type AuditCode, } from "./errors.js";
+export { EVIDENCE_SCHEMA_VERSION, DEFAULT_RETENTION, type AuditRedactionConfig, type BuildOptions, type EvidenceBuildInput, type EvidenceCommandExecution, type EvidenceDeps, type EvidenceFailure, type EvidenceManifest, type EvidenceModel, type EvidenceBrowserCapture, type EvidenceBrowserContentCapture, type EvidenceBrowserEvent, type EvidenceBrowserEventType, type EvidenceBrowserScreenshot, type EvidenceBrowserViewportPx, type EvidencePatch, type EvidenceReasoningEntry, type EvidenceRunIdentity, type EvidenceStateTransition, type EvidenceTaskType, type EvidenceToolCall, type EvidenceUsageTotals, type EvidenceVerificationResult, type RetentionPolicy, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@oscharko-dev/keiko-evidence/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACpF,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7F,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,uBAAuB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,sBAAsB,GAC5B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,2BAA2B,EAC3B,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,KAAK,aAAa,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,aAAa,EACb,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,GAC3B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,WAAW,EACX,UAAU,EACV,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,KAAK,SAAS,GACf,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,EAClC,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,EAC9B,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC5B,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,eAAe,GACrB,MAAM,YAAY,CAAC"}

package/node_modules/@oscharko-dev/keiko-evidence/dist/index.js

@@ -0,0 +1,19 @@
+// Public surface of @oscharko-dev/keiko-evidence (ADR-0010 D12 + ADR-0019). Re-exports the public
+// evidence surface — the builder, the persist orchestration, the redactor, the store port +
+// adapters, aggregation, the index/list API, retention, the report, runId validation, side-file
+// writing, and the workflow-evidence mapping — alongside the package version constant. The layer
+// does NOT export a bare `summarizeForAudit` or `redact` (it composes them internally).
+export { KEIKO_EVIDENCE_VERSION } from "./version.js";
+export { buildEvidenceManifest } from "./build.js";
+export { persistEvidence } from "./persist.js";
+export { createAuditRedactor, deepRedactStrings } from "./redaction.js";
+export { aggregateUsage } from "./aggregate.js";
+export { listEvidence, loadEvidence } from "./index-api.js";
+export { applyRetention } from "./retention.js";
+export { buildEvidenceReport, renderEvidenceReport } from "./report.js";
+export { assertValidRunId } from "./runid.js";
+export { buildWorkflowManifest, foldWorkflowUsage, persistWorkflowEvidence, } from "./workflow-evidence.js";
+export { createInMemoryEvidenceStore, createNodeEvidenceStore, DEFAULT_EVIDENCE_DIR, resolveEvidenceDir, } from "./store.js";
+export { writeSideFile, } from "./side-file.js";
+export { AUDIT_CODES, AuditError, EvidenceReadError, EvidenceSchemaError, EvidenceWriteError, InvalidRunIdError, } from "./errors.js";
+export { EVIDENCE_SCHEMA_VERSION, DEFAULT_RETENTION, } from "./types.js";

package/node_modules/@oscharko-dev/keiko-evidence/dist/persist.d.ts

@@ -0,0 +1,9 @@
+import { type EvidenceReport } from "./report.js";
+import type { EvidenceBuildInput, EvidenceDeps, EvidenceManifest, RetentionPolicy } from "./types.js";
+export interface PersistResult {
+    readonly manifest: EvidenceManifest;
+    readonly location: string;
+    readonly report: EvidenceReport;
+}
+export declare function persistEvidence(input: EvidenceBuildInput, deps: EvidenceDeps, retention?: RetentionPolicy): PersistResult;
+//# sourceMappingURL=persist.d.ts.map

package/node_modules/@oscharko-dev/keiko-evidence/dist/persist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persist.d.ts","sourceRoot":"","sources":["../src/persist.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAGvE,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,eAAe,EAChB,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;CACjC;AAOD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,kBAAkB,EACzB,IAAI,EAAE,YAAY,EAClB,SAAS,GAAE,eAAmC,GAC7C,aAAa,CAgBf"}

package/node_modules/@oscharko-dev/keiko-evidence/dist/persist.js

@@ -0,0 +1,40 @@
+// Top-level orchestration (ADR-0010 D11, D9): build -> deep re-redact (defense in depth) ->
+// store.put -> applyRetention -> buildEvidenceReport. This is the single entry the CLI and the SDK
+// call to write evidence. It is the supported SDK persist entry (the harness is NOT modified — the
+// reuse-unchanged rule is absolute; AC #6 "SDK runs write evidence" is satisfied here and at the CLI
+// layer, not by editing runAgent).
+//
+// Defense-in-depth redaction (coordinator refinement, replacing the ADR's serialized-string pass):
+// the builder is redacted-by-construction (primary), and this layer re-applies the redactor to EVERY
+// STRING LEAF of the assembled manifest object via a generic deep walk BEFORE JSON.stringify. This is
+// idempotent and cannot break JSON structure (a serialized-string re-redaction could miss
+// JSON-escaped secrets and risk corrupting the document). It catches a secret smuggled in through a
+// verbatim-embedded summary (context/verification) that the builder does not itself redact.
+import { isAbsolute, resolve } from "node:path";
+import { buildEvidenceManifest } from "./build.js";
+import { createAuditRedactor, deepRedactStrings } from "./redaction.js";
+import { buildEvidenceReport } from "./report.js";
+import { applyRetention } from "./retention.js";
+import { createNodeEvidenceStore, resolveEvidenceDir } from "./store.js";
+import { DEFAULT_RETENTION } from "./types.js";
+function defaultEvidenceDir(input, env) {
+    const configured = resolveEvidenceDir(undefined, env);
+    return isAbsolute(configured) ? configured : resolve(input.manifest.workingDirectory, configured);
+}
+export function persistEvidence(input, deps, retention = DEFAULT_RETENTION) {
+    const env = deps.env ?? {};
+    // The builder is already redacted-by-construction (incl. the deep-redact of embedded summaries);
+    // re-apply the redactor over every string leaf here as IDEMPOTENT defense in depth, so a builder
+    // bug that missed a field still cannot persist a secret.
+    const manifest = buildEvidenceManifest(input, deps);
+    const redact = createAuditRedactor(input.redaction ?? {}, env);
+    const safeManifest = deepRedactStrings(manifest, redact);
+    const json = JSON.stringify(safeManifest, null, 2);
+    // C5/AC#6: with no explicit store, persist to the predictable local node store (resolved dir incl.
+    // KEIKO_EVIDENCE_DIR), NOT an in-memory store that would silently discard the evidence. Tests
+    // inject createInMemoryEvidenceStore explicitly so they never write to the repository tree.
+    const store = deps.store ?? createNodeEvidenceStore(defaultEvidenceDir(input, deps.env));
+    const location = store.put(safeManifest.run.runId, json);
+    applyRetention(store, retention);
+    return { manifest: safeManifest, location, report: buildEvidenceReport(safeManifest, location) };
+}

package/node_modules/@oscharko-dev/keiko-evidence/dist/redaction.d.ts

@@ -0,0 +1,2 @@
+export { createAuditRedactor, deepRedactStrings } from "@oscharko-dev/keiko-security";
+//# sourceMappingURL=redaction.d.ts.map

package/node_modules/@oscharko-dev/keiko-evidence/dist/redaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redaction.d.ts","sourceRoot":"","sources":["../src/redaction.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC"}

package/node_modules/@oscharko-dev/keiko-evidence/dist/redaction.js

@@ -0,0 +1,4 @@
+// Re-export shim: the audit-redaction layer (createAuditRedactor + deepRedactStrings) now lives in
+// @oscharko-dev/keiko-security (issue #159, ADR-0019). All existing import sites
+// (`from "./redaction.js"`) keep resolving unchanged via this barrel.
+export { createAuditRedactor, deepRedactStrings } from "@oscharko-dev/keiko-security";

package/node_modules/@oscharko-dev/keiko-evidence/dist/report.d.ts

@@ -0,0 +1,17 @@
+import type { CostClass, RunOutcome, VerificationStatus } from "@oscharko-dev/keiko-contracts";
+import type { EvidenceManifest, EvidenceTaskType, EvidenceUsageTotals } from "./types.js";
+export interface EvidenceReport {
+    readonly evidenceLocation: string;
+    readonly runId: string;
+    readonly fingerprint: string;
+    readonly taskType: EvidenceTaskType;
+    readonly outcome: RunOutcome;
+    readonly changedFiles: number;
+    readonly usageTotals: EvidenceUsageTotals;
+    readonly costClass: CostClass | "unknown";
+    readonly verificationStatus: VerificationStatus | "not-run";
+    readonly knownLimitations: readonly string[];
+}
+export declare function buildEvidenceReport(manifest: EvidenceManifest, location: string): EvidenceReport;
+export declare function renderEvidenceReport(report: EvidenceReport): string;
+//# sourceMappingURL=report.d.ts.map

package/node_modules/@oscharko-dev/keiko-evidence/dist/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../src/report.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAC/F,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EAEpB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,mBAAmB,CAAC;IAC1C,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,SAAS,CAAC;IAC5D,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAuBD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAahG;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAgBnE"}

package/node_modules/@oscharko-dev/keiko-evidence/dist/report.js

@@ -0,0 +1,50 @@
+// Final-report payload + renderer (ADR-0010 D9). buildEvidenceReport produces a structured,
+// JSON-serializable summary of a persisted manifest; renderEvidenceReport renders it for the CLI.
+// Both are PURE (no IO). knownLimitations is static text stating the Wave-1 evidence bounds
+// (no tamper-evidence, no encryption at rest, per-run cost attribution) so a reviewer reads the
+// honest trust boundary alongside the evidence.
+const KNOWN_LIMITATIONS = [
+    "Evidence files are developer-writable: no tamper-evidence or immutability (out of scope).",
+    "Evidence is stored as plaintext JSON: no encryption at rest; redaction removes known shapes only.",
+    "Cost attribution is per-run (the declared model's class), not per model call.",
+];
+function statusFromHarnessResults(results) {
+    if (results === undefined || results.length === 0) {
+        return "not-run";
+    }
+    return results.every((result) => result.passed) ? "passed" : "failed";
+}
+function verificationStatus(manifest) {
+    return (manifest.verification?.overallStatus ?? statusFromHarnessResults(manifest.verificationResults));
+}
+export function buildEvidenceReport(manifest, location) {
+    return {
+        evidenceLocation: location,
+        runId: manifest.run.runId,
+        fingerprint: manifest.run.fingerprint,
+        taskType: manifest.run.taskType,
+        outcome: manifest.run.outcome,
+        changedFiles: manifest.patch?.changedFiles ?? 0,
+        usageTotals: manifest.usageTotals,
+        costClass: manifest.model.costClass,
+        verificationStatus: verificationStatus(manifest),
+        knownLimitations: KNOWN_LIMITATIONS,
+    };
+}
+export function renderEvidenceReport(report) {
+    const { usageTotals: u } = report;
+    const lines = [
+        `Evidence: ${report.evidenceLocation}`,
+        `  run            ${report.runId} (fingerprint ${report.fingerprint})`,
+        `  task           ${report.taskType}`,
+        `  outcome        ${report.outcome}`,
+        `  changed files  ${String(report.changedFiles)}`,
+        `  usage          ${String(u.promptTokens)} prompt / ${String(u.completionTokens)} completion tokens, ` +
+            `${String(u.requestCount)} request(s), ${String(u.totalLatencyMs)}ms`,
+        `  cost class     ${report.costClass}`,
+        `  verification   ${report.verificationStatus}`,
+        "  known limitations:",
+        ...report.knownLimitations.map((limitation) => `    - ${limitation}`),
+    ];
+    return `${lines.join("\n")}\n`;
+}

package/node_modules/@oscharko-dev/keiko-evidence/dist/retention.d.ts

@@ -0,0 +1,4 @@
+import type { EvidenceStore } from "./store.js";
+import type { RetentionPolicy } from "./types.js";
+export declare function applyRetention(store: EvidenceStore, policy: RetentionPolicy): void;
+//# sourceMappingURL=retention.d.ts.map

package/node_modules/@oscharko-dev/keiko-evidence/dist/retention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retention.d.ts","sourceRoot":"","sources":["../src/retention.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AA+FlD,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAQlF"}

package/node_modules/@oscharko-dev/keiko-evidence/dist/retention.js

@@ -0,0 +1,95 @@
+// Retention and rotation (ADR-0010 D6). The single most dangerous operation in the layer, so it is
+// the most tightly bounded: it deletes ONLY ledger-created `<runId>.json` files (every runId the
+// store enumerates already passed assertValidRunId), inside the contained base dir, via
+// EvidenceStore.delete. It computes the delete set then deletes that set (no recursion). "Oldest" is
+// read from each manifest's finishedAt header — never filesystem mtime, which a developer touch
+// could perturb. When disabled, deletion is a no-op. An unparseable manifest is left untouched
+// rather than risking deletion of a file we cannot read a header from.
+function readHeader(json) {
+    try {
+        const parsed = JSON.parse(json);
+        const finishedAt = parsed.run?.finishedAt;
+        if (typeof finishedAt !== "number") {
+            return undefined;
+        }
+        return { finishedAt, bytes: Buffer.byteLength(json, "utf8") };
+    }
+    catch {
+        return undefined;
+    }
+}
+// Newest-first ordering by finishedAt; ties broken by runId so the order is deterministic.
+function collectCandidates(store) {
+    const candidates = [];
+    for (const runId of store.list()) {
+        const json = store.get(runId);
+        if (json === undefined) {
+            continue;
+        }
+        const header = readHeader(json);
+        if (header === undefined) {
+            continue;
+        }
+        candidates.push({ runId, finishedAt: header.finishedAt, bytes: header.bytes });
+    }
+    candidates.sort((a, b) => b.finishedAt - a.finishedAt || a.runId.localeCompare(b.runId));
+    return candidates;
+}
+function beyondMaxRuns(sorted, maxRuns) {
+    return sorted.slice(Math.max(maxRuns, 0)).map((c) => c.runId);
+}
+function olderThanAge(sorted, maxAgeMs) {
+    const newest = sorted[0]?.finishedAt;
+    if (newest === undefined) {
+        return [];
+    }
+    const cutoff = newest - maxAgeMs;
+    return sorted.filter((c) => c.finishedAt < cutoff).map((c) => c.runId);
+}
+function overByteCap(sorted, maxTotalBytes) {
+    const doomed = [];
+    let running = 0;
+    // Walk newest-first, keeping manifests until the cap is reached; the rest (oldest) are deleted.
+    // The newest manifest (index 0) is ALWAYS kept even if it alone exceeds the cap — retention must
+    // never delete the just-written run, and "delete oldest until under the cap" cannot apply to a
+    // single most-recent file.
+    for (let i = 0; i < sorted.length; i += 1) {
+        const candidate = sorted[i];
+        if (candidate === undefined) {
+            continue;
+        }
+        running += candidate.bytes;
+        if (i > 0 && running > maxTotalBytes) {
+            doomed.push(candidate.runId);
+        }
+    }
+    return doomed;
+}
+function computeDeleteSet(sorted, policy) {
+    const doomed = new Set();
+    if (policy.maxRuns !== undefined) {
+        for (const id of beyondMaxRuns(sorted, policy.maxRuns)) {
+            doomed.add(id);
+        }
+    }
+    if (policy.maxAgeMs !== undefined) {
+        for (const id of olderThanAge(sorted, policy.maxAgeMs)) {
+            doomed.add(id);
+        }
+    }
+    if (policy.maxTotalBytes !== undefined) {
+        for (const id of overByteCap(sorted, policy.maxTotalBytes)) {
+            doomed.add(id);
+        }
+    }
+    return doomed;
+}
+export function applyRetention(store, policy) {
+    if (policy.disabled === true) {
+        return;
+    }
+    const sorted = collectCandidates(store);
+    for (const runId of computeDeleteSet(sorted, policy)) {
+        store.delete(runId);
+    }
+}

package/node_modules/@oscharko-dev/keiko-evidence/dist/runid.d.ts

@@ -0,0 +1,2 @@
+export { assertValidRunId } from "@oscharko-dev/keiko-security";
+//# sourceMappingURL=runid.d.ts.map

package/node_modules/@oscharko-dev/keiko-evidence/dist/runid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runid.d.ts","sourceRoot":"","sources":["../src/runid.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC"}

package/node_modules/@oscharko-dev/keiko-evidence/dist/runid.js

@@ -0,0 +1,4 @@
+// Re-export shim: the runId validator now lives in @oscharko-dev/keiko-security
+// (issue #159, ADR-0019). All existing import sites (`from "./runid.js"`) keep resolving
+// unchanged via this barrel.
+export { assertValidRunId } from "@oscharko-dev/keiko-security";

package/node_modules/@oscharko-dev/keiko-evidence/dist/side-file.d.ts

@@ -0,0 +1,9 @@
+import type { SideFileWriteResult } from "@oscharko-dev/keiko-contracts";
+import { type WorkspaceFs } from "@oscharko-dev/keiko-workspace";
+export type { SideFileWriteResult };
+export interface SideFileWriterOptions {
+    readonly fs?: WorkspaceFs;
+    readonly randomSuffix?: () => string;
+}
+export declare function writeSideFile(baseDir: string, runId: string, name: string, data: Buffer, options?: SideFileWriterOptions): SideFileWriteResult;
+//# sourceMappingURL=side-file.d.ts.map

package/node_modules/@oscharko-dev/keiko-evidence/dist/side-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"side-file.d.ts","sourceRoot":"","sources":["../src/side-file.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,+BAA+B,CAAC;AAWvC,YAAY,EAAE,mBAAmB,EAAE,CAAC;AAEpC,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC;IAC1B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,MAAM,CAAC;CACtC;AAwDD,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,qBAA0B,GAClC,mBAAmB,CAmBrB"}

package/node_modules/@oscharko-dev/keiko-evidence/dist/side-file.js

@@ -0,0 +1,81 @@
+// ADR-0017 D5 — side-file writer for binary evidence (e.g. screenshots) that does NOT fit the
+// text-only EvidenceManifest JSON. Atomic O_EXCL temp + rename, realpath-contained against the
+// per-run subdirectory of evidenceDir, SHA-256 computed over the raw bytes. Reuses the workspace
+// realpath-containment primitive — no new path-safety mechanism is introduced. `evidenceSchemaVersion`
+// stays "1" (additive manifest field consumed by callers).
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { assertContainedRealPath, resolveWithinWorkspace, } from "@oscharko-dev/keiko-workspace";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+import { assertValidRunId } from "./runid.js";
+import { EvidenceWriteError } from "./errors.js";
+const MAX_NAME_LENGTH = 128;
+// Validates a side-file basename. The set is intentionally narrower than runId's: a name segment
+// is a single non-empty path component with no separators, no leading dot, no `..`, length cap. No
+// regex — character-class check stays linear-time.
+function assertValidName(name) {
+    if (name.length === 0 || name.length > MAX_NAME_LENGTH) {
+        throw new EvidenceWriteError("side-file name length is invalid");
+    }
+    if (name.startsWith(".")) {
+        throw new EvidenceWriteError("side-file name must not start with a dot");
+    }
+    for (let i = 0; i < name.length; i += 1) {
+        if (!isAllowedNameChar(name.charCodeAt(i))) {
+            throw new EvidenceWriteError("side-file name contains a disallowed character");
+        }
+    }
+}
+function isAllowedNameChar(code) {
+    const isDigit = code >= 48 && code <= 57;
+    const isUpper = code >= 65 && code <= 90;
+    const isLower = code >= 97 && code <= 122;
+    const isPunct = code === 46 || code === 95 || code === 45;
+    return isDigit || isUpper || isLower || isPunct;
+}
+function ensureDir(absolute) {
+    try {
+        mkdirSync(absolute, { recursive: true });
+    }
+    catch (error) {
+        throw new EvidenceWriteError(`cannot create evidence subdirectory: ${error instanceof Error ? error.message : "unknown"}`);
+    }
+}
+function atomicWriteBytes(target, data, randomSuffix) {
+    const temp = `${target}.${randomSuffix()}.tmp`;
+    try {
+        // O_EXCL ("wx") refuses to open through a pre-planted symlink at the temp path. The randomUUID
+        // suffix never collides so "wx" never spuriously fails.
+        writeFileSync(temp, data, { flag: "wx" });
+        renameSync(temp, target);
+    }
+    catch (error) {
+        rmSync(temp, { force: true });
+        throw new EvidenceWriteError(`side-file write failed: ${error instanceof Error ? error.message : "unknown"}`);
+    }
+}
+// Writes a binary side-file under `<baseDir>/<runId>/<name>` atomically. Containment is enforced
+// by realpath-resolving the per-run directory after creation, then checking the final lexical path
+// against that real root via assertContainedRealPath. Returns the relative path to embed in the
+// manifest plus the SHA-256 of the raw bytes (tamper-evidence).
+export function writeSideFile(baseDir, runId, name, data, options = {}) {
+    assertValidRunId(runId);
+    assertValidName(name);
+    const fs = options.fs ?? nodeWorkspaceFs;
+    const randomSuffix = options.randomSuffix ?? randomUUID;
+    ensureDir(baseDir);
+    const runDir = join(baseDir, runId);
+    ensureDir(runDir);
+    const realRunDir = fs.realPath(runDir);
+    const lexicalTarget = resolveWithinWorkspace(realRunDir, name);
+    const absoluteTarget = assertContainedRealPath(fs, realRunDir, lexicalTarget, name);
+    const sha256 = createHash("sha256").update(data).digest("hex");
+    atomicWriteBytes(absoluteTarget, data, randomSuffix);
+    return {
+        relativePath: name,
+        sha256,
+        bytes: data.length,
+        absolutePath: absoluteTarget,
+    };
+}

package/node_modules/@oscharko-dev/keiko-evidence/dist/store.d.ts

@@ -0,0 +1,8 @@
+import { type WorkspaceFs } from "@oscharko-dev/keiko-workspace";
+export declare const DEFAULT_EVIDENCE_DIR = "./.keiko/evidence";
+export declare function resolveEvidenceDir(explicit: string | undefined, env: Readonly<Record<string, string | undefined>> | undefined): string;
+import type { EvidenceStore } from "@oscharko-dev/keiko-contracts";
+export type { EvidenceStore };
+export declare function createInMemoryEvidenceStore(): EvidenceStore;
+export declare function createNodeEvidenceStore(baseDir: string, fs?: WorkspaceFs, randomSuffix?: () => string): EvidenceStore;
+//# sourceMappingURL=store.d.ts.map

package/node_modules/@oscharko-dev/keiko-evidence/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAsBA,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,+BAA+B,CAAC;AAQvC,eAAO,MAAM,oBAAoB,sBAAsB,CAAC;AAKxD,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,GAAG,SAAS,GAC5D,MAAM,CAER;AAID,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,YAAY,EAAE,aAAa,EAAE,CAAC;AAI9B,wBAAgB,2BAA2B,IAAI,aAAa,CAsB3D;AAoKD,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,EAAE,GAAE,WAA6B,EACjC,YAAY,GAAE,MAAM,MAAmB,GACtC,aAAa,CAWf"}