@oscharko-dev/keiko-server 0.2.0

package/dist/editor/postApplyVerification.js

@@ -0,0 +1,177 @@
+// Post-apply verification orchestration for editor-driven patch apply (Issue #1204, ADR-0042 D7,
+// ADR-0043). After a generated test patch is applied to the workspace, this re-confirms the candidate
+// IN PLACE — it runs the applied test file(s) as a targeted-test step through the keiko-verification
+// orchestrator, isolated by an ENFORCED, deny-by-default network-egress boundary (keiko-sandbox). It is
+// a confirmation that an already-assured candidate still holds (integration + write-conflict), NOT the
+// generation-time mutation/coverage gate (that stays in #1202/#1203).
+//
+// Egress is enforced fail-closed: the host is probed for a network-isolating sandbox backend, and the
+// orchestrator runs with "enforce-or-fail-closed". On a host with a backend the applied test executes
+// with network:"none" (attested); on a host without one the untrusted test code is NOT executed and the
+// outcome is `denied`. The applied test runs against the real workspace (filesystem inherited) because
+// the user explicitly applied the patch there; only egress — the data-exfiltration threat — is blocked.
+//
+// The node effects (sandbox probe, orchestrator run) sit behind an injectable port so the route's tests
+// drive deterministic outcomes without a sandbox backend.
+import { currentPlatform, planIsolatedRun, probeBackends } from "@oscharko-dev/keiko-sandbox";
+import { DEFAULT_SANDBOX_POLICY } from "@oscharko-dev/keiko-tools";
+import { DEFAULT_VERIFICATION_LIMITS, planDirectTargetedTests, runVerification, } from "@oscharko-dev/keiko-verification";
+import { detectWorkspaceAt } from "@oscharko-dev/keiko-workspace";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+const ENV_ALLOWLIST_COUNT = DEFAULT_SANDBOX_POLICY.envAllowlist.length;
+function bounds() {
+    return {
+        wallTimeMs: DEFAULT_VERIFICATION_LIMITS.wallTimeMs,
+        maxOutputBytes: DEFAULT_VERIFICATION_LIMITS.maxOutputBytes,
+        envAllowlistCount: ENV_ALLOWLIST_COUNT,
+    };
+}
+/** The summary for a post-apply verification that did not run (no resolvable targeted test). */
+export function notRunVerificationSummary() {
+    return {
+        outcome: "not-run",
+        networkEnforced: false,
+        sandboxBackend: "none",
+        stepCount: 0,
+        passed: 0,
+        failed: 0,
+        durationMs: 0,
+        bounds: bounds(),
+        preApply: false,
+        secretsRedacted: true,
+        detail: "No runnable test was resolved for the applied files; verification did not run.",
+    };
+}
+/** The summary for a verification explicitly skipped by configured deployment policy. */
+export function skippedVerificationSummary() {
+    return {
+        outcome: "skipped",
+        networkEnforced: false,
+        sandboxBackend: "none",
+        stepCount: 0,
+        passed: 0,
+        failed: 0,
+        durationMs: 0,
+        bounds: bounds(),
+        preApply: false,
+        secretsRedacted: true,
+        detail: "Post-apply verification was disabled by configured policy.",
+    };
+}
+/** The summary for a verification denied before patch application because egress cannot be enforced. */
+export function deniedVerificationSummary() {
+    return {
+        outcome: "denied",
+        networkEnforced: false,
+        sandboxBackend: "none",
+        stepCount: 0,
+        passed: 0,
+        failed: 0,
+        durationMs: 0,
+        bounds: bounds(),
+        preApply: true,
+        secretsRedacted: true,
+        detail: "No enforcing sandbox backend is available on this host; the patch was not applied.",
+    };
+}
+function isRunnableTestFramework(workspace) {
+    return workspace.testFramework === "vitest" || workspace.testFramework === "jest";
+}
+// Probes whether THIS host can enforce a deny-by-default network-egress boundary for a run rooted at
+// `cwd` (filesystem inherited — the applied test runs against the real workspace). No untrusted command
+// is spawned during the probe. A network:"none" run is enforceable on more backends (macOS seatbelt,
+// Linux bubblewrap/unshare) than the execution-root boundary the assured pre-filter requires.
+export function probeNetworkIsolation(cwd) {
+    const decision = planIsolatedRun({ command: "node", args: [], cwd, network: "none" }, probeBackends(), currentPlatform());
+    return {
+        available: decision.kind === "wrapped" && decision.attestation.networkEnforced,
+        backend: decision.attestation.backend,
+    };
+}
+// Statuses that count as an actual test failure. `denied` is deliberately excluded: a denied step was
+// never executed (egress could not be enforced), so it is surfaced via the distinct `denied` outcome,
+// not as a failed test.
+const FAILED_STATUSES = new Set([
+    "failed",
+    "timed-out",
+    "resource-exceeded",
+]);
+function networkEnforcedFromReport(results) {
+    return results.some((result) => result.appliedLimits.some((decision) => decision.dimension === "network" && decision.enforced));
+}
+// Maps the orchestrator report onto the content-free verification summary. A `denied` step (egress could
+// not be enforced) is surfaced distinctly from a `failed` step (the applied test did not pass).
+function toSummary(report, probe) {
+    const results = report.results;
+    const denied = results.some((result) => result.status === "denied");
+    const passed = results.filter((result) => result.status === "passed").length;
+    const failed = results.filter((result) => FAILED_STATUSES.has(result.status)).length;
+    const outcome = denied ? "denied" : report.overallStatus === "passed" ? "passed" : "failed";
+    return {
+        outcome,
+        networkEnforced: !denied && networkEnforcedFromReport(results),
+        sandboxBackend: denied ? "none" : probe.backend,
+        stepCount: results.length,
+        passed,
+        failed,
+        durationMs: report.durationMs,
+        bounds: bounds(),
+        preApply: false,
+        secretsRedacted: true,
+        detail: detailFor(outcome),
+    };
+}
+function detailFor(outcome) {
+    if (outcome === "denied") {
+        return "No enforcing sandbox backend is available on this host; the applied test was not executed.";
+    }
+    if (outcome === "failed") {
+        return "The applied test did not pass under enforced isolation. Review the change and the revert proposal.";
+    }
+    return "The applied test passed under enforced isolation.";
+}
+function verificationCommand(workspace) {
+    if (workspace.testFramework === "vitest") {
+        return "npx vitest run";
+    }
+    if (workspace.testFramework === "jest") {
+        return "npx jest";
+    }
+    return "none";
+}
+export function requiresPostApplyVerificationPreflight(workspace, appliedTestFiles) {
+    if (!isRunnableTestFramework(workspace)) {
+        return false;
+    }
+    return appliedTestFiles.length > 0;
+}
+// The route's default post-apply verification: plan a targeted-test step for the applied files, then run
+// it through the orchestrator with enforced, fail-closed egress isolation.
+export const defaultPostApplyVerification = async (args) => {
+    const workspace = detectWorkspaceAt(args.realRoot, nodeWorkspaceFs);
+    const steps = planDirectTargetedTests(workspace, args.appliedTestFiles, nodeWorkspaceFs);
+    if (steps.length === 0) {
+        return { summary: notRunVerificationSummary(), command: "none" };
+    }
+    const probe = probeNetworkIsolation(args.realRoot);
+    const report = await runVerification({ workspaceRoot: workspace.root, steps }, {
+        workspace,
+        signal: args.signal,
+        networkEnforcement: "enforce-or-fail-closed",
+        enforcedNetworkAvailable: probe.available,
+    });
+    return { summary: toSummary(report, probe), command: verificationCommand(workspace) };
+};
+// Preflight the same isolation control before any workspace write. If no targeted test would run, the
+// route may apply and report `not-run` post-apply; otherwise an unenforced host fails closed before write.
+export const defaultPostApplyVerificationPreflight = (args) => {
+    const workspace = detectWorkspaceAt(args.realRoot, nodeWorkspaceFs);
+    if (!requiresPostApplyVerificationPreflight(workspace, args.appliedTestFiles)) {
+        return Promise.resolve({ ok: true });
+    }
+    const probe = probeNetworkIsolation(args.realRoot);
+    if (probe.available) {
+        return Promise.resolve({ ok: true });
+    }
+    return Promise.resolve({ ok: false, summary: deniedVerificationSummary(), command: "none" });
+};

package/dist/editor/testGenerationEvidence.d.ts

@@ -0,0 +1,6 @@
+import type { EditorTestGenerationWireResponse, EvidenceStore } from "@oscharko-dev/keiko-contracts";
+import type { Redactor } from "../deps.js";
+export declare const TEST_GENERATION_EVIDENCE_SCHEMA_VERSION: "1";
+export declare function testGenerationEvidenceRunId(response: EditorTestGenerationWireResponse, emittedAtMs: number): string;
+export declare function recordTestGenerationEvidence(store: EvidenceStore, redactor: Redactor, response: EditorTestGenerationWireResponse, emittedAtMs: number): string;
+//# sourceMappingURL=testGenerationEvidence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"testGenerationEvidence.d.ts","sourceRoot":"","sources":["../../src/editor/testGenerationEvidence.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAGV,gCAAgC,EAChC,aAAa,EACd,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,uCAAuC,EAAG,GAAY,CAAC;AA+BpE,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,gCAAgC,EAC1C,WAAW,EAAE,MAAM,GAClB,MAAM,CAQR;AAaD,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,gCAAgC,EAC1C,WAAW,EAAE,MAAM,GAClB,MAAM,CAmBR"}

package/dist/editor/testGenerationEvidence.js

@@ -0,0 +1,72 @@
+// Content-free audit linkage for editor-driven test generation (Issue #1202, ADR-0042 D7). The
+// persisted record carries ONLY the content-free outcome — status, assurance, the assured pre-filter
+// funnel (counts + per-gate state), and the candidate file count plus model-provenance ids/hashes. It
+// NEVER carries the candidate patch text (`newText`), a prompt, a workspace root, or a secret. It uses
+// its own `editorTestGenerationSchemaVersion` key and omits `evidenceSchemaVersion`, so the grounded /
+// QI evidence reader skips it. Persistence failure never fails the request (mirrors the coding-context
+// and memory-audit handlers).
+import { createHash } from "node:crypto";
+import { CODING_CONTEXT_SOURCE_KINDS } from "@oscharko-dev/keiko-contracts";
+export const TEST_GENERATION_EVIDENCE_SCHEMA_VERSION = "1";
+// The content-free count of governed coding-context citations that contributed to the generated-test
+// context, keyed by source class — repository search, Local Knowledge, memory, Quality Intelligence,
+// connected/workflow/files context (Issue #1203 AC6). Counts only; never citation text or ids.
+function countBySourceKind(context) {
+    const counts = Object.fromEntries(CODING_CONTEXT_SOURCE_KINDS.map((kind) => [kind, 0]));
+    for (const entry of context.entries) {
+        counts[entry.sourceKind] += 1;
+    }
+    return counts;
+}
+// The content-free evidence-source provenance for a response: the contributing source-class counts and
+// the total citation count, present only when governed discovery ran (deferred/generated). AC6.
+function contextSourceFields(response) {
+    if (response.context === undefined) {
+        return {};
+    }
+    return {
+        contextCitationCount: response.context.entries.length,
+        contextSourceKinds: countBySourceKind(response.context),
+    };
+}
+// Deterministic, content-free run id derived from status + emission time + candidate count.
+export function testGenerationEvidenceRunId(response, emittedAtMs) {
+    const material = [
+        response.status,
+        String(emittedAtMs),
+        String(response.funnel.candidatesGenerated),
+    ].join("\n");
+    const digest = createHash("sha256").update(material).digest("hex").slice(0, 16);
+    return `editor-test-generation-${digest}`;
+}
+function provenanceFields(response) {
+    if (response.provenance === undefined) {
+        return {};
+    }
+    return {
+        modelId: response.provenance.modelId,
+        gatewayPolicyVersion: response.provenance.gatewayPolicyVersion,
+        promptHash: response.provenance.promptHash,
+    };
+}
+export function recordTestGenerationEvidence(store, redactor, response, emittedAtMs) {
+    const runId = testGenerationEvidenceRunId(response, emittedAtMs);
+    const manifest = {
+        editorTestGenerationSchemaVersion: TEST_GENERATION_EVIDENCE_SCHEMA_VERSION,
+        runId,
+        status: response.status,
+        emittedAtMs,
+        ...(response.assurance === undefined ? {} : { assurance: response.assurance }),
+        funnel: response.funnel,
+        fileCount: response.patch?.files.length ?? 0,
+        ...contextSourceFields(response),
+        ...provenanceFields(response),
+    };
+    try {
+        store.put(runId, JSON.stringify(redactor(manifest)));
+    }
+    catch {
+        // Audit persistence is best-effort; a write failure must never fail the user's request.
+    }
+    return runId;
+}

package/dist/editor/testGenerationPatch.d.ts

@@ -0,0 +1,10 @@
+import type { EditorTestGenerationWirePatch } from "@oscharko-dev/keiko-contracts";
+/** Resolves the current workspace content of a file, or undefined when it does not exist / is unreadable. */
+export type OriginalContentReader = (relativePath: string) => string | undefined;
+/**
+ * Parses the proposed unified diff and projects it to the wire patch. Returns undefined when the diff
+ * is unparseable or yields no renderable file change, so the caller can degrade to `deferred`/`failed`
+ * rather than surface an empty patch.
+ */
+export declare function translateDiffToWirePatch(diff: string, patchId: string, readOriginal: OriginalContentReader): EditorTestGenerationWirePatch | undefined;
+//# sourceMappingURL=testGenerationPatch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"testGenerationPatch.d.ts","sourceRoot":"","sources":["../../src/editor/testGenerationPatch.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAIV,6BAA6B,EAG9B,MAAM,+BAA+B,CAAC;AAGvC,6GAA6G;AAC7G,MAAM,MAAM,qBAAqB,GAAG,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;AA6CjF;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,qBAAqB,GAClC,6BAA6B,GAAG,SAAS,CAc3C"}

package/dist/editor/testGenerationPatch.js

@@ -0,0 +1,66 @@
+// Pure translation of a unit-test workflow's proposed unified diff into the editor test-generation
+// wire patch (Issue #1202, ADR-0042 D2/D7). The unified-diff parser and the hunk applier stay
+// server-side (ADR-0042 D2: keiko-tools owns diff parsing; the browser tier only renders the resulting
+// `{ range, newText }` edits). Pure over its inputs: the original-content lookup is injected so this is
+// fully unit-testable without the filesystem.
+import { computeFileContent, parseUnifiedDiff, PatchParseError } from "@oscharko-dev/keiko-tools";
+import { isDenied } from "@oscharko-dev/keiko-workspace";
+import { isValidScopePath } from "@oscharko-dev/keiko-contracts";
+const CHANGE_KIND = {
+    create: "added",
+    modify: "modified",
+    delete: "deleted",
+};
+// The end position of a full-file span: the last line index and its UTF-16 length. Empty content maps
+// to the zero position (an insertion at the start of the file).
+function endPosition(content) {
+    if (content === "") {
+        return { line: 0, character: 0 };
+    }
+    const lines = content.split("\n");
+    const lastIndex = lines.length - 1;
+    return { line: lastIndex, character: (lines[lastIndex] ?? "").length };
+}
+// Translates one parsed file change into a single full-file-replacement edit (range = the original
+// span; `newText` = the post-image). Returns undefined when the original is required but unavailable,
+// or when applying the hunks conflicts — the candidate then omits that file rather than corrupting it.
+function fileChangeToWire(change, readOriginal) {
+    if (!isValidScopePath(change.path, { mustBeRelative: true }) || isDenied(change.path)) {
+        return undefined;
+    }
+    const original = change.kind === "create" ? undefined : readOriginal(change.path);
+    if (change.kind !== "create" && original === undefined) {
+        return undefined;
+    }
+    const outcome = computeFileContent(change, original);
+    if (outcome.conflicts.length > 0) {
+        return undefined;
+    }
+    const end = original === undefined ? { line: 0, character: 0 } : endPosition(original);
+    const edit = {
+        range: { start: { line: 0, character: 0 }, end },
+        newText: outcome.content ?? "",
+    };
+    return { path: change.path, changeKind: CHANGE_KIND[change.kind], edits: [edit] };
+}
+/**
+ * Parses the proposed unified diff and projects it to the wire patch. Returns undefined when the diff
+ * is unparseable or yields no renderable file change, so the caller can degrade to `deferred`/`failed`
+ * rather than surface an empty patch.
+ */
+export function translateDiffToWirePatch(diff, patchId, readOriginal) {
+    let parsed;
+    try {
+        parsed = parseUnifiedDiff(diff);
+    }
+    catch (error) {
+        if (error instanceof PatchParseError) {
+            return undefined;
+        }
+        throw error;
+    }
+    const files = parsed.files
+        .map((change) => fileChangeToWire(change, readOriginal))
+        .filter((change) => change !== undefined);
+    return files.length === 0 ? undefined : { patchId, files };
+}

package/dist/editor/testGenerationRoutes.d.ts

@@ -0,0 +1,21 @@
+import type { EnvSource } from "@oscharko-dev/keiko-model-gateway";
+import { type RouteContext, type RouteResult } from "../routes.js";
+import type { UiHandlerDeps } from "../deps.js";
+import { type TestGenerationRunner } from "./testGenerationRunner.js";
+import { type AssuredPreFilterPort } from "./assuredPreFilterRunner.js";
+/** Injectable options for the route (tests supply a fake runner, pre-filter, and a fixed clock). */
+export interface EditorTestGenerationRouteOptions {
+    readonly runner?: TestGenerationRunner | undefined;
+    readonly preFilter?: AssuredPreFilterPort | undefined;
+    readonly now?: (() => number) | undefined;
+}
+/** Whether the test-generation feature is surfaced by deployment policy (Gate A; default off). */
+export declare function isTestGenerationEnabledByPolicy(env: EnvSource | undefined): boolean;
+/**
+ * Whether the route may produce a candidate (Gate B; default off). Requires the feature flag AND the
+ * explicit execution flag — the latter is the wave-2 enablement that only an enforced egress boundary
+ * justifies. No candidate (no model call) is produced until both are set.
+ */
+export declare function isTestGenerationExecutionEnabledByPolicy(env: EnvSource | undefined): boolean;
+export declare function handleEditorTestGeneration(ctx: RouteContext, deps: UiHandlerDeps, options?: EditorTestGenerationRouteOptions): Promise<RouteResult>;
+//# sourceMappingURL=testGenerationRoutes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"testGenerationRoutes.d.ts","sourceRoot":"","sources":["../../src/editor/testGenerationRoutes.ts"],"names":[],"mappings":"AAsCA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAAa,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAMhD,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAA2B,KAAK,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAoBjG,oGAAoG;AACpG,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,MAAM,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACnD,QAAQ,CAAC,SAAS,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACtD,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;CAC3C;AAMD,kGAAkG;AAClG,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAEnF;AAED;;;;GAIG;AACH,wBAAgB,wCAAwC,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAI5F;AA2ND,wBAAsB,0BAA0B,CAC9C,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,EACnB,OAAO,GAAE,gCAAqC,GAC7C,OAAO,CAAC,WAAW,CAAC,CAuCtB"}

package/dist/editor/testGenerationRoutes.js

@@ -0,0 +1,254 @@
+// BFF route for governed, editor-driven unit-test generation (Issue #1202, ADR-0042 D7).
+//
+//   POST /api/editor/test-generation — assemble governed coding context for an editor target and,
+//                                      when enabled, produce a reviewable candidate test patch.
+//
+// Wave-2 surface, shipped switched OFF (ADR-0042 D7). Editor-driven test generation, execution, and
+// verification execute untrusted, model-generated code through an assured pre-filter and are deferred
+// behind a default-off feature flag enabled only once a deny-by-default network-egress boundary is
+// enforced and proven by an automated test. The route therefore exposes two independent gates, both
+// default-off:
+//
+//   Gate A — KEIKO_EDITOR_TEST_GENERATION           — surfaces the feature at all. Off (default) →
+//            `disabled`: no retrieval, no model, no execution. This is the v1 behaviour.
+//   Gate B — KEIKO_EDITOR_TEST_GENERATION_EXECUTION — permits producing a candidate (a governed model
+//            call) once the enforced egress boundary is available. Off (default) → `deferred`: the
+//            route still runs governed discovery (#1211, `purpose: "test-generation"`) for provenance
+//            but makes NO model call and produces no candidate. No v1 flow executes model-generated
+//            code (the assured pre-filter that EXECUTES candidates is shared with #1204/#1206 and stays
+//            `not-run`; a candidate this route surfaces can only ever be `unverified`).
+//
+// Containment reuses the files routes' realpath resolution; the response is redacted (D9) and
+// content-free apart from the reviewable patch `newText`. The browser never reaches a model directly.
+import { CODING_CONTEXT_BUDGETS, CODING_CONTEXT_SCHEMA_VERSION, EDITOR_TEST_GENERATION_SCHEMA_VERSION, isValidScopePath, notRunTestGenerationFunnel, parseEditorTestGenerationRequest, toCodingContextWirePack, } from "@oscharko-dev/keiko-contracts";
+import { errorBody } from "../routes.js";
+import { readJsonObject, resolveRoot, runFilesHandler } from "../files.js";
+import { assembleCodingContext } from "./codingContext.js";
+import { recordCodingContextEvidence } from "./codingContextEvidence.js";
+import { clientAbortSignal, resolveOverlayPath } from "./languageRoutes.js";
+import { recordTestGenerationEvidence } from "./testGenerationEvidence.js";
+import { defaultTestGenerationRunner, } from "./testGenerationRunner.js";
+import { defaultAssuredPreFilter } from "./assuredPreFilterRunner.js";
+// The overlay buffer(s) may be up to the document-size cap; allow 64 KiB of JSON on top, doubled to
+// accommodate a small changed-file set.
+const MAX_TEST_GENERATION_BODY_BYTES = 2 * (1_048_576 + 64 * 1024);
+const MAX_CHANGED_SET_DOCUMENTS = 32;
+// Gate A — surfaces the feature at all (default OFF: this is a wave-2 feature shipped switched off).
+const TEST_GENERATION_POLICY_ENV = "KEIKO_EDITOR_TEST_GENERATION";
+// Gate B — permits producing a candidate once the enforced egress boundary is available (default OFF).
+const TEST_GENERATION_EXECUTION_ENV = "KEIKO_EDITOR_TEST_GENERATION_EXECUTION";
+const ENABLE_TOKENS = new Set(["1", "true", "on", "yes", "enabled"]);
+// Content-free, static explanations (never a prompt, model output, or secret).
+const DISABLED_REASON = "Editor-driven test generation is disabled in this build. It is a wave-2 feature gated behind an enforced network-egress boundary (ADR-0042 D7).";
+const DEFERRED_REASON = "Editor-driven test generation is enabled, but the assured pre-filter requires an enforced, deny-by-default network-egress boundary that is not yet available. No tests were generated or executed.";
+const FAILED_REASON = "Test generation could not be completed. The editor is still usable.";
+function envFlagEnabled(value) {
+    return value !== undefined && ENABLE_TOKENS.has(value.trim().toLowerCase());
+}
+/** Whether the test-generation feature is surfaced by deployment policy (Gate A; default off). */
+export function isTestGenerationEnabledByPolicy(env) {
+    return envFlagEnabled(env?.[TEST_GENERATION_POLICY_ENV]);
+}
+/**
+ * Whether the route may produce a candidate (Gate B; default off). Requires the feature flag AND the
+ * explicit execution flag — the latter is the wave-2 enablement that only an enforced egress boundary
+ * justifies. No candidate (no model call) is produced until both are set.
+ */
+export function isTestGenerationExecutionEnabledByPolicy(env) {
+    return (isTestGenerationEnabledByPolicy(env) && envFlagEnabled(env?.[TEST_GENERATION_EXECUTION_ENV]));
+}
+function isRouteResult(value) {
+    return typeof value === "object" && value !== null && "status" in value && "body" in value;
+}
+function disabledResponse() {
+    return {
+        schemaVersion: EDITOR_TEST_GENERATION_SCHEMA_VERSION,
+        status: "disabled",
+        reason: DISABLED_REASON,
+        funnel: notRunTestGenerationFunnel(),
+    };
+}
+function deferredResponse(context) {
+    return {
+        schemaVersion: EDITOR_TEST_GENERATION_SCHEMA_VERSION,
+        status: "deferred",
+        reason: DEFERRED_REASON,
+        funnel: notRunTestGenerationFunnel(),
+        context,
+    };
+}
+function failedResponse(context) {
+    return {
+        schemaVersion: EDITOR_TEST_GENERATION_SCHEMA_VERSION,
+        status: "failed",
+        reason: FAILED_REASON,
+        funnel: notRunTestGenerationFunnel(),
+        context,
+    };
+}
+function unsupportedVerificationResponse(context, produced) {
+    return {
+        schemaVersion: EDITOR_TEST_GENERATION_SCHEMA_VERSION,
+        status: "generated",
+        assurance: "unverified",
+        funnel: produced.funnel,
+        context,
+        patch: produced.patch,
+        provenance: produced.provenance,
+        reason: produced.unsupportedVerificationReason ??
+            "The generated candidate cannot run through a supported assured pre-filter and is unverified review evidence only.",
+    };
+}
+// ─── Target coordinates ──────────────────────────────────────────────────────────────────────────
+function targetDocumentPaths(target) {
+    return target.kind === "changed-file-set"
+        ? target.documents.map((document) => document.path)
+        : [target.document.path];
+}
+function anchorDocumentPath(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;
+}
+function targetSymbolName(target) {
+    return target.kind === "symbol" ? target.symbol.name : undefined;
+}
+function changedFilePaths(target) {
+    return target.kind === "changed-file-set" ? target.documents.map((d) => d.path) : undefined;
+}
+// Validates the shape + containment of every document path the target references. Returns a 400/403
+// RouteResult on the first failure, or undefined when every path is a contained, workspace-relative path.
+function validateTargetContainment(realRoot, target) {
+    if (target.kind === "changed-file-set" && target.documents.length > MAX_CHANGED_SET_DOCUMENTS) {
+        return {
+            status: 400,
+            body: errorBody("INVALID_REQUEST", `target.documents must contain at most ${MAX_CHANGED_SET_DOCUMENTS.toString()} documents.`),
+        };
+    }
+    for (const path of targetDocumentPaths(target)) {
+        if (!isValidScopePath(path, { mustBeRelative: true })) {
+            return {
+                status: 400,
+                body: errorBody("INVALID_REQUEST", `target document path is not workspace-relative: ${path}`),
+            };
+        }
+        // Throws FilesError on escape/denied (handled by runFilesHandler).
+        resolveOverlayPath(realRoot, path);
+    }
+    return undefined;
+}
+// ─── Governed discovery (#1211) ────────────────────────────────────────────────────────────────────
+function contextBudgetBytes(request) {
+    return Math.min(CODING_CONTEXT_BUDGETS["test-generation"].budgetBytes, Math.max(0, Math.trunc(request.contextBudgetBytes)));
+}
+function buildDiscoveryRequest(request) {
+    const target = request.target;
+    return {
+        schemaVersion: CODING_CONTEXT_SCHEMA_VERSION,
+        purpose: "test-generation",
+        documentPath: anchorDocumentPath(target),
+        symbol: targetSymbolName(target) ?? request.context?.symbol,
+        queryText: request.context?.queryText,
+        changedFiles: changedFilePaths(target) ?? request.context?.changedFiles,
+        capsuleId: request.context?.capsuleId,
+        capsuleSetId: request.context?.capsuleSetId,
+    };
+}
+// Runs the existing governed retrieval substrate (#1211) for related-file/test discovery — repository
+// search plus, when a capsule/connector is selected and policy-allowed, Local Knowledge and memory —
+// rather than a new editor-only collector. Records content-free evidence and returns the wire pack.
+async function assembleDiscoveryContext(request, deps, realRoot, signal, nowMs, allowEmbeddingProviders) {
+    const pack = await assembleCodingContext(buildDiscoveryRequest(request), {
+        deps,
+        realRoot,
+        signal,
+        nowMs,
+        budgetBytes: contextBudgetBytes(request),
+        allowEmbeddingProviders,
+    });
+    const wire = toCodingContextWirePack(pack);
+    recordCodingContextEvidence(deps.evidenceStore, deps.redactor, wire, nowMs);
+    return { pack, wire };
+}
+// Produces the candidate outcome once the feature is enabled. Gate B off → `deferred` with NO model
+// call. Gate B on (wave 2) → the injectable runner produces a candidate, which the assured pre-filter
+// then EXECUTES in an enforced-egress disposable root: it is surfaced as `assured` only when it builds,
+// passes, is stable, increases coverage, and kills enough mutants; otherwise it is `unverified`
+// (untrusted evidence only — including the fail-closed path when egress cannot be enforced). The patch
+// is always returned for review; assurance tells the editor whether it is apply-ready.
+async function produceOutcome(ctx, discovery) {
+    if (!isTestGenerationExecutionEnabledByPolicy(ctx.deps.env)) {
+        return deferredResponse(discovery.wire);
+    }
+    const runner = ctx.options.runner ?? defaultTestGenerationRunner;
+    try {
+        const produced = await runner({
+            request: ctx.request,
+            deps: ctx.deps,
+            realRoot: ctx.realRoot,
+            signal: ctx.signal,
+            nowMs: ctx.nowMs,
+            contextPack: discovery.pack,
+        });
+        if (produced === undefined) {
+            return deferredResponse(discovery.wire);
+        }
+        if (produced.verification === undefined) {
+            return unsupportedVerificationResponse(discovery.wire, produced);
+        }
+        const preFilter = ctx.options.preFilter ?? defaultAssuredPreFilter;
+        const assured = await preFilter({
+            patch: produced.patch,
+            request: ctx.request,
+            realRoot: ctx.realRoot,
+            signal: ctx.signal,
+            verification: produced.verification,
+        });
+        return {
+            schemaVersion: EDITOR_TEST_GENERATION_SCHEMA_VERSION,
+            status: "generated",
+            assurance: assured.assurance,
+            funnel: assured.funnel,
+            context: discovery.wire,
+            patch: produced.patch,
+            provenance: produced.provenance,
+            applyableDiff: produced.proposedDiff,
+            ...(assured.rejectionReason === undefined ? {} : { reason: assured.rejectionReason }),
+        };
+    }
+    catch {
+        return failedResponse(discovery.wire);
+    }
+}
+export async function handleEditorTestGeneration(ctx, deps, options = {}) {
+    // Gate A — default OFF: the feature is switched off, so no request-body parsing, retrieval, model, or
+    // execution runs. This avoids serializing/parsing the full editor buffer for a disabled wave-2 feature.
+    if (!isTestGenerationEnabledByPolicy(deps.env)) {
+        return { status: 200, body: deps.redactor(disabledResponse()) };
+    }
+    const body = await readJsonObject(ctx.req, MAX_TEST_GENERATION_BODY_BYTES);
+    if (isRouteResult(body)) {
+        return body;
+    }
+    const parsed = parseEditorTestGenerationRequest(body);
+    if (!parsed.ok) {
+        return { status: 400, body: errorBody("INVALID_REQUEST", parsed.errors.join("; ")) };
+    }
+    const request = parsed.value;
+    return runFilesHandler(async () => {
+        const root = await resolveRoot(deps.store, request.root, deps.redactor);
+        const containment = validateTargetContainment(root.realRoot, request.target);
+        if (containment !== undefined) {
+            return containment;
+        }
+        const nowMs = (options.now ?? Date.now)();
+        const signal = clientAbortSignal(ctx);
+        const executionEnabled = isTestGenerationExecutionEnabledByPolicy(deps.env);
+        const discovery = await assembleDiscoveryContext(request, deps, root.realRoot, signal, nowMs, executionEnabled);
+        const outcome = await produceOutcome({ request, deps, realRoot: root.realRoot, signal, nowMs, options }, discovery);
+        recordTestGenerationEvidence(deps.evidenceStore, deps.redactor, outcome, nowMs);
+        return { status: 200, body: deps.redactor(outcome) };
+    });
+}

package/dist/editor/testGenerationRunner.d.ts

@@ -0,0 +1,23 @@
+import { type CodingContextPack, type EditorTestGenerationFunnel, type EditorTestGenerationWirePatch, type EditorTestGenerationWireProvenance, type EditorTestGenerationWireRequest } from "@oscharko-dev/keiko-contracts";
+import { type UiHandlerDeps } from "../deps.js";
+import type { AssuredVerificationKind } from "./assuredPreFilterRunner.js";
+export interface TestGenerationRunnerArgs {
+    readonly request: EditorTestGenerationWireRequest;
+    readonly deps: UiHandlerDeps;
+    readonly realRoot: string;
+    readonly signal: AbortSignal;
+    readonly nowMs: number;
+    readonly contextPack: CodingContextPack;
+}
+export interface TestGenerationRunResult {
+    readonly patch: EditorTestGenerationWirePatch;
+    readonly provenance: EditorTestGenerationWireProvenance;
+    readonly funnel: EditorTestGenerationFunnel;
+    readonly verification?: AssuredVerificationKind | undefined;
+    readonly unsupportedVerificationReason?: string | undefined;
+    readonly proposedDiff: string;
+}
+/** Injectable candidate producer. Returns undefined when no candidate could be produced (→ deferred). */
+export type TestGenerationRunner = (args: TestGenerationRunnerArgs) => Promise<TestGenerationRunResult | undefined>;
+export declare const defaultTestGenerationRunner: TestGenerationRunner;
+//# sourceMappingURL=testGenerationRunner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"testGenerationRunner.d.ts","sourceRoot":"","sources":["../../src/editor/testGenerationRunner.ts"],"names":[],"mappings":"AAsBA,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,0BAA0B,EAC/B,KAAK,6BAA6B,EAClC,KAAK,kCAAkC,EACvC,KAAK,+BAA+B,EAErC,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAwB,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAEtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAK3E,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,OAAO,EAAE,+BAA+B,CAAC;IAClD,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAGvB,QAAQ,CAAC,WAAW,EAAE,iBAAiB,CAAC;CACzC;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,KAAK,EAAE,6BAA6B,CAAC;IAC9C,QAAQ,CAAC,UAAU,EAAE,kCAAkC,CAAC;IACxD,QAAQ,CAAC,MAAM,EAAE,0BAA0B,CAAC;IAK5C,QAAQ,CAAC,YAAY,CAAC,EAAE,uBAAuB,GAAG,SAAS,CAAC;IAC5D,QAAQ,CAAC,6BAA6B,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAG5D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,yGAAyG;AACzG,MAAM,MAAM,oBAAoB,GAAG,CACjC,IAAI,EAAE,wBAAwB,KAC3B,OAAO,CAAC,uBAAuB,GAAG,SAAS,CAAC,CAAC;AAuElD,eAAO,MAAM,2BAA2B,EAAE,oBA8CzC,CAAC"}