ast-mcp-server 0.13.1 → 0.14.0

package/dist/services/diagnostics.js

@@ -56,20 +56,222 @@ export function buildDiagnosticAggregates(diagnostics, requestContext = NO_REQUE
         files: { ...files, unfiled_diagnostic_count: unfiled },
     };
 }
-export function normalizeDiagnostic(diagnostic, projectRoot, requestContext = NO_REQUEST_CONTEXT) {
+export function observeDiagnostic(diagnostic, projectRoot, ordinal = 0, requestContext = NO_REQUEST_CONTEXT) {
     requestContext.checkpoint();
     const sourceFile = diagnostic.getSourceFile();
-    const start = diagnostic.getStart();
-    const location = sourceFile && start !== undefined ? sourceFile.getLineAndColumnAtPos(start) : undefined;
+    const start = diagnostic.getStart() ?? null;
+    const length = diagnostic.getLength() ?? null;
+    const location = sourceFile && start !== null ? sourceFile.getLineAndColumnAtPos(start) : undefined;
     return {
-        code: diagnostic.getCode(),
-        category: DiagnosticCategory[diagnostic.getCategory()] ?? String(diagnostic.getCategory()),
-        file: sourceFile ? path.relative(projectRoot, sourceFile.getFilePath()) : null,
-        line: location?.line ?? null,
-        column: location?.column ?? null,
-        message: ts.flattenDiagnosticMessageText(diagnostic.compilerObject.messageText, "\n"),
+        public: {
+            code: diagnostic.getCode(),
+            category: DiagnosticCategory[diagnostic.getCategory()] ?? String(diagnostic.getCategory()),
+            file: sourceFile ? path.relative(projectRoot, sourceFile.getFilePath()) : null,
+            line: location?.line ?? null,
+            column: location?.column ?? null,
+            message: ts.flattenDiagnosticMessageText(diagnostic.compilerObject.messageText, "\n"),
+        },
+        start,
+        length,
+        ordinal,
     };
 }
+export function normalizeDiagnostic(diagnostic, projectRoot, requestContext = NO_REQUEST_CONTEXT) {
+    return observeDiagnostic(diagnostic, projectRoot, 0, requestContext).public;
+}
+const DEFAULT_EDIT_BUDGET = { frontierSteps: 1_000_000, traceCells: 250_000, hunks: 10_000 };
+const BUDGET_EXCEEDED = Symbol("edit-budget-exceeded");
+const EDIT_CHECKPOINT_INTERVAL = 4_096;
+function createEditWorkTracker(budget) {
+    return { budget, work: 0, traceCells: 0, hunks: 0, exhausted: false };
+}
+function exhaust(tracker) {
+    tracker.exhausted = true;
+    throw BUDGET_EXCEEDED;
+}
+function chargeWork(tracker, requestContext) {
+    if (tracker.exhausted || tracker.work >= tracker.budget.frontierSteps)
+        exhaust(tracker);
+    tracker.work += 1;
+    if (tracker.work % EDIT_CHECKPOINT_INTERVAL === 0)
+        requestContext.checkpoint();
+}
+function chargeTraceCell(tracker) {
+    if (tracker.exhausted || tracker.traceCells >= tracker.budget.traceCells)
+        exhaust(tracker);
+    tracker.traceCells += 1;
+}
+function chargeHunk(tracker, requestContext) {
+    chargeWork(tracker, requestContext);
+    if (tracker.hunks >= tracker.budget.hunks)
+        exhaust(tracker);
+    tracker.hunks += 1;
+}
+function coarseContext(oldLength, newLength, prefix, suffix) {
+    const runs = [];
+    if (prefix > 0)
+        runs.push({ oldStart: 0, oldEnd: prefix, newStart: 0, newEnd: prefix });
+    if (suffix > 0) {
+        runs.push({
+            oldStart: oldLength - suffix,
+            oldEnd: oldLength,
+            newStart: newLength - suffix,
+            newEnd: newLength,
+        });
+    }
+    return {
+        coarse: true,
+        runs,
+        hunks: [
+            {
+                oldStart: prefix,
+                oldEnd: oldLength - suffix,
+                newStart: prefix,
+                newEnd: newLength - suffix,
+            },
+        ],
+    };
+}
+function backtrack(trace, depth, oldLength, newLength, tracker, requestContext) {
+    const reversed = [];
+    let x = oldLength;
+    let y = newLength;
+    for (let d = depth; d > 0; d -= 1) {
+        requestContext.checkpoint();
+        const previous = trace[d - 1];
+        const diagonal = x - y;
+        const left = previous.get(diagonal - 1) ?? Number.NEGATIVE_INFINITY;
+        const right = previous.get(diagonal + 1) ?? Number.NEGATIVE_INFINITY;
+        const previousDiagonal = diagonal === -d || (diagonal !== d && left < right) ? diagonal + 1 : diagonal - 1;
+        const previousX = previous.get(previousDiagonal);
+        const previousY = previousX - previousDiagonal;
+        while (x > previousX && y > previousY) {
+            chargeWork(tracker, requestContext);
+            reversed.push("equal");
+            x -= 1;
+            y -= 1;
+        }
+        chargeWork(tracker, requestContext);
+        if (x === previousX) {
+            reversed.push("insert");
+            y -= 1;
+        }
+        else {
+            reversed.push("delete");
+            x -= 1;
+        }
+    }
+    while (x > 0 && y > 0) {
+        chargeWork(tracker, requestContext);
+        reversed.push("equal");
+        x -= 1;
+        y -= 1;
+    }
+    return reversed.reverse();
+}
+function emitContext(operations, prefix, tracker, requestContext) {
+    const runs = [];
+    const hunks = [];
+    let oldPosition = prefix;
+    let newPosition = prefix;
+    if (prefix > 0)
+        runs.push({ oldStart: 0, oldEnd: prefix, newStart: 0, newEnd: prefix });
+    for (let index = 0; index < operations.length;) {
+        requestContext.checkpoint();
+        const equal = operations[index] === "equal";
+        const oldStart = oldPosition;
+        const newStart = newPosition;
+        while (index < operations.length && (operations[index] === "equal") === equal) {
+            chargeWork(tracker, requestContext);
+            if (operations[index] !== "insert")
+                oldPosition += 1;
+            if (operations[index] !== "delete")
+                newPosition += 1;
+            index += 1;
+        }
+        const span = { oldStart, oldEnd: oldPosition, newStart, newEnd: newPosition };
+        if (equal)
+            runs.push(span);
+        else {
+            chargeHunk(tracker, requestContext);
+            hunks.push(span);
+        }
+    }
+    return { coarse: false, runs, hunks };
+}
+function buildEditContextWithTracker(oldText, newText, tracker, requestContext) {
+    requestContext.checkpoint();
+    let prefix = 0;
+    let suffix = 0;
+    try {
+        while (prefix < oldText.length && prefix < newText.length) {
+            chargeWork(tracker, requestContext);
+            if (oldText[prefix] !== newText[prefix])
+                break;
+            prefix += 1;
+        }
+        while (suffix < oldText.length - prefix && suffix < newText.length - prefix) {
+            chargeWork(tracker, requestContext);
+            if (oldText[oldText.length - suffix - 1] !== newText[newText.length - suffix - 1])
+                break;
+            suffix += 1;
+        }
+        if (prefix === oldText.length && prefix === newText.length) {
+            return {
+                coarse: false,
+                runs: prefix === 0 ? [] : [{ oldStart: 0, oldEnd: prefix, newStart: 0, newEnd: prefix }],
+                hunks: [],
+            };
+        }
+        const oldMiddle = oldText.slice(prefix, oldText.length - suffix);
+        const newMiddle = newText.slice(prefix, newText.length - suffix);
+        const trace = [];
+        let previous = new Map([[1, 0]]);
+        for (let depth = 0; depth <= oldMiddle.length + newMiddle.length; depth += 1) {
+            const current = new Map();
+            for (let diagonal = -depth; diagonal <= depth; diagonal += 2) {
+                requestContext.checkpoint();
+                chargeWork(tracker, requestContext);
+                chargeTraceCell(tracker);
+                const left = previous.get(diagonal - 1) ?? Number.NEGATIVE_INFINITY;
+                const right = previous.get(diagonal + 1) ?? Number.NEGATIVE_INFINITY;
+                let x = diagonal === -depth || (diagonal !== depth && left < right) ? right : left + 1;
+                let y = x - diagonal;
+                while (x < oldMiddle.length && y < newMiddle.length) {
+                    chargeWork(tracker, requestContext);
+                    if (oldMiddle[x] !== newMiddle[y])
+                        break;
+                    x += 1;
+                    y += 1;
+                }
+                current.set(diagonal, x);
+                if (x >= oldMiddle.length && y >= newMiddle.length) {
+                    trace.push(current);
+                    const context = emitContext(backtrack(trace, depth, oldMiddle.length, newMiddle.length, tracker, requestContext), prefix, tracker, requestContext);
+                    if (suffix > 0)
+                        context.runs.push({
+                            oldStart: oldText.length - suffix,
+                            oldEnd: oldText.length,
+                            newStart: newText.length - suffix,
+                            newEnd: newText.length,
+                        });
+                    return context;
+                }
+            }
+            trace.push(current);
+            previous = current;
+        }
+        throw new Error("Myers alignment did not terminate.");
+    }
+    catch (error) {
+        if (error !== BUDGET_EXCEEDED)
+            throw error;
+        return coarseContext(oldText.length, newText.length, prefix, suffix);
+    }
+}
+export function buildEditContext(oldText, newText, budget = DEFAULT_EDIT_BUDGET, requestContext = NO_REQUEST_CONTEXT) {
+    return buildEditContextWithTracker(oldText, newText, createEditWorkTracker(budget), requestContext);
+}
 function identity(diagnostic) {
     return JSON.stringify([
         diagnostic.code,
@@ -78,6 +280,88 @@ function identity(diagnostic) {
         diagnostic.message,
     ]);
 }
+function touchesHunk(start, length, hunks, side) {
+    const end = start + length;
+    return hunks.some((hunk) => {
+        const hunkStart = side === "old" ? hunk.oldStart : hunk.newStart;
+        const hunkEnd = side === "old" ? hunk.oldEnd : hunk.newEnd;
+        return end >= hunkStart && start <= hunkEnd;
+    });
+}
+function observationKey(observation, change, side) {
+    const diagnostic = observation.public;
+    if (diagnostic.file === null) {
+        return JSON.stringify([identity(diagnostic), diagnostic.line, diagnostic.column]);
+    }
+    if (!change) {
+        return JSON.stringify([identity(diagnostic), observation.start, observation.length]);
+    }
+    if (change.beforeText === null ||
+        change.afterText === null ||
+        observation.start === null ||
+        observation.length === null ||
+        !change.context ||
+        touchesHunk(observation.start, observation.length, change.context.hunks, side)) {
+        return null;
+    }
+    const run = change.context.runs.find((candidate) => {
+        const runStart = side === "old" ? candidate.oldStart : candidate.newStart;
+        const runEnd = side === "old" ? candidate.oldEnd : candidate.newEnd;
+        return observation.start >= runStart && observation.start + observation.length <= runEnd;
+    });
+    if (!run)
+        return null;
+    const mappedStart = side === "old" ? run.newStart + observation.start - run.oldStart : observation.start;
+    return JSON.stringify([identity(diagnostic), mappedStart, observation.length]);
+}
+export function compareObservedDiagnostics(before, after, changes, requestContext = NO_REQUEST_CONTEXT) {
+    requestContext.checkpoint();
+    const edits = new Map();
+    const tracker = createEditWorkTracker(DEFAULT_EDIT_BUDGET);
+    for (const change of changes) {
+        requestContext.checkpoint();
+        edits.set(change.file, {
+            ...change,
+            context: change.beforeText === null || change.afterText === null
+                ? null
+                : buildEditContextWithTracker(change.beforeText, change.afterText, tracker, requestContext),
+        });
+    }
+    const queues = new Map();
+    for (let index = 0; index < before.length; index += 1) {
+        requestContext.checkpoint();
+        const observation = before[index];
+        const key = observationKey(observation, observation.public.file === null ? undefined : edits.get(observation.public.file), "old");
+        if (key !== null) {
+            const queue = queues.get(key) ?? { indices: [], cursor: 0 };
+            queue.indices.push(index);
+            queues.set(key, queue);
+        }
+    }
+    const matchedBefore = new Set();
+    const matchedAfter = new Set();
+    for (let index = 0; index < after.length; index += 1) {
+        requestContext.checkpoint();
+        const observation = after[index];
+        const key = observationKey(observation, observation.public.file === null ? undefined : edits.get(observation.public.file), "new");
+        const queue = key === null ? undefined : queues.get(key);
+        if (queue && queue.cursor < queue.indices.length) {
+            matchedBefore.add(queue.indices[queue.cursor++]);
+            matchedAfter.add(index);
+        }
+    }
+    const added = after
+        .filter((_, index) => !matchedAfter.has(index))
+        .map(({ public: value }) => value);
+    const removed = before
+        .filter((_, index) => !matchedBefore.has(index))
+        .map(({ public: value }) => value);
+    return {
+        added,
+        removed,
+        addedErrors: added.filter((diagnostic) => diagnostic.category === "Error"),
+    };
+}
 function subtract(candidates, baseline, requestContext) {
     const counts = new Map();
     for (const diagnostic of baseline) {

package/dist/services/impact.js

@@ -3,7 +3,7 @@ import { createTruncationMetadata, createSourceLocation, } from "./read-contract
 import { getSourceFileOrThrow } from "./project.js";
 import { findLocatedDeclaration } from "./symbols.js";
 import { NO_REQUEST_CONTEXT } from "./request-context.js";
-import { createCompilerRelationshipResolver, RELATIONSHIP_EDGE_KINDS, } from "./relationships.js";
+import { createCompilerRelationshipResolver, isRelationshipCoverageComplete, mergeRelationshipCoverage, RELATIONSHIP_EDGE_KINDS, } from "./relationships.js";
 export const IMPACT_DIRECTIONS = Object.freeze(["incoming", "outgoing", "both"]);
 export const DEFAULT_IMPACT_MAX_DEPTH = 3;
 export const DEFAULT_IMPACT_MAX_NODES = 100;
@@ -24,7 +24,7 @@ export function isExactImpactEdge(edge) {
         Array.isArray(edge.freshness.causes) &&
         edge.freshness.causes.length === 0);
 }
-export function assertExactImpactEvidence(impact) {
+export function assertCompleteExactImpactEvidence(impact) {
     if (typeof impact !== "object" || impact === null || !Array.isArray(impact.edges)) {
         throw new Error("Impact evidence is invalid.");
     }
@@ -35,6 +35,9 @@ export function assertExactImpactEvidence(impact) {
         throw new Error("Test candidates require fresh exact compiler impact evidence.");
     }
 }
+export function assertExactImpactEvidence(impact) {
+    assertCompleteExactImpactEvidence(impact);
+}
 const IMPACT_PROBE_WORK_ITEMS = 1_024;
 const IMPACT_RELATIONSHIP_WORK_ITEMS = 100_000;
 function assertIntegerInRange(value, minimum, maximum, name) {
@@ -152,7 +155,7 @@ function collectNeighbors(current, edges, options, requestContext) {
     }
     return [...neighbors.values()].sort(neighborOrder);
 }
-function traverseWithNeighborProvider(root, neighborsFor, options = {}, requestContext = NO_REQUEST_CONTEXT) {
+function traverseWithNeighborProvider(root, neighborsFor, options = {}, requestContext = NO_REQUEST_CONTEXT, semanticAuthority = false) {
     requestContext.checkpoint();
     if (typeof root !== "object" || root === null) {
         throw new Error("Impact traversal input is invalid.");
@@ -165,6 +168,27 @@ function traverseWithNeighborProvider(root, neighborsFor, options = {}, requestC
     const queue = [{ key: endpointKey(root), endpoint: root, depth: 0 }];
     const truncationReasons = new Set();
     let maxDepthReached = 0;
+    let coverage = [];
+    let relationshipWorkItems = 0;
+    let relationshipWorkLimitReached = false;
+    const resolveNeighbors = (current, providerOptions, context, maxEdges, stopAfterFirst, allowedNeighborKeys, excludedRelationshipIds, maxWorkItems) => {
+        const remainingWorkItems = IMPACT_RELATIONSHIP_WORK_ITEMS - relationshipWorkItems;
+        if (remainingWorkItems <= 0) {
+            relationshipWorkLimitReached = true;
+            return {
+                neighbors: [],
+                incomplete: true,
+                excludedNeighbors: false,
+                workLimitReached: true,
+            };
+        }
+        const result = neighborsFor(current, providerOptions, context, maxEdges, stopAfterFirst, allowedNeighborKeys, excludedRelationshipIds, Math.min(maxWorkItems ?? remainingWorkItems, remainingWorkItems));
+        coverage = mergeRelationshipCoverage(coverage, result.coverage ?? []);
+        relationshipWorkItems += result.work?.work_items ?? 0;
+        relationshipWorkLimitReached ||=
+            result.workLimitReached || result.work?.work_limit_reached === true;
+        return result;
+    };
     const classifyObservedNeighbor = (current, neighbor, edgeBlocked) => {
         const nextKey = endpointKey(neighbor.endpoint);
         const isKnownNode = nodes.has(nextKey);
@@ -182,7 +206,7 @@ function traverseWithNeighborProvider(root, neighborsFor, options = {}, requestC
         const current = queue.shift();
         const remainingEdges = normalized.max_edges - selectedEdges.size;
         if (remainingEdges <= 0) {
-            const probe = neighborsFor(current.endpoint, normalized, requestContext, 1, true, undefined, new Set(selectedEdges.keys()), IMPACT_PROBE_WORK_ITEMS);
+            const probe = resolveNeighbors(current.endpoint, normalized, requestContext, 1, true, undefined, new Set(selectedEdges.keys()), IMPACT_PROBE_WORK_ITEMS);
             for (const neighbor of probe.neighbors) {
                 classifyObservedNeighbor(current, neighbor, true);
             }
@@ -196,11 +220,9 @@ function traverseWithNeighborProvider(root, neighborsFor, options = {}, requestC
                 ? "record_limit"
                 : undefined;
         const allowedNeighborKeys = restrictionReason ? new Set(nodes.keys()) : undefined;
-        const batch = neighborsFor(current.endpoint, normalized, requestContext, remainingEdges, false, allowedNeighborKeys, new Set(selectedEdges.keys()));
+        const batch = resolveNeighbors(current.endpoint, normalized, requestContext, remainingEdges, false, allowedNeighborKeys, new Set(selectedEdges.keys()));
         if (batch.excludedNeighbors && restrictionReason)
             truncationReasons.add(restrictionReason);
-        if (batch.workLimitReached)
-            truncationReasons.add("record_limit");
         let skippedNewNode = false;
         for (const neighbor of batch.neighbors) {
             requestContext.checkpoint();
@@ -236,7 +258,7 @@ function traverseWithNeighborProvider(root, neighborsFor, options = {}, requestC
         if (restrictionReason) {
             if (batch.incomplete && !batch.workLimitReached)
                 truncationReasons.add("edge_limit");
-            const probe = neighborsFor(current.endpoint, normalized, requestContext, 1, true, undefined, new Set(selectedEdges.keys()), IMPACT_PROBE_WORK_ITEMS);
+            const probe = resolveNeighbors(current.endpoint, normalized, requestContext, 1, true, undefined, new Set(selectedEdges.keys()), IMPACT_PROBE_WORK_ITEMS);
             for (const neighbor of probe.neighbors) {
                 classifyObservedNeighbor(current, neighbor, selectedEdges.size >= normalized.max_edges);
             }
@@ -244,11 +266,9 @@ function traverseWithNeighborProvider(root, neighborsFor, options = {}, requestC
         }
         if ((skippedNewNode || nodes.size >= normalized.max_nodes) &&
             selectedEdges.size < normalized.max_edges) {
-            const knownBatch = neighborsFor(current.endpoint, normalized, requestContext, normalized.max_edges - selectedEdges.size, false, new Set(nodes.keys()), new Set(selectedEdges.keys()));
+            const knownBatch = resolveNeighbors(current.endpoint, normalized, requestContext, normalized.max_edges - selectedEdges.size, false, new Set(nodes.keys()), new Set(selectedEdges.keys()));
             if (knownBatch.excludedNeighbors)
                 truncationReasons.add("record_limit");
-            if (knownBatch.workLimitReached)
-                truncationReasons.add("record_limit");
             for (const neighbor of knownBatch.neighbors) {
                 requestContext.checkpoint();
                 if (selectedEdges.size >= normalized.max_edges) {
@@ -263,7 +283,7 @@ function traverseWithNeighborProvider(root, neighborsFor, options = {}, requestC
         }
         else if (batch.incomplete && !batch.workLimitReached) {
             truncationReasons.add("edge_limit");
-            const overflowProbe = neighborsFor(current.endpoint, normalized, requestContext, 1, true, undefined, new Set(selectedEdges.keys()), IMPACT_PROBE_WORK_ITEMS);
+            const overflowProbe = resolveNeighbors(current.endpoint, normalized, requestContext, 1, true, undefined, new Set(selectedEdges.keys()), IMPACT_PROBE_WORK_ITEMS);
             for (const neighbor of overflowProbe.neighbors) {
                 classifyObservedNeighbor(current, neighbor, true);
             }
@@ -271,6 +291,9 @@ function traverseWithNeighborProvider(root, neighborsFor, options = {}, requestC
     }
     const orderedReasons = ["depth_limit", "record_limit", "edge_limit"].filter((reason) => truncationReasons.has(reason));
     const truncated = orderedReasons.length > 0;
+    const boundedIncomplete = truncated || relationshipWorkLimitReached;
+    const semanticIncomplete = boundedIncomplete || !isRelationshipCoverageComplete(coverage);
+    const incomplete = semanticAuthority ? semanticIncomplete : boundedIncomplete;
     requestContext.checkpoint();
     return {
         root,
@@ -287,7 +310,14 @@ function traverseWithNeighborProvider(root, neighborsFor, options = {}, requestC
         max_depth: normalized.max_depth,
         max_nodes: normalized.max_nodes,
         max_edges: normalized.max_edges,
-        incomplete: truncated,
+        coverage,
+        work: {
+            work_items: relationshipWorkItems,
+            max_work_items: IMPACT_RELATIONSHIP_WORK_ITEMS,
+            work_limit_reached: relationshipWorkLimitReached,
+        },
+        proven_empty: selectedEdges.size === 0 && !semanticIncomplete,
+        incomplete,
         truncation: createTruncationMetadata(truncated, truncated ? orderedReasons[0] : null),
         truncation_reasons: orderedReasons,
     };
@@ -326,9 +356,11 @@ export function traverseCompilerImpact(project, projectRoot, root, freshness, op
         });
         return {
             neighbors: collectNeighbors(current, resolution.edges, normalized, requestContext),
+            coverage: resolution.coverage,
+            work: resolution.work,
             incomplete: resolution.incomplete,
             excludedNeighbors: resolution.excluded_neighbors,
             workLimitReached: resolution.work_limit_reached,
         };
-    }, options, requestContext);
+    }, options, requestContext, options.authority === "semantic");
 }

package/dist/services/managed-file.js

@@ -1,8 +1,8 @@
 import { randomUUID, createHash } from "node:crypto";
-import { spawn } from "node:child_process";
 import { constants as fsConstants } from "node:fs";
 import { lstat, mkdir, open, realpath, rm } from "node:fs/promises";
 import path from "node:path";
+import { runPublicationPrimitive } from "./authenticated-publication.js";
 export class ManagedFileApplyError extends Error {
     commitState;
     rollbackState;
@@ -23,8 +23,6 @@ export class ManagedFileRollbackError extends Error {
 }
 const GNU_LN_PATH = "/usr/bin/ln";
 const GNU_MV_PATH = "/usr/bin/mv";
-const COREUTILS_TIMEOUT_MS = 5_000;
-const COREUTILS_STDERR_LIMIT = 4_096;
 function errno(error) {
     return error.code;
 }
@@ -34,51 +32,6 @@ function objectIdentity(stats) {
 function identitiesEqual(left, right) {
     return (left !== undefined && right !== undefined && left.dev === right.dev && left.ino === right.ino);
 }
-async function runCoreutils(executable, args, inheritedDescriptors) {
-    await new Promise((resolve, reject) => {
-        const child = spawn(executable, args, {
-            env: { LANG: "C", LC_ALL: "C", PATH: "/usr/bin:/bin" },
-            shell: false,
-            stdio: ["ignore", "ignore", "pipe", ...inheritedDescriptors],
-            windowsHide: true,
-        });
-        let stderrBytes = 0;
-        let settled = false;
-        let requestedFailure;
-        const requestFailure = (message, cause) => {
-            if (settled || requestedFailure !== undefined)
-                return;
-            requestedFailure = new Error(message, cause === undefined ? undefined : { cause });
-            clearTimeout(timeout);
-            child.kill("SIGKILL");
-        };
-        const timeout = setTimeout(() => requestFailure(`Managed Linux primitive timed out: ${path.basename(executable)}`), COREUTILS_TIMEOUT_MS);
-        child.stderr.on("data", (chunk) => {
-            stderrBytes += chunk.byteLength;
-            if (stderrBytes > COREUTILS_STDERR_LIMIT) {
-                requestFailure(`Managed Linux primitive exceeded its stderr limit: ${path.basename(executable)}`);
-            }
-        });
-        child.on("error", (error) => {
-            requestFailure(`Managed Linux primitive is unavailable: ${path.basename(executable)}`, error);
-        });
-        child.on("close", (code, signal) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeout);
-            if (requestedFailure !== undefined) {
-                reject(requestedFailure);
-                return;
-            }
-            if (code === 0 && signal === null) {
-                resolve();
-                return;
-            }
-            reject(new Error(`Managed Linux primitive failed: ${path.basename(executable)} (${signal ?? code ?? "unknown"})`));
-        });
-    });
-}
 export function hashBytes(content) {
     return createHash("sha256").update(content).digest("hex");
 }
@@ -425,10 +378,10 @@ async function removePathIfOwned(directory, basename, expectedIdentity) {
     return (await capturePathIdentity(directory, basename)) === undefined ? "removed" : "changed";
 }
 async function linkHeldFile(source, directory, basename) {
-    await runCoreutils(GNU_LN_PATH, ["-L", "-T", "--", "/proc/self/fd/3", `/proc/self/fd/4/${basename}`], [source.fd, directory.fd]);
+    await runPublicationPrimitive(GNU_LN_PATH, ["-L", "-T", "--", "/proc/self/fd/3", `/proc/self/fd/4/${basename}`], [source.fd, directory.fd]);
 }
 async function exchangeDirectoryEntries(directory, leftBasename, rightBasename) {
-    await runCoreutils(GNU_MV_PATH, [
+    await runPublicationPrimitive(GNU_MV_PATH, [
         "--exchange",
         "--no-copy",
         "-T",

package/dist/services/operation-plan-file.js

@@ -5,7 +5,7 @@ import path from "node:path";
 import { z } from "zod";
 import { applyOperation, configureOperationApply, exportOperationRecord, importOperationRecord, } from "./operations.js";
 import { ensurePrivateDirectory, resolveRuntimeStateDirectory, } from "./runtime-state.js";
-export const PLAN_SCHEMA_VERSION = 1;
+export const PLAN_SCHEMA_VERSION = 2;
 export const MAX_PLAN_BYTES = 50 * 1024 * 1024;
 const HashSchema = z.string().regex(/^[a-f0-9]{64}$/);
 const IsoDateSchema = z.string().datetime({ offset: true });
@@ -62,12 +62,13 @@ const PersistedOperationSchema = z
     files: z.array(PersistedFileSchema).min(1),
 })
     .strict();
-const PlanEnvelopeSchema = z
-    .object({
-    schema_version: z.literal(PLAN_SCHEMA_VERSION),
-    operation: PersistedOperationSchema,
-})
-    .strict();
+const PlanEnvelopeSchema = z.discriminatedUnion("schema_version", [
+    z.object({ schema_version: z.literal(1), operation: PersistedOperationSchema }).strict(),
+    z.object({ schema_version: z.literal(2), operation: PersistedOperationSchema }).strict(),
+]);
+function planEnvelope(version, operation) {
+    return version === 1 ? { schema_version: 1, operation } : { schema_version: 2, operation };
+}
 function stateDirectory(options) {
     return resolveRuntimeStateDirectory(options);
 }
@@ -147,10 +148,7 @@ async function readPlanEnvelope(planFileInput) {
 export async function persistOperationPlan(operationId, options = {}) {
     const plansDirectory = path.join(stateDirectory(options), "plans");
     const planFile = path.join(plansDirectory, `${operationId}.astplan`);
-    await atomicWritePlan(planFile, {
-        schema_version: PLAN_SCHEMA_VERSION,
-        operation: exportOperationRecord(operationId),
-    });
+    await atomicWritePlan(planFile, planEnvelope(PLAN_SCHEMA_VERSION, exportOperationRecord(operationId)));
     return planFile;
 }
 export async function applyPersistedOperation(planFileInput, planHash, options = {}) {
@@ -158,15 +156,16 @@ export async function applyPersistedOperation(planFileInput, planHash, options =
         throw new Error("plan_hash must be a 64-character lowercase SHA-256 digest.");
     }
     const current = await readPlanEnvelope(planFileInput);
-    const operationId = current.envelope.operation.operation_id;
-    importOperationRecord(current.envelope.operation, planHash);
+    const { schema_version: planVersion, operation } = current.envelope;
+    if (planVersion === 1 && operation.status === "prepared") {
+        throw new Error("Legacy v1 prepared plans are not authorized for apply.");
+    }
+    const operationId = operation.operation_id;
+    importOperationRecord(operation, planHash, planVersion);
     configureOperationApply(operationId, {
         stateDirectory: options.stateDirectory,
         receiptWriter: async () => {
-            await atomicWritePlan(current.planFile, {
-                schema_version: PLAN_SCHEMA_VERSION,
-                operation: exportOperationRecord(operationId),
-            });
+            await atomicWritePlan(current.planFile, planEnvelope(planVersion, exportOperationRecord(operationId)));
         },
     });
     return applyOperation(operationId, planHash);
@@ -175,7 +174,7 @@ export async function inspectPersistedPlan(planFileInput) {
     const { envelope } = await readPlanEnvelope(planFileInput);
     const operation = envelope.operation;
     return {
-        schema_version: PLAN_SCHEMA_VERSION,
+        schema_version: envelope.schema_version,
         operation_id: operation.operation_id,
         plan_hash: operation.plan_hash,
         status: operation.status,