@oscharko-dev/keiko-server 0.2.0

package/dist/editor/testGenerationRunner.js

@@ -0,0 +1,120 @@
+// Default candidate producer for editor-driven test generation (Issue #1202, ADR-0042 D7).
+//
+// Reuses the existing `unit-test-generation` workflow (`@oscharko-dev/keiko-workflows`) in DRY-RUN
+// (apply=false; the workflow fail-closes any patch write) to produce a reviewable candidate test patch,
+// then translates its proposed unified diff into the content-free wire patch. This is the WAVE-2
+// enablement seam: it is reached only when Gate B (KEIKO_EDITOR_TEST_GENERATION_EXECUTION) is set, which
+// only an enforced deny-by-default egress boundary justifies. When the route produces a candidate, it
+// immediately sends that candidate through the assured pre-filter before deciding whether the patch is
+// apply-ready (`assured`) or untrusted evidence (`unverified`); the seam is proven by tests.
+//
+// Dry-run generation is a governed model call that produces a diff — it does NOT execute the generated
+// tests (the workflow runs verification only in apply mode). The route owns the subsequent assured
+// pre-filter execution step, so this runner only reports that one candidate was generated.
+import { createHash } from "node:crypto";
+import { resolve } from "node:path";
+import { generateUnitTests, } from "@oscharko-dev/keiko-workflows";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+import { notRunTestGenerationFunnel, } from "@oscharko-dev/keiko-contracts";
+import { currentGatewayConfig } from "../deps.js";
+import { translateDiffToWirePatch } from "./testGenerationPatch.js";
+const GATEWAY_POLICY_VERSION = "editor-test-generation/1";
+const PATCH_ID_LENGTH = 32;
+function anchorPath(target) {
+    if (target.kind === "changed-file-set") {
+        // The parser guarantees a non-empty document set; `?? ""` only satisfies the index check.
+        return target.documents[0]?.path ?? "";
+    }
+    return target.document.path;
+}
+// Maps the governed editor target to the workflow's UnitTestTarget. The workflow supports file (with an
+// optional target function), module, and changed-file targets; a selection maps to its file, a symbol /
+// component maps to a file target function.
+function toUnitTestTarget(target) {
+    if (target.kind === "changed-file-set") {
+        return { kind: "changedFiles", filePaths: target.documents.map((document) => document.path) };
+    }
+    if (target.kind === "symbol") {
+        return { kind: "file", filePath: target.document.path, targetFunction: target.symbol.name };
+    }
+    if (target.kind === "frontend-component") {
+        return { kind: "file", filePath: target.document.path, targetFunction: target.componentName };
+    }
+    return { kind: "file", filePath: target.document.path };
+}
+function resolveModelId(deps) {
+    return currentGatewayConfig(deps)?.providers[0]?.modelId;
+}
+// A content-free, deterministic SHA-256 over length-prefixed parts (ids/paths only, never content).
+// Length-prefixing makes the encoding unambiguous, so distinct part lists can never collide.
+function contentFreeHash(parts) {
+    const hash = createHash("sha256");
+    for (const part of parts) {
+        hash.update(`${part.length.toString()}:${part}`);
+    }
+    return hash.digest("hex");
+}
+function originalReader(realRoot) {
+    return (relativePath) => {
+        const absolute = resolve(realRoot, relativePath);
+        try {
+            return nodeWorkspaceFs.exists(absolute) ? nodeWorkspaceFs.readFileUtf8(absolute) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+}
+// One generated candidate produced this round; the assured pre-filter (#1204/#1206) is `not-run`.
+function generatedFunnel() {
+    return { ...notRunTestGenerationFunnel(), candidatesGenerated: 1, candidatesSurfaced: 1 };
+}
+function toAssuredVerificationKind(verification) {
+    return verification === "vitest" || verification === "playwright" ? verification : undefined;
+}
+function unsupportedVerificationReason(verification) {
+    if (toAssuredVerificationKind(verification) !== undefined) {
+        return undefined;
+    }
+    return "The generated candidate uses a test runner that is not supported by the assured pre-filter. It is returned as unverified review evidence only.";
+}
+export const defaultTestGenerationRunner = async (args) => {
+    const modelId = resolveModelId(args.deps);
+    if (modelId === undefined) {
+        return undefined;
+    }
+    const model = args.deps.modelPortFactory(modelId);
+    if (model === undefined) {
+        return undefined;
+    }
+    const report = await generateUnitTests({
+        workspaceRoot: args.realRoot,
+        target: toUnitTestTarget(args.request.target),
+        apply: false,
+        modelId,
+    }, { model, signal: args.signal });
+    if (report.proposedDiff === undefined) {
+        return undefined;
+    }
+    const anchor = anchorPath(args.request.target);
+    const patchId = contentFreeHash([modelId, anchor, String(args.nowMs)]).slice(0, PATCH_ID_LENGTH);
+    const patch = translateDiffToWirePatch(report.proposedDiff, patchId, originalReader(args.realRoot));
+    if (patch === undefined) {
+        return undefined;
+    }
+    const verification = toAssuredVerificationKind(report.verification);
+    const reason = unsupportedVerificationReason(report.verification);
+    return {
+        patch,
+        provenance: {
+            modelId,
+            gatewayPolicyVersion: GATEWAY_POLICY_VERSION,
+            promptHash: contentFreeHash([modelId, anchor]),
+            producedAt: args.nowMs,
+        },
+        funnel: generatedFunnel(),
+        ...(verification === undefined ? {} : { verification }),
+        ...(reason === undefined ? {} : { unsupportedVerificationReason: reason }),
+        proposedDiff: report.proposedDiff,
+    };
+};

package/dist/editor/textOffsets.d.ts

@@ -0,0 +1,6 @@
+import type { LanguagePosition, LanguageRange } from "@oscharko-dev/keiko-contracts";
+export declare function computeLineStarts(text: string): readonly number[];
+export declare function positionToOffset(text: string, lineStarts: readonly number[], position: LanguagePosition): number;
+export declare function offsetToPosition(text: string, lineStarts: readonly number[], offset: number): LanguagePosition;
+export declare function spanToRange(text: string, lineStarts: readonly number[], start: number | undefined, length: number | undefined): LanguageRange;
+//# sourceMappingURL=textOffsets.d.ts.map

package/dist/editor/textOffsets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textOffsets.d.ts","sourceRoot":"","sources":["../../src/editor/textOffsets.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAOrF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAWjE;AA8BD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,QAAQ,EAAE,gBAAgB,GACzB,MAAM,CAKR;AAID,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,MAAM,EAAE,MAAM,GACb,gBAAgB,CAalB;AAID,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,aAAa,CAOf"}

package/dist/editor/textOffsets.js

@@ -0,0 +1,82 @@
+// Pure conversion between zero-based {line, character} positions (LSP 3.17) and absolute UTF-16
+// code-unit offsets in a source buffer (Issue #1198). Deterministic: it maps an editor position
+// onto the TypeScript offset model and maps analysis spans back to wire ranges. The TypeScript
+// language service speaks in offsets; the editor wire contract speaks in line/character.
+const LF = 0x0a;
+const CR = 0x0d;
+// The absolute offset at which each line begins. `lineStarts[0]` is always 0. Both LF and CRLF
+// terminate a line; a lone CR also starts a new line (old-mac line endings).
+export function computeLineStarts(text) {
+    const starts = [0];
+    for (let index = 0; index < text.length; index += 1) {
+        const code = text.charCodeAt(index);
+        if (code === LF) {
+            starts.push(index + 1);
+        }
+        else if (code === CR && text.charCodeAt(index + 1) !== LF) {
+            starts.push(index + 1);
+        }
+    }
+    return starts;
+}
+function clamp(value, min, max) {
+    if (value < min)
+        return min;
+    if (value > max)
+        return max;
+    return value;
+}
+// The offset just past the last content character of a line, excluding its terminator. Used to
+// clamp a character offset so it never lands inside a line break. Never precedes `lineStart`, so the
+// phantom empty line after a trailing newline maps to end-of-buffer rather than the prior line.
+function lineContentEnd(text, lineStarts, line) {
+    const lineStart = lineStarts[line] ?? 0;
+    const nextLineStart = line + 1 < lineStarts.length ? (lineStarts[line + 1] ?? text.length) : text.length;
+    let end = nextLineStart;
+    if (end > lineStart && text.charCodeAt(end - 1) === LF) {
+        end -= 1;
+        if (end > lineStart && text.charCodeAt(end - 1) === CR) {
+            end -= 1;
+        }
+    }
+    else if (end > lineStart && text.charCodeAt(end - 1) === CR) {
+        // Old-Mac, lone-CR line terminator: strip it so a character offset never lands on the CR.
+        end -= 1;
+    }
+    return end;
+}
+// Maps a zero-based {line, character} position to an absolute offset, clamping out-of-range input
+// into the buffer so a malformed editor position can never index outside the text.
+export function positionToOffset(text, lineStarts, position) {
+    const line = clamp(position.line, 0, lineStarts.length - 1);
+    const lineStart = lineStarts[line] ?? 0;
+    const contentEnd = lineContentEnd(text, lineStarts, line);
+    return clamp(lineStart + position.character, lineStart, contentEnd);
+}
+// Maps an absolute offset back to a zero-based {line, character} position via binary search over the
+// line-start table.
+export function offsetToPosition(text, lineStarts, offset) {
+    const bounded = clamp(offset, 0, text.length);
+    let low = 0;
+    let high = lineStarts.length - 1;
+    while (low < high) {
+        const mid = low + Math.ceil((high - low) / 2);
+        if ((lineStarts[mid] ?? 0) <= bounded) {
+            low = mid;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    return { line: low, character: bounded - (lineStarts[low] ?? 0) };
+}
+// Maps a TypeScript text span (start offset + length) to a wire range. A missing start (some global
+// diagnostics carry none) collapses to the buffer origin.
+export function spanToRange(text, lineStarts, start, length) {
+    const safeStart = start ?? 0;
+    const safeLength = length ?? 0;
+    return {
+        start: offsetToPosition(text, lineStarts, safeStart),
+        end: offsetToPosition(text, lineStarts, safeStart + safeLength),
+    };
+}

package/dist/editor/typescriptLanguageProvider.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageProvider } from "./languageProvider.js";
+export declare function createTypescriptLanguageProvider(): LanguageProvider;
+//# sourceMappingURL=typescriptLanguageProvider.d.ts.map

package/dist/editor/typescriptLanguageProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescriptLanguageProvider.d.ts","sourceRoot":"","sources":["../../src/editor/typescriptLanguageProvider.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAGV,gBAAgB,EAGjB,MAAM,uBAAuB,CAAC;AAqP/B,wBAAgB,gCAAgC,IAAI,gBAAgB,CAcnE"}

package/dist/editor/typescriptLanguageProvider.js

@@ -0,0 +1,217 @@
+// The first deterministic language provider (Issue #1198): TypeScript/JavaScript backed by the
+// TypeScript language service. Model-free and governed (ADR-0042 D4). It runs every query over the
+// in-memory overlay so diagnostics reflect unsaved edits, threads the deadline/abort cancellation
+// token into the service, and caps result counts so analysis stays bounded. A fresh language
+// service is created per request and disposed afterwards, keeping each call stateless and
+// deterministic.
+import ts from "typescript";
+import { MAX_LANGUAGE_FORMATTING_TAB_SIZE, } from "@oscharko-dev/keiko-contracts";
+import { createContainedLanguageServiceHost, } from "./languageServiceHost.js";
+import { computeLineStarts, positionToOffset, spanToRange } from "./textOffsets.js";
+const TS_LANGUAGES = [
+    "typescript",
+    "typescriptreact",
+    "javascript",
+    "javascriptreact",
+];
+const DESCRIPTOR = {
+    id: "typescript",
+    languages: TS_LANGUAGES,
+    operations: ["diagnostics", "completion", "hover", "symbols", "formatting"],
+    availability: "available",
+};
+const SEVERITY_BY_CATEGORY = {
+    [ts.DiagnosticCategory.Error]: "error",
+    [ts.DiagnosticCategory.Warning]: "warning",
+    [ts.DiagnosticCategory.Suggestion]: "hint",
+    [ts.DiagnosticCategory.Message]: "info",
+};
+// Map (not an object literal) so a TypeScript element kind whose string value is "constructor"
+// cannot collide with `Object.prototype.constructor`.
+const COMPLETION_KIND_BY_ELEMENT = new Map([
+    [ts.ScriptElementKind.functionElement, "function"],
+    [ts.ScriptElementKind.localFunctionElement, "function"],
+    [ts.ScriptElementKind.memberFunctionElement, "method"],
+    [ts.ScriptElementKind.memberVariableElement, "property"],
+    [ts.ScriptElementKind.memberGetAccessorElement, "property"],
+    [ts.ScriptElementKind.memberSetAccessorElement, "property"],
+    [ts.ScriptElementKind.classElement, "class"],
+    [ts.ScriptElementKind.interfaceElement, "interface"],
+    [ts.ScriptElementKind.enumElement, "enum"],
+    [ts.ScriptElementKind.enumMemberElement, "enum"],
+    [ts.ScriptElementKind.moduleElement, "module"],
+    [ts.ScriptElementKind.variableElement, "variable"],
+    [ts.ScriptElementKind.letElement, "variable"],
+    [ts.ScriptElementKind.constElement, "constant"],
+    [ts.ScriptElementKind.alias, "variable"],
+    [ts.ScriptElementKind.parameterElement, "variable"],
+    [ts.ScriptElementKind.typeParameterElement, "typeParameter"],
+    [ts.ScriptElementKind.keyword, "keyword"],
+    [ts.ScriptElementKind.constructorImplementationElement, "constructor"],
+    [ts.ScriptElementKind.typeElement, "interface"],
+]);
+const SYMBOL_KIND_BY_ELEMENT = new Map([
+    [ts.ScriptElementKind.moduleElement, "module"],
+    [ts.ScriptElementKind.classElement, "class"],
+    [ts.ScriptElementKind.interfaceElement, "interface"],
+    [ts.ScriptElementKind.enumElement, "enum"],
+    [ts.ScriptElementKind.enumMemberElement, "enumMember"],
+    [ts.ScriptElementKind.functionElement, "function"],
+    [ts.ScriptElementKind.localFunctionElement, "function"],
+    [ts.ScriptElementKind.memberFunctionElement, "method"],
+    [ts.ScriptElementKind.memberVariableElement, "property"],
+    [ts.ScriptElementKind.memberGetAccessorElement, "property"],
+    [ts.ScriptElementKind.memberSetAccessorElement, "property"],
+    [ts.ScriptElementKind.constructorImplementationElement, "constructor"],
+    [ts.ScriptElementKind.variableElement, "variable"],
+    [ts.ScriptElementKind.letElement, "variable"],
+    [ts.ScriptElementKind.constElement, "constant"],
+    [ts.ScriptElementKind.typeParameterElement, "typeParameter"],
+    [ts.ScriptElementKind.typeElement, "interface"],
+]);
+function completionKind(kind) {
+    return COMPLETION_KIND_BY_ELEMENT.get(kind) ?? "text";
+}
+function symbolKind(kind) {
+    return SYMBOL_KIND_BY_ELEMENT.get(kind) ?? "variable";
+}
+function withService(ctx, run) {
+    const hostOptions = {
+        fs: ctx.fs,
+        realRoot: ctx.root,
+        overlayPath: ctx.overlayPath,
+        overlayText: ctx.overlayText,
+        languageId: ctx.languageId,
+        cancellation: ctx.cancellation.hostToken(),
+        limits: ctx.limits,
+    };
+    const host = createContainedLanguageServiceHost(hostOptions);
+    const service = ts.createLanguageService(host, ts.createDocumentRegistry());
+    try {
+        return run(service);
+    }
+    finally {
+        service.dispose();
+    }
+}
+function buildDiagnostics(ctx, service) {
+    ctx.cancellation.throwIfCancellationRequested();
+    const syntactic = service.getSyntacticDiagnostics(ctx.overlayPath);
+    ctx.cancellation.throwIfCancellationRequested();
+    const semantic = service.getSemanticDiagnostics(ctx.overlayPath);
+    const lineStarts = computeLineStarts(ctx.overlayText);
+    const all = [...syntactic, ...semantic];
+    const capped = all.slice(0, ctx.limits.maxDiagnostics);
+    const diagnostics = capped.map((diagnostic) => {
+        const range = spanToRange(ctx.overlayText, lineStarts, diagnostic.start, diagnostic.length);
+        const severity = SEVERITY_BY_CATEGORY[diagnostic.category];
+        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+        return { range, severity, message, source: DESCRIPTOR.id, code: String(diagnostic.code) };
+    });
+    return { diagnostics, truncated: all.length > capped.length };
+}
+function buildCompletionItem(entry) {
+    const base = {
+        label: entry.name,
+        kind: completionKind(entry.kind),
+        sortText: entry.sortText,
+    };
+    return entry.insertText !== undefined ? { ...base, insertText: entry.insertText } : base;
+}
+function buildCompletions(ctx, service, position) {
+    ctx.cancellation.throwIfCancellationRequested();
+    const lineStarts = computeLineStarts(ctx.overlayText);
+    const offset = positionToOffset(ctx.overlayText, lineStarts, position);
+    const completions = service.getCompletionsAtPosition(ctx.overlayPath, offset, {
+        includeCompletionsForModuleExports: false,
+        includeCompletionsForImportStatements: false,
+        includeInsertTextCompletions: true,
+    });
+    if (completions === undefined) {
+        return { items: [], isIncomplete: false, truncated: false };
+    }
+    const capped = completions.entries.slice(0, ctx.limits.maxCompletionItems);
+    return {
+        items: capped.map(buildCompletionItem),
+        isIncomplete: completions.isIncomplete ?? false,
+        truncated: completions.entries.length > capped.length,
+    };
+}
+function buildHover(ctx, service, position) {
+    ctx.cancellation.throwIfCancellationRequested();
+    const lineStarts = computeLineStarts(ctx.overlayText);
+    const offset = positionToOffset(ctx.overlayText, lineStarts, position);
+    const info = service.getQuickInfoAtPosition(ctx.overlayPath, offset);
+    if (info === undefined) {
+        return { contents: null };
+    }
+    const display = ts.displayPartsToString(info.displayParts);
+    const documentation = ts.displayPartsToString(info.documentation);
+    const contents = documentation.length > 0 ? `${display}\n\n${documentation}` : display;
+    const range = spanToRange(ctx.overlayText, lineStarts, info.textSpan.start, info.textSpan.length);
+    return { contents: contents.length > 0 ? contents : null, range };
+}
+function flattenSymbols(node, containerName, lineStarts, text, out, limit) {
+    for (const child of node.childItems ?? []) {
+        if (out.length >= limit)
+            return;
+        const span = child.spans[0];
+        const range = spanToRange(text, lineStarts, span?.start, span?.length);
+        const symbol = {
+            name: child.text,
+            kind: symbolKind(child.kind),
+            range,
+            ...(containerName !== undefined ? { containerName } : {}),
+        };
+        out.push(symbol);
+        flattenSymbols(child, child.text, lineStarts, text, out, limit);
+    }
+}
+function buildSymbols(ctx, service) {
+    ctx.cancellation.throwIfCancellationRequested();
+    const tree = service.getNavigationTree(ctx.overlayPath);
+    const lineStarts = computeLineStarts(ctx.overlayText);
+    const out = [];
+    const limit = ctx.limits.maxSymbols;
+    flattenSymbols(tree, undefined, lineStarts, ctx.overlayText, out, limit + 1);
+    const truncated = out.length > limit;
+    return { symbols: truncated ? out.slice(0, limit) : out, truncated };
+}
+// Build the TypeScript formatter settings from the caller's preferences (Issue #1201). Starts from
+// the compiler's own defaults (consistent, deterministic whitespace rules) and overrides only the
+// indentation fields the editor supplies, so a buffer is reflowed to the active editor configuration
+// rather than an arbitrary one. The newline is pinned to "\n" so the result is stable across hosts.
+function buildFormatCodeSettings(options) {
+    const settings = { ...ts.getDefaultFormatCodeSettings("\n") };
+    if (options?.tabSize !== undefined) {
+        const tabSize = Math.min(Math.max(1, options.tabSize), MAX_LANGUAGE_FORMATTING_TAB_SIZE);
+        settings.tabSize = tabSize;
+        settings.indentSize = tabSize;
+    }
+    if (options?.insertSpaces !== undefined) {
+        settings.convertTabsToSpaces = options.insertSpaces;
+    }
+    return settings;
+}
+function buildFormatting(ctx, service, options) {
+    ctx.cancellation.throwIfCancellationRequested();
+    const changes = service.getFormattingEditsForDocument(ctx.overlayPath, buildFormatCodeSettings(options));
+    const lineStarts = computeLineStarts(ctx.overlayText);
+    const capped = changes.slice(0, ctx.limits.maxFormattingEdits);
+    const edits = capped.map((change) => ({
+        range: spanToRange(ctx.overlayText, lineStarts, change.span.start, change.span.length),
+        newText: change.newText,
+    }));
+    return { edits, truncated: changes.length > capped.length };
+}
+export function createTypescriptLanguageProvider() {
+    return {
+        descriptor: DESCRIPTOR,
+        supports: (languageId) => TS_LANGUAGES.includes(languageId),
+        getDiagnostics: (ctx) => withService(ctx, (svc) => buildDiagnostics(ctx, svc)),
+        getCompletions: (ctx, position) => withService(ctx, (svc) => buildCompletions(ctx, svc, position)),
+        getHover: (ctx, position) => withService(ctx, (svc) => buildHover(ctx, svc, position)),
+        getSymbols: (ctx) => withService(ctx, (svc) => buildSymbols(ctx, svc)),
+        getFormatting: (ctx, options) => withService(ctx, (svc) => buildFormatting(ctx, svc, options)),
+    };
+}

package/dist/evidence.d.ts

@@ -0,0 +1,28 @@
+import { type EvidenceReport, type EvidenceManifest } from "@oscharko-dev/keiko-evidence";
+import { type RunResult } from "@oscharko-dev/keiko-harness";
+import { type EnvSource } from "@oscharko-dev/keiko-model-gateway";
+import type { EvidenceStore } from "@oscharko-dev/keiko-evidence";
+import type { StreamEvent } from "./sink.js";
+import type { RunKind } from "./run-request.js";
+import type { RunStatus } from "./runs.js";
+type TerminalStatus = Exclude<RunStatus, "running">;
+export interface EvidencePersistContext {
+    readonly store: EvidenceStore;
+    readonly env: EnvSource;
+    readonly additionalSecrets?: readonly string[] | undefined;
+}
+export interface RunIdentity {
+    readonly runId: string;
+    readonly fingerprint: string;
+    readonly modelId: string;
+    readonly kind: RunKind;
+    readonly status: TerminalStatus;
+    readonly startedAt: number;
+    readonly finishedAt: number;
+    readonly workspaceRoot?: string | undefined;
+}
+export declare function persistWorkflowEvidence(identity: RunIdentity, report: unknown, events: readonly StreamEvent[], ctx: EvidencePersistContext, governedHandoff?: EvidenceManifest["governedHandoff"]): EvidenceReport;
+export declare function persistExplainEvidence(identity: RunIdentity, result: RunResult, ctx: EvidencePersistContext): EvidenceReport;
+export declare function persistVerifyEvidence(identity: RunIdentity, ctx: EvidencePersistContext, governedHandoff?: EvidenceManifest["governedHandoff"]): EvidenceReport;
+export {};
+//# sourceMappingURL=evidence.d.ts.map

package/dist/evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence.d.ts","sourceRoot":"","sources":["../src/evidence.ts"],"names":[],"mappings":"AAWA,OAAO,EAKL,KAAK,cAAc,EACnB,KAAK,gBAAgB,EAEtB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EAAmB,KAAK,SAAS,EAAiB,MAAM,6BAA6B,CAAC;AAC7F,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,KAAK,cAAc,GAAG,OAAO,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;AAEpD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;CAC5D;AAID,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7C;AAWD,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,WAAW,EACrB,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,GAAG,EAAE,sBAAsB,EAC3B,eAAe,CAAC,EAAE,gBAAgB,CAAC,iBAAiB,CAAC,GACpD,cAAc,CAiBhB;AAKD,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,WAAW,EACrB,MAAM,EAAE,SAAS,EACjB,GAAG,EAAE,sBAAsB,GAC1B,cAAc,CAMhB;AAYD,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,WAAW,EACrB,GAAG,EAAE,sBAAsB,EAC3B,eAAe,CAAC,EAAE,gBAAgB,CAAC,iBAAiB,CAAC,GACpD,cAAc,CAMhB"}

package/dist/evidence.js

@@ -0,0 +1,145 @@
+// Evidence persistence for UI-initiated runs (ADR-0011 AC5; #10 audit public API only). The Wave 2
+// BFF never persisted evidence, so UI runs (including cancellations) never reached the evidence
+// browser. This module folds a terminated run into a redacted EvidenceManifest and writes it through
+// the #10 EvidenceStore, composing the audit layer's PUBLIC API UNCHANGED (no frozen-core edit).
+//
+// The WORKFLOW manifest mapping now lives in the shared audit module `workflow-evidence.ts` (ADR-0012
+// C2), so the evaluation harness and this BFF build it from one implementation. This module keeps the
+// EXPLAIN-PLAN harness path (whose `usage` shape differs) local, and adapts the UI RunKind/RunStatus
+// to the shared module's narrow workflow types. Persistence errors surface to the run engine so the
+// final registry payload cannot silently omit required evidence.
+import { buildEvidenceReport, createAuditRedactor, EVIDENCE_SCHEMA_VERSION, persistWorkflowEvidence as persistWorkflowEvidenceCore, } from "@oscharko-dev/keiko-evidence";
+import { deepRedactStrings } from "@oscharko-dev/keiko-evidence";
+import { HARNESS_VERSION } from "@oscharko-dev/keiko-harness";
+import { resolveCostClass } from "@oscharko-dev/keiko-model-gateway";
+// Only the two model-driven workflow kinds map to the shared audit core; explain-plan and verify
+// follow their own manifest paths (different usage shape / no usage at all).
+function toWorkflowKind(kind) {
+    return kind === "bug-investigation" ? "bug-investigation" : "unit-tests";
+}
+// Persists a terminated WORKFLOW run (unit-tests / bug-investigation) via the shared audit core. The
+// UI run browser needs the review artifact after the in-memory run record is gone, so the diff is
+// included through the evidence core's explicit redacted-diff opt-in.
+export function persistWorkflowEvidence(identity, report, events, ctx, governedHandoff) {
+    return persistWorkflowEvidenceCore({
+        runId: identity.runId,
+        fingerprint: identity.fingerprint,
+        modelId: identity.modelId,
+        kind: toWorkflowKind(identity.kind),
+        status: identity.status,
+        startedAt: identity.startedAt,
+        finishedAt: identity.finishedAt,
+        ...(identity.workspaceRoot === undefined ? {} : { workspaceRoot: identity.workspaceRoot }),
+    }, report, events, { ...ctx, costClassResolver: resolveCostClass }, { governedHandoff, includeDiff: true });
+}
+// Persists a terminated EXPLAIN-PLAN harness run. The RunResult carries the raw harness events whose
+// `usage` shape the audit fold understands; the usage is folded directly so the explain path keeps a
+// single manifest-build path independent of the shared workflow core (which folds top-level fields).
+export function persistExplainEvidence(identity, result, ctx) {
+    const manifest = buildExplainManifest(identity, result);
+    const redactor = createAuditRedactor({ additionalSecrets: ctx.additionalSecrets ?? [] }, ctx.env);
+    const redacted = deepRedactStrings(manifest, redactor);
+    const location = ctx.store.put(redacted.run.runId, JSON.stringify(redacted));
+    return buildEvidenceReport(redacted, location);
+}
+const KIND_TO_TASK_TYPE = {
+    "unit-tests": "generate-unit-tests",
+    "bug-investigation": "investigate-bug",
+    "explain-plan": "explain-plan",
+    verify: "verify",
+};
+// Persists a terminated VERIFY run. Verify never calls a model, so usageTotals are all zero and
+// stateTransitions/toolCalls/commandExecutions stay empty (the verification orchestrator's own
+// audit summarisation lives in `@oscharko-dev/keiko-verification` and is out of scope for this leaf).
+export function persistVerifyEvidence(identity, ctx, governedHandoff) {
+    const manifest = buildVerifyManifest(identity, governedHandoff);
+    const redactor = createAuditRedactor({ additionalSecrets: ctx.additionalSecrets ?? [] }, ctx.env);
+    const redacted = deepRedactStrings(manifest, redactor);
+    const location = ctx.store.put(redacted.run.runId, JSON.stringify(redacted));
+    return buildEvidenceReport(redacted, location);
+}
+function buildVerifyManifest(identity, governedHandoff) {
+    const context = identity.workspaceRoot === undefined
+        ? undefined
+        : {
+            workspaceRoot: identity.workspaceRoot,
+            totalCandidates: 0,
+            usedBytes: 0,
+            budgetBytes: 0,
+            droppedForBudget: 0,
+            entries: [],
+        };
+    return {
+        evidenceSchemaVersion: EVIDENCE_SCHEMA_VERSION,
+        run: {
+            runId: identity.runId,
+            fingerprint: identity.fingerprint,
+            harnessVersion: HARNESS_VERSION,
+            taskType: KIND_TO_TASK_TYPE[identity.kind],
+            outcome: identity.status,
+            startedAt: identity.startedAt,
+            finishedAt: identity.finishedAt,
+            durationMs: Math.max(0, identity.finishedAt - identity.startedAt),
+        },
+        model: { modelId: identity.modelId, costClass: resolveCostClass(identity.modelId) },
+        usageTotals: { promptTokens: 0, completionTokens: 0, requestCount: 0, totalLatencyMs: 0 },
+        ...(context === undefined ? {} : { context }),
+        stateTransitions: [],
+        toolCalls: [],
+        commandExecutions: [],
+        verification: undefined,
+        patch: undefined,
+        failure: undefined,
+        ...(governedHandoff === undefined ? {} : { governedHandoff }),
+    };
+}
+function buildExplainManifest(identity, result) {
+    const context = identity.workspaceRoot === undefined
+        ? undefined
+        : {
+            workspaceRoot: identity.workspaceRoot,
+            totalCandidates: 0,
+            usedBytes: 0,
+            budgetBytes: 0,
+            droppedForBudget: 0,
+            entries: [],
+        };
+    return {
+        evidenceSchemaVersion: EVIDENCE_SCHEMA_VERSION,
+        run: {
+            runId: identity.runId,
+            fingerprint: identity.fingerprint,
+            harnessVersion: HARNESS_VERSION,
+            taskType: KIND_TO_TASK_TYPE[identity.kind],
+            outcome: identity.status,
+            startedAt: identity.startedAt,
+            finishedAt: identity.finishedAt,
+            durationMs: Math.max(0, identity.finishedAt - identity.startedAt),
+        },
+        model: { modelId: identity.modelId, costClass: resolveCostClass(identity.modelId) },
+        usageTotals: foldHarnessUsage(result.events),
+        ...(context === undefined ? {} : { context }),
+        stateTransitions: [],
+        toolCalls: [],
+        commandExecutions: [],
+        verification: undefined,
+        patch: undefined,
+        failure: undefined,
+    };
+}
+function foldHarnessUsage(events) {
+    let promptTokens = 0;
+    let completionTokens = 0;
+    let requestCount = 0;
+    let totalLatencyMs = 0;
+    for (const event of events) {
+        if (event.type !== "model:call:completed") {
+            continue;
+        }
+        promptTokens += event.usage.promptTokens;
+        completionTokens += event.usage.completionTokens;
+        totalLatencyMs += event.usage.latencyMs;
+        requestCount += 1;
+    }
+    return { promptTokens, completionTokens, requestCount, totalLatencyMs };
+}

package/dist/files-deny.d.ts

@@ -0,0 +1,3 @@
+export declare const DENIED_MESSAGE = "The requested path is excluded from the read surface.";
+export declare function pathIsDenied(relativePath: string): boolean;
+//# sourceMappingURL=files-deny.d.ts.map

package/dist/files-deny.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files-deny.d.ts","sourceRoot":"","sources":["../src/files-deny.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,cAAc,0DAA0D,CAAC;AAEtF,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAE1D"}

package/dist/files-deny.js

@@ -0,0 +1,12 @@
+// Deny-list wiring for the Files BFF (`/api/files/*`). Reuses
+// `src/workspace/ignore.ts` unchanged: `isDenied` is the always-on security
+// gate that filters secret/dep/build/vcs/log entries from both tree listings
+// and previews. See ADR-0016.
+import { isDenied } from "@oscharko-dev/keiko-workspace";
+// Generic, non-leaking deny message. NEVER include the requested path or the
+// matched pattern: the deny list is treated as a server-side safety invariant
+// the client must not be able to probe.
+export const DENIED_MESSAGE = "The requested path is excluded from the read surface.";
+export function pathIsDenied(relativePath) {
+    return isDenied(relativePath);
+}