@aefree/pi-plastic 0.8.4 → 0.8.5

package/src/domain/pending.ts

@@ -14,6 +14,8 @@ export type PendingItem = {
     revisionId?: string;
     sourceWorkspacePath?: string;
     baseRepository?: string;
+    /** Observation-only fraction in [0, 1]; producer precision is transport-specific. */
+    similarity?: number;
 };
 
 export type PendingItemSummary = {
@@ -35,6 +37,8 @@ export type MachineReadableStatusItem = {
     isDirectory: boolean;
     revisionId?: string;
     sourcePath?: string;
+    /** Observation-only fraction in [0, 1], never rename authorization. */
+    similarity?: number;
 };
 
 export type MachineReadableStatusSummary = Omit<PendingItemSummary, "privatePaths">;
@@ -185,11 +189,29 @@ export const parseMachineReadablePendingItems = (output: string, cwd: string): P
 export const hasStatusPathDecodingLoss = (path: string, platform: NodeJS.Platform = process.platform): boolean =>
     path.includes("\uFFFD") || (platform === "win32" && path.includes("?"));
 
+// Observation-only lexical identities. Never use these diagnostics as mutation admission.
+export const statusObservationPathKey = (value: string): string | null => {
+    if (!value || value.length > 4096 || /[\u0000-\u001f\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(value)) return null;
+    const path = value.replace(/\\/g, "/");
+    if (!/^(?:\/|[A-Za-z]:\/)/.test(path) || path.split("/").some(part => part === "." || part === "..")) return null;
+    const windows = /^[A-Za-z]:\//.test(path) || path.startsWith("//");
+    const tail = path.slice(path.startsWith("//") ? 2 : windows ? 3 : 1);
+    if (tail.includes("//") || (windows && (/[<>:"|?*]/.test(tail) || tail.split("/").some(part => /[. ]$/.test(part))))) return null;
+    if (path.startsWith("//") && !/^\/\/[^/]+\/[^/]+\//.test(path)) return null;
+    const key = windows ? path.toLowerCase() : path;
+    return key.length > (windows ? 3 : 1) ? key.replace(/\/$/, "") : key;
+};
+export const statusObservationPathRoot = (value: string): string => {
+    const path = value.replace(/\\/g, "/").toLowerCase();
+    return path.match(/^[a-z]:/)?.[0] ?? (path.startsWith("//") ? path.split("/").slice(0, 4).join("/") : "/");
+};
+
 // Diagnostics deliberately leave the legacy selection parser unchanged for mutation/diff consumers.
 export const diagnoseMachineReadablePendingItems = (output: string, cwd: string, platform: NodeJS.Platform = process.platform) =>
 {
     const diagnostics = { valid: 0, blank: 0, header: 0, unsupported: 0, malformed: 0, ambiguousLegacyMove: 0 };
     const pendingItems: PendingItem[] = [];
+    const seen = new Set<string>();
     for (const rawLine of output.split(/\r?\n/))
     {
         const line = rawLine.trim();
@@ -198,7 +220,32 @@ export const diagnoseMachineReadablePendingItems = (output: string, cwd: string,
         if (fields[0] === "STATUS" && fields.length === 4 && /^\d+$/.test(fields[1]) && fields[2] && fields[3]) { diagnostics.header++; continue; }
         if (/^STATUS \d+ \S+ \S+$/.test(line)) { diagnostics.header++; continue; }
         if (fields[0] === "STATUS" || line.startsWith("STATUS ")) { diagnostics.malformed++; continue; }
+        // Inferred moves are observed separately; legacy mutation/diff selection is unchanged.
+        if (fields[0] === "LM") {
+            const [, percent, source, destination, directory, revision, metadata] = fields;
+            const sourceKey = statusObservationPathKey(source ?? "");
+            const destinationKey = statusObservationPathKey(destination ?? "");
+            const validPercent = (percent?.length ?? 0) <= 64 && /^(?:100(?:\.0+)?|[0-9]{1,2}(?:\.[0-9]+)?)%$/.test(percent ?? "");
+            if (fields.length !== 7 || !validPercent || !sourceKey || !destinationKey || sourceKey === destinationKey ||
+                statusObservationPathRoot(source) !== statusObservationPathRoot(destination) ||
+                seen.has(sourceKey) || seen.has(destinationKey) || (directory !== "True" && directory !== "False") ||
+                !/^[1-9][0-9]{0,19}$/.test(revision ?? "") || metadata !== "NO_MERGES" ||
+                [source, destination].some(path => hasStatusPathDecodingLoss(path, platform))) {
+                diagnostics.malformed++; continue;
+            }
+            seen.add(sourceKey); seen.add(destinationKey);
+            pendingItems.push({ statusCode: "LM", kind: "moved", workspacePath: destination,
+                normalizedPath: toNormalizedAbsolutePath(destination, cwd), comparisonKey: toPathComparisonKey(destination, cwd),
+                isDirectory: directory === "True", revisionId: revision, sourceWorkspacePath: source, similarity: Number(percent.slice(0, -1)) / 100 });
+            diagnostics.valid++; continue;
+        }
         const items = parseMachineReadablePendingItems(line, cwd);
+        for (const item of items) {
+            for (const path of [item.workspacePath, item.sourceWorkspacePath].filter((path): path is string => path !== undefined)) {
+                const key = statusObservationPathKey(path);
+                if (key) { if (seen.has(key)) diagnostics.malformed++; seen.add(key); }
+            }
+        }
         pendingItems.push(...items);
         if (items.length) {
             diagnostics.valid++;
@@ -239,6 +286,7 @@ export const toMachineReadableStatusItems = (pendingItems: PendingItem[]): Machi
         isDirectory: item.isDirectory,
         ...(item.revisionId ? { revisionId: item.revisionId } : {}),
         ...(item.sourceWorkspacePath ? { sourcePath: item.sourceWorkspacePath } : {}),
+        ...(item.similarity !== undefined ? { similarity: item.similarity } : {}),
     }));
 
 export const toMachineReadableStatusSummary = (pendingItems: PendingItem[], cwd: string): MachineReadableStatusSummary =>

package/src/domain/server-merge-contract.ts

@@ -13,7 +13,7 @@ export type MergeReceiptData = {
     capability: { state: "not-checked" | "advertised" | "missing" | "unavailable"; missingTokens: string[] };
     attempt: MergeAttempt;
     capture: { help: MergeCapture | null; merge: MergeCapture | null };
-    parse: { records: number; malformed: boolean; unknownOperations: number; changesetsObserved: number; conflictsObserved: number; warningsObserved: number } | null;
+    parse: { records: number; malformed: boolean; unknownOperations: number; changesetsObserved: number; conflictsObserved: number; warningsObserved: number; unknownOperationClasses: string[]; resolvedConflictsVerified: number } | null;
     observedChangesets: ServerChangeset[];
     conflictPaths: string[];
     counts: { changesetsReturned: number; changesetsOmitted: number; conflictsReturned: number; conflictsOmitted: number };

package/src/domain/status-xml.ts

@@ -1,5 +1,5 @@
 import { DOMParser, type Element } from "@xmldom/xmldom";
-import type { MachineReadableStatusItem, MachineReadableStatusSummary } from "./pending";
+import { statusObservationPathKey, statusObservationPathRoot, type MachineReadableStatusItem, type MachineReadableStatusSummary } from "./pending";
 
 import { STATUS_XML_LIMITS } from "../execution/status-xml-limits";
 export { STATUS_XML_LIMITS } from "../execution/status-xml-limits";
@@ -13,11 +13,12 @@ export class StatusXmlError extends Error {
 }
 function invalid(): never { throw new StatusXmlError(); }
 function limit(): never { throw new StatusXmlError("output_overflow"); }
-const kinds = { CH: "changed", CO: "changed", CP: "added", RP: "changed", AD: "added", DE: "deleted", LD: "deleted", MV: "moved", PR: "private" } as const;
+const kinds = { CH: "changed", CO: "changed", CP: "added", RP: "changed", AD: "added", DE: "deleted", LD: "deleted", MV: "moved", LM: "moved", PR: "private" } as const;
 const fields = new Set(["Type", "TypeVerbose", "Path", "OldPath", "PrintableMovedPath", "MergesInfo", "SimilarityPerUnit", "Similarity", "Size", "PrintableSize", "PrintableLastModified", "RevisionType", "LastModified"]);
 const isAbsolute = (path: string): boolean => path.startsWith("/") || /^[A-Za-z]:\\/.test(path) || /^\\\\[^\\]+\\[^\\]+\\/.test(path);
 const identity = (value: string): string => {
     if (!value || value.length > STATUS_XML_LIMITS.path || !isAbsolute(value) || /[\u0000-\u001f\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(value) || (process.platform === "win32" && value.includes("?"))) invalid();
+    if (!statusObservationPathKey(value)) invalid();
     return value;
 };
 
@@ -107,13 +108,26 @@ export function parseStatusXml(bytes: Uint8Array): { output: string; items: XmlS
         if (!/^en[A-Za-z0-9]+$/.test(revisionType)) invalid();
         const supportedType = revisionType === "enDirectory" || revisionType === "enTextFile" || revisionType === "enBinaryFile";
         if (supportedStatus && (kind === "moved") !== Boolean(oldPath)) invalid();
-        if (oldPath && identity(oldPath) === path) invalid();
-        if (seen.has(path)) invalid();
-        seen.add(path);
+        if (oldPath) identity(oldPath);
+        const keys = [path, ...(oldPath ? [oldPath] : [])].map(value => statusObservationPathKey(value)!);
+        if (new Set(keys).size !== keys.length || keys.some(key => seen.has(key))) invalid();
+        for (const key of keys) seen.add(key);
+        let similarity: number | undefined;
+        if (statusCode === "LM") {
+            if (statusObservationPathRoot(path) !== statusObservationPathRoot(oldPath)) invalid();
+            const perUnit = leaf(row.get("SimilarityPerUnit"));
+            if (perUnit.length > 64 || !/^(?:0(?:\.[0-9]+)?|1(?:\.0+)?)$/.test(perUnit)) invalid();
+            similarity = Number(perUnit);
+            // Rounded display is neither the identity nor an exact equality check on the fraction.
+            if (row.has("Similarity")) {
+                const display = leaf(row.get("Similarity"));
+                if (display.length > 64 || !/^(?:100(?:\.0+)?|[0-9]{1,2}(?:\.[0-9]+)?)%$/.test(display)) invalid();
+            }
+        }
         // Validate the entire document before reporting unsupported profiles: a later unsafe
         // identity/structure must not be masked by an earlier unadmitted record.
         if (!supportedStatus || !supportedType) { unsupported = true; continue; }
-        items.push({ statusCode: statusCode as keyof typeof kinds, kind: kind!, path, isDirectory: revisionType === "enDirectory", ...(oldPath ? { sourcePath: oldPath } : {}) });
+        items.push({ statusCode: statusCode as keyof typeof kinds, kind: kind!, path, isDirectory: revisionType === "enDirectory", ...(oldPath ? { sourcePath: oldPath } : {}), ...(similarity !== undefined ? { similarity } : {}) });
     }
     if (unsupported) throw new StatusXmlError("unsupported_source");
     const summary: MachineReadableStatusSummary = { totalPending: items.length, added: 0, changed: 0, moved: 0, deleted: 0, private: 0, other: 0, tracked: 0 };

package/src/operations/checkin-receipt.ts

@@ -1,3 +1,6 @@
+import { win32 } from "node:path";
+import { admitMergedStandardStatus, correlateMergedCheckin } from "../domain/merged-workspace";
+import { parseSwitchLoadedBranch } from "../domain/switch-contract";
 import { randomBytes } from "node:crypto";
 import { buildFallbackScopePaths } from "../domain/paths";
 import { summarizePendingItems, resolveCheckinPaths, filterPendingItemsByScope, selectPrivatePathsForAutoAdd, type PendingItem } from "../domain/pending";
@@ -7,6 +10,34 @@ const pendingArgv = ["status", "--machinereadable", "--includeRevId", "--fieldse
 const summary = (items: PendingItem[], cwd: string): CheckinSummary => { const { privatePaths: _, ...s } = summarizePendingItems(items, cwd); return s; };
 const normal = (o: CheckinCommandObservation) => o.capture.complete && !o.failed && o.attempt.state === "started" && o.attempt.terminal === "observed" && o.attempt.exitCode !== null && !o.attempt.aborted && !o.attempt.timedOut;
 const success = (o: CheckinCommandObservation) => normal(o) && o.attempt.exitCode === 0 && o.capture.stderrBytes === 0;
+// Inspect section/row markers, never words embedded in a branch or filename.
+// Default status can omit unchanged checkouts, so a valid header-only body is
+// allowed; unfamiliar sections/metadata still cannot establish ordinary state.
+function ordinaryStatusBodyAdmitted(text: string): boolean {
+    const shapes = {
+        Changed: { header: /^    Status +Size +Last Modified +Path *$/, label: "(?:Changed|Checked-out \\((?:changed|unchanged)\\))" },
+        Added: { header: /^    Status +Size +Last Modified +Path *$/, label: "(?:Added|Private)" },
+        Deleted: { header: /^    Status +Size +Path *$/, label: "(?:Deleted|Locally deleted|Removed)" },
+        Moved: { header: /^    Status +Size +Similarity +Path *$/, label: "(?:Moved|Moved locally)" },
+    };
+    let section: keyof typeof shapes | null = null, needsHeader = false;
+    const seen = new Set<string>();
+    for (const line of text.split(/\r?\n/).slice(1)) {
+        if (!line.trim()) continue;
+        if (line.length > 4096 || /[\u0000-\u001f\u007f-\u009f]/.test(line)) return false;
+        if (Object.hasOwn(shapes, line)) {
+            if (needsHeader || seen.has(line)) return false;
+            seen.add(line); section = line as keyof typeof shapes; needsHeader = true; continue;
+        }
+        if (!section) return false;
+        const shape = shapes[section];
+        if (needsHeader) { if (!shape.header.test(line)) return false; needsHeader = false; continue; }
+        // A status-label annotation is metadata, unlike a parenthesis in the
+        // later path cell. Unknown annotations (including Merge from) fail.
+        if (new RegExp(`^    ${shape.label} +\\(`).test(line) || !new RegExp(`^    ${shape.label} {2,}.+$`).test(line)) return false;
+    }
+    return !needsHeader;
+}
 function validateRequest(input: unknown): asserts input is CheckinRequest {
     if (!input || typeof input !== "object" || Array.isArray(input)) throw Error("Invalid bounded checkin input.");
     const r = input as Record<string, unknown>;
@@ -66,6 +97,21 @@ export async function assembleCheckinReceipt(input: unknown): Promise<CheckinRec
         const before = await read("pending-before");
         if (!before) return finish("unsupported", "pending_source_unadmitted", "pending", "Pending selection could not be admitted; no mutation was dispatched.");
         data.pendingBefore = summary(before.items, cwd);
+        const merged = before.merged;
+        let loaded: ReturnType<typeof parseSwitchLoadedBranch> = null;
+        // CO/-1/NO_MERGES also occurs during an unresolved merge. Read the
+        // native link state before any checkin, including standalone/preflight.
+        if (merged || before.items.some(i => i.statusCode === "CO")) {
+            const { o, s } = await record("merge-readiness", ["status"]);
+            loaded = success(o) ? parseSwitchLoadedBranch(o.stdout ?? "") : null;
+            const source = /^    Merge from cs:[1-9][0-9]{0,19} at (.+)\r?$/m.exec(o.stdout ?? "")?.[1];
+            const ready = loaded && loaded.repository === before.repository && loaded.server === before.server && (merged
+                ? !!source && admitMergedStandardStatus(o.stdout!, merged, source, cwd)
+                : ordinaryStatusBodyAdmitted(o.stdout ?? ""));
+            if (!ready) return finish("unsupported", "merge_readiness_unadmitted", "pending", "Merge source/resolution metadata could not be admitted; no checkin was dispatched.");
+            s.evidence = "admitted";
+        }
+        if (merged && input.includePrivate) return finish("unsupported", "merged_private_scope", "pending", "Merged checkin does not admit private inclusion; leave unrelated private work excluded.");
         let includedAbsolute: string[] = [], scoped = before.items, apply = input.applyChanged ?? false;
         if (input.paths?.length) {
             const r = resolveCheckinPaths(input.paths, before.items, cwd);
@@ -74,20 +120,33 @@ export async function assembleCheckinReceipt(input: unknown): Promise<CheckinRec
             scoped = filterPendingItemsByScope(before.items, includedAbsolute);
             if (!data.includedPaths.length) return finish("failed", "NO_PENDING_PATHS", "pending", "None of the provided checkin paths have admitted pending changes.");
         }
+        if (merged) {
+            data.excludedPaths.push(...before.items.filter(i => i.kind === "private").map(i => ({ path: i.workspacePath, reason: "Unrelated private work excluded from merged checkin (includePrivate=false)." })));
+            scoped = scoped.filter(i => i.kind !== "private");
+            if (merged.privateRows.length) {
+                // Do not rely on workspace-wide --all selection in the presence
+                // of private work. These directories are proven disjoint above.
+                data.includedPaths = merged.rows.map(r => win32.relative(cwd, r.path));
+            }
+            // All merged controlled rows must remain selected. Partial merge
+            // checkins and directory scopes overlapping private rows are unproven.
+            if (scoped.length !== merged.rows.length) return finish("unsupported", "merged_partial_scope", "pending", "All correlated merged controlled paths must be selected.");
+        }
         const nonce = randomBytes(16).toString("hex"), seps = { start: `__PI_CI_START_${nonce}__`, end: `__PI_CI_END_${nonce}__`, field: `__PI_CI_FIELD_${nonce}__` };
         const command = (paths: string[], force: boolean) => ["checkin", `-c=${input.message}`, ...(input.includeAll ? ["--all"] : []), ...(force ? ["--applychanged"] : []), ...(input.includePrivate ? ["--private"] : []), ...paths, "--machinereadable", `--startlineseparator=${seps.start}`, `--endlineseparator=${seps.end}`, `--fieldseparator=${seps.field}`];
         const initial = command(data.includedPaths, apply); data.command = ["cm", ...initial]; data.wouldRun = true;
         if (input.preflight) return finish("preflight");
         const attempt = async (name: "initial-checkin" | "private-retry" | "fallback-checkin", argv: string[]) => {
             const { o, s } = await record(name, argv), p = parseCheckinEvidence(o.stdout ?? "", seps); s.records = p.records;
-            const admitted = p.admitted && p.changesets.every(c => c.repository === before.repository);
+            const mergedEvents = !merged || correlateMergedCheckin(p.events, merged, cwd);
+            const admitted = p.admitted && mergedEvents && p.changesets.every(c => c.repository === before.repository && c.server === before.server && (!loaded || c.branch === loaded.branch));
             if (admitted && normal(o)) {
                 s.evidence = "admitted";
                 data.itemEvents.push(...p.events); data.observedChangesets.push(...p.changesets);
             }
             if (success(o) && admitted && p.changesets.length === 1) { created = p.changesets[0]; s.changeset = created; s.effect = "changeset-created"; }
             // Only genuine complete native failure without a created record may drive the existing recovery policy.
-            const retryEligible = normal(o) && admitted && o.attempt.exitCode !== 0 && p.changesets.length === 0;
+            const retryEligible = !merged && normal(o) && admitted && o.attempt.exitCode !== 0 && p.changesets.length === 0;
             return { completed: !!s.changeset, retryEligible, message: retryEligible ? o.stderr ?? "" : "" };
         };
         stage = "checkin";

package/src/operations/consolidated-diff.ts

@@ -17,10 +17,23 @@ export type DiffRequest = { workdir?:string;format?:"text"|"json";maxChars?:numb
     {mode:"workspace";paths:string[];allPending?:never;includePrivate?:never;maxFiles?:number} |
     {mode:"workspace";allPending:true;paths?:never;includePrivate?:boolean;maxFiles?:number}
 );
+const baseMessages = {
+    "fileinfo-command": "Loaded-base fileinfo observation failed. No baseline was selected; inspect command/capture state before another attempt.",
+    "fileinfo-profile": "Loaded-base fileinfo XML is unsupported or malformed. Retain sanitized producer evidence; no baseline was guessed.",
+    "fileinfo-path": "Loaded-base fileinfo path does not match the requested workspace path. No baseline was selected.",
+    "fileinfo-type": "Loaded-base fileinfo item type is unsupported. No baseline was selected.",
+    "deletion-state": "Loaded deletion metadata conflicts with pending status. No empty baseline was substituted.",
+    "ls-command": "Loaded-base ls observation failed. No baseline was selected; inspect command/capture state before another attempt.",
+    "ls-profile": "Loaded-base ls XML is unsupported or malformed. Retain sanitized producer evidence; no baseline was guessed.",
+    "ls-path": "Loaded-base tree path does not match the inspected path. No baseline was selected.",
+    "revision-mismatch": "Loaded-base changeset/hash observations disagree. No baseline was selected; workspace changes may have displaced the observation.",
+    "ownership-mismatch": "Loaded-base repository/server identity is inconsistent. Alias equivalence is unverified. No baseline was selected.",
+} as const;
+type BaseReason = keyof typeof baseMessages;
 export class ConsolidatedDiffError extends Error {
-    constructor(readonly code:string,readonly stage:string) { super("The requested diff could not be verified."); }
+    constructor(readonly code:string,readonly stage:string,readonly reason?:BaseReason) { super("The requested diff could not be verified."); }
 }
-const fail=(code:string,stage:string):never=>{throw new ConsolidatedDiffError(code,stage);};
+const fail=(code:string,stage:string,reason?:BaseReason):never=>{throw new ConsolidatedDiffError(code,stage,reason);};
 const aborted=()=>{if(getActiveAbortSignal()?.aborted)fail("aborted","comparison");};
 const safe=(s:unknown,max:number):s is string=>typeof s==="string"&&s.length>0&&s.length<=max&&s.trim()===s&&!/[\u0000-\u001f\u007f-\u009f]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(s);
 export function validateDiffRequest(input:unknown):asserts input is DiffRequest {
@@ -76,21 +89,32 @@ function comparison(observation:DiffRevisionsObservation,left:DiffSide,right:Dif
 const side=(origin:DiffSide["origin"],bytes:Buffer,path:string|null,selector:string|null,identity:LoadedIdentity|null=null):DiffSide=>({origin,path,selector,identity,bytes:bytes.length,binary:isBinaryContent(bytes)});
 async function pending(cwd:string):Promise<DiffPendingSnapshot>{try{return parseDiffPending(await xmlCommand(["status","--xml","--encoding=utf-8","--fullpaths","--iscochanged"],cwd,"status"));}catch(e){if(e instanceof ConsolidatedDiffError)throw e;return fail("malformed_output","status");}}
 async function base(path:string,cwd:string,snapshot:DiffPendingSnapshot,item:DiffPendingItem|null):Promise<{selector:string;identity:LoadedIdentity;hash:string;algorithm:"md5"|"sha1"}>{
+    let phase:"fileinfo-profile"|"ls-profile"="fileinfo-profile";
     try {
         const info=parseLoadedFileInfo(await xmlCommand(["fileinfo",path,"--fields=ClientPath,ServerPath,RevisionChangeset,Hash,RepSpec,Status,Type","--xml","--encoding=utf-8"],cwd,"base"));
-        if(key(info.clientPath)!==key(path)||!["txt","bin","file"].includes(info.type.toLowerCase()))return fail("base_unavailable","base");
+        if(key(info.clientPath)!==key(path))return fail("base_unavailable","base","fileinfo-path");
+        if(!["txt","bin","file"].includes(info.type.toLowerCase()))return fail("base_unavailable","base","fileinfo-type");
         // DE removes live-tree membership/RepSpec. Deliberately inspect the
         // frozen loaded root tree, never retry a failed live-tree lookup or
         // guess a parent owning repository. Require loaded changeset/hash match.
         const deleted=item?.code==="DE";
-        if(deleted&&info.status!=="deleted")return fail("base_changed","base");
+        if(deleted&&info.status!=="deleted")return fail("base_changed","base","deletion-state");
         const query=deleted?["ls",info.serverPath,"--tree=cs:"+snapshot.changeset+"@"+snapshot.repository+"@"+snapshot.server,"--xml","--encoding=utf-8"]:["ls",path,"--xml","--encoding=utf-8"];
+        phase="ls-profile";
         const row=parseLoadedLs(await xmlCommand(query,cwd,"base"));
-        if((deleted?row.path!==info.serverPath:key(row.path)!==key(path))||row.changeset!==info.changeset||row.hash!==info.hash||!deleted&&info.repSpec!==row.repository+"@"+row.server)return fail("base_changed","base");
+        if(deleted?row.path!==info.serverPath:key(row.path)!==key(path))return fail("base_changed","base","ls-path");
+        if(row.changeset!==info.changeset||row.hash!==info.hash)return fail("base_changed","base","revision-mismatch");
+        if(!deleted&&info.repSpec!==row.repository+"@"+row.server)return fail("base_changed","base","ownership-mismatch");
         const selector="revid:"+row.revisionId+"@rep:"+row.repository+"@repserver:"+row.server;
         if(!validDiffRevisionsSelector(selector))return fail("invalid_selector","base");
         return {selector,identity:{revisionId:row.revisionId,changeset:row.changeset,repository:row.repository,server:row.server},hash:row.hash,algorithm:row.algorithm};
-    }catch(e){if(e instanceof ConsolidatedDiffError)throw e;return fail("base_unavailable","base");}
+    }catch(e){
+        if(e instanceof ConsolidatedDiffError){
+            if(e.code==="command_failed")return fail(e.code,e.stage,phase==="fileinfo-profile"?"fileinfo-command":"ls-command");
+            throw e;
+        }
+        return fail("base_unavailable","base",phase);
+    }
 }
 async function fileComparison(args:DiffRequest&{mode:"file"},cwd:string,root:string,snapshot:DiffPendingSnapshot|null,item:DiffPendingItem|null):Promise<Comparison>{
     const path=resolve(cwd,args.path);if(!contains(root,path))return fail("outside_workspace","selection");
@@ -111,7 +135,7 @@ async function fileComparison(args:DiffRequest&{mode:"file"},cwd:string,root:str
     } finally {await fs.rm(temp,{recursive:true,force:true}).catch(()=>fail("cleanup_failed","cleanup"));}
 }
 export type DiffOutcome={path:string;sourcePath:string|null;kind:string;status:"compared";comparison:Comparison}|{path:string;sourcePath:string|null;kind:string;status:"skipped-directory"}|{path:string;sourcePath:string|null;kind:string;status:"unavailable";error:{code:string;stage:string;message:string}};
-export function diffError(e:unknown){const r=e as {code?:unknown;stage?:unknown};const codes=new Set(["invalid_request","invalid_selector","workspace_unavailable","outside_workspace","base_unavailable","base_changed","malformed_output","command_failed","aborted","cleanup_failed","materialization_failed","materialization_limit","invalid_utf8","capture_incomplete","output_overflow","missing_file","unsupported_file","file_limit","file_changed","read_failed"]);return {code:typeof r?.code==="string"&&codes.has(r.code)?r.code:"comparison_failed",stage:typeof r?.stage==="string"&&["input","selection","status","base","left","right","comparison","cleanup","producer"].includes(r.stage)?r.stage:"comparison",message:"The requested diff could not be verified."};}
+export function diffError(e:unknown){const r=e as {code?:unknown;stage?:unknown};const codes=new Set(["invalid_request","invalid_selector","workspace_unavailable","outside_workspace","base_unavailable","base_changed","malformed_output","command_failed","aborted","cleanup_failed","materialization_failed","materialization_limit","invalid_utf8","capture_incomplete","output_overflow","missing_file","unsupported_file","file_limit","file_changed","read_failed"]);return {code:typeof r?.code==="string"&&codes.has(r.code)?r.code:"comparison_failed",stage:typeof r?.stage==="string"&&["input","selection","status","base","left","right","comparison","cleanup","producer"].includes(r.stage)?r.stage:"comparison",message:e instanceof ConsolidatedDiffError&&e.reason?baseMessages[e.reason]:r?.code==="materialization_limit"?"Historical file exceeds the 4 MiB materialization limit. maxChars controls output only; no empty baseline was substituted.":"The requested diff could not be verified."};}
 export async function assembleConsolidatedDiff(input:unknown){
     validateDiffRequest(input);const args=input;aborted();
     const header={schemaVersion:1 as const,action:"diff" as const,mode:args.mode,provenance:{source:"plastic" as const,producer:"@aefree/pi-plastic" as const,contentTrust:"external" as const}};

package/src/operations/patch-receipt.ts

@@ -39,7 +39,7 @@ export function patchFailure(d: PatchData, code: Extract<PatchReceipt,{ok:false}
     return {...header(d),ok:false,outcome:["started","unknown"].includes(d.attempt.state)&&!d.artifact?"uncertain":"failed",error:{code,message}};
 }
 export async function assemblePatchReceipt(args: unknown): Promise<PatchReceipt> {
-    const d=emptyPatchData();let stage: string|null=null;let entered=false;let failure: {code:Extract<PatchReceipt,{ok:false}>["error"]["code"];message:string}|null=null;
+    const d=emptyPatchData();let stage: string|null=null;let setupStage:"backend"|"selector"|"output"="backend";let entered=false;let failure: {code:Extract<PatchReceipt,{ok:false}>["error"]["code"];message:string}|null=null;
     try {
         if (!args||typeof args!=="object"||Array.isArray(args)||Object.keys(args).some(k=>!["source","destination","output","toolPath","clean","integration","workdir","preflight","format"].includes(k)))
             return patchFailure(d,"invalid_request","Use declared bounded patch controls only.");
@@ -49,11 +49,13 @@ export async function assemblePatchReceipt(args: unknown): Promise<PatchReceipt>
         d.requested=r;d.publication=r.output===null?"not-requested":"not-published";
         const toolPath=resolvePatchToolPath(r.toolPath??undefined);
         if (!validPatchText(toolPath)) throw new Error("Invalid patch backend.");
+        setupStage="selector";
         const branch=await resolvePatchBranchSpecs({source:r.source,...(r.destination===null?{}:{destination:r.destination})},r.workdir);
         const v={source:branch.source,destination:branch.destination??null,toolPath,output:r.output===null?null:isAbsolute(r.output)?r.output:resolve(r.workdir,r.output)};
         if ([v.source,v.destination,v.toolPath,v.output].some(s=>s!==null&&(s.length>8192||/[\u0000-\u001f\u007f-\u009f]/.test(s)))) throw new Error("Resolved patch controls exceed limits.");
         d.resolved=v;d.intendedArgv=patchReceiptArgv(r,v);
         if (r.preflight) return {...header(d),ok:true,outcome:"preflight"};
+        setupStage="output";
         if (v.output!==null) await ensurePatchOutputDoesNotExist(v.output);
         stage=await fs.mkdtemp(join(v.output===null?tmpdir():resolve(v.output,".."),".pi-plastic-patch-"));
         const staged=join(stage,"patch-output");
@@ -77,7 +79,12 @@ export async function assemblePatchReceipt(args: unknown): Promise<PatchReceipt>
         }
     } catch {
         if (entered&&d.capture===null) {d.attempt={...emptyWorkspaceMergeAttempt(),state:"unknown"};d.effect="unverified";}
-        failure={code:entered?"producer_failed":"setup_failed",message:entered?"Patch observation failed; earlier observed effects remain recorded, no automatic retry.":"Patch setup unavailable. Verify exact selector repository, backend and new output parent; no command was dispatched."};
+        const setupMessages={
+            backend:"Patch backend unavailable. Set PI_PLASTIC_PATCH_EXECUTABLE to a verified non-GUI GNU-compatible executable, or pass toolPath. No command was dispatched.",
+            selector:"Patch selector repository could not be verified. Use an exact qualified br:/branch@repository@server selector. No command was dispatched.",
+            output:"Patch output is unavailable or already exists. Use a new filename in an existing writable parent directory. No command was dispatched.",
+        };
+        failure={code:entered?"producer_failed":"setup_failed",message:entered?"Patch observation failed; earlier observed effects remain recorded, no automatic retry.":setupMessages[setupStage]};
     } finally {
         if (stage!==null) {
             if (entered&&(d.attempt.state==="unknown"||d.attempt.state==="started")&&(d.attempt.terminal!=="observed"||d.attempt.aborted||d.attempt.timedOut)) {d.cleanup="retained";d.retainedStagingDirectory=stage;}

package/src/operations/server-merge.ts

@@ -1,10 +1,12 @@
-import { randomBytes } from "node:crypto";
+import { lstat, open, realpath } from "node:fs/promises";
+import { resolve } from "node:path";
+import { randomBytes, createHash } from "node:crypto";
 import { assertAbsoluteResolutionPath, inspectResolutionFile } from "../domain/server-merge-resolutions";
 import { getActiveAbortSignal } from "../execution/context";
 import { captureServerMergeCommand } from "../execution/server-merge-command";
 import { tool } from "../tool-definition";
 import { outputFormatArg, formatServerMergeResult } from "../presentation/results";
-import { parseServerMergeOutput } from "../domain/merge-output";
+import { isSafeServerMergePath, parseServerMergeOutput } from "../domain/merge-output";
 import { emptyMergeAttempt, splitServerBranch, type MergeReceipt, type MergeReceiptData, type ServerMergeRequest } from "../domain/server-merge-contract";
 export { splitServerBranch };
 export type { MergeReceipt } from "../domain/server-merge-contract";
@@ -14,7 +16,7 @@ export const SERVER_MERGE_OUTPUT_LIMIT = 32768, SERVER_MERGE_HELP_TIMEOUT_MS = 3
 export const serverMergeControlPattern = /[\u0000-\u001f\u007f-\u009f]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
 export const serverMergeCapabilityTokens = ["--to", "--merge", "--nointeractiveresolution", "--machinereadable", "--startlineseparator", "--endlineseparator", "--fieldseparator"];
 export function assertSafeServerMergeValue(name: string, value: string): string {
-    if (typeof value !== "string" || !value.trim() || value.length > 4096 || serverMergeControlPattern.test(value)) throw new ServerMergeInputError(`${name} must be non-empty, bounded and free of control/malformed characters.`);
+    if (typeof value !== "string" || !value.trim() || value.length > 4096 || (name === "message" ? /[\u0000-\u0009\u000b\u000c\u000e-\u001f\u007f-\u009f]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(value) : serverMergeControlPattern.test(value))) throw new ServerMergeInputError(`${name} must be non-empty, bounded and free of unsupported controls or malformed Unicode; only comments may contain CR/LF.`);
     return value.trim();
 }
 export function parseQualifiedServerBranch(name: string, value: string): QualifiedServerBranch {
@@ -40,6 +42,41 @@ export function validateServerMergeRequest(input: unknown): asserts input is Ser
     if (s.repository !== t.repository || s.server !== t.server) throw new ServerMergeInputError("source and target must identify the same exact repository and server.");
     if (s.branch === t.branch) throw new ServerMergeInputError("source and target must identify different branches.");
 }
+// Only the observed resultFile-only candidate closeout uses this bounded snapshot.
+// It verifies caller inputs, not the bytes stored by the server; callers still own
+// immutability during dispatch and point-in-time races remain possible.
+type ResolutionSnapshot = { digest: string; paths: string[] };
+async function snapshotResolutionInputs(path: string): Promise<ResolutionSnapshot> {
+    const bounded = async (path: string, cap: number): Promise<Buffer> => {
+        const st = await lstat(path);
+        const lexical = resolve(path), physical = await realpath(path);
+        const key = (s: string) => process.platform === "win32" ? s.toLowerCase() : s;
+        if (!st.isFile() || st.isSymbolicLink() || key(lexical) !== key(physical) || st.size > cap) throw Error("invalid");
+        const handle = await open(path, "r");
+        try {
+            const before = await handle.stat();
+            if (!before.isFile() || before.dev !== st.dev || before.ino !== st.ino || before.size !== st.size || before.mtimeMs !== st.mtimeMs || before.ctimeMs !== st.ctimeMs) throw Error("unstable");
+            const bytes = Buffer.alloc(cap + 1); let length = 0;
+            while (length < bytes.length) { const r = await handle.read(bytes, length, bytes.length - length, null); if (!r.bytesRead) break; length += r.bytesRead; }
+            const after = await handle.stat(), final = await lstat(path);
+            if (length > cap || length !== before.size || after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs || final.isSymbolicLink() || final.ino !== before.ino || final.dev !== before.dev || final.size !== before.size || final.mtimeMs !== before.mtimeMs || final.ctimeMs !== before.ctimeMs) throw Error("unstable");
+            return bytes.subarray(0, length);
+        } finally { await handle.close(); }
+    };
+    const bytes = await bounded(path, 1024 * 1024);
+    const json = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    if (!Array.isArray(json.resolutions) || json.resolutions.length > 500) throw Error("invalid");
+    const hash = createHash("sha256").update(bytes), paths: string[] = [], keys = new Set<string>();
+    let remaining = 4 * 1024 * 1024;
+    for (const entry of json.resolutions) {
+        if (typeof entry.path !== "string" || !isSafeServerMergePath(entry.path) || keys.has(entry.path.toLowerCase()) || typeof entry.resultFile !== "string" || Object.keys(entry).some(k => !["path", "resultFile"].includes(k))) throw Error("invalid");
+        assertAbsoluteResolutionPath(entry.resultFile);
+        keys.add(entry.path.toLowerCase()); paths.push(entry.path);
+        const result = await bounded(entry.resultFile, remaining); remaining -= result.length;
+        hash.update(createHash("sha256").update(result).digest());
+    }
+    return { digest: hash.digest("hex"), paths };
+}
 export async function assembleServerMergeReceipt(input: unknown): Promise<MergeReceipt> {
     const data: MergeReceiptData = { mode: "apply", resolutionsFile: null, unlistedConflictPolicy: null, requestedIdentity: null, command: null, capability: { state: "not-checked", missingTokens: [] }, attempt: emptyMergeAttempt(), capture: { help: null, merge: null }, parse: null, observedChangesets: [], conflictPaths: [], counts: { changesetsReturned: 0, changesetsOmitted: 0, conflictsReturned: 0, conflictsOmitted: 0 }, createdChangeset: null, effect: "not-attempted", serverAliasEquivalence: "unverified", mergeLinkIdentity: "unverified", xlinkEffects: "unverified", wouldRun: false, remoteAnalysis: "not-performed" };
     const completeness: MergeReceipt["completeness"] = { capture: "unknown", projection: true };
@@ -54,6 +91,7 @@ export async function assembleServerMergeReceipt(input: unknown): Promise<MergeR
         }
         return dto;
     };
+    let resolutionSnapshot: ResolutionSnapshot | null = null;
     let stage: "input" | "help" | "merge" = "input";
     try {
         validateServerMergeRequest(input);
@@ -64,6 +102,10 @@ export async function assembleServerMergeReceipt(input: unknown): Promise<MergeR
             try { data.resolutionsFile = await inspectResolutionFile(input.fileConflictsResolutionsFile); }
             catch (error) { throw new ServerMergeInputError(error instanceof Error && /^(Invalid resolution entry|Resolutions|Resolution)/.test(error.message) ? error.message : "Resolutions file or a result file is unavailable or invalid."); }
         }
+        if (data.resolutionsFile && data.resolutionsFile.resultFiles === data.resolutionsFile.entries && !data.unlistedConflictPolicy) {
+            try { resolutionSnapshot = await snapshotResolutionInputs(data.resolutionsFile.path); }
+            catch { throw new ServerMergeInputError("Resolution result inputs must be stable regular nonsymlink files with canonical unique conflict paths and at most 4 MiB aggregate result bytes."); }
+        }
         const seps = createServerMergeSeparators();
         const command = ["merge", source.raw, `--to=${target.raw}`, ...(data.mode === "apply" ? ["--merge", `-c=${assertSafeServerMergeValue("message", input.message!)}`] : []), ...(data.resolutionsFile ? [`--fileconflictsresolutionsfile=${data.resolutionsFile.path}`] : []), ...(data.unlistedConflictPolicy ? [data.unlistedConflictPolicy === "source" ? "--keepsource" : "--keepdestination"] : []), "--nointeractiveresolution", "--machinereadable", `--startlineseparator=${seps.start}`, `--endlineseparator=${seps.end}`, `--fieldseparator=${seps.field}`];
         data.requestedIdentity = { source: source.raw, target: target.raw, branch: target.branch, repository: target.repository, server: target.server }; data.command = ["cm", ...command]; data.wouldRun = true;
@@ -81,7 +123,7 @@ export async function assembleServerMergeReceipt(input: unknown): Promise<MergeR
         if (data.resolutionsFile) {
             try {
                 const current = await inspectResolutionFile(data.resolutionsFile.path);
-                if (current.sha256 !== data.resolutionsFile.sha256) throw new Error("changed");
+                if (current.sha256 !== data.resolutionsFile.sha256 || resolutionSnapshot && (await snapshotResolutionInputs(data.resolutionsFile.path)).digest !== resolutionSnapshot.digest) throw new Error("changed");
             } catch { return finish("failed", "input", "invalid_request", "Resolution inputs changed or became unavailable before merge dispatch."); }
         }
         stage = "merge";
@@ -89,16 +131,24 @@ export async function assembleServerMergeReceipt(input: unknown): Promise<MergeR
         completeness.capture = obs.capture.complete ? "complete" : "incomplete";
         if (obs.attempt.state === "not-attempted" || obs.attempt.state === "not-started") return finish("failed", "merge", obs.attempt.aborted ? "aborted" : "launch_failed");
         const parsed = parseServerMergeOutput(obs.stdout ?? "", seps, data.mode);
-        const paths = parsed.records.filter(r => r.operation === "FILE_CONFLICT" && r.fields.length === 6 && r.fields[1]!.length <= 4096 && !serverMergeControlPattern.test(r.fields[1]!)).map(r => r.fields[1]!);
-        data.parse = { records: parsed.records.length, malformed: parsed.malformed, unknownOperations: parsed.unknownOperations.length, changesetsObserved: parsed.changesets.length, conflictsObserved: paths.length, warningsObserved: parsed.warningsObserved };
+        const paths = parsed.records.filter(r => r.operation === "FILE_CONFLICT" && r.fields.length === 6 && isSafeServerMergePath(r.fields[1]!)).map(r => r.fields[1]!);
+        data.parse = { records: parsed.records.length, malformed: parsed.malformed, unknownOperations: parsed.unknownOperations.length, changesetsObserved: parsed.changesets.length, conflictsObserved: paths.length, warningsObserved: parsed.warningsObserved, unknownOperationClasses: parsed.unknownOperations, resolvedConflictsVerified: 0 };
         // One aggregate evidence budget, not one budget per collection.
         data.observedChangesets = parsed.changesets.slice(0, 100); data.conflictPaths = paths.slice(0, 100 - data.observedChangesets.length);
         data.counts = { changesetsReturned: data.observedChangesets.length, changesetsOmitted: parsed.changesets.length - data.observedChangesets.length, conflictsReturned: data.conflictPaths.length, conflictsOmitted: paths.length - data.conflictPaths.length };
         if (data.counts.changesetsOmitted || data.counts.conflictsOmitted) completeness.projection = false;
-        const matching = parsed.changesets.filter(c => c.branch === target.branch && c.repository === target.repository && c.mount === "/");
+        const matching = parsed.changesets.filter(c => c.branch === target.branch && c.repository === target.repository && c.server === target.server && c.mount === "/");
+        let resolvedCandidates = false;
+        if (resolutionSnapshot && parsed.hasConflict && data.resolutionsFile) {
+            try {
+                const current = await snapshotResolutionInputs(data.resolutionsFile.path);
+                resolvedCandidates = current.digest === resolutionSnapshot.digest && paths.length === resolutionSnapshot.paths.length && new Set(paths).size === paths.length && paths.every(p => resolutionSnapshot!.paths.includes(p));
+            } catch { /* Changed/unavailable inputs retain effect uncertainty. */ }
+        }
+        if (resolvedCandidates) data.parse.resolvedConflictsVerified = paths.length;
         // Emitted server aliases are kept verbatim. Matching uses dispatch context,
         // not an invented equivalence between requested and emitted server names.
-        const ambiguous = !obs.capture.complete || obs.failed || obs.attempt.aborted || obs.attempt.timedOut || obs.attempt.terminal !== "observed" || obs.attempt.exitCode === null || parsed.malformed || parsed.unknownOperations.length > 0 || parsed.changesets.length > 1 || parsed.changesets.length > 0 && matching.length !== 1 || parsed.hasConflict && parsed.changesets.length > 0 || parsed.isAlreadyConnected && (parsed.changesets.length > 0 || parsed.hasConflict);
+        const ambiguous = !obs.capture.complete || obs.failed || obs.attempt.aborted || obs.attempt.timedOut || obs.attempt.terminal !== "observed" || obs.attempt.exitCode === null || parsed.malformed || parsed.unknownOperations.length > 0 || parsed.changesets.length > 1 || parsed.changesets.length > 0 && matching.length !== 1 || parsed.hasConflict && parsed.changesets.length > 0 && !resolvedCandidates || parsed.isAlreadyConnected && (parsed.changesets.length > 0 || parsed.hasConflict);
         if (data.mode === "analyze") {
             if (!ambiguous && obs.attempt.exitCode === 0 && !obs.capture.stderrBytes && !parsed.changesets.length && parsed.records.length > 0) {
                 data.remoteAnalysis = "performed";
@@ -107,7 +157,7 @@ export async function assembleServerMergeReceipt(input: unknown): Promise<MergeR
             const reason = parsed.malformed ? "Malformed server analysis framing or fields." : parsed.unknownOperations.length ? "Unsupported server analysis operation or subtype." : "Server conflict analysis could not be verified.";
             return finish("uncertain", "merge", "uncertain", reason + " No applying command was requested.");
         }
-        if (!ambiguous && obs.attempt.exitCode === 0 && !obs.capture.stderrBytes && matching.length === 1 && !parsed.hasConflict && !parsed.isAlreadyConnected) { data.createdChangeset = matching[0]!; return finish("completed", "merge"); }
+        if (!ambiguous && obs.attempt.exitCode === 0 && !obs.capture.stderrBytes && matching.length === 1 && (!parsed.hasConflict || resolvedCandidates) && !parsed.isAlreadyConnected) { data.createdChangeset = matching[0]!; return finish("completed", "merge"); }
         if (!ambiguous && obs.attempt.exitCode === 0 && !obs.capture.stderrBytes && parsed.isAlreadyConnected && !parsed.changesets.length && !parsed.hasConflict) return finish("no-op", "merge");
         if (!ambiguous && obs.attempt.exitCode !== 0 && parsed.hasConflict && !parsed.changesets.length) return finish("conflict", "merge", "conflict");
         return finish("uncertain", "merge", "uncertain");
@@ -121,11 +171,12 @@ export async function assembleServerMergeReceipt(input: unknown): Promise<MergeR
 export async function presentServerMergeReceipt(dto: MergeReceipt, format: "text" | "json" = "text"): Promise<string> {
     const title = dto.outcome === "no-op" ? "No-op" : dto.outcome[0]!.toUpperCase() + dto.outcome.slice(1);
     const text = dto.outcome === "preflight" ? `## Server Merge Preflight\n\n- Would run: yes\n- Remote analysis: not performed\n- Command argv: ${JSON.stringify(dto.data.command)}` : dto.outcome === "analyzed" ? `## Server Merge Analysis\n\n- Read-only: no applying merge requested\n- File conflicts observed: ${dto.data.parse?.conflictsObserved ?? "unknown"}\n${dto.data.conflictPaths.map(path => "- " + path).join("\n")}\n- Conflicts omitted: ${dto.data.counts.conflictsOmitted}\n- Discard CHG warnings observed: ${dto.data.parse?.warningsObserved ?? "unknown"} (content equality unverified)\n- Point-in-time evidence only; no contributor content retrieved.` : `## Server Merge ${title}\n\n${dto.data.createdChangeset ? "- Created target changeset: cs:" + dto.data.createdChangeset.id + "\n" : ""}- Effect: ${dto.data.effect}\n- Server alias equivalence, merge-link identity and Xlink effects: unverified\n${dto.ok ? "" : "- " + dto.error.message + "\n- Do not retry automatically; inspect server state if an attempt may have started."}`;
-    const rendered = await formatServerMergeResult(format, dto.outcome, text, dto.data);
+    const diagnostics = `\n- Unsupported operation classes: ${dto.data.parse?.unknownOperationClasses.join(", ") || "none"}\n- Conflict candidates with verified result inputs: ${dto.data.parse?.resolvedConflictsVerified ?? 0} (not independent server-byte verification)`;
+    const rendered = await formatServerMergeResult(format, dto.outcome, text + diagnostics, dto.data);
     return rendered.length <= 24000 ? rendered : JSON.stringify({ action: dto.action, outcome: dto.outcome, ok: dto.ok, note: "Presentation omitted; use the registered tool structuredContent for the bounded receipt." });
 }
 export const mergeBranches = tool({
     description: "Inspect server merge conflicts with mode=analyze, then apply reviewed per-file JSON resolutions without a workspace or UI. Server aliases, merge links and Xlink effects remain unverified.",
-    args: { source: tool.schema.string().min(1).describe("Fully qualified source branch; branch/repository may not contain @; full server tail retained."), target: tool.schema.string().min(1).describe("Fully qualified distinct target in the same exact requested repository/server."), message: tool.schema.string().min(1).optional().describe("Required for apply; omit in analyze mode. Bounded nonempty comment, no editor fallback."), mode: tool.schema.enum(["apply", "analyze"]).optional().describe("Default apply creates a merge changeset. Analyze performs read-only remote conflict discovery without --merge; not command-only preflight."), fileConflictsResolutionsFile: tool.schema.string().min(1).optional().describe("Apply only: absolute existing UTF-8 JSON file with resolutions entries (exact conflict path plus keep or absolute readable resultFile). Inputs must remain immutable until completion."), unlistedConflictPolicy: tool.schema.enum(["source", "destination"]).optional().describe("Apply only: explicitly keep this contributor for conflicts absent from the JSON. Omit to retain noninteractive default behavior; never selected automatically."), preflight: tool.schema.boolean().optional().describe("Render intent only, zero commands; does not analyze remote conflicts."), format: outputFormatArg },
+    args: { source: tool.schema.string().min(1).describe("Fully qualified source branch; branch/repository may not contain @; full server tail retained."), target: tool.schema.string().min(1).describe("Fully qualified distinct target in the same exact requested repository/server."), message: tool.schema.string().min(1).optional().describe("Required for apply; omit in analyze mode. Bounded nonempty comment; CR/LF allowed, other controls rejected. No editor fallback."), mode: tool.schema.enum(["apply", "analyze"]).optional().describe("Default apply creates a merge changeset. Analyze performs read-only remote conflict discovery without --merge; not command-only preflight."), fileConflictsResolutionsFile: tool.schema.string().min(1).optional().describe("Apply only: absolute existing UTF-8 JSON file with resolutions entries (exact conflict path plus keep or absolute readable resultFile). Inputs must remain immutable until completion."), unlistedConflictPolicy: tool.schema.enum(["source", "destination"]).optional().describe("Apply only: explicitly keep this contributor for conflicts absent from the JSON. Omit to retain noninteractive default behavior; never selected automatically."), preflight: tool.schema.boolean().optional().describe("Render intent only, zero commands; does not analyze remote conflicts."), format: outputFormatArg },
     async execute(args) { const dto = await assembleServerMergeReceipt(args); if (!dto.ok && dto.error.stage === "input") throw new Error(dto.error.message); return presentServerMergeReceipt(dto, args.format); },
 });

package/src/pi/checkin-output.ts

@@ -10,7 +10,7 @@ const cs = object({ id: Type.String({ pattern: "^(0|[1-9][0-9]{0,19})$" }), bran
 const summary = object({ totalPending: uint(499), tracked: uint(499), private: uint(499), added: uint(499), changed: uint(499), moved: uint(499), deleted: uint(499), other: uint(499) });
 const attempt = object({ state: enumOf(["not-attempted", "not-started", "started", "unknown"]), terminal: enumOf(["not-observed", "observed"]), exitCode: Type.Union([uint(2147483647), Type.Null()]), aborted: Type.Boolean(), timedOut: Type.Boolean() });
 const capture = object({ stdoutBytes: uint(), stderrBytes: uint(), stdoutRetainedBytes: uint(65536), stderrRetainedBytes: uint(16384), truncated: Type.Boolean(), complete: Type.Boolean(), validUtf8: Type.Boolean() });
-const step = object({ name: enumOf(["pending-before", "initial-checkin", "private-add", "private-retry", "pending-recovery", "fallback-checkin", "pending-after", "merge-diagnostic"]), operation: enumOf(["status", "checkin", "add"]), attempt, capture, effect: enumOf(["not-attempted", "uncertain", "command-completed", "changeset-created", "read-observed"]), evidence: enumOf(["unadmitted", "admitted"]), records: uint(501), summary: nullable(summary), changeset: nullable(cs) });
+const step = object({ name: enumOf(["pending-before", "initial-checkin", "private-add", "private-retry", "pending-recovery", "fallback-checkin", "pending-after", "merge-diagnostic", "merge-readiness"]), operation: enumOf(["status", "checkin", "add"]), attempt, capture, effect: enumOf(["not-attempted", "uncertain", "command-completed", "changeset-created", "read-observed"]), evidence: enumOf(["unadmitted", "admitted"]), records: uint(501), summary: nullable(summary), changeset: nullable(cs) });
 const paths = Type.Array(str(), { maxItems: 100 });
 const reasons = Type.Array(object({ path: str(), reason: str(256) }), { maxItems: 100 });
 const data = { sourceAdmission: Type.Literal("windows-cm11.0.16.10371-observed"), requestedPaths: paths, includedPaths: paths, fallbackPaths: paths, excludedPaths: reasons, privateAddPaths: paths, blockedPrivatePaths: reasons, itemEvents: Type.Array(Type.Union([object({ operation: enumOf(["CO", "AD", "DE", "CP", "RP"]), path: str() }), object({ operation: Type.Literal("MV"), sourcePath: str(), path: str() })]), { maxItems: 100 }), observedChangesets: Type.Array(cs, { maxItems: 100 }), command: nullable(Type.Array(str(8192), { maxItems: 120 })), steps: Type.Array(step, { maxItems: 8 }), autoEnabledApplyChanged: Type.Boolean(), usedFallbackRetry: Type.Boolean(), usedPrivateAutoAddRecovery: Type.Boolean(), pendingBefore: nullable(summary), pendingAfter: nullable(summary), wouldRun: Type.Boolean(), omittedReferences: uint(10000), scopeExhaustion: Type.Literal("unverified"), branchHead: Type.Literal("unverified"), serverAliasEquivalence: Type.Literal("unverified"), xlinkEffects: Type.Literal("unverified"), mergeLinkIdentity: Type.Literal("unverified") };
@@ -38,6 +38,7 @@ export function validateCheckinOutput(value: unknown): value is CheckinReceipt {
     for (const s of d.steps) {
         const a = s.attempt, c = s.capture;
         if (a.exitCode !== null && a.terminal !== "observed" || c.stdoutRetainedBytes > c.stdoutBytes || c.stderrRetainedBytes > c.stderrBytes || c.complete && (!c.validUtf8 || c.truncated || a.terminal !== "observed" || a.aborted || a.timedOut)) return false;
+        if (s.name === "merge-readiness" && (s.operation !== "status" || s.effect !== "not-attempted" || s.summary || s.evidence === "admitted" && (!normal(s) || a.exitCode !== 0 || c.stderrBytes))) return false;
         if (s.summary && (!summaryValid(s.summary) || s.operation !== "status" || s.effect !== "read-observed")) return false;
         if (s.operation === "status" && !["not-attempted", "read-observed"].includes(s.effect)) return false;
         if (s.operation !== "status" && s.summary) return false;
@@ -47,11 +48,13 @@ export function validateCheckinOutput(value: unknown): value is CheckinReceipt {
         if (s.changeset && s.effect !== "changeset-created") return false;
         if (s.operation !== "status" && s.effect === "not-attempted" && !["not-attempted", "not-started"].includes(a.state)) return false;
     }
+    const readiness = d.steps.filter(s => s.name === "merge-readiness");
+    if (readiness.length > 1 || readiness.length && (d.steps[0]?.name !== "pending-before" || d.steps[1] !== readiness[0] || (dto.ok || d.steps.length > 2) && readiness[0].evidence !== "admitted")) return false;
     const mutations = d.steps.filter(s => s.operation !== "status"), created = mutations.filter(s => s.effect === "changeset-created");
     const expected = created.length ? "changeset-created" : mutations.some(s => s.effect === "uncertain") ? "uncertain" : mutations.some(s => s.effect === "command-completed") ? "command-completed" : "not-attempted";
     if (d.effect !== expected || created.length > 1 || !!d.createdChangeset !== !!created.length || d.createdChangeset && !same(d.createdChangeset, created[0].changeset)) return false;
     if (dto.outcome === "completed" && (!d.createdChangeset || !d.pendingBefore || !d.wouldRun)) return false;
-    if (dto.outcome === "preflight" && (mutations.length || !d.pendingBefore || !d.wouldRun || d.steps.length !== 1)) return false;
+    if (dto.outcome === "preflight" && (mutations.length || !d.pendingBefore || !d.wouldRun || d.steps.some(s => !["pending-before", "merge-readiness"].includes(s.name)))) return false;
     if ((dto.outcome === "failed" || dto.outcome === "unsupported") && mutations.length) return false;
     if (d.usedFallbackRetry !== d.steps.some(s => s.name === "fallback-checkin")) return false;
     if (d.usedPrivateAutoAddRecovery !== d.steps.some(s => s.name === "private-add" && s.effect === "command-completed")) return false;

package/src/pi/closeout-output.ts

@@ -67,7 +67,7 @@ export function validateCloseoutOutput(value:unknown):value is CloseoutReceipt {
    if(s.kind==="switch"){if(s.name!=="switch"||!validateSwitchOutput(s.result)||s.result.data.requestedTarget!==d.targetBranch||s.result.data.pendingPolicy!=="cancel"||s.result.data.preflight||s.result.data.workdir!==resolve(r.workdir))return false;}
    else if(s.kind==="update"){if(s.name!=="update"||!validateUpdateOutput(s.result)||s.result.data.workingDirectory!==r.workdir)return false;}
    else if(s.kind==="merge"){if(s.name!=="merge"||!validateWorkspaceMergeOutput(s.result)||s.result.action!=="merge"||s.result.data.requestedSource!==d.sourceBranch||s.result.data.strategy!==r.strategy||s.result.data.workingDirectory!==r.workdir||s.result.data.previewRequested!==false||s.result.data.cherrypicking||s.result.data.forced)return false;}
-   else{if(!["checkin-preflight","checkin"].includes(s.name)||!validateCheckinOutput(s.result)||s.name==="checkin-preflight"&&s.result.ok&&s.result.outcome!=="preflight"||s.name==="checkin"&&s.result.ok&&s.result.outcome!=="completed")return false;const cmd=s.result.data.command,expected=["cm","checkin",`-c=${d.checkinMessage}`,"--all",...(r.includePrivate?["--private"]:[])];if(cmd&&(!same(cmd.slice(0,expected.length),expected)||cmd[expected.length]!=="--machinereadable"))return false;}
+   else{if(!["checkin-preflight","checkin"].includes(s.name)||!validateCheckinOutput(s.result)||s.name==="checkin-preflight"&&s.result.ok&&s.result.outcome!=="preflight"||s.name==="checkin"&&s.result.ok&&s.result.outcome!=="completed")return false;const cmd=s.result.data.command,expected=["cm","checkin",`-c=${d.checkinMessage}`,"--all",...(r.includePrivate?["--private"]:[]),...s.result.data.includedPaths];if(cmd&&(!same(cmd.slice(0,expected.length),expected)||cmd[expected.length]!=="--machinereadable"))return false;}
    if(index<stages.length-1&&!s.result.ok)return false;
   }
  }