knodin 0.5.1 → 0.7.3

package/dist/src/engine/prune.js

@@ -2,7 +2,7 @@ import path from "node:path";
 /**
  * Single source of truth for "which directories does knodin ignore" (R14).
  *
- * Before this module, the same intent — skip node_modules, .git, .reckon,
+ * Before this module, the same intent — skip node_modules, .git, .knodin,
  * build output, caches, VCS internals — was encoded THREE separate times:
  *   1. src/__tests__/setup.ts's `PRUNE_DIRS` regex (glob-shim exclude filter)
  *   2. the indexer's own directory filter (`EXCLUDED_DIR_SEGMENTS` / `isIndexablePath`)
@@ -25,7 +25,7 @@ import path from "node:path";
 export const PRUNE_DIR_NAMES = new Set([
     "node_modules",
     ".git",
-    ".reckon",
+    ".knodin",
     // Local state maintained by other code-intelligence tools. It is neither
     // repository source nor stable project configuration, and indexing it makes
     // a healthy checkout look perpetually stale as those tools update databases

package/dist/src/engine/scip-import.js

@@ -0,0 +1,408 @@
+import fs from "node:fs";
+import path from "node:path";
+export const SCIP_DEFAULT_LIMITS = {
+    maxBytes: 64 * 1024 * 1024,
+    maxFiles: 10_000,
+    maxFacts: 250_000,
+    timeoutMs: 30_000,
+};
+const textDecoder = new TextDecoder("utf-8", { fatal: true });
+let activeDeadline = Number.POSITIVE_INFINITY;
+let activeTimeoutMs = 0;
+function fail(message) {
+    activeDeadline = Number.POSITIVE_INFINITY;
+    activeTimeoutMs = 0;
+    throw new Error(`knodin SCIP import: ${message}`);
+}
+function checkDeadline() {
+    if (performance.now() > activeDeadline)
+        fail(`import exceeded ${activeTimeoutMs} ms limit`);
+}
+function readVarint(bytes, offset) {
+    let value = 0;
+    let shift = 0;
+    for (let count = 0; count < 10 && offset < bytes.length; count++) {
+        const byte = bytes[offset++];
+        if (shift < 53)
+            value += (byte & 0x7f) * 2 ** shift;
+        if ((byte & 0x80) === 0)
+            return [value, offset];
+        shift += 7;
+    }
+    return fail("malformed protobuf varint");
+}
+function visitFields(bytes, visitor) {
+    let offset = 0;
+    while (offset < bytes.length) {
+        checkDeadline();
+        let tag;
+        [tag, offset] = readVarint(bytes, offset);
+        const number = Math.floor(tag / 8);
+        const wire = tag & 7;
+        if (number < 1)
+            fail("malformed protobuf field number");
+        if (wire === 0) {
+            let value;
+            [value, offset] = readVarint(bytes, offset);
+            visitor(number, wire, value);
+        }
+        else if (wire === 2) {
+            let length;
+            [length, offset] = readVarint(bytes, offset);
+            if (!Number.isSafeInteger(length) || length < 0 || offset + length > bytes.length)
+                fail("malformed protobuf length");
+            visitor(number, wire, bytes.subarray(offset, offset + length));
+            offset += length;
+        }
+        else if (wire === 1) {
+            offset += 8;
+        }
+        else if (wire === 5) {
+            offset += 4;
+        }
+        else {
+            fail(`unsupported protobuf wire type ${wire}`);
+        }
+        if (offset > bytes.length)
+            fail("truncated protobuf field");
+    }
+}
+function countLengthDelimitedFields(bytes, target, maximum) {
+    let count = 0;
+    let offset = 0;
+    while (offset < bytes.length) {
+        checkDeadline();
+        let tag;
+        [tag, offset] = readVarint(bytes, offset);
+        const number = Math.floor(tag / 8);
+        const wire = tag & 7;
+        if (number < 1)
+            fail("malformed protobuf field number");
+        if (wire === 0) {
+            [, offset] = readVarint(bytes, offset);
+        }
+        else if (wire === 2) {
+            let length;
+            [length, offset] = readVarint(bytes, offset);
+            if (!Number.isSafeInteger(length) || length < 0 || offset + length > bytes.length)
+                fail("malformed protobuf length");
+            if (number === target && ++count > maximum)
+                return count;
+            offset += length;
+        }
+        else if (wire === 1)
+            offset += 8;
+        else if (wire === 5)
+            offset += 4;
+        else
+            fail(`unsupported protobuf wire type ${wire}`);
+        if (offset > bytes.length)
+            fail("truncated protobuf field");
+    }
+    return count;
+}
+function strings(message, number) {
+    const result = [];
+    visitFields(message, (fieldNumber, wire, value) => {
+        if (fieldNumber === number && wire === 2)
+            result.push(textDecoder.decode(value));
+    });
+    return result;
+}
+function messages(message, number) {
+    const result = [];
+    visitFields(message, (fieldNumber, wire, value) => {
+        if (fieldNumber === number && wire === 2)
+            result.push(value);
+    });
+    return result;
+}
+function numberField(message, number) {
+    let result = 0;
+    let found = false;
+    visitFields(message, (fieldNumber, wire, value) => {
+        if (!found && fieldNumber === number && wire === 0) {
+            result = value;
+            found = true;
+        }
+    });
+    return result;
+}
+function packedNumbers(message, number) {
+    const result = [];
+    visitFields(message, (fieldNumber, wire, value) => {
+        if (fieldNumber !== number)
+            return;
+        if (wire === 0)
+            result.push(value);
+        if (wire === 2) {
+            const bytes = value;
+            let offset = 0;
+            while (offset < bytes.length) {
+                let packedValue;
+                [packedValue, offset] = readVarint(bytes, offset);
+                result.push(packedValue);
+            }
+        }
+    });
+    return result;
+}
+function parseRange(values) {
+    if (values.length !== 3 && values.length !== 4)
+        fail("range must contain three or four integers");
+    const [startLine, startCol] = values;
+    const endLine = values.length === 3 ? startLine : values[2];
+    const endCol = values.length === 3 ? values[2] : values[3];
+    if ([startLine, startCol, endLine, endCol].some((value) => !Number.isSafeInteger(value)))
+        fail("range contains an unsafe integer");
+    if (endLine < startLine || (endLine === startLine && endCol < startCol))
+        fail("range is reversed");
+    return { startLine, startCol, endLine, endCol };
+}
+function parseOccurrence(message) {
+    const singleLine = messages(message, 8)[0];
+    const multiLine = messages(message, 9)[0];
+    const symbol = strings(message, 2)[0] ?? "";
+    let range;
+    if (singleLine) {
+        const line = numberField(singleLine, 1);
+        range = parseRange([line, numberField(singleLine, 2), numberField(singleLine, 3)]);
+    }
+    else if (multiLine) {
+        range = parseRange([
+            numberField(multiLine, 1),
+            numberField(multiLine, 2),
+            numberField(multiLine, 3),
+            numberField(multiLine, 4),
+        ]);
+    }
+    else {
+        range = parseRange(packedNumbers(message, 1));
+    }
+    if (!symbol)
+        fail("occurrence is missing its symbol");
+    return { range, symbol, roles: numberField(message, 3) };
+}
+function parseSymbolInfo(message) {
+    const symbol = strings(message, 1)[0] ?? "";
+    if (!symbol)
+        fail("symbol information is missing its symbol");
+    return {
+        symbol,
+        displayName: strings(message, 6)[0] ?? "",
+        kind: numberField(message, 5),
+        relationships: messages(message, 4).map((relationship) => ({
+            symbol: strings(relationship, 1)[0] ?? "",
+            isReference: numberField(relationship, 2) !== 0,
+            isImplementation: numberField(relationship, 3) !== 0,
+            isTypeDefinition: numberField(relationship, 4) !== 0,
+            isDefinition: numberField(relationship, 5) !== 0,
+        })),
+    };
+}
+function safeRelativePath(repoPath, value) {
+    if (!value || value.includes("\0") || path.isAbsolute(value))
+        fail(`hostile document path ${JSON.stringify(value)}`);
+    const normalized = value.replaceAll("\\", "/");
+    if (normalized.split("/").some((part) => part === ".." || part === ""))
+        fail(`hostile document path ${JSON.stringify(value)}`);
+    const absolute = path.resolve(repoPath, normalized);
+    const relative = path.relative(repoPath, absolute);
+    if (relative.startsWith("..") || path.isAbsolute(relative))
+        fail(`document escapes repository: ${value}`);
+    let stat;
+    try {
+        stat = fs.lstatSync(absolute);
+    }
+    catch {
+        return fail(`document is missing: ${normalized}`);
+    }
+    if (!stat.isFile() || stat.isSymbolicLink())
+        fail(`document is not a regular repository file: ${normalized}`);
+    return normalized;
+}
+function symbolName(symbol, displayName) {
+    if (displayName.trim())
+        return displayName.trim();
+    if (symbol.startsWith("local "))
+        return symbol;
+    const descriptor = symbol.trim().split(/\s+/).at(-1) ?? symbol;
+    const withoutSuffix = descriptor.replace(/\([^)]*\)\.$|[#/.:!]$/, "");
+    const cleaned = (withoutSuffix.split(/[/#]/).at(-1) ?? descriptor).replaceAll("`", "");
+    return cleaned || symbol;
+}
+function symbolKind(_kind) {
+    // Do not translate a versioned producer enum into a potentially false native
+    // semantic kind; the original SCIP symbol remains in provenance.
+    return "SCIP_Symbol";
+}
+function parseMetadata(index) {
+    const metadata = messages(index, 1)[0];
+    if (!metadata)
+        return [];
+    const toolInfo = messages(metadata, 2)[0];
+    if (!toolInfo)
+        return [];
+    const name = strings(toolInfo, 1)[0];
+    const version = strings(toolInfo, 2)[0];
+    return name ? [`${name}${version ? `@${version}` : ""}`] : [];
+}
+export function readScipIndex(repoPath, options) {
+    const started = performance.now();
+    const limits = { ...SCIP_DEFAULT_LIMITS, ...options };
+    for (const [name, value] of Object.entries(limits)) {
+        if (name === "path")
+            continue;
+        if (!Number.isSafeInteger(value) || value < 1)
+            fail(`${name} must be a positive integer`);
+    }
+    activeTimeoutMs = limits.timeoutMs;
+    activeDeadline = started + limits.timeoutMs;
+    const resolvedRepo = path.resolve(repoPath);
+    const inputPath = path.resolve(resolvedRepo, options.path);
+    const inputRelative = path.relative(resolvedRepo, inputPath);
+    if (inputRelative.startsWith("..") || path.isAbsolute(inputRelative))
+        fail("input path escapes repository");
+    let inputStat;
+    try {
+        inputStat = fs.lstatSync(inputPath);
+    }
+    catch {
+        return fail(`input is missing: ${inputRelative}`);
+    }
+    if (!inputStat.isFile() || inputStat.isSymbolicLink())
+        fail("input must be a regular repository file");
+    if (inputStat.size > limits.maxBytes)
+        fail(`input exceeds ${limits.maxBytes} byte limit`);
+    const bytes = fs.readFileSync(inputPath);
+    const index = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const documents = [];
+    let parsedFacts = 0;
+    const documentCount = countLengthDelimitedFields(index, 2, limits.maxFiles);
+    if (documentCount > limits.maxFiles)
+        fail(`index exceeds ${limits.maxFiles} file limit`);
+    for (const message of messages(index, 2)) {
+        const filePath = safeRelativePath(resolvedRepo, strings(message, 1)[0] ?? "");
+        const sourceStat = fs.statSync(path.join(resolvedRepo, filePath));
+        if (sourceStat.mtimeMs > inputStat.mtimeMs + 1)
+            fail(`input is stale for ${filePath}`);
+        const occurrenceCount = countLengthDelimitedFields(message, 2, limits.maxFacts - parsedFacts);
+        parsedFacts += occurrenceCount;
+        if (parsedFacts > limits.maxFacts)
+            fail(`index exceeds ${limits.maxFacts} fact limit`);
+        const symbolCount = countLengthDelimitedFields(message, 3, limits.maxFacts - parsedFacts);
+        parsedFacts += symbolCount;
+        if (parsedFacts > limits.maxFacts)
+            fail(`index exceeds ${limits.maxFacts} fact limit`);
+        const occurrenceMessages = messages(message, 2);
+        const symbolMessages = messages(message, 3);
+        for (const symbolMessage of symbolMessages) {
+            const remainingRelationships = Math.floor((limits.maxFacts - parsedFacts) / 4);
+            parsedFacts += countLengthDelimitedFields(symbolMessage, 4, remainingRelationships) * 4;
+            if (parsedFacts > limits.maxFacts)
+                fail(`index exceeds ${limits.maxFacts} fact limit`);
+        }
+        documents.push({
+            filePath,
+            language: strings(message, 4)[0] ?? "unknown",
+            occurrences: occurrenceMessages.map(parseOccurrence),
+            symbols: symbolMessages.map(parseSymbolInfo),
+        });
+        if (performance.now() - started > limits.timeoutMs)
+            fail(`import exceeded ${limits.timeoutMs} ms limit`);
+    }
+    const scopedSymbol = (document, symbol) => symbol.startsWith("local ") ? `${document.filePath}\0${symbol}` : `\0${symbol}`;
+    const definitions = new Map();
+    for (const document of documents) {
+        const infos = new Map(document.symbols.map((info) => [info.symbol, info]));
+        for (const occurrence of document.occurrences) {
+            const key = scopedSymbol(document, occurrence.symbol);
+            if ((occurrence.roles & 1) !== 0 && !definitions.has(key)) {
+                definitions.set(key, {
+                    document,
+                    occurrence,
+                    info: infos.get(occurrence.symbol),
+                });
+            }
+        }
+    }
+    const symbols = [...definitions.values()].map((definition) => ({
+        symbol: definition.occurrence.symbol,
+        name: symbolName(definition.occurrence.symbol, definition.info?.displayName ?? ""),
+        kind: symbolKind(definition.info?.kind ?? 0),
+        filePath: definition.document.filePath,
+        startLine: definition.occurrence.range.startLine + 1,
+        endLine: definition.occurrence.range.endLine + 1,
+        startCol: definition.occurrence.range.startCol + 1,
+        endCol: definition.occurrence.range.endCol + 1,
+    }));
+    const references = [];
+    for (const document of documents) {
+        for (const occurrence of document.occurrences) {
+            if ((occurrence.roles & 1) !== 0)
+                continue;
+            const target = definitions.get(scopedSymbol(document, occurrence.symbol));
+            if (!target)
+                continue;
+            references.push({
+                callerSymbol: null,
+                callerFile: document.filePath,
+                calleeSymbol: symbolName(occurrence.symbol, target.info?.displayName ?? ""),
+                calleeFile: target.document.filePath,
+                line: occurrence.range.startLine + 1,
+                column: occurrence.range.startCol + 1,
+                kind: "scip_reference",
+            });
+        }
+        for (const info of document.symbols) {
+            const source = definitions.get(scopedSymbol(document, info.symbol));
+            if (!source)
+                continue;
+            for (const relationship of info.relationships) {
+                const target = definitions.get(scopedSymbol(document, relationship.symbol));
+                if (!target)
+                    continue;
+                const kinds = [];
+                if (relationship.isReference)
+                    kinds.push("scip_relationship_reference");
+                if (relationship.isImplementation)
+                    kinds.push("scip_implementation");
+                if (relationship.isTypeDefinition)
+                    kinds.push("scip_type_definition");
+                if (relationship.isDefinition)
+                    kinds.push("scip_definition");
+                for (const kind of kinds)
+                    references.push({
+                        callerSymbol: symbolName(info.symbol, info.displayName),
+                        callerFile: source.document.filePath,
+                        calleeSymbol: symbolName(relationship.symbol, target.info?.displayName ?? ""),
+                        calleeFile: target.document.filePath,
+                        line: source.occurrence.range.startLine + 1,
+                        column: source.occurrence.range.startCol + 1,
+                        kind,
+                    });
+            }
+        }
+    }
+    const factCount = symbols.length + references.length;
+    if (factCount > limits.maxFacts)
+        fail(`index exceeds ${limits.maxFacts} fact limit`);
+    if (performance.now() - started > limits.timeoutMs)
+        fail(`import exceeded ${limits.timeoutMs} ms limit`);
+    const result = {
+        inputPath: inputRelative.replaceAll("\\", "/"),
+        bytes: inputStat.size,
+        files: documents.length,
+        facts: factCount,
+        languages: [...new Set(documents.map((document) => document.language))].sort(),
+        indexers: parseMetadata(index).sort(),
+        symbols: symbols.sort((a, b) => a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine),
+        references: references.sort((a, b) => a.callerFile.localeCompare(b.callerFile) ||
+            a.line - b.line ||
+            a.calleeSymbol.localeCompare(b.calleeSymbol)),
+        elapsedMs: Math.round((performance.now() - started) * 1000) / 1000,
+    };
+    activeDeadline = Number.POSITIVE_INFINITY;
+    activeTimeoutMs = 0;
+    return result;
+}

package/dist/src/engine/symbol-delete.js

@@ -45,7 +45,7 @@ export function deleteSymbolsForFile(db, filePath) {
 /**
  * Delete every symbol whose file path matches a LIKE pattern, plus its
  * embeddings. Used by the dbt path, whose symbols live under synthetic
- * `.reckon/dbt/%` paths rather than one real file.
+ * `.knodin/dbt/%` paths rather than one real file.
  */
 export function deleteSymbolsMatchingPath(db, likePattern) {
     db.run("DELETE FROM symbol_embeddings WHERE symbolId IN (SELECT id FROM symbols WHERE filePath LIKE ?)", [likePattern]);

package/dist/src/execution-profile.js

@@ -0,0 +1,203 @@
+import childProcess from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { compressOutput } from "./output-compression.js";
+function defaultGlobalConfigPath() {
+    const base = process.env.XDG_CONFIG_HOME
+        ? path.resolve(process.env.XDG_CONFIG_HOME)
+        : path.join(os.homedir(), ".config");
+    return path.join(base, "knodin", "execution.json");
+}
+function readDocument(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function sandboxLiteral(value) {
+    return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+function macosPolicy(repo, _executable) {
+    const protectedRoots = ["/Users", "/Volumes", "/Network", "/private/tmp", "/private/var/folders"];
+    return [
+        "(version 1)",
+        "(allow default)",
+        "(deny network*)",
+        "(deny process-fork)",
+        `(deny file-read* ${protectedRoots.map((item) => `(subpath ${sandboxLiteral(item)})`).join(" ")})`,
+        "(deny file-write*)",
+        `(allow file-read* file-write* (subpath ${sandboxLiteral(repo)}) (literal "/dev/null"))`,
+    ].join(" ");
+}
+function unavailable(profile, warning) {
+    return {
+        schemaVersion: 1,
+        status: "unavailable",
+        profile,
+        exit: { code: null, signal: null },
+        containment: {
+            level: "containment-unavailable",
+            platform: process.platform,
+            adapter: "unavailable",
+            filesystem: "unavailable",
+            network: "unavailable",
+            processes: "unavailable",
+            warning,
+        },
+        limits: { timeoutMs: 0, maxOutputBytes: 0, maxProcesses: 1 },
+        output: null,
+        audit: { commandTextRecorded: false, profileRecorded: true },
+    };
+}
+function validateProfile(profileName, value) {
+    if (!value || typeof value !== "object")
+        throw new Error(`execution profile ${profileName} is invalid`);
+    const profile = value;
+    if (!path.isAbsolute(profile.executable ?? ""))
+        throw new Error(`execution profile ${profileName}: executable must be absolute`);
+    if (!Array.isArray(profile.args) ||
+        profile.args.some((arg) => typeof arg !== "string" || arg.includes("\0")))
+        throw new Error(`execution profile ${profileName}: args must be a NUL-free string array`);
+    if (profile.network !== "deny")
+        throw new Error(`execution profile ${profileName}: network must be deny`);
+    if (!Number.isInteger(profile.timeoutMs) ||
+        (profile.timeoutMs ?? 0) < 1 ||
+        (profile.timeoutMs ?? 0) > 300_000)
+        throw new Error(`execution profile ${profileName}: timeoutMs must be 1..300000`);
+    if (!Number.isInteger(profile.maxOutputBytes) ||
+        (profile.maxOutputBytes ?? 0) < 256 ||
+        (profile.maxOutputBytes ?? 0) > 16 * 1024 * 1024)
+        throw new Error(`execution profile ${profileName}: maxOutputBytes must be 256..16777216`);
+    if (profile.maxProcesses !== 1)
+        throw new Error(`execution profile ${profileName}: maxProcesses must be 1 for hard fork denial`);
+    if (profile.containment !== undefined && profile.containment !== "fully-contained")
+        throw new Error(`execution profile ${profileName}: only fully-contained is supported`);
+    return profile;
+}
+function appendAudit(repo, record) {
+    const destination = path.join(repo, ".knodin", "execution-audit.jsonl");
+    fs.mkdirSync(path.dirname(destination), { recursive: true });
+    fs.appendFileSync(destination, `${JSON.stringify(record)}\n`, { mode: 0o600 });
+}
+export async function runExecutionProfile(options) {
+    const repo = fs.realpathSync(options.repo);
+    if (!/^[a-z][a-z0-9_-]{0,63}$/.test(options.profile))
+        throw new Error("execution profile identity must match [a-z][a-z0-9_-]{0,63}");
+    const globalDocument = readDocument(options.globalConfigPath ?? defaultGlobalConfigPath());
+    const repositoryDocument = readDocument(path.join(repo, ".knodin", "execution.json"));
+    if (globalDocument?.execution?.enabled !== true)
+        return unavailable(options.profile, "execution is disabled globally");
+    if (repositoryDocument?.execution?.enabled !== true)
+        return unavailable(options.profile, "execution is disabled for this repository");
+    const configured = repositoryDocument.execution.profiles?.[options.profile];
+    if (!configured)
+        throw new Error(`execution profile not found: ${options.profile}`);
+    const profile = validateProfile(options.profile, configured);
+    if (process.platform !== "darwin" || !fs.existsSync("/usr/bin/sandbox-exec"))
+        return unavailable(options.profile, "no certified containment adapter is available on this platform");
+    const executable = fs.realpathSync(profile.executable);
+    const temporaryDirectory = fs.mkdtempSync(path.join(repo, ".knodin", "execution-tmp-"));
+    const environment = {
+        PATH: `${path.dirname(executable)}:/usr/bin:/bin`,
+        LANG: "C.UTF-8",
+        LC_ALL: "C.UTF-8",
+        TMPDIR: temporaryDirectory,
+    };
+    const policy = macosPolicy(repo, executable);
+    const proc = childProcess.spawn("/usr/bin/sandbox-exec", ["-p", policy, executable, ...profile.args], {
+        cwd: repo,
+        env: environment,
+        shell: false,
+        detached: true,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = Buffer.alloc(0);
+    let stderr = Buffer.alloc(0);
+    let reason = "exit";
+    let stopped = false;
+    const stop = (next) => {
+        if (stopped || reason !== "exit")
+            return;
+        reason = next;
+        if (proc.pid)
+            try {
+                process.kill(-proc.pid, "SIGKILL");
+            }
+            catch { }
+    };
+    const append = (stream, chunk) => {
+        const remaining = Math.max(0, profile.maxOutputBytes - stdout.length - stderr.length);
+        const accepted = chunk.subarray(0, remaining);
+        if (stream === "stdout")
+            stdout = Buffer.concat([stdout, accepted]);
+        else
+            stderr = Buffer.concat([stderr, accepted]);
+        if (accepted.length < chunk.length)
+            stop("output-limit");
+    };
+    proc.stdout.on("data", (chunk) => append("stdout", chunk));
+    proc.stderr.on("data", (chunk) => append("stderr", chunk));
+    const timer = setTimeout(() => stop("timeout"), profile.timeoutMs);
+    const closed = await new Promise((resolve, reject) => {
+        proc.once("error", reject);
+        proc.once("close", (code, signal) => resolve({ code, signal }));
+    });
+    stopped = true;
+    clearTimeout(timer);
+    fs.rmSync(temporaryDirectory, { recursive: true, force: true });
+    const combined = [
+        ...(stdout.length ? [{ stream: "stdout", text: stdout.toString("utf8") }] : []),
+        ...(stderr.length ? [{ stream: "stderr", text: stderr.toString("utf8") }] : []),
+    ];
+    const output = compressOutput(repo, {
+        events: combined,
+        exitCode: closed.code,
+        signal: closed.signal,
+        lineBudget: 200,
+        byteBudget: Math.min(profile.maxOutputBytes, 16_384),
+        retain: true,
+    });
+    const finalReason = reason;
+    const status = finalReason === "timeout"
+        ? "timed-out"
+        : finalReason === "output-limit"
+            ? "output-limit"
+            : closed.code === 0
+                ? "completed"
+                : "failed";
+    const result = {
+        schemaVersion: 1,
+        status,
+        profile: options.profile,
+        exit: closed,
+        containment: {
+            level: "fully-contained",
+            platform: process.platform,
+            adapter: "macos-sandbox-exec",
+            filesystem: "repository-write-user-data-read-bounded",
+            network: "deny",
+            processes: "fork-denied",
+            warning: "macOS sandbox-exec is deprecated. Writes are repository-bound; system runtime paths remain readable while user homes, mounted volumes, network paths, and shared temporary roots are read-denied outside the repository.",
+        },
+        limits: {
+            timeoutMs: profile.timeoutMs,
+            maxOutputBytes: profile.maxOutputBytes,
+            maxProcesses: 1,
+        },
+        output,
+        audit: { commandTextRecorded: false, profileRecorded: true },
+    };
+    appendAudit(repo, {
+        timestamp: new Date().toISOString(),
+        profile: options.profile,
+        status,
+        exitCode: closed.code,
+        signal: closed.signal,
+        containment: result.containment.level,
+        outputArtifactId: output.artifact.id,
+    });
+    return result;
+}