@oscharko-dev/keiko-server 0.2.0

package/dist/editor/localKnowledgeRetrieval.js

@@ -0,0 +1,44 @@
+// Shared query-only Local Knowledge retrieval for the editor coding-context service (Issue #1211).
+// Both the context-pack provider and the /api/editor/local-knowledge/retrieve route run the same
+// governed four-step dance — resolve scope, check capsule ready-state, build the embedding adapter
+// (identity-consistency enforced), run retrieval WITHOUT answer generation — so it lives here once
+// rather than as a parallel implementation. Callers own the KnowledgeStore lifecycle and map the
+// discriminated outcome to their surface (omission vs RouteResult).
+import { runLocalKnowledgeRetrieval } from "@oscharko-dev/keiko-local-knowledge";
+import { createEmbeddingAdapter, scopeStateFailure, selectedCapsulesForScope, } from "../local-knowledge-grounded-qa.js";
+// Builds a typed Local Knowledge scope from plain string ids. Exactly one id must be present; the
+// connectedAtMs field is irrelevant to retrieval (it is a chat-binding timestamp) so it is zeroed.
+export function buildLocalKnowledgeScope(capsuleId, capsuleSetId) {
+    if ((capsuleId === undefined) === (capsuleSetId === undefined)) {
+        return undefined;
+    }
+    if (capsuleId !== undefined) {
+        return { kind: "capsule", capsuleId: capsuleId, connectedAtMs: 0 };
+    }
+    return { kind: "capsule-set", capsuleSetId: capsuleSetId, connectedAtMs: 0 };
+}
+export async function retrieveEditorLocalKnowledge(deps, store, scope, queryText, signal) {
+    const selected = selectedCapsulesForScope(scope, store);
+    if ("status" in selected) {
+        return { kind: "conflict", routeResult: selected };
+    }
+    const stateFailure = scopeStateFailure(selected);
+    if (stateFailure !== undefined) {
+        return { kind: "not-ready", reason: stateFailure.reason, message: stateFailure.message };
+    }
+    const adapter = createEmbeddingAdapter(deps, selected.capsules);
+    if ("status" in adapter) {
+        return { kind: "conflict", routeResult: adapter };
+    }
+    const retrieval = await runLocalKnowledgeRetrieval({ store, embeddingAdapter: adapter, signal }, {
+        text: queryText,
+        ...(scope.kind === "capsule" ? { capsuleId: scope.capsuleId } : {}),
+        ...(scope.kind === "capsule-set" ? { capsuleSetId: scope.capsuleSetId } : {}),
+    });
+    return {
+        kind: "ok",
+        references: retrieval.references,
+        noEvidence: retrieval.noEvidence,
+        reason: retrieval.reason,
+    };
+}

package/dist/editor/patchApplyEvidence.d.ts

@@ -0,0 +1,21 @@
+import type { EditorPatchApplyChangeCounts, EditorPatchApplyRejection, EditorPatchApplyStatus, EditorPatchApplyDecision, EditorPatchVerificationSummary, EvidenceStore } from "@oscharko-dev/keiko-contracts";
+import type { Redactor } from "../deps.js";
+export declare const PATCH_APPLY_EVIDENCE_SCHEMA_VERSION: "1";
+export interface PatchApplyEvidenceInput {
+    readonly patchId: string;
+    readonly decision: EditorPatchApplyDecision;
+    readonly status: EditorPatchApplyStatus;
+    readonly applied: boolean;
+    readonly counts?: EditorPatchApplyChangeCounts | undefined;
+    readonly rejections?: readonly EditorPatchApplyRejection[] | undefined;
+    readonly allowOverwrite: boolean;
+}
+export declare function recordPatchApplyEvidence(store: EvidenceStore, redactor: Redactor, input: PatchApplyEvidenceInput, emittedAtMs: number): string;
+export interface PatchVerificationEvidenceInput {
+    readonly patchId: string;
+    readonly rootRealPath: string;
+    readonly command: string;
+    readonly summary: EditorPatchVerificationSummary;
+}
+export declare function recordPatchVerificationEvidence(store: EvidenceStore, redactor: Redactor, input: PatchVerificationEvidenceInput, emittedAtMs: number): string;
+//# sourceMappingURL=patchApplyEvidence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"patchApplyEvidence.d.ts","sourceRoot":"","sources":["../../src/editor/patchApplyEvidence.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,4BAA4B,EAC5B,yBAAyB,EACzB,sBAAsB,EACtB,wBAAwB,EACxB,8BAA8B,EAC9B,aAAa,EACd,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,mCAAmC,EAAG,GAAY,CAAC;AAsBhE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,4BAA4B,GAAG,SAAS,CAAC;IAC3D,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,yBAAyB,EAAE,GAAG,SAAS,CAAC;IACvE,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;CAClC;AAID,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,uBAAuB,EAC9B,WAAW,EAAE,MAAM,GAClB,MAAM,CAuBR;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,8BAA8B,CAAC;CAClD;AAKD,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,8BAA8B,EACrC,WAAW,EAAE,MAAM,GAClB,MAAM,CA8BR"}

package/dist/editor/patchApplyEvidence.js

@@ -0,0 +1,87 @@
+// Content-free audit linkage for editor-driven patch apply (Issue #1204, ADR-0042 D6/D7, ADR-0043).
+// Records the three lifecycle phases distinctly — proposal, apply, and verification — tied together by
+// the shared, content-free `patchId` correlation (AC4). The proposal phase is recorded by the
+// test-generation evidence (Issue #1202); this module records the APPLY and VERIFICATION phases.
+//
+// Every record is content-free: it carries only enum literals, counts, a SHA-256 hash of the workspace
+// root, and the bounded-execution configuration (command label, timeout, env-allowlist size, network
+// status, secret-redaction status, pre/post-apply). It NEVER carries the patch text, a test log line, a
+// workspace path, or a secret. Each record uses its own `editorPatchApplySchemaVersion` key and omits
+// `evidenceSchemaVersion`, so the grounded / QI evidence reader skips it. Persistence failure never
+// fails the request.
+import { createHash } from "node:crypto";
+export const PATCH_APPLY_EVIDENCE_SCHEMA_VERSION = "1";
+// Deterministic, content-free run id derived from the patchId correlation, the phase, and the emission
+// time, so an auditor can chain proposal → apply → verification by the shared patchId.
+function patchApplyEvidenceRunId(patchId, phase, emittedAtMs) {
+    const material = [patchId, phase, String(emittedAtMs)].join("\n");
+    const digest = createHash("sha256").update(material).digest("hex").slice(0, 16);
+    return `editor-patch-${phase}-${digest}`;
+}
+// A SHA-256 hash of the canonical workspace root: a content-free pointer that identifies the root in
+// the audit trail without recording the path itself (AC13 "cwd/root").
+function rootHash(rootRealPath) {
+    return createHash("sha256").update(rootRealPath).digest("hex").slice(0, 16);
+}
+// Records the APPLY-phase evidence: the decision, the outcome status, content-free change counts, and the
+// rejection reasons (enums only — no paths). Returns the run id for the response evidence pointer.
+export function recordPatchApplyEvidence(store, redactor, input, emittedAtMs) {
+    const runId = patchApplyEvidenceRunId(input.patchId, "apply", emittedAtMs);
+    const manifest = {
+        editorPatchApplySchemaVersion: PATCH_APPLY_EVIDENCE_SCHEMA_VERSION,
+        runId,
+        phase: "apply",
+        patchId: input.patchId,
+        decision: input.decision,
+        status: input.status,
+        applied: input.applied,
+        allowOverwrite: input.allowOverwrite,
+        changedFiles: input.counts?.changedFiles ?? 0,
+        created: input.counts?.created ?? 0,
+        deleted: input.counts?.deleted ?? 0,
+        rejectionReasons: (input.rejections ?? []).map((rejection) => rejection.reason),
+        emittedAtMs,
+    };
+    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;
+}
+// Records the VERIFICATION-phase evidence. Per the Issue #1204 owner addendum, it states the command,
+// cwd/root (hashed), timeout, env allowlist, network status, secret-redaction status, and whether the
+// run was pre- or post-apply — all content-free.
+export function recordPatchVerificationEvidence(store, redactor, input, emittedAtMs) {
+    const runId = patchApplyEvidenceRunId(input.patchId, "verification", emittedAtMs);
+    const { summary } = input;
+    const manifest = {
+        editorPatchApplySchemaVersion: PATCH_APPLY_EVIDENCE_SCHEMA_VERSION,
+        runId,
+        phase: "verification",
+        patchId: input.patchId,
+        command: input.command,
+        rootHash: rootHash(input.rootRealPath),
+        outcome: summary.outcome,
+        networkStatus: summary.networkEnforced ? "enforced-none" : "inherited",
+        sandboxBackend: summary.sandboxBackend,
+        timeoutMs: summary.bounds.wallTimeMs,
+        maxOutputBytes: summary.bounds.maxOutputBytes,
+        envAllowlistCount: summary.bounds.envAllowlistCount,
+        secretsRedacted: summary.secretsRedacted,
+        preApply: summary.preApply,
+        stepCount: summary.stepCount,
+        passed: summary.passed,
+        failed: summary.failed,
+        durationMs: summary.durationMs,
+        emittedAtMs,
+    };
+    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/patchApplyRoutes.d.ts

@@ -0,0 +1,16 @@
+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 PostApplyVerificationPreflightPort, type PostApplyVerificationPort } from "./postApplyVerification.js";
+/** Injectable options for the route (tests supply a deterministic verification port and a fixed clock). */
+export interface EditorPatchApplyRouteOptions {
+    readonly verification?: PostApplyVerificationPort | undefined;
+    readonly verificationPreflight?: PostApplyVerificationPreflightPort | undefined;
+    readonly now?: (() => number) | undefined;
+}
+/** Whether editor-driven patch apply is surfaced by deployment policy (Gate A; default off). */
+export declare function isPatchApplyEnabledByPolicy(env: EnvSource | undefined): boolean;
+/** Whether post-apply verification runs (default on; off only when explicitly disabled by policy). */
+export declare function isPatchApplyVerificationEnabledByPolicy(env: EnvSource | undefined): boolean;
+export declare function handleEditorPatchApply(ctx: RouteContext, deps: UiHandlerDeps, options?: EditorPatchApplyRouteOptions): Promise<RouteResult>;
+//# sourceMappingURL=patchApplyRoutes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"patchApplyRoutes.d.ts","sourceRoot":"","sources":["../../src/editor/patchApplyRoutes.ts"],"names":[],"mappings":"AA0CA,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;AAIhD,OAAO,EAIL,KAAK,kCAAkC,EACvC,KAAK,yBAAyB,EAC/B,MAAM,4BAA4B,CAAC;AAsBpC,2GAA2G;AAC3G,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,YAAY,CAAC,EAAE,yBAAyB,GAAG,SAAS,CAAC;IAC9D,QAAQ,CAAC,qBAAqB,CAAC,EAAE,kCAAkC,GAAG,SAAS,CAAC;IAChF,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;CAC3C;AAMD,gGAAgG;AAChG,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAG/E;AAED,sGAAsG;AACtG,wBAAgB,uCAAuC,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAG3F;AA2SD,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,EACnB,OAAO,GAAE,4BAAiC,GACzC,OAAO,CAAC,WAAW,CAAC,CA8CtB"}

package/dist/editor/patchApplyRoutes.js

@@ -0,0 +1,307 @@
+// BFF route for governed, editor-driven patch APPLY + post-apply VERIFICATION (Issue #1204,
+// ADR-0042 D7, ADR-0043).
+//
+//   POST /api/editor/patch-apply — apply or reject a reviewed candidate patch, then (for an apply) run
+//                                  post-apply verification in an enforced, deny-by-default egress
+//                                  boundary and record proposal/apply/verification evidence.
+//
+// Wave-2 surface, shipped switched OFF (ADR-0042 D7): patch apply and the verification that follows it
+// EXECUTE untrusted, model-generated test code, so they are gated behind a default-off feature flag
+// enabled only once the enforced egress boundary (delivered by #1202, ADR-0043) is available. Off
+// (default) → `disabled`: no validation, write, or execution.
+//
+// Apply is fail-closed and explicit (AC1): a patch is applied only on an explicit `"apply"` decision and
+// only after it passes keiko-tools validation (scope containment AC2, per-hunk write-conflict detection,
+// size/line/file limits, and the no-silent-overwrite guardrail AC7/AC14). The diff is round-tripped from
+// the generation response and re-validated from scratch — the client's framing is never trusted. On a
+// failed verification a guarded restore proposal for explicit re-apply is surfaced; the server never
+// reverts silently (AC5).
+import { EDITOR_PATCH_APPLY_SCHEMA_VERSION, parseEditorPatchApplyRequest, } from "@oscharko-dev/keiko-contracts";
+import { applyPatch, buildRestorePatch, validatePatch, } from "@oscharko-dev/keiko-tools";
+import { detectWorkspaceAt } from "@oscharko-dev/keiko-workspace";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+import { errorBody } from "../routes.js";
+import { readJsonObject, resolveRoot, runFilesHandler } from "../files.js";
+import { clientAbortSignal } from "./languageRoutes.js";
+import { recordPatchApplyEvidence, recordPatchVerificationEvidence } from "./patchApplyEvidence.js";
+import { defaultPostApplyVerification, defaultPostApplyVerificationPreflight, skippedVerificationSummary, } from "./postApplyVerification.js";
+// A unified diff plus the apply envelope; bounded generously (validatePatch enforces the real patch
+// byte/line/file limits). 2 MiB of body accommodates a large multi-file candidate diff.
+const MAX_PATCH_APPLY_BODY_BYTES = 2 * 1_048_576;
+// Gate A — surfaces editor-driven patch apply at all (default OFF: a wave-2 feature shipped switched off).
+const PATCH_APPLY_POLICY_ENV = "KEIKO_EDITOR_PATCH_APPLY";
+// Post-apply verification runs by DEFAULT; a deployment disables it only by setting this to a disable
+// token (the other branch of AC: "skipped only when explicitly disabled by configured policy").
+const PATCH_APPLY_VERIFICATION_ENV = "KEIKO_EDITOR_PATCH_APPLY_VERIFICATION";
+const ENABLE_TOKENS = new Set(["1", "true", "on", "yes", "enabled"]);
+const DISABLE_TOKENS = new Set(["0", "false", "off", "no", "disabled"]);
+const DISABLED_REASON = "Editor-driven patch apply is disabled in this build. It is a wave-2 feature gated behind an enforced network-egress boundary (ADR-0042 D7).";
+const DISABLED_PATCH_ID = "disabled";
+const REJECTED_REASON = "The candidate patch was rejected; the workspace was not modified.";
+const FAILED_REASON = "The patch could not be applied. The editor is still usable.";
+const REVERT_REASON = "Post-apply verification failed. Review this revert proposal and apply it to restore the previous state; nothing was reverted automatically.";
+function envToken(value) {
+    return value === undefined ? undefined : value.trim().toLowerCase();
+}
+/** Whether editor-driven patch apply is surfaced by deployment policy (Gate A; default off). */
+export function isPatchApplyEnabledByPolicy(env) {
+    const token = envToken(env?.[PATCH_APPLY_POLICY_ENV]);
+    return token !== undefined && ENABLE_TOKENS.has(token);
+}
+/** Whether post-apply verification runs (default on; off only when explicitly disabled by policy). */
+export function isPatchApplyVerificationEnabledByPolicy(env) {
+    const token = envToken(env?.[PATCH_APPLY_VERIFICATION_ENV]);
+    return token === undefined || !DISABLE_TOKENS.has(token);
+}
+function isRouteResult(value) {
+    return typeof value === "object" && value !== null && "status" in value && "body" in value;
+}
+// ─── Response builders ───────────────────────────────────────────────────────────────────────────
+function disabledResponse() {
+    return {
+        schemaVersion: EDITOR_PATCH_APPLY_SCHEMA_VERSION,
+        status: "disabled",
+        patchId: DISABLED_PATCH_ID,
+        reason: DISABLED_REASON,
+    };
+}
+function rejectedResponse(patchId, evidence) {
+    return {
+        schemaVersion: EDITOR_PATCH_APPLY_SCHEMA_VERSION,
+        status: "rejected",
+        patchId,
+        reason: REJECTED_REASON,
+        evidence,
+    };
+}
+function conflictResponse(patchId, rejections, evidence) {
+    return {
+        schemaVersion: EDITOR_PATCH_APPLY_SCHEMA_VERSION,
+        status: "conflict",
+        patchId,
+        rejections,
+        evidence,
+    };
+}
+function failedResponse(patchId, evidence) {
+    return {
+        schemaVersion: EDITOR_PATCH_APPLY_SCHEMA_VERSION,
+        status: "failed",
+        patchId,
+        reason: FAILED_REASON,
+        evidence,
+    };
+}
+// ─── Rejection mapping (PatchValidation → content-free editor rejections) ──────────────────────────
+function mapRejectionReason(reason) {
+    if (reason.code === "path-unsafe" || reason.code === "path-denied") {
+        return "out-of-scope";
+    }
+    if (reason.message.includes("does not contain any file changes")) {
+        return "empty-patch";
+    }
+    return "invalid-patch";
+}
+function toRejections(validation) {
+    const rejections = [];
+    for (const reason of validation.reasons) {
+        rejections.push({
+            reason: mapRejectionReason(reason),
+            ...(reason.path === undefined ? {} : { path: reason.path }),
+            detail: reason.message,
+        });
+    }
+    for (const conflict of validation.conflicts) {
+        rejections.push({
+            reason: conflict.reason === "create target already exists" ? "would-overwrite" : "write-conflict",
+            path: conflict.path,
+            detail: conflict.reason,
+        });
+    }
+    return rejections;
+}
+function changeCounts(result) {
+    return {
+        changedFiles: result.changedFiles.length,
+        created: result.created.length,
+        deleted: result.deleted.length,
+    };
+}
+// The applied test files to verify: every changed file that was not deleted (deleted paths have no test
+// to run). The generated candidate creates/rewrites test files, so these are the targeted-test inputs.
+function verifiableFiles(result) {
+    const deleted = new Set(result.deleted);
+    return result.changedFiles.filter((path) => !deleted.has(path));
+}
+function verifiableValidationFiles(files) {
+    return files.filter((file) => file.kind !== "delete").map((file) => file.path);
+}
+function buildRevertProposal(request, restoreDiff, result) {
+    return {
+        patchId: request.patchId,
+        diff: restoreDiff,
+        changedFiles: result.changedFiles,
+        reason: REVERT_REASON,
+    };
+}
+async function runVerificationPhase(ctx, result) {
+    if (!isPatchApplyVerificationEnabledByPolicy(ctx.deps.env)) {
+        return { summary: skippedVerificationSummary(), command: "none" };
+    }
+    const port = ctx.options.verification ?? defaultPostApplyVerification;
+    return port({
+        realRoot: ctx.realRoot,
+        appliedTestFiles: verifiableFiles(result),
+        signal: ctx.signal,
+    });
+}
+function conflictOutcome(ctx, validation) {
+    const rejections = toRejections(validation);
+    const applyRunId = recordPatchApplyEvidence(ctx.deps.evidenceStore, ctx.deps.redactor, {
+        patchId: ctx.request.patchId,
+        decision: "apply",
+        status: "conflict",
+        applied: false,
+        rejections,
+        allowOverwrite: ctx.request.allowOverwrite === true,
+    }, ctx.nowMs);
+    return conflictResponse(ctx.request.patchId, rejections, { applyRunId });
+}
+function failureOutcome(ctx) {
+    const applyRunId = recordPatchApplyEvidence(ctx.deps.evidenceStore, ctx.deps.redactor, {
+        patchId: ctx.request.patchId,
+        decision: "apply",
+        status: "failed",
+        applied: false,
+        allowOverwrite: ctx.request.allowOverwrite === true,
+    }, ctx.nowMs);
+    return failedResponse(ctx.request.patchId, { applyRunId });
+}
+async function verificationPreflightOutcome(ctx, validation) {
+    if (!isPatchApplyVerificationEnabledByPolicy(ctx.deps.env)) {
+        return undefined;
+    }
+    const port = ctx.options.verificationPreflight ?? defaultPostApplyVerificationPreflight;
+    const preflight = await port({
+        realRoot: ctx.realRoot,
+        appliedTestFiles: verifiableValidationFiles(validation.files),
+    });
+    if (preflight.ok) {
+        return undefined;
+    }
+    const applyRunId = recordPatchApplyEvidence(ctx.deps.evidenceStore, ctx.deps.redactor, {
+        patchId: ctx.request.patchId,
+        decision: "apply",
+        status: "failed",
+        applied: false,
+        allowOverwrite: ctx.request.allowOverwrite === true,
+    }, ctx.nowMs);
+    const verificationRunId = recordPatchVerificationEvidence(ctx.deps.evidenceStore, ctx.deps.redactor, {
+        patchId: ctx.request.patchId,
+        rootRealPath: ctx.realRoot,
+        command: preflight.command,
+        summary: preflight.summary,
+    }, ctx.nowMs);
+    return failedResponse(ctx.request.patchId, { applyRunId, verificationRunId });
+}
+async function appliedOutcome(ctx, result, restoreDiff) {
+    const { request, deps, nowMs } = ctx;
+    const counts = changeCounts(result);
+    const applyRunId = recordPatchApplyEvidence(deps.evidenceStore, deps.redactor, {
+        patchId: request.patchId,
+        decision: "apply",
+        status: "applied",
+        applied: true,
+        counts,
+        allowOverwrite: request.allowOverwrite === true,
+    }, nowMs);
+    const { summary, command } = await runVerificationPhase(ctx, result);
+    const verificationRunId = recordPatchVerificationEvidence(deps.evidenceStore, deps.redactor, { patchId: request.patchId, rootRealPath: ctx.realRoot, command, summary }, nowMs);
+    const revertProposal = summary.outcome === "failed" && restoreDiff !== undefined
+        ? buildRevertProposal(request, restoreDiff, result)
+        : undefined;
+    return {
+        schemaVersion: EDITOR_PATCH_APPLY_SCHEMA_VERSION,
+        status: "applied",
+        patchId: request.patchId,
+        applied: counts,
+        verification: summary,
+        ...(revertProposal === undefined ? {} : { revertProposal }),
+        evidence: { applyRunId, verificationRunId },
+    };
+}
+async function handleApply(ctx) {
+    const allowOverwrite = ctx.request.allowOverwrite === true;
+    const workspace = detectWorkspaceAt(ctx.realRoot, nodeWorkspaceFs);
+    const validation = validatePatch(workspace, ctx.request.diff, { allowOverwrite });
+    if (!validation.ok) {
+        return conflictOutcome(ctx, validation);
+    }
+    const preflightResponse = await verificationPreflightOutcome(ctx, validation);
+    if (preflightResponse !== undefined) {
+        return preflightResponse;
+    }
+    let restoreDiff;
+    try {
+        restoreDiff = buildRestorePatch(workspace, validation.normalizedDiff ?? ctx.request.diff, {
+            allowOverwrite,
+        });
+    }
+    catch {
+        return failureOutcome(ctx);
+    }
+    let result;
+    try {
+        result = applyPatch(workspace, ctx.request.diff, {
+            applyEnabled: true,
+            signal: ctx.signal,
+            allowOverwrite,
+        });
+    }
+    catch {
+        return failureOutcome(ctx);
+    }
+    return appliedOutcome(ctx, result, restoreDiff);
+}
+export async function handleEditorPatchApply(ctx, deps, options = {}) {
+    // Gate A — default OFF: surface disabled without reading, parsing, validation, writes, or execution.
+    if (!isPatchApplyEnabledByPolicy(deps.env)) {
+        return { status: 200, body: deps.redactor(disabledResponse()) };
+    }
+    const body = await readJsonObject(ctx.req, MAX_PATCH_APPLY_BODY_BYTES);
+    if (isRouteResult(body)) {
+        return body;
+    }
+    const parsed = parseEditorPatchApplyRequest(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 nowMs = (options.now ?? Date.now)();
+        const signal = clientAbortSignal(ctx);
+        if (request.decision === "reject") {
+            const applyRunId = recordPatchApplyEvidence(deps.evidenceStore, deps.redactor, {
+                patchId: request.patchId,
+                decision: "reject",
+                status: "rejected",
+                applied: false,
+                allowOverwrite: request.allowOverwrite === true,
+            }, nowMs);
+            return {
+                status: 200,
+                body: deps.redactor(rejectedResponse(request.patchId, { applyRunId })),
+            };
+        }
+        const response = await handleApply({
+            request,
+            deps,
+            realRoot: root.realRoot,
+            signal,
+            nowMs,
+            options,
+        });
+        return { status: 200, body: deps.redactor(response) };
+    });
+}

package/dist/editor/postApplyVerification.d.ts

@@ -0,0 +1,42 @@
+import { type WorkspaceInfo } from "@oscharko-dev/keiko-workspace";
+import type { EditorPatchVerificationSummary } from "@oscharko-dev/keiko-contracts";
+export interface PostApplyVerificationArgs {
+    readonly realRoot: string;
+    readonly appliedTestFiles: readonly string[];
+    readonly signal: AbortSignal;
+}
+export interface PostApplyVerificationResult {
+    readonly summary: EditorPatchVerificationSummary;
+    readonly command: string;
+}
+/** Injectable post-apply verification port (tests supply a deterministic outcome). */
+export type PostApplyVerificationPort = (args: PostApplyVerificationArgs) => Promise<PostApplyVerificationResult>;
+export interface PostApplyVerificationPreflightArgs {
+    readonly realRoot: string;
+    readonly appliedTestFiles: readonly string[];
+}
+export type PostApplyVerificationPreflightResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly summary: EditorPatchVerificationSummary;
+    readonly command: string;
+};
+/** Injectable pre-write verification preflight port. */
+export type PostApplyVerificationPreflightPort = (args: PostApplyVerificationPreflightArgs) => Promise<PostApplyVerificationPreflightResult>;
+/** The summary for a post-apply verification that did not run (no resolvable targeted test). */
+export declare function notRunVerificationSummary(): EditorPatchVerificationSummary;
+/** The summary for a verification explicitly skipped by configured deployment policy. */
+export declare function skippedVerificationSummary(): EditorPatchVerificationSummary;
+/** The summary for a verification denied before patch application because egress cannot be enforced. */
+export declare function deniedVerificationSummary(): EditorPatchVerificationSummary;
+interface NetworkIsolationProbe {
+    readonly available: boolean;
+    readonly backend: string;
+}
+export declare function probeNetworkIsolation(cwd: string): NetworkIsolationProbe;
+export declare function requiresPostApplyVerificationPreflight(workspace: WorkspaceInfo, appliedTestFiles: readonly string[]): boolean;
+export declare const defaultPostApplyVerification: PostApplyVerificationPort;
+export declare const defaultPostApplyVerificationPreflight: PostApplyVerificationPreflightPort;
+export {};
+//# sourceMappingURL=postApplyVerification.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postApplyVerification.d.ts","sourceRoot":"","sources":["../../src/editor/postApplyVerification.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEtF,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,+BAA+B,CAAC;AAEpF,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC9B;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,OAAO,EAAE,8BAA8B,CAAC;IAEjD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,sFAAsF;AACtF,MAAM,MAAM,yBAAyB,GAAG,CACtC,IAAI,EAAE,yBAAyB,KAC5B,OAAO,CAAC,2BAA2B,CAAC,CAAC;AAE1C,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAED,MAAM,MAAM,oCAAoC,GAC5C;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAA;CAAE,GACrB;IACE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,OAAO,EAAE,8BAA8B,CAAC;IACjD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEN,wDAAwD;AACxD,MAAM,MAAM,kCAAkC,GAAG,CAC/C,IAAI,EAAE,kCAAkC,KACrC,OAAO,CAAC,oCAAoC,CAAC,CAAC;AAYnD,gGAAgG;AAChG,wBAAgB,yBAAyB,IAAI,8BAA8B,CAc1E;AAED,yFAAyF;AACzF,wBAAgB,0BAA0B,IAAI,8BAA8B,CAc3E;AAED,wGAAwG;AACxG,wBAAgB,yBAAyB,IAAI,8BAA8B,CAc1E;AAED,UAAU,qBAAqB;IAC7B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAUD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAUxE;AA+DD,wBAAgB,sCAAsC,CACpD,SAAS,EAAE,aAAa,EACxB,gBAAgB,EAAE,SAAS,MAAM,EAAE,GAClC,OAAO,CAKT;AAID,eAAO,MAAM,4BAA4B,EAAE,yBAiB1C,CAAC;AAIF,eAAO,MAAM,qCAAqC,EAAE,kCAUnD,CAAC"}