rea-agents 6.5.0 → 6.7.0

package/dist/application/CapabilityInventory.js

@@ -340,14 +340,17 @@ const workflowAvailabilityFor = ({ name, kind, policy, }) => {
         return ownerProbeAvailability(policy.adbAnalysisAvailability, "Set REA_ADB_PATH to a caller-supplied adb executable or make adb available on PATH. This checks the client version only; device and serial availability depend on the request.");
     if (kind === "apktool-provider")
         return ownerProbeAvailability(policy.apktoolAnalysisAvailability, "Set REA_APKTOOL_COMMAND to a caller-supplied Apktool executable or make Apktool 2.7.0 or newer available on PATH.");
-    if (kind === "jeb-provider")
-        return policy.jebAnalysisAvailability?.status === "available"
-            ? { reason: "available", remediation: null }
-            : {
-                reason: "provider_missing",
-                remediation: policy.jebAnalysisAvailability?.reason ??
-                    "Start a JEB client serving MCP (GUI client, or headless via its programmatic launcher) and point REA_JEB_MCP_URL at it (default http://127.0.0.1:8425/mcp). REA does not install or launch JEB.",
-            };
+    if (kind === "jeb-provider") {
+        const availability = policy.jebAnalysisAvailability;
+        if (availability?.status === "available")
+            return availability.supportedOperations.some((operation) => operation === name)
+                ? { reason: "available", remediation: null }
+                : {
+                    reason: "provider_unavailable",
+                    remediation: `The running JEB endpoint does not advertise support for ${name}. Use a JEB client build that provides this operation.`,
+                };
+        return ownerProbeAvailability(availability, "Start a JEB client serving MCP (GUI client, or headless via its programmatic launcher) and point REA_JEB_MCP_URL at it (default http://127.0.0.1:8425/mcp). REA does not install or launch JEB.");
+    }
     const browser = browserProviderAvailability(name, kind, policy);
     if (browser !== null)
         return browser;
@@ -483,6 +486,9 @@ const providerAvailability = ({ descriptors, kind, name, }) => {
         };
 };
 const composedAvailability = (name, descriptors) => {
+    if (name === "binary_overview" &&
+        descriptors.get("read_binary_inventory_summary")?.available === true)
+        return { reason: "available", remediation: null };
     const requirements = ENHANCED_REQUIREMENTS[name];
     if (requirements === undefined)
         return {

package/dist/application/ClaudeDesktopConfigLocation.js

@@ -11,8 +11,8 @@ const PROCESS_VIEW_PROBES = 8;
  * L=San Francisco, S=California, C=US, …`.
  */
 export const CLAUDE_DESKTOP_PACKAGE_FAMILY = "Claude_pzs8sxrjxfjjc";
-/** `Claude_` plus a 13-character Crockford base32 MSIX publisher ID. */
-const CLAUDE_PACKAGE_FAMILY = /^Claude_[0-9a-hjkmnp-tv-z]{13}$/iu;
+/** Observed Claude package names plus Windows' 13-character publisher ID. */
+const CLAUDE_PACKAGE_FAMILY = /^(?:AnthropicPBC\.)?Claude_[0-9a-hjkmnp-tv-z]{13}$/iu;
 const systemFileSystem = {
     readdir: (path) => readdirSync(path),
     lstat: (path) => lstatSync(path),
@@ -22,8 +22,8 @@ const systemFileSystem = {
  * Resolve the `claude_desktop_config.json` that Windows Claude Desktop reads.
  * Without its MSIX package storage, that is the AppData file. With it, the
  * package reads its private copy when one exists and the AppData file
- * otherwise; a new registration goes to the private copy. A `Claude_*`
- * package from another publisher leaves the reader unknown.
+ * otherwise; a new registration goes to the private copy. Other Claude
+ * package identities and deployments leave the reader unknown.
  */
 export const resolveWindowsClaudeDesktopLocation = (home, env, fileSystem = systemFileSystem) => {
     const roots = windowsAppDataRoots(home, env);
@@ -48,7 +48,7 @@ export const resolveWindowsClaudeDesktopLocation = (home, env, fileSystem = syst
     if (foreign.length > 0)
         return err({
             path: join(packagesDirectory, foreign[0] ?? ""),
-            message: `MSIX package storage ${foreign.map((name) => join(packagesDirectory, name)).join(", ")} uses Claude Desktop's package name with an unrecognized publisher (Claude Desktop is ${CLAUDE_DESKTOP_PACKAGE_FAMILY}). REA cannot establish which ${CONFIG_FILE} that package reads and does not fall back to ${appDataConfigPath}. Remove the unrecognized package, or register REA in the configuration it reads.`,
+            message: `MSIX package storage ${foreign.map((name) => join(packagesDirectory, name)).join(", ")} has an unrecognized Claude Desktop package identity or deployment (the supported identity is ${CLAUDE_DESKTOP_PACKAGE_FAMILY}). REA cannot establish which ${CONFIG_FILE} that package reads and does not fall back to ${appDataConfigPath}. Quit Claude Desktop fully and register REA in the configuration the installed app reads.`,
         });
     const family = families[0];
     if (family === undefined)

package/dist/application/ClientConfigurationCleanup.js

@@ -0,0 +1,73 @@
+import { ArtifactResourceRetryFailure, } from "../artifacts/ArtifactResourceScope.js";
+import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
+import { RegularFileCleanupFailure, retryRegularFileCleanupFailures, } from "./RegularFileRead.js";
+/** Completion and exact staging owner retained when publication cleanup fails. */
+export class ClientConfigurationPublicationFailure extends ArtifactResourceRetryFailure {
+    path;
+    outcome;
+    cleanupCause;
+    owner;
+    cleanupLease;
+    constructor(path, outcome, cleanupCause, owner, cleanupLease) {
+        super([{ owner, lease: cleanupLease }], "Configuration publication cleanup remains incomplete", {
+            cause: new AggregateError([...(outcome.kind === "failed" ? [outcome.cause] : []), cleanupCause], "Configuration operation and staging cleanup failures"),
+            cleanup: ArtifactReaderFailure.cleanupObservation(cleanupCause, owner.resource),
+        });
+        this.path = path;
+        this.outcome = outcome;
+        this.cleanupCause = cleanupCause;
+        this.owner = owner;
+        this.cleanupLease = cleanupLease;
+    }
+}
+export const isClientConfigurationCleanupFailure = (cause) => cause instanceof RegularFileCleanupFailure ||
+    cause instanceof ClientConfigurationPublicationFailure;
+/** Adopt only capabilities carried by explicit operation outcomes, never opaque causes. */
+export const retryClientConfigurationCleanup = async (failure, resources) => {
+    const failures = [];
+    const observations = [];
+    let current = failure;
+    let primary;
+    for (;;) {
+        let nested;
+        if (current instanceof RegularFileCleanupFailure) {
+            const retried = await retryRegularFileCleanupFailures(current, resources);
+            failures.push(...retried.failures);
+            if (retried.cleanup !== undefined)
+                observations.push(retried.cleanup);
+            primary = retried.primary;
+            const last = retried.failures.at(-1);
+            nested = last.outcome.kind === "failed" ? last.outcome.cause : undefined;
+        }
+        else {
+            const released = await resources.release({
+                kind: "lease",
+                resource: current.owner.resource,
+                lease: current.cleanupLease,
+            });
+            if (released.kind === "failed")
+                observations.push(ArtifactReaderFailure.cleanupObservation(released.cause, current.owner.resource));
+            primary =
+                current.outcome.kind === "failed"
+                    ? current.outcome.cause
+                    : current.cleanupCause;
+            nested =
+                current.outcome.kind === "failed" ? current.outcome.cause : undefined;
+        }
+        if (!isClientConfigurationCleanupFailure(nested))
+            break;
+        current = nested;
+    }
+    return {
+        primary,
+        failures,
+        ...(observations.length === 0
+            ? {}
+            : {
+                cleanup: {
+                    reason: observations.map(({ reason }) => reason).join("; "),
+                    resources: observations.flatMap(({ resources }) => resources),
+                },
+            }),
+    };
+};

package/dist/application/ClientConfigurationDocument.js

@@ -2,8 +2,9 @@ import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 import { isDeepStrictEqual } from "node:util";
 import { parseDshCordisDocument, serializeDshDocument, editDshDocument, dshClientRegistrationEntry, } from "./DshCordisPatch.js";
 import { editHermesConfigurationYaml, parseHermesConfigurationYaml, stringifyHermesConfigurationYaml, } from "./HermesConfigurationYaml.js";
-import { applyEdits, findNodeAtLocation, modify, parse as parseJsonc, parseTree, printParseErrorCode, } from "jsonc-parser";
+import { applyEdits, createScanner, format as formatJson, parse as parseJsonc, parseTree, printParseErrorCode, } from "jsonc-parser";
 import { z } from "zod";
+import { err, ok } from "../domain/result.js";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 const objectSchema = z.record(z.string(), z.unknown());
@@ -39,9 +40,33 @@ export const clientConfigurationServersKey = (format) => {
  * create a zero-byte config file before any server is added.
  */
 const isEmptyClientConfigurationText = (text) => text.replace(/^\uFEFF/, "").trim() === "";
+const INT64_MIN = -(2n ** 63n);
+const INT64_MAX = 2n ** 63n - 1n;
+/**
+ * Parse client TOML with TOML 1.0's signed 64-bit integer contract. Integers
+ * beyond JavaScript's safe range stay exact as bigint; values outside Int64,
+ * which Codex rejects, are malformed.
+ */
+const parseClientToml = (text) => {
+    const parsed = parseToml(text, { integersAsBigInt: "asNeeded" });
+    const pending = [parsed];
+    for (let value = pending.pop(); value !== undefined; value = pending.pop()) {
+        if (typeof value === "bigint") {
+            if (value < INT64_MIN || value > INT64_MAX)
+                throw new SyntaxError(`Invalid TOML document: integer ${String(value)} is outside the signed 64-bit range`);
+        }
+        else if (typeof value === "object" &&
+            value !== null &&
+            !(value instanceof Date))
+            // Large documents can exceed argument limits, so do not spread.
+            for (const nested of Object.values(value))
+                pending.push(nested);
+    }
+    return parsed;
+};
 const parseDocument = (text, format) => {
     if (format === "toml" || format === "grok")
-        return requireObject(parseToml(text), "The configuration root");
+        return requireObject(parseClientToml(text), "The configuration root");
     // Pi loads `mcp.json` with a strict `JSON.parse` and no BOM tolerance, so
     // comments, trailing commas, a BOM, or an empty existing file must be
     // rejected instead of registering into a document the client cannot load.
@@ -61,6 +86,10 @@ const parseDocument = (text, format) => {
     // ZCode loads nonempty native files with strict JSON.parse.
     if (format === "zcode")
         return requireObject(JSON.parse(text), "The configuration root");
+    // Claude Code loads `.claude.json` with strict JSON.parse after a UTF-8 BOM,
+    // so comments and trailing commas it rejects must not be admitted as JSONC.
+    if (format === "claude_code")
+        return requireObject(JSON.parse(text.replace(/^\uFEFF/, "")), "The configuration root");
     const errors = [];
     // Accept a UTF-8 BOM without shifting diagnostics or editing the original text.
     const jsonText = text.startsWith("\uFEFF") ? ` ${text.slice(1)}` : text;
@@ -511,6 +540,8 @@ const tomlInlineValue = (value) => {
         return value ? "true" : "false";
     if (typeof value === "number" && Number.isFinite(value))
         return String(value);
+    if (typeof value === "bigint")
+        return String(value);
     if (Array.isArray(value))
         return `[${value.map((item) => tomlInlineValue(item)).join(", ")}]`;
     if (typeof value === "object" && value !== null) {
@@ -653,7 +684,7 @@ const rebuildDelimitedEntries = (pairs, trailing, insertion, open, close) => {
  */
 const tomlStringValue = (text) => {
     try {
-        const value = parseToml(`value = ${text}`)["value"];
+        const value = parseClientToml(`value = ${text}`)["value"];
         return typeof value === "string" ? value : undefined;
     }
     catch (cause) {
@@ -740,6 +771,13 @@ const disabledServerListLines = (edit, lines, lineIndex, endLine) => {
         }
     }
 };
+/** Strip terminal LF without rescanning internal blank-line runs. */
+const withoutTrailingLineFeeds = (text) => {
+    let end = text.length;
+    while (end > 0 && text.charCodeAt(end - 1) === 10)
+        end -= 1;
+    return text.slice(0, end);
+};
 /**
  * Replace REA's TOML server tables and assignments. Comments that introduce a
  * following table stay. Codex also retains comments around REA's own table.
@@ -770,17 +808,15 @@ const upsertTomlServerSection = (originalText, serverKey, entry, format) => {
     const discardPending = () => {
         pending.length = 0;
     };
+    // Document line counts must not become engine-limited argument counts.
+    const appendLines = (lines) => {
+        for (const line of lines)
+            kept.push(line);
+    };
     const flushPending = () => {
-        kept.push(...pending);
+        appendLines(pending);
         pending.length = 0;
     };
-    const lineIndexAt = (offset) => {
-        let line = 0;
-        for (let index = 0; index < lineStarts.length; index += 1)
-            if ((lineStarts[index] ?? 0) <= offset)
-                line = index;
-        return line;
-    };
     let lineIndex = 0;
     while (lineIndex < lines.length) {
         const physical = lines[lineIndex] ?? "";
@@ -817,7 +853,12 @@ const upsertTomlServerSection = (originalText, serverKey, entry, format) => {
             let statementEnd = valueEnd;
             while (statementEnd < text.length && text[statementEnd] !== "\n")
                 statementEnd += 1;
-            const endLine = lineIndexAt(Math.max(statementEnd - 1, lineStart));
+            const lastOffset = Math.max(statementEnd - 1, lineStart);
+            let endLine = lineIndex;
+            // Statements advance through the source; only inspect their own lines.
+            while (endLine + 1 < lineStarts.length &&
+                (lineStarts[endLine + 1] ?? 0) <= lastOffset)
+                endLine += 1;
             if (skipping) {
                 discardPending();
                 lineIndex = endLine + 1;
@@ -839,7 +880,7 @@ const upsertTomlServerSection = (originalText, serverKey, entry, format) => {
                 : undefined;
             if (disabledLines !== undefined) {
                 flushPending();
-                kept.push(...disabledLines);
+                appendLines(disabledLines);
                 lineIndex = endLine + 1;
                 mode = "none";
                 continue;
@@ -858,7 +899,7 @@ const upsertTomlServerSection = (originalText, serverKey, entry, format) => {
                     const replacement = edited === undefined
                         ? text.slice(lineStart, statementEnd)
                         : `${prefix}${edited}${suffix}`;
-                    kept.push(...replacement.split("\n"));
+                    appendLines(replacement.split("\n"));
                     inlineServerTable = true;
                 }
                 else
@@ -907,14 +948,12 @@ const upsertTomlServerSection = (originalText, serverKey, entry, format) => {
     if (body.endsWith("\r"))
         body += "\n";
     if (entry !== undefined && !inlineServerTable) {
-        let fragment = stringifyToml({
-            mcp_servers: { [serverKey]: entry },
-        }).replace(/\n+$/u, "");
+        let fragment = withoutTrailingLineFeeds(stringifyToml({ mcp_servers: { [serverKey]: entry } }));
         if (crlf)
             fragment = fragment.replaceAll("\n", "\r\n");
         const nl = crlf ? "\r\n" : "\n";
         const endedWithNewline = body.endsWith("\n");
-        const base = body.replace(/\n+$/u, "");
+        const base = withoutTrailingLineFeeds(body);
         const trimmed = endedWithNewline && base.endsWith("\r") ? base.slice(0, -1) : base;
         body =
             trimmed.length === 0
@@ -993,7 +1032,7 @@ const serializeCodexConfiguration = (document, originalText) => {
 };
 const tomlTextHolds = (text, document) => {
     try {
-        return clientConfigurationValuesEqual(withoutEmptyServerTable(objectSchema.parse(parseToml(text))), withoutEmptyServerTable(document));
+        return clientConfigurationValuesEqual(withoutEmptyServerTable(objectSchema.parse(parseClientToml(text))), withoutEmptyServerTable(document));
     }
     catch (cause) {
         // An unparsable edit is rejected in favor of the full rewrite.
@@ -1001,131 +1040,134 @@ const tomlTextHolds = (text, document) => {
         return false;
     }
 };
-/** Comments in the trivia between two properties. `undefined` when there are none. */
-const commentsBetweenProperties = (gap) => {
-    const pieces = [];
-    let index = 0;
-    while (index < gap.length) {
-        const line = gap.indexOf("//", index);
-        const block = gap.indexOf("/*", index);
-        if (line < 0 && block < 0)
-            break;
-        const start = line < 0 ? block : block < 0 ? line : Math.min(line, block);
-        const lineComment = start === line;
-        const close = lineComment
-            ? gap.indexOf("\n", start)
-            : gap.indexOf("*/", start + 2);
-        if (!lineComment && close < 0)
-            return undefined;
-        const end = lineComment ? (close < 0 ? gap.length : close) : close + 2;
-        const comment = gap.slice(start, end);
-        const lineBreak = gap.lastIndexOf("\n", start - 1);
-        if (lineBreak < 0)
-            pieces.push(` ${comment}`);
-        else {
-            const prefix = gap.slice(lineBreak + 1, start);
-            let indentEnd = 0;
-            while (prefix[indentEnd] === " " || prefix[indentEnd] === "\t")
-                indentEnd += 1;
-            const newline = lineBreak > 0 && gap[lineBreak - 1] === "\r" ? "\r\n" : "\n";
-            pieces.push(`${newline}${prefix.slice(0, indentEnd)}${comment}`);
-        }
-        index = end;
+// jsonc-parser declares SyntaxKind as an ambient const enum, so keep its token
+// code local and type-checked as in the JSON scanner used by IDA diagnostics.
+const JSON_COMMA = 5;
+/** Find the next non-trivia JSONC token at or after `offset`. */
+const nextJsoncToken = (text, offset) => {
+    const scanner = createScanner(text, true);
+    scanner.setPosition(offset);
+    const kind = scanner.scan();
+    return { kind, offset: scanner.getTokenOffset() };
+};
+const isJsonMember = (property, key) => property.children?.length === 2 && property.children[0]?.value === key;
+/**
+ * The property a client reads for `key`. `JSON.parse` and JSONC `parse` keep
+ * the last duplicate member, while jsonc-parser's `findNodeAtLocation` and
+ * `modify` select the first, so JSON text edits locate members only here.
+ */
+const effectiveJsonProperty = (object, key) => object.children?.findLast((property) => isJsonMember(property, key));
+/** Apply one edit and format the lines it touched, as `modify` does. */
+const applyFormattedJsonEdit = (text, edit) => {
+    const edited = applyEdits(text, [edit]);
+    let begin = edit.offset;
+    let end = edit.offset + edit.content.length;
+    if (edit.length === 0) {
+        while (begin > 0 && !"\r\n".includes(edited.charAt(begin - 1)))
+            begin -= 1;
+        while (end < edited.length && !"\r\n".includes(edited.charAt(end)))
+            end += 1;
     }
-    return pieces.length === 0 ? undefined : pieces.join("");
+    return applyEdits(edited, formatJson(edited, { offset: begin, length: end - begin }, { insertSpaces: true, tabSize: 2, eol: "\n", keepLines: false }));
 };
 /**
- * Delete an object property without taking a comment from the gap before it.
- * jsonc-parser's removal span includes that gap, so a trailing comment on the
- * previous property would disappear. Returns `undefined` to keep the stock edit.
+ * Delete a property by its JSONC AST span and the separator needed to keep its
+ * parent object valid. All whitespace and comments outside those tokens stay
+ * byte-for-byte in place.
  */
-const deleteJsonPropertyPreservingComments = (text, path) => {
-    const root = parseTree(text, [], { allowTrailingComma: true });
-    const value = root === undefined ? undefined : findNodeAtLocation(root, [...path]);
-    const property = value?.parent;
-    const parent = property?.parent;
-    if (property === undefined ||
-        parent?.type !== "object" ||
-        property.type !== "property" ||
-        parent.children === undefined)
-        return undefined;
-    const propertyIndex = parent.children.indexOf(property);
-    const previous = parent.children[propertyIndex - 1];
-    if (propertyIndex <= 0 || previous === undefined)
-        return undefined;
-    const comments = commentsBetweenProperties(text.slice(previous.offset + previous.length, property.offset));
-    if (comments === undefined)
-        return undefined;
-    let removeEnd = property.offset + property.length;
-    const hasNext = parent.children[propertyIndex + 1] !== undefined;
-    if (hasNext) {
-        let comma = removeEnd;
-        while (comma < text.length) {
-            const char = text[comma];
-            if (char === " " || char === "\t" || char === "\r" || char === "\n") {
-                comma += 1;
-                continue;
-            }
-            if (text.startsWith("/*", comma)) {
-                const close = text.indexOf("*/", comma + 2);
-                if (close < 0)
-                    return undefined;
-                comma = close + 2;
-                continue;
-            }
-            if (text.startsWith("//", comma)) {
-                while (comma < text.length &&
-                    text[comma] !== "\n" &&
-                    text[comma] !== "\r")
-                    comma += 1;
-                continue;
-            }
-            break;
+const deleteJsonProperty = (text, object, property) => {
+    const siblings = object.children ?? [];
+    const propertyIndex = siblings.indexOf(property);
+    const previous = siblings[propertyIndex - 1];
+    const next = siblings[propertyIndex + 1];
+    const comma = nextJsoncToken(text, previous === undefined
+        ? property.offset + property.length
+        : previous.offset + previous.length);
+    if (propertyIndex < 0 ||
+        (comma.kind !== JSON_COMMA &&
+            (previous !== undefined || next !== undefined)))
+        throw new TypeError("JSON property separator was not found");
+    const edits = [
+        { offset: property.offset, length: property.length, content: "" },
+        ...(comma.kind === JSON_COMMA
+            ? [{ offset: comma.offset, length: 1, content: "" }]
+            : []),
+    ];
+    return applyEdits(text, edits);
+};
+/**
+ * Set or delete the member a client reads at `path`, keeping every byte
+ * outside that member. Shadowed duplicates stay in place, and deleting a
+ * member that shadows one is refused so the earlier member never becomes
+ * active, whatever its ownership.
+ */
+const editJsonMember = (text, path, value) => {
+    let object = parseTree(text, [], { allowTrailingComma: true });
+    for (const [index, key] of path.entries()) {
+        if (object?.type !== "object")
+            throw new TypeError("JSON edit parent is not an object");
+        const property = effectiveJsonProperty(object, key);
+        const member = property?.children?.[1];
+        if (property === undefined || member === undefined) {
+            if (value === undefined)
+                return ok(text);
+            const content = `${JSON.stringify(key)}: ${JSON.stringify(path
+                .slice(index + 1)
+                .reduceRight((nested, name) => ({ [name]: nested }), value))}`;
+            const previous = object.children?.at(-1);
+            return ok(applyFormattedJsonEdit(text, previous === undefined
+                ? { offset: object.offset + 1, length: 0, content }
+                : {
+                    offset: previous.offset + previous.length,
+                    length: 0,
+                    content: `,${content}`,
+                }));
         }
-        if (text[comma] !== ",")
-            return undefined;
-        removeEnd = comma + 1;
+        if (index < path.length - 1) {
+            object = member;
+            continue;
+        }
+        if (value !== undefined)
+            return ok(applyFormattedJsonEdit(text, {
+                offset: member.offset,
+                length: member.length,
+                content: JSON.stringify(value),
+            }));
+        if (object.children?.some((sibling) => sibling !== property && isJsonMember(sibling, key)))
+            return err({ kind: "shadowed_member", path });
+        return ok(deleteJsonProperty(text, object, property));
     }
-    // A line comment runs to the next break. Keep the following token outside it.
-    const remainder = text.slice(removeEnd);
-    let suffix = `${hasNext ? "," : ""}${comments}`;
-    if (suffix.includes("//") &&
-        !suffix.endsWith("\n") &&
-        !suffix.endsWith("\r") &&
-        !remainder.startsWith("\n") &&
-        !remainder.startsWith("\r"))
-        suffix += "\n";
-    return `${text.slice(0, previous.offset + previous.length)}${suffix}${remainder}`;
+    throw new TypeError("JSON edit path is empty");
 };
-/** Serialize a validated client document, retaining JSONC and TOML comments. */
+/**
+ * Serialize a validated client document, retaining JSONC and TOML comments.
+ * JSON edits fail only when they would activate a shadowed duplicate member.
+ */
 export const serializeClientConfiguration = (document, format, originalText, editedPaths) => {
     if (format === undefined || format === "unsupported")
         throw new TypeError("client does not have a supported MCP config format");
     if (format === "toml")
-        return serializeCodexConfiguration(document, originalText);
+        return ok(serializeCodexConfiguration(document, originalText));
     if (format === "grok")
-        return serializeGrokConfiguration(document, originalText);
+        return ok(serializeGrokConfiguration(document, originalText));
     if (format === "hermes")
-        return serializeHermesConfiguration(document, originalText);
+        return ok(serializeHermesConfiguration(document, originalText));
     if (format === "dsh")
-        return serializeDshDocument(document);
+        return ok(serializeDshDocument(document));
     // An empty original holds no comments or settings to preserve. Writing a
     // fresh document also keeps a lone BOM from shifting past the closing brace.
-    if (originalText !== undefined &&
-        !isEmptyClientConfigurationText(originalText) &&
-        editedPaths !== undefined)
-        return editedPaths.reduce((text, path) => {
-            const value = valueAt(document, path);
-            if (value === undefined) {
-                const preserved = deleteJsonPropertyPreservingComments(text, path);
-                if (preserved !== undefined)
-                    return preserved;
-            }
-            return applyEdits(text, modify(text, [...path], value, {
-                formattingOptions: { insertSpaces: true, tabSize: 2, eol: "\n" },
-            }));
-        }, originalText);
-    return `${JSON.stringify(document, null, 2)}\n`;
+    if (originalText === undefined ||
+        isEmptyClientConfigurationText(originalText) ||
+        editedPaths === undefined)
+        return ok(`${JSON.stringify(document, null, 2)}\n`);
+    let text = originalText;
+    for (const path of editedPaths) {
+        const edited = editJsonMember(text, path, valueAt(document, path));
+        if (!edited.ok)
+            return edited;
+        text = edited.value;
+    }
+    return ok(text);
 };
 /** Key path of a named registration in the server table. */
 export const clientServerPath = (parsed, name) => [...parsed.serversPath, name];