@oscharko-dev/keiko-server 0.2.0

package/dist/editor/contextRoutes.js

@@ -0,0 +1,411 @@
+// BFF routes for governed coding-context retrieval (Issue #1211, ADR-0042 D6). Three routes:
+//   POST /api/editor/context                  — assemble a bounded, redacted coding-context pack for
+//                                                an editor-originated request and return the CONTENT-
+//                                                FREE wire pack (citations + tier + accounting) plus an
+//                                                audit-linkage run id. Excerpt text never leaves the
+//                                                process.
+//   POST /api/editor/repo-search              — governed lexical repo search returning EvidenceAtom[]
+//                                                (stableId + provenance, content-free) under the same
+//                                                deny/realpath/size governance as the files routes.
+//   POST /api/editor/local-knowledge/retrieve — query-only Local Knowledge retrieval returning
+//                                                references/citations only (NO LLM answer).
+// Workspace-root containment reuses the files routes' realpath + deny-list resolution; responses are
+// redacted (D9). The browser never gains direct retrieval, embedding, or model access.
+import { isAbsolute, resolve } from "node:path";
+import { CODING_CONTEXT_SCHEMA_VERSION, isValidScopePath, toCodingContextWirePack, validateCodingContextRequest, } from "@oscharko-dev/keiko-contracts";
+import { DEFAULT_SEARCH_LIMITS, containedRealPathInfo, detectWorkspaceAt, findFiles, readExcerpt, RepoSearchInvalidQueryError, RepoSearchInvalidRangeError, RepoSearchUnsupportedFileError, searchText, } from "@oscharko-dev/keiko-workspace";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+import { assembleGroundedContext } from "@oscharko-dev/keiko-local-knowledge";
+import { errorBody } from "../routes.js";
+import { FilesError, readJsonObject, resolveRoot, runFilesHandler } from "../files.js";
+import { DENIED_MESSAGE, pathIsDenied } from "../files-deny.js";
+import { openStoreForDeps } from "../local-knowledge-grounded-qa.js";
+import { assembleCodingContext } from "./codingContext.js";
+import { recordCodingContextEvidence } from "./codingContextEvidence.js";
+import { buildLocalKnowledgeScope, retrieveEditorLocalKnowledge, } from "./localKnowledgeRetrieval.js";
+const MAX_CONTEXT_BODY_BYTES = 64 * 1024;
+const REPO_SEARCH_MAX_RESULTS = 50;
+const MAX_CONTEXT_CHANGED_FILES = 64;
+const MAX_REPO_SEARCH_PATHS = 64;
+const DEFAULT_REPO_SEARCH_EXCERPT_BYTES = 8 * 1024;
+const MAX_REPO_SEARCH_EXCERPT_BYTES = 32 * 1024;
+function isRouteResult(value) {
+    return typeof value === "object" && value !== null && "status" in value && "body" in value;
+}
+function rootFieldOf(body) {
+    return typeof body.root === "string" ? body.root : null;
+}
+function invalidRequest(message) {
+    return { status: 400, body: errorBody("INVALID_REQUEST", message) };
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function dedupePaths(paths) {
+    return [...new Set(paths)];
+}
+function invalidPathShape(field, path) {
+    return invalidRequest(`${field} contains an invalid workspace-relative path: ${path}`);
+}
+function validateRelativePathShape(field, path) {
+    if (!isValidScopePath(path, { mustBeRelative: true })) {
+        return invalidPathShape(field, path);
+    }
+    return undefined;
+}
+function dedupeAndCapPathList(field, paths, maxCount) {
+    const deduped = dedupePaths(paths);
+    if (deduped.length > maxCount) {
+        return invalidRequest(`${field} must contain at most ${maxCount.toString()} paths.`);
+    }
+    return deduped;
+}
+function assertContained(realRoot, relativePath) {
+    if (isAbsolute(relativePath) || pathIsDenied(relativePath)) {
+        throw new FilesError(403, "DENIED", DENIED_MESSAGE);
+    }
+    try {
+        containedRealPathInfo(nodeWorkspaceFs, realRoot, resolve(realRoot, relativePath));
+    }
+    catch {
+        throw new FilesError(403, "DENIED", DENIED_MESSAGE);
+    }
+}
+function clientAbortSignal(ctx) {
+    const controller = new AbortController();
+    ctx.req.on("close", () => {
+        controller.abort();
+    });
+    if (typeof ctx.res.on === "function") {
+        ctx.res.on("close", () => {
+            if (!ctx.res.writableEnded) {
+                controller.abort();
+            }
+        });
+    }
+    return controller.signal;
+}
+function buildInternalRequest(body) {
+    return {
+        schemaVersion: CODING_CONTEXT_SCHEMA_VERSION,
+        purpose: body.purpose,
+        documentPath: body.documentPath,
+        symbol: typeof body.symbol === "string" ? body.symbol : undefined,
+        queryText: typeof body.queryText === "string" ? body.queryText : undefined,
+        changedFiles: Array.isArray(body.changedFiles) ? body.changedFiles : undefined,
+        capsuleId: typeof body.capsuleId === "string" ? body.capsuleId : undefined,
+        capsuleSetId: typeof body.capsuleSetId === "string" ? body.capsuleSetId : undefined,
+    };
+}
+function sanitizeCodingContextRequest(request) {
+    if (request.capsuleId !== undefined && request.capsuleSetId !== undefined) {
+        return invalidRequest("At most one of capsuleId or capsuleSetId may be provided.");
+    }
+    const changedFiles = dedupeAndCapPathList("changedFiles", request.changedFiles ?? [], MAX_CONTEXT_CHANGED_FILES);
+    if (isRouteResult(changedFiles)) {
+        return changedFiles;
+    }
+    return {
+        ...request,
+        changedFiles: changedFiles.length > 0 ? changedFiles : undefined,
+    };
+}
+// ─── POST /api/editor/context ─────────────────────────────────────────────────────
+export async function handleEditorContext(ctx, deps) {
+    const body = await readJsonObject(ctx.req, MAX_CONTEXT_BODY_BYTES);
+    if (isRouteResult(body)) {
+        return body;
+    }
+    const validation = validateCodingContextRequest(body);
+    if (!validation.ok) {
+        return { status: 400, body: errorBody("INVALID_REQUEST", validation.reasons.join("; ")) };
+    }
+    const rootInput = rootFieldOf(body);
+    return runFilesHandler(async () => {
+        const root = await resolveRoot(deps.store, rootInput, deps.redactor);
+        const request = sanitizeCodingContextRequest(buildInternalRequest(body));
+        if (isRouteResult(request)) {
+            return request;
+        }
+        assertContained(root.realRoot, request.documentPath);
+        const invalidDocument = validateRelativePathShape("documentPath", request.documentPath);
+        if (invalidDocument !== undefined) {
+            return invalidDocument;
+        }
+        for (const changed of request.changedFiles ?? []) {
+            assertContained(root.realRoot, changed);
+            const invalidChanged = validateRelativePathShape("changedFiles", changed);
+            if (invalidChanged !== undefined) {
+                return invalidChanged;
+            }
+        }
+        const nowMs = Date.now();
+        const pack = await assembleCodingContext(request, {
+            deps,
+            realRoot: root.realRoot,
+            signal: clientAbortSignal(ctx),
+            nowMs,
+        });
+        const wire = toCodingContextWirePack(pack);
+        const evidenceRunId = recordCodingContextEvidence(deps.evidenceStore, deps.redactor, wire, nowMs);
+        return { status: 200, body: deps.redactor({ pack: wire, evidenceRunId }) };
+    });
+}
+function clampMaxResults(value) {
+    const raw = typeof value === "number" ? value : REPO_SEARCH_MAX_RESULTS;
+    return Math.max(1, Math.min(REPO_SEARCH_MAX_RESULTS, Math.trunc(raw)));
+}
+function clampMaxBytes(value) {
+    const raw = typeof value === "number" ? value : DEFAULT_REPO_SEARCH_EXCERPT_BYTES;
+    return Math.max(0, Math.min(MAX_REPO_SEARCH_EXCERPT_BYTES, Math.trunc(raw)));
+}
+function parsePositiveInteger(value, field) {
+    if (!Number.isInteger(value) || typeof value !== "number" || value < 1) {
+        return invalidRequest(`${field} must be a positive integer.`);
+    }
+    return value;
+}
+function parseRepoSearchOperation(value) {
+    if (value === undefined || value === "searchText") {
+        return "searchText";
+    }
+    if (value === "findFiles" || value === "readExcerpt") {
+        return value;
+    }
+    return invalidRequest("operation must be searchText, findFiles, or readExcerpt.");
+}
+function parseRepoSearchBase(body) {
+    if (body.symbol !== undefined && typeof body.symbol !== "string") {
+        return invalidRequest("symbol must be a string when provided.");
+    }
+    if (body.paths !== undefined && !isStringArray(body.paths)) {
+        return invalidRequest("paths must be an array of strings.");
+    }
+    const paths = dedupeAndCapPathList("paths", isStringArray(body.paths) ? body.paths : [], MAX_REPO_SEARCH_PATHS);
+    if (isRouteResult(paths)) {
+        return paths;
+    }
+    return {
+        root: rootFieldOf(body),
+        symbol: typeof body.symbol === "string" ? body.symbol : undefined,
+        paths,
+    };
+}
+function parseRepoSearchQueryInput(operation, body, base) {
+    if (typeof body.queryText !== "string" || body.queryText.trim().length === 0) {
+        return invalidRequest("queryText must be a non-empty string.");
+    }
+    return {
+        ...base,
+        operation,
+        queryText: body.queryText,
+        maxResults: clampMaxResults(body.maxResults),
+    };
+}
+function parseRepoSearchExcerptInput(body, base) {
+    if (typeof body.scopePath !== "string" || body.scopePath.trim().length === 0) {
+        return invalidRequest("scopePath must be a non-empty string.");
+    }
+    const startLine = parsePositiveInteger(body.startLine, "startLine");
+    if (isRouteResult(startLine)) {
+        return startLine;
+    }
+    const endLine = parsePositiveInteger(body.endLine, "endLine");
+    if (isRouteResult(endLine)) {
+        return endLine;
+    }
+    if (endLine < startLine) {
+        return invalidRequest("endLine must be greater than or equal to startLine.");
+    }
+    return {
+        ...base,
+        operation: "readExcerpt",
+        queryText: typeof body.queryText === "string" ? body.queryText : undefined,
+        maxResults: clampMaxResults(body.maxResults),
+        scopePath: body.scopePath,
+        startLine,
+        endLine,
+        maxBytes: clampMaxBytes(body.maxBytes),
+    };
+}
+function parseRepoSearchInput(body) {
+    const operation = parseRepoSearchOperation(body.operation);
+    if (isRouteResult(operation)) {
+        return operation;
+    }
+    const base = parseRepoSearchBase(body);
+    if (isRouteResult(base)) {
+        return base;
+    }
+    if (operation === "readExcerpt") {
+        return parseRepoSearchExcerptInput(body, base);
+    }
+    return parseRepoSearchQueryInput(operation, body, base);
+}
+function repoSearchErrorResult(error) {
+    if (error instanceof RepoSearchInvalidQueryError || error instanceof RepoSearchInvalidRangeError) {
+        return invalidRequest(error.message);
+    }
+    if (error instanceof RepoSearchUnsupportedFileError) {
+        return { status: 400, body: errorBody("UNSUPPORTED_FILE", error.message) };
+    }
+    return undefined;
+}
+function validateRepoSearchPaths(realRoot, input) {
+    for (const path of input.paths) {
+        assertContained(realRoot, path);
+        const invalid = validateRelativePathShape("paths", path);
+        if (invalid !== undefined) {
+            return invalid;
+        }
+    }
+    if (input.operation === "readExcerpt") {
+        assertContained(realRoot, input.scopePath);
+        return validateRelativePathShape("scopePath", input.scopePath);
+    }
+    return undefined;
+}
+function buildRepoSearchScope(realRoot, input) {
+    return {
+        workspace: detectWorkspaceAt(realRoot, nodeWorkspaceFs),
+        scopeId: "editor-repo-search",
+        relativePaths: input.paths,
+    };
+}
+function buildRepoSearchQuery(input, nowMs) {
+    return {
+        kind: input.operation === "findFiles"
+            ? "file-pattern"
+            : input.symbol !== undefined
+                ? "exact-symbol"
+                : "natural-language",
+        text: input.operation === "findFiles" ? input.queryText : input.symbol ?? input.queryText,
+        caseSensitive: false,
+        maxResults: input.maxResults,
+        emittedAtMs: nowMs,
+    };
+}
+async function runReadExcerptOperation(deps, scope, input, signal) {
+    const result = await readExcerpt(scope, {
+        scopePath: input.scopePath,
+        startLine: input.startLine,
+        endLine: input.endLine,
+        maxBytes: input.maxBytes,
+    }, { signal });
+    return {
+        status: 200,
+        body: deps.redactor({
+            atom: result.atom,
+            atoms: [result.atom],
+            truncated: result.truncated,
+            byteCount: new TextEncoder().encode(result.content).length,
+        }),
+    };
+}
+async function runQueryOperation(deps, scope, input, signal) {
+    const query = buildRepoSearchQuery(input, Date.now());
+    const result = input.operation === "findFiles"
+        ? await findFiles(scope, query, DEFAULT_SEARCH_LIMITS, { signal })
+        : await searchText(scope, query, DEFAULT_SEARCH_LIMITS, { signal });
+    return {
+        status: 200,
+        body: deps.redactor({
+            atoms: result.atoms,
+            truncated: result.truncated,
+            filesScanned: result.filesScanned,
+        }),
+    };
+}
+async function runRepoSearchOperation(deps, scope, input, signal) {
+    try {
+        return input.operation === "readExcerpt"
+            ? await runReadExcerptOperation(deps, scope, input, signal)
+            : await runQueryOperation(deps, scope, input, signal);
+    }
+    catch (error) {
+        const routeError = repoSearchErrorResult(error);
+        if (routeError !== undefined) {
+            return routeError;
+        }
+        throw error;
+    }
+}
+export async function handleEditorRepoSearch(ctx, deps) {
+    const body = await readJsonObject(ctx.req, MAX_CONTEXT_BODY_BYTES);
+    if (isRouteResult(body)) {
+        return body;
+    }
+    const input = parseRepoSearchInput(body);
+    if (isRouteResult(input)) {
+        return input;
+    }
+    return runFilesHandler(async () => {
+        const root = await resolveRoot(deps.store, input.root, deps.redactor);
+        const invalid = validateRepoSearchPaths(root.realRoot, input);
+        if (invalid !== undefined) {
+            return invalid;
+        }
+        return await runRepoSearchOperation(deps, buildRepoSearchScope(root.realRoot, input), input, clientAbortSignal(ctx));
+    });
+}
+function parseLocalKnowledgeRetrieveInput(body) {
+    if (typeof body.queryText !== "string" || body.queryText.trim().length === 0) {
+        return invalidRequest("queryText must be a non-empty string.");
+    }
+    const capsuleId = typeof body.capsuleId === "string" ? body.capsuleId : undefined;
+    const capsuleSetId = typeof body.capsuleSetId === "string" ? body.capsuleSetId : undefined;
+    if ((capsuleId === undefined) === (capsuleSetId === undefined)) {
+        return invalidRequest("Exactly one of capsuleId or capsuleSetId is required.");
+    }
+    return { queryText: body.queryText, capsuleId, capsuleSetId };
+}
+async function localKnowledgeRetrieveResponse(deps, store, input, signal) {
+    const scope = buildLocalKnowledgeScope(input.capsuleId, input.capsuleSetId);
+    if (scope === undefined) {
+        return invalidRequest("Exactly one of capsuleId or capsuleSetId is required.");
+    }
+    const outcome = await retrieveEditorLocalKnowledge(deps, store, scope, input.queryText, signal);
+    if (outcome.kind === "conflict") {
+        return outcome.routeResult;
+    }
+    if (outcome.kind === "not-ready") {
+        return {
+            status: 409,
+            body: errorBody("LOCAL_KNOWLEDGE_CONFLICT", String(deps.redactor(outcome.message))),
+        };
+    }
+    return {
+        status: 200,
+        body: deps.redactor({
+            pack: assembleGroundedContext(outcome.references),
+            noEvidence: outcome.noEvidence,
+            ...(outcome.reason !== undefined ? { reason: outcome.reason } : {}),
+        }),
+    };
+}
+export async function handleEditorLocalKnowledgeRetrieve(ctx, deps) {
+    const body = await readJsonObject(ctx.req, MAX_CONTEXT_BODY_BYTES);
+    if (isRouteResult(body)) {
+        return body;
+    }
+    const input = parseLocalKnowledgeRetrieveInput(body);
+    if (isRouteResult(input)) {
+        return input;
+    }
+    let env;
+    try {
+        env = openStoreForDeps(deps);
+    }
+    catch {
+        return {
+            status: 503,
+            body: errorBody("LOCAL_KNOWLEDGE_UNAVAILABLE", "Local knowledge storage is unavailable."),
+        };
+    }
+    try {
+        return await localKnowledgeRetrieveResponse(deps, env.store, input, clientAbortSignal(ctx));
+    }
+    finally {
+        env.close();
+    }
+}

package/dist/editor/disposableAssuredExecution.d.ts

@@ -0,0 +1,22 @@
+import { type AssuredPreFilterConfig, type AssuredPreFilterOutcome } from "./assuredPreFilter.js";
+import { type SandboxedCommand, type SandboxedRunResult } from "./assuredGateRunner.js";
+export declare function sandboxEnforcesAssuredIsolation(cwd: string): boolean;
+export interface DisposableExecutionPorts {
+    readonly enforced: boolean;
+    readonly makeRoot: () => Promise<string>;
+    readonly measureBaseline: (root: string) => Promise<void>;
+    readonly applyCandidate: (root: string) => Promise<void>;
+    readonly run: (root: string, cmd: SandboxedCommand) => Promise<SandboxedRunResult>;
+    readonly readReport: (root: string, relativePath: string) => unknown;
+    readonly dispose: (root: string) => Promise<void>;
+    readonly buildCommand: SandboxedCommand;
+    readonly testCommand: SandboxedCommand;
+    readonly coverageCommand: SandboxedCommand;
+    readonly mutationCommand: SandboxedCommand;
+    readonly baselineCoverageReportPath: string;
+    readonly patchedCoverageReportPath: string;
+    readonly mutationReportPath: string;
+    readonly targetCoverageKeys: readonly string[];
+}
+export declare function runDisposableAssuredPreFilter(ports: DisposableExecutionPorts, config?: AssuredPreFilterConfig): Promise<AssuredPreFilterOutcome>;
+//# sourceMappingURL=disposableAssuredExecution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"disposableAssuredExecution.d.ts","sourceRoot":"","sources":["../../src/editor/disposableAssuredExecution.ts"],"names":[],"mappings":"AAcA,OAAO,EAIL,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC7B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACxB,MAAM,wBAAwB,CAAC;AAIhC,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAWpE;AAUD,MAAM,WAAW,wBAAwB;IAEvC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAE3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAEzC,QAAQ,CAAC,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1D,QAAQ,CAAC,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzD,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAEnF,QAAQ,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC;IAErE,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;IACxC,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC;IACvC,QAAQ,CAAC,eAAe,EAAE,gBAAgB,CAAC;IAC3C,QAAQ,CAAC,eAAe,EAAE,gBAAgB,CAAC;IAC3C,QAAQ,CAAC,0BAA0B,EAAE,MAAM,CAAC;IAC5C,QAAQ,CAAC,yBAAyB,EAAE,MAAM,CAAC;IAC3C,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;CAChD;AAED,wBAAsB,6BAA6B,CACjD,KAAK,EAAE,wBAAwB,EAC/B,MAAM,GAAE,sBAA0D,GACjE,OAAO,CAAC,uBAAuB,CAAC,CA0BlC"}

package/dist/editor/disposableAssuredExecution.js

@@ -0,0 +1,57 @@
+// Disposable-execution composition for the assured pre-filter (Issue #1202 wave-2; ADR-0043).
+//
+// Determines whether THIS host can enforce a deny-by-default egress boundary (keiko-sandbox) and, when
+// it can, runs the assured pre-filter against a disposable execution root: a throwaway copy of the
+// target project where the candidate is applied, the gates run through the enforced sandboxed command
+// boundary, and which is always disposed — the user's workspace is never written. When the host cannot
+// enforce egress the pre-filter fails closed: the candidate is reported as untrusted evidence only and
+// is never `assured` (owner decision on #1202).
+//
+// The lifecycle is expressed over injectable ports so the composition (copy -> baseline -> apply ->
+// gates -> dispose, with dispose guaranteed) is unit-tested with fakes; the node ports that perform the
+// real filesystem copy and sandboxed command runs are assembled in assuredPreFilterRunner.ts.
+import { currentPlatform, planIsolatedRun, probeBackends } from "@oscharko-dev/keiko-sandbox";
+import { DEFAULT_ASSURED_PRE_FILTER_CONFIG, runAssuredPreFilter, } from "./assuredPreFilter.js";
+import { createSandboxedGateRunner, } from "./assuredGateRunner.js";
+// Whether keiko-sandbox can enforce the full assured boundary for a network:"none" execution-root
+// run on this host (no untrusted command is run during this planning check).
+export function sandboxEnforcesAssuredIsolation(cwd) {
+    const decision = planIsolatedRun({ command: "node", args: [], cwd, network: "none", filesystem: "execution-root" }, probeBackends(), currentPlatform());
+    return (decision.kind === "wrapped" &&
+        decision.attestation.networkEnforced &&
+        decision.attestation.filesystemEnforced);
+}
+// A gate runner whose gates must never be invoked (used on the fail-closed path; runAssuredPreFilter
+// returns before calling any gate when `enforced` is false).
+function failClosedRunner() {
+    const never = () => Promise.reject(new Error("assured pre-filter gate must not run when egress is not enforced"));
+    return { enforced: false, build: never, runTests: never, coverage: never, mutation: never };
+}
+export async function runDisposableAssuredPreFilter(ports, config = DEFAULT_ASSURED_PRE_FILTER_CONFIG) {
+    if (!ports.enforced) {
+        return runAssuredPreFilter(failClosedRunner(), config);
+    }
+    const root = await ports.makeRoot();
+    try {
+        await ports.measureBaseline(root);
+        await ports.applyCandidate(root);
+        const runner = createSandboxedGateRunner({
+            enforced: true,
+            run: (cmd) => ports.run(root, cmd),
+            readReport: (relativePath) => ports.readReport(root, relativePath),
+            buildCommand: ports.buildCommand,
+            testCommand: ports.testCommand,
+            coverageCommand: ports.coverageCommand,
+            mutationCommand: ports.mutationCommand,
+            baselineCoverageReportPath: ports.baselineCoverageReportPath,
+            patchedCoverageReportPath: ports.patchedCoverageReportPath,
+            mutationReportPath: ports.mutationReportPath,
+            targetCoverageKeys: ports.targetCoverageKeys,
+            minMutantsKilled: config.minMutantsKilled,
+        });
+        return await runAssuredPreFilter(runner, config);
+    }
+    finally {
+        await ports.dispose(root);
+    }
+}

package/dist/editor/editorCompletionModel.d.ts

@@ -0,0 +1,47 @@
+import type { CodingContextPack, LanguageCompletionItemKind, LanguagePosition, UsageMetadata } from "@oscharko-dev/keiko-contracts";
+export interface ModelCompletionItem {
+    readonly label: string;
+    readonly kind: LanguageCompletionItemKind;
+    readonly insertText: string;
+}
+export interface ModelChatRequest {
+    readonly system: string;
+    readonly user: string;
+}
+export interface ModelChatResult {
+    readonly content: string;
+    readonly usage?: UsageMetadata | undefined;
+}
+/** The server-side chat seam (the Model Gateway). Returns raw text plus optional usage metadata. */
+export type ModelChatFn = (request: ModelChatRequest, signal: AbortSignal) => Promise<string | ModelChatResult>;
+export interface GenerateModelCompletionsInput {
+    readonly overlayText: string;
+    readonly position: LanguagePosition;
+    readonly languageId: string;
+    readonly contextPack?: CodingContextPack | undefined;
+    readonly maxItems: number;
+    readonly maxInsertTextChars: number;
+    /** Optional route-owned prompt redaction applied before prefix/suffix enter the model prompt. */
+    readonly redactText?: ((value: string) => string) | undefined;
+}
+export interface GenerateModelCompletionsResult {
+    readonly items: readonly ModelCompletionItem[];
+    readonly promptHash: string;
+    readonly truncated: boolean;
+    readonly usage?: UsageMetadata | undefined;
+}
+/** Split the overlay text into prefix/suffix around a 0-based {@link LanguagePosition}. */
+export declare function splitAtPosition(text: string, position: LanguagePosition): {
+    prefix: string;
+    suffix: string;
+};
+/** Build the aligned-infilling prompt; context excerpts are delimited as reference-only material. */
+export declare function buildModelCompletionPrompt(input: GenerateModelCompletionsInput): ModelChatRequest;
+/** Parse the model output into bounded, deduped completion items. Returns `[]` on any malformation. */
+export declare function parseModelCompletionItems(content: string, maxItems: number, maxInsertTextChars: number): {
+    items: readonly ModelCompletionItem[];
+    truncated: boolean;
+};
+/** Assemble the prompt, call the model, and parse its output into completion items. */
+export declare function generateModelCompletions(input: GenerateModelCompletionsInput, chat: ModelChatFn, signal: AbortSignal): Promise<GenerateModelCompletionsResult>;
+//# sourceMappingURL=editorCompletionModel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"editorCompletionModel.d.ts","sourceRoot":"","sources":["../../src/editor/editorCompletionModel.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,iBAAiB,EACjB,0BAA0B,EAC1B,gBAAgB,EAChB,aAAa,EACd,MAAM,+BAA+B,CAAC;AAEvC,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,0BAA0B,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;CAC5C;AAED,oGAAoG;AACpG,MAAM,MAAM,WAAW,GAAG,CACxB,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,WAAW,KAChB,OAAO,CAAC,MAAM,GAAG,eAAe,CAAC,CAAC;AAEvC,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACrD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,iGAAiG;IACjG,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,GAAG,SAAS,CAAC;CAC/D;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,KAAK,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC/C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;CAC5C;AAqBD,2FAA2F;AAC3F,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,gBAAgB,GACzB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAUpC;AAcD,qGAAqG;AACrG,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,6BAA6B,GAAG,gBAAgB,CAqBjG;AAiDD,uGAAuG;AACvG,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,kBAAkB,EAAE,MAAM,GACzB;IAAE,KAAK,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CA8B/D;AAED,uFAAuF;AACvF,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,6BAA6B,EACpC,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,8BAA8B,CAAC,CAOzC"}