rea-agents 6.1.0 → 6.3.0

package/dist/application/SetupSkill.js

@@ -10,7 +10,33 @@ const SKILL_FILES = [
     "references/runtime-observation.md",
     "references/evidence-workflows.md",
 ];
-const skillRoot = (home) => join(home, ".agents/skills", PRODUCT_IDENTITY.skillName);
+/** Resolve Claude Code personal skills from the selected environment. */
+export const claudeCodeSkillsDirectory = (home, environment = {}) => join(environment.CLAUDE_CONFIG_DIR ?? join(home, ".claude"), "skills");
+/** Resolve the skill roots required by a client selection, or all owned roots. */
+export const skillDestinations = (home, clientIds, claudeSkillsDirectory = claudeCodeSkillsDirectory(home)) => {
+    const includeClaude = clientIds === undefined || clientIds.includes("claude_code");
+    const includeShared = clientIds === undefined ||
+        clientIds.length === 0 ||
+        clientIds.some((clientId) => clientId !== "claude_code");
+    return [
+        ...(includeShared
+            ? [
+                {
+                    client: "shared",
+                    path: join(home, ".agents/skills", PRODUCT_IDENTITY.skillName),
+                },
+            ]
+            : []),
+        ...(includeClaude
+            ? [
+                {
+                    client: "claude_code",
+                    path: join(claudeSkillsDirectory, PRODUCT_IDENTITY.skillName),
+                },
+            ]
+            : []),
+    ];
+};
 const readOptionalText = async (path) => {
     try {
         return await readFile(path, "utf8");
@@ -21,18 +47,18 @@ const readOptionalText = async (path) => {
         throw cause;
     }
 };
-const canonicalSkillFiles = async (home) => Promise.all(SKILL_FILES.map(async (relativePath) => {
-    const destination = join(skillRoot(home), relativePath);
+const canonicalSkillFiles = async (home, clientIds, claudeSkillsDirectory) => Promise.all(skillDestinations(home, clientIds, claudeSkillsDirectory).flatMap(({ path: root }) => SKILL_FILES.map(async (relativePath) => {
+    const destination = join(root, relativePath);
     return {
         destination,
         content: await readFile(new URL(`../../skills/${PRODUCT_IDENTITY.skillName}/${relativePath}`, import.meta.url), "utf8"),
         original: await readOptionalText(destination),
     };
-}));
+})));
 /** Report whether setup would change any file in the managed REA skill bundle. */
-export const canonicalSkillNeedsInstall = async (home) => {
+export const canonicalSkillNeedsInstall = async (home, clientIds = [], claudeSkillsDirectory) => {
     try {
-        return (await canonicalSkillFiles(home)).some(({ content, original }) => original !== content);
+        return (await canonicalSkillFiles(home, clientIds, claudeSkillsDirectory)).some(({ content, original }) => original !== content);
     }
     catch (cause) {
         // Unreadable skill state fails open to install so setup can repair it.
@@ -50,10 +76,10 @@ const restoreSkillFiles = async (changed) => {
     }
 };
 /** Transactionally install or upgrade the canonical REA skill and references. */
-export const installCanonicalSkill = async (home) => {
+export const installCanonicalSkill = async (home, clientIds = [], claudeSkillsDirectory) => {
     let changed = [];
     try {
-        const canonical = await canonicalSkillFiles(home);
+        const canonical = await canonicalSkillFiles(home, clientIds, claudeSkillsDirectory);
         changed = canonical.filter(({ content, original }) => original !== content);
         if (changed.length === 0)
             return "unchanged";
@@ -82,3 +108,26 @@ export const installCanonicalSkill = async (home) => {
         return "failed";
     }
 };
+/** Read installed skill metadata and compare every managed location. */
+export const readInstalledSkillIdentity = async (home, clientIds, claudeSkillsDirectory) => {
+    const destinations = skillDestinations(home, clientIds, claudeSkillsDirectory);
+    let content;
+    for (const destination of destinations) {
+        try {
+            content = await readFile(join(destination.path, "SKILL.md"), "utf8");
+            break;
+        }
+        catch {
+            // Another selected copy may provide metadata; canonical validation below
+            // still marks missing or unreadable copies as stale.
+        }
+    }
+    if (content === undefined)
+        return undefined;
+    const toolCount = /^\s{2}tool_count:\s*(\d+)\s*$/mu.exec(content)?.[1];
+    return {
+        canonical: !(await canonicalSkillNeedsInstall(home, clientIds, claudeSkillsDirectory)),
+        version: /^\s{2}version:\s*"([^"]+)"\s*$/mu.exec(content)?.[1] ?? null,
+        toolCount: toolCount === undefined ? null : Number.parseInt(toolCount, 10),
+    };
+};

package/dist/application/SupportedClients.js

@@ -34,6 +34,38 @@ export const GROK_BOT_MANUAL_REGISTRATION_REMEDIATION = "Grok Bot keeps connecto
 export const manualRegistrationRemediation = (clientName) => clientName === "grok_bot"
     ? GROK_BOT_MANUAL_REGISTRATION_REMEDIATION
     : undefined;
+const OMP_PROFILE_NAME = /^[a-z0-9][a-z0-9._-]{0,63}$/u;
+/**
+ * OMP's active named profile. OMP_PROFILE wins over the legacy PI_PROFILE even
+ * when empty; empty and "default" select the default profile. OMP refuses to
+ * start with an invalid name, so one leaves the default location in place.
+ */
+const ompProfile = ({ env }) => {
+    const name = (env.OMP_PROFILE ?? env.PI_PROFILE)?.trim();
+    return name === undefined ||
+        name === "" ||
+        name === "default" ||
+        name.endsWith(".") ||
+        !OMP_PROFILE_NAME.test(name)
+        ? undefined
+        : name;
+};
+/**
+ * The OMP agent directory whose `mcp.json` holds user-scope MCP servers. OMP
+ * joins PI_CONFIG_DIR to the home directory, and a named profile ignores
+ * PI_CODING_AGENT_DIR. OMP resolves a relative agent directory against each
+ * process's working directory, so only an absolute override names one file.
+ */
+const ompAgentDirectory = (context) => {
+    const root = join(context.home, context.env.PI_CONFIG_DIR || ".omp");
+    const profile = ompProfile(context);
+    if (profile !== undefined)
+        return join(root, "profiles", profile, "agent");
+    const override = context.env.PI_CODING_AGENT_DIR;
+    return override !== undefined && override !== "" && isAbsolute(override)
+        ? override
+        : join(root, "agent");
+};
 const copilotDirectory = ({ home, env }) => env.COPILOT_HOME ?? join(home, ".copilot");
 const commandCodeDirectory = ({ home }) => join(home, ".commandcode");
 const opencodeDirectory = ({ home, env }) => join(env.XDG_CONFIG_HOME ?? join(home, ".config"), "opencode");
@@ -157,6 +189,13 @@ export const SUPPORTED_CLIENT_DEFINITIONS = [
         markerPath: grokDirectory,
         format: "grok",
     },
+    {
+        name: "omp",
+        displayName: "OMP",
+        configPath: (context) => join(ompAgentDirectory(context), "mcp.json"),
+        markerPath: ompAgentDirectory,
+        format: "omp",
+    },
     {
         name: "grok_bot",
         displayName: "Grok Bot",
@@ -173,7 +212,11 @@ export const supportedClients = (home, platform = process.platform, env = {
     CODEX_HOME: process.env.CODEX_HOME,
     COPILOT_HOME: process.env.COPILOT_HOME,
     GROK_HOME: process.env.GROK_HOME,
+    OMP_PROFILE: process.env.OMP_PROFILE,
     OPENCODE_CONFIG: process.env.OPENCODE_CONFIG,
+    PI_CODING_AGENT_DIR: process.env.PI_CODING_AGENT_DIR,
+    PI_CONFIG_DIR: process.env.PI_CONFIG_DIR,
+    PI_PROFILE: process.env.PI_PROFILE,
     SAND_DATA_ROOT: process.env.SAND_DATA_ROOT,
     XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
 }) => {

package/dist/application/Uninstall.js

@@ -1,16 +1,18 @@
 import { parseClientConfiguration, serializeClientConfiguration, clientServerPath, legacyClientServerPath, withClientServers, } from "./ClientConfigurationDocument.js";
 import { copyFile, lstat, readFile, realpath, rm } from "node:fs/promises";
-import { homedir } from "node:os";
+import { constants as fsConstants } from "node:fs";
+import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
 import { join } from "node:path";
 import writeFileAtomic from "write-file-atomic";
 import { z } from "zod";
 import { PRODUCT_IDENTITY } from "../identity.js";
+import { claudeCodeSkillsDirectory, skillDestinations } from "./SetupSkill.js";
 import { isOwnedClientRegistrationCommand } from "./ClientRegistrationIdentity.js";
 import { resolveClientConfigTransactionPath } from "./ClientConfigPath.js";
 import { manualRegistrationRemediation, supportedClients, } from "./SupportedClients.js";
 const systemFileSystem = {
     readText: (path) => readFile(path, "utf8"),
-    copy: (source, destination) => copyFile(source, destination),
+    copy: (source, destination) => copyFile(source, destination, fsConstants.COPYFILE_EXCL),
     writeText: (path, contents) => writeFileAtomic(path, contents, { encoding: "utf8" }),
     stat: (path) => lstat(path),
     realpath: (path) => realpath(path),
@@ -30,14 +32,26 @@ export const isUninstallFailure = (result) => {
         }
     }
 };
-/** Remove only REA-owned registrations and managed files, optionally including local state. */
+/**
+ * Remove only REA-owned registrations and managed files, optionally including
+ * local state. A client configuration that cannot be read safely stops the
+ * operation before anything is removed; one that fails during removal stops
+ * the remaining removals.
+ */
 export const runUninstall = async (purgeData, host = systemUninstallHost()) => {
-    const items = [];
-    for (const client of await host.clients())
-        items.push(await host.removeClient(client));
-    items.push(await host.removeSkill());
-    if (purgeData)
-        items.push(...(await host.purgeData()));
+    const clients = await host.clients();
+    const blocked = [];
+    for (const client of clients) {
+        const blocking = await host.inspectClient(client);
+        if (blocking !== undefined)
+            blocked.push(blocking);
+    }
+    const items = blocked.length > 0
+        ? [
+            ...blocked,
+            item("uninstall", "skipped", "No REA registration, skill, or data was removed. Repair each failed configuration, then rerun uninstall."),
+        ]
+        : await removeAll(clients, purgeData, host);
     items.push({
         name: "analysis_engine",
         status: "retained",
@@ -50,41 +64,80 @@ export const runUninstall = async (purgeData, host = systemUninstallHost()) => {
         items,
     };
 };
+/**
+ * Each client is reread when it is edited, so a concurrent change is never
+ * overwritten. A client that fails then still stops the remaining removals.
+ */
+const removeAll = async (clients, purgeData, host) => {
+    const items = [];
+    for (const client of clients) {
+        const removed = await host.removeClient(client);
+        items.push(removed);
+        if (removed.status === "failed")
+            return [
+                ...items,
+                item("uninstall", "skipped", "Uninstall stopped at this failure; the items above report what changed. Repair the failed configuration, then rerun uninstall."),
+            ];
+    }
+    items.push(await host.removeSkill());
+    if (purgeData)
+        items.push(...(await host.purgeData()));
+    return items;
+};
 /** Create uninstall effects contained to detected client configs and REA-owned paths. */
-export const systemUninstallHost = (home = homedir(), fileSystem = systemFileSystem) => ({
-    clients: () => Promise.resolve(supportedClients(home)),
-    removeClient: (client) => removeClient(client, fileSystem),
-    removeSkill: () => removeManagedSkills(home, fileSystem),
-    purgeData: async () => [
-        await removeManagedPath(join(home, ".rea/cache"), "cache", fileSystem),
-        await removeManagedPath(join(home, ".rea/state"), "state", fileSystem),
-    ],
-});
-const removeClient = async (client, fileSystem) => {
+export const systemUninstallHost = (selectedHome = undefined, fileSystem = systemFileSystem, environment = process.env, platform = process.platform) => {
+    const home = selectedHome ?? homeDirectoryFromEnvironment(environment, platform);
+    return {
+        clients: () => Promise.resolve(supportedClients(home, platform, environment)),
+        inspectClient: async (client) => {
+            const read = await readClientConfiguration(client, fileSystem);
+            return read.kind === "item" && read.item.status === "failed"
+                ? read.item
+                : undefined;
+        },
+        removeClient: (client) => removeClient(client, fileSystem),
+        removeSkill: () => removeManagedSkills(home, fileSystem, environment),
+        purgeData: async () => [
+            await removeManagedPath(join(home, ".rea/cache"), "cache", fileSystem),
+            await removeManagedPath(join(home, ".rea/state"), "state", fileSystem),
+        ],
+    };
+};
+const readClientConfiguration = async (client, fileSystem) => {
     if (client.format === "unsupported")
-        return item(client.name, "skipped", manualRegistrationRemediation(client.name) ??
-            "This client has no documented local MCP configuration boundary.");
+        return itemRead(item(client.name, "skipped", manualRegistrationRemediation(client.name) ??
+            "This client has no documented local MCP configuration boundary."));
     const resolved = await resolveUninstallConfigPath(client, fileSystem);
     if (typeof resolved !== "string")
-        return resolved;
+        return itemRead(resolved);
     const transactionPath = resolved;
     let original;
     try {
         original = await fileSystem.readText(transactionPath);
     }
     catch (cause) {
-        return isMissing(cause)
+        return itemRead(isMissing(cause)
             ? item(client.name, "skipped", "Configuration does not exist.")
-            : item(client.name, "failed", "Configuration could not be read. Check file permissions, then rerun uninstall.");
+            : item(client.name, "failed", "Configuration could not be read. Check file permissions, then rerun uninstall."));
     }
-    let parsed;
     try {
-        parsed = parseClientConfiguration(original, client.format);
+        const parsed = parseClientConfiguration(original, client.format);
+        return { kind: "configuration", transactionPath, original, parsed };
     }
     catch (cause) {
         void cause;
-        return item(client.name, "failed", `Configuration is not valid ${client.format === "toml" || client.format === "grok" ? "TOML" : client.format === "opencode" ? "JSONC" : "JSON"} and was not changed. Repair it, then rerun uninstall.`);
+        return itemRead(item(client.name, "failed", `Configuration is not valid ${client.format === "toml" || client.format === "grok" ? "TOML" : client.format === "opencode" ? "JSONC" : "JSON"} and was not changed. Repair it, then rerun uninstall.`));
     }
+};
+const itemRead = (result) => ({
+    kind: "item",
+    item: result,
+});
+const removeClient = async (client, fileSystem) => {
+    const read = await readClientConfiguration(client, fileSystem);
+    if (read.kind === "item")
+        return read.item;
+    const { transactionPath, original, parsed } = read;
     const name = PRODUCT_IDENTITY.mcpServerKey;
     // Beside a native OpenCode V2 table, OpenCode also loads a V1 `mcp.rea`.
     const legacyPath = legacyClientServerPath(parsed, name);
@@ -109,8 +162,8 @@ const removeClient = async (client, fileSystem) => {
         await fileSystem.copy(transactionPath, backupPath);
     }
     catch (cause) {
-        void cause;
-        return item(client.name, "failed", "Configuration could not be backed up, so no change was made. Check file permissions, then rerun uninstall.");
+        if (!(cause instanceof Error && "code" in cause && cause.code === "EEXIST"))
+            return item(client.name, "failed", "Configuration could not be backed up, so no change was made. Check file permissions, then rerun uninstall.");
     }
     try {
         await fileSystem.writeText(transactionPath, serializeClientConfiguration(document, client.format, original, editedPaths));
@@ -172,7 +225,22 @@ const removeManagedPath = async (path, name, fileSystem) => {
             : item(name, "failed", "This item could not be removed. Check file permissions, then rerun uninstall.");
     }
 };
-const removeManagedSkills = async (home, fileSystem) => removeManagedPath(join(home, ".agents/skills", PRODUCT_IDENTITY.skillName), "skill", fileSystem);
+const removeManagedSkills = async (home, fileSystem, environment) => {
+    const results = await Promise.all(skillDestinations(home, undefined, claudeCodeSkillsDirectory(home, environment)).map(({ client, path }) => removeManagedPath(path, client === "claude_code" ? "Claude Code skill" : "skill", fileSystem)));
+    const failed = results.find(({ status }) => status === "failed");
+    if (failed !== undefined)
+        return item("skill", "failed", results
+            .map(({ name, status, detail }) => `${name}: ${status} (${detail})`)
+            .join(" "));
+    const status = results.some(({ status: resultStatus }) => resultStatus === "removed")
+        ? "removed"
+        : results.some(({ status: resultStatus }) => resultStatus === "retained")
+            ? "retained"
+            : "skipped";
+    return item("skill", status, results
+        .map(({ name, status: resultStatus, detail }) => `${name}: ${resultStatus} (${detail})`)
+        .join(" "));
+};
 const item = (name, status, detail) => ({ name, status, detail });
 const registrationSchema = z
     .object({ command: z.string(), args: z.array(z.string()) })

package/dist/application/UpdateMaintenance.js

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { isOwnedClientRegistrationCommand } from "./ClientRegistrationIdentity.js";
 import { readClientRegistrationStatuses } from "./ClientRegistrationStatus.js";
-import { effectiveClientServer, parseClientConfiguration, } from "./ClientConfigurationDocument.js";
+import { clientServerForcedEnabled, clientServerListedDisabled, effectiveClientServer, parseClientConfiguration, } from "./ClientConfigurationDocument.js";
 import { supportedClients } from "./SupportedClients.js";
 const setupPlanSchema = z.object({
     status: z.literal("planned"),
@@ -21,9 +21,11 @@ const setupPlanSchema = z.object({
     })),
 });
 /** Discover owned registrations and an existing REA skill without writes. */
-export const existingMaintenanceScope = async (home, entryPoint) => {
-    const registrations = await readClientRegistrationStatuses(home, entryPoint);
-    const supported = supportedClients(home);
+export const existingMaintenanceScope = async (home, entryPoint, environment) => {
+    const registrations = await readClientRegistrationStatuses(home, entryPoint, {
+        environment,
+    });
+    const supported = supportedClients(home, process.platform, environment);
     const clients = [];
     for (const registration of registrations) {
         if ((registration.state !== "aligned" && registration.state !== "stale") ||
@@ -39,7 +41,11 @@ export const existingMaintenanceScope = async (home, entryPoint) => {
             disabled: z.boolean().optional(),
         })
             .parse(effectiveClientServer(parsed, PRODUCT_IDENTITY.mcpServerKey));
-        if (enabled.enabled !== false && enabled.disabled !== true)
+        // Root disable lists override enabled entries and OMP's force-on allowlist.
+        if ((enabled.enabled !== false ||
+            clientServerForcedEnabled(parsed, PRODUCT_IDENTITY.mcpServerKey)) &&
+            enabled.disabled !== true &&
+            !clientServerListedDisabled(parsed, PRODUCT_IDENTITY.mcpServerKey))
             clients.push(client.name);
     }
     let skill = false;
@@ -56,9 +62,9 @@ export const existingMaintenanceScope = async (home, entryPoint) => {
     return { clients, skill };
 };
 /** Ask the verified new executable to plan only existing REA integrations. */
-export const planIntegrationMaintenance = async (home, entryPoint, execute) => {
+export const planIntegrationMaintenance = async (home, entryPoint, environment, execute) => {
     try {
-        const scope = await existingMaintenanceScope(home, entryPoint);
+        const scope = await existingMaintenanceScope(home, entryPoint, environment);
         if (scope.clients.length === 0 && !scope.skill)
             return { status: "current", plannedActions: [] };
         const command = [

package/dist/application/UpdateRuntime.js

@@ -1,5 +1,5 @@
 import { realpath } from "node:fs/promises";
-import { homedir } from "node:os";
+import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import spawn from "cross-spawn";
@@ -9,13 +9,13 @@ import { safeParseJson } from "../domain/safeJson.js";
 import { updateInstallCommand, } from "./Update.js";
 import { planIntegrationMaintenance } from "./UpdateMaintenance.js";
 /** Run an updater subprocess with complete diagnostics and isolated machine output. */
-export const runUpdateCommand = (command, output = "structured") => new Promise((resolveResult) => {
+export const runUpdateCommand = (command, selectedEnvironment, output = "structured") => new Promise((resolveResult) => {
     const [executable, ...args] = command;
     if (executable === undefined) {
         resolveResult(err("No executable supplied."));
         return;
     }
-    const environment = { ...process.env };
+    const environment = { ...selectedEnvironment };
     // A fresh installed entry point must not inherit npx's invocation identity.
     delete environment.npm_command;
     const child = spawn(executable, args, {
@@ -46,8 +46,8 @@ export const runUpdateCommand = (command, output = "structured") => new Promise(
                 ? `Process exited with code ${String(code)}.`
                 : `Process terminated by ${signal}.`))));
 });
-const requireCommandOutput = async (command) => {
-    const result = await runUpdateCommand(command);
+const requireCommandOutput = async (command, environment) => {
+    const result = await runUpdateCommand(command, environment);
     if (!result.ok)
         throw new Error(result.error);
     return result.value;
@@ -130,21 +130,21 @@ export const npmReleaseLookup = (response) => {
         : err({ kind: "invalid-metadata", detail: parsed.error });
 };
 /** Create npm, registry, verification, and read-only maintenance effects. */
-export const systemUpdateHost = (packageRoot = fileURLToPath(new URL("../..", import.meta.url)), home = homedir()) => ({
+export const systemUpdateHost = (packageRoot = fileURLToPath(new URL("../..", import.meta.url)), home = undefined, environment = process.env) => ({
     installation: () => detectNpmInstallation(packageRoot, {
         canonicalPath: realpath,
-        globalRoot: () => requireCommandOutput(["npm", "root", "--global"]),
-        globalPrefix: () => requireCommandOutput(["npm", "prefix", "--global"]),
+        globalRoot: () => requireCommandOutput(["npm", "root", "--global"], environment),
+        globalPrefix: () => requireCommandOutput(["npm", "prefix", "--global"], environment),
     }),
-    latestVersion: async (installation) => npmReleaseLookup(await runUpdateCommand(npmLatestVersionCommand(installation))),
+    latestVersion: async (installation) => npmReleaseLookup(await runUpdateCommand(npmLatestVersionCommand(installation), environment)),
     installVersion: async (installation, version, output) => {
-        const result = await runUpdateCommand(updateInstallCommand(installation, version), output);
+        const result = await runUpdateCommand(updateInstallCommand(installation, version), environment, output);
         return result.ok ? ok(undefined) : result;
     },
     installedVersion: (installation) => runUpdateCommand([
         process.execPath,
         join(installation.packageRoot, "scripts", "rea.mjs"),
         "--version",
-    ]),
-    planMaintenance: (installation) => planIntegrationMaintenance(home, join(installation.packageRoot, "scripts", "rea.mjs"), runUpdateCommand),
+    ], environment),
+    planMaintenance: (installation) => planIntegrationMaintenance(home ?? homeDirectoryFromEnvironment(environment, process.platform), join(installation.packageRoot, "scripts", "rea.mjs"), environment, (command) => runUpdateCommand(command, environment)),
 });

package/dist/application/Utf8JsonInput.js

@@ -0,0 +1,64 @@
+import { constants } from "node:buffer";
+import { AnalysisResourceConstraintError } from "../domain/analysisErrorCore.js";
+import { safeParseJson } from "../domain/safeJson.js";
+/** Recovery that preserves complete, authenticated Evidence workflow inputs. */
+export const JSON_INPUT_RESOURCE_REMEDIATION = "Provide a smaller valid JSON value. For Evidence workflows, re-analyze a smaller selection of the original target and use its complete Evidence; splitting JSON text or trimming Evidence fields does not produce valid workflow input.";
+/** Decode JSON bytes without confusing a runtime string limit with malformed input. */
+export const parseUtf8Json = (bytes, operation, path, boundary = "json-input") => {
+    const stringLimitFailure = (cause, decodedUnits) => new AnalysisResourceConstraintError(operation, "memory", "JSON input exceeds the runtime's maximum decoded string length", {
+        boundary,
+        input_path: path,
+        input_bytes: bytes.byteLength,
+        max_string_code_units: constants.MAX_STRING_LENGTH,
+        ...(decodedUnits === undefined
+            ? {}
+            : { decoded_string_code_units_at_least: decodedUnits }),
+    }, {
+        ...(cause === undefined ? {} : { cause }),
+        remediationAction: JSON_INPUT_RESOURCE_REMEDIATION,
+    });
+    let text;
+    try {
+        const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+        if (bytes.byteLength <= constants.MAX_STRING_LENGTH) {
+            text = decoder.decode(bytes);
+        }
+        else {
+            // Node 22's UTF-8 fast path bounds encoded bytes before decoding. Decode
+            // large inputs in chunks so valid multibyte text is bounded by its actual
+            // UTF-16 length. Streaming also preserves characters spanning chunks.
+            const parts = [];
+            let decodedUnits = 0;
+            const append = (part) => {
+                decodedUnits += part.length;
+                if (decodedUnits > constants.MAX_STRING_LENGTH)
+                    throw stringLimitFailure(undefined, decodedUnits);
+                parts.push(part);
+            };
+            const chunkBytes = 1024 * 1024;
+            for (let offset = 0; offset < bytes.byteLength; offset += chunkBytes)
+                append(decoder.decode(bytes.subarray(offset, offset + chunkBytes), {
+                    stream: true,
+                }));
+            append(decoder.decode());
+            text = parts.join("");
+        }
+    }
+    catch (cause) {
+        if (cause instanceof AnalysisResourceConstraintError)
+            throw cause;
+        const code = typeof cause === "object" && cause !== null && "code" in cause
+            ? cause.code
+            : undefined;
+        if (code === "ERR_STRING_TOO_LONG")
+            throw stringLimitFailure(cause);
+        if (code !== "ERR_ENCODING_INVALID_ENCODED_DATA")
+            throw cause;
+        return {
+            ok: false,
+            error: "JSON input is not valid UTF-8",
+            cause,
+        };
+    }
+    return safeParseJson(text);
+};

package/dist/application/WebScriptExportService.js

@@ -1,11 +1,10 @@
 import { createHash } from "node:crypto";
-import { readFile } from "node:fs/promises";
 import { isAbsolute } from "node:path";
 import { z } from "zod";
 import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
 import { publishWebScripts } from "../browser/assets/PublishWebScripts.js";
 import { selectScriptCapture } from "../browser/assets/ScriptCaptureAdapters.js";
-import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
+import { AnalysisAccessDeniedError, AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
 import { createEvidence } from "../domain/evidence.js";
 import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
@@ -15,6 +14,8 @@ import { safeParseJson } from "../domain/safeJson.js";
 import { exportWebScriptsInputSchema, } from "../domain/webScriptExport.js";
 import { WebScriptExportError } from "../domain/webScriptExportError.js";
 import { WEB_SCRIPT_EXPORT_PROVIDER as PROVIDER } from "./InvestigationProviders.js";
+import { readRegularFile } from "./RegularFileRead.js";
+import { NonRegularFileReadError } from "../filesystem/RegularFile.js";
 const OPERATION = "export_web_scripts";
 /** Export one local capture through the shared CLI/MCP application workflow. */
 export const exportWebScripts = async (rawInput, options = {}) => {
@@ -35,9 +36,10 @@ export const exportWebScriptsValidated = async (input, options = {}) => {
         ]));
     try {
         options.signal?.throwIfAborted();
-        const bytes = await readFile(input.capture_path, {
-            signal: options.signal,
-        });
+        const read = await readCapture(input.capture_path, options.signal);
+        if (!read.ok)
+            return read;
+        const bytes = read.value;
         const loaded = parseCapture(bytes);
         if (!loaded.ok)
             return loaded;
@@ -90,6 +92,37 @@ export const exportWebScriptsValidated = async (input, options = {}) => {
         }));
     }
 };
+/**
+ * Read the caller-selected capture. A missing, non-file or unreadable
+ * selection is a caller or host-permission failure, not an export failure.
+ */
+const readCapture = async (path, signal) => {
+    try {
+        return ok(await readRegularFile(path, signal));
+    }
+    catch (cause) {
+        const code = cause instanceof Error && "code" in cause ? String(cause.code) : "";
+        if (code === "EACCES" || code === "EPERM")
+            return err(new AnalysisAccessDeniedError(OPERATION, path, code, { cause }));
+        if (cause instanceof NonRegularFileReadError ||
+            code === "ENOENT" ||
+            code === "ENOTDIR" ||
+            code === "EISDIR" ||
+            code === "ENXIO")
+            return err(new AnalysisInputError(OPERATION, { cause }, [
+                {
+                    path: ["capture_path"],
+                    reason: "invalid_value",
+                    message: cause instanceof NonRegularFileReadError && code !== "EISDIR"
+                        ? cause.message
+                        : code === "EISDIR"
+                            ? `Selected capture is a directory, not a file: ${path}`
+                            : `Selected capture could not be read (${code}): ${path}`,
+                },
+            ]));
+        throw cause;
+    }
+};
 const parseCapture = (bytes) => {
     try {
         const text = new TextDecoder("utf-8", {

package/dist/application/WorkflowEvidence.js

@@ -1,6 +1,6 @@
 import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "./InvestigationProviders.js";
 import { analysisProfileSchema, committedProviderSchema, } from "../domain/analysisProfile.js";
-import { createEvidence } from "../domain/evidence.js";
+import { createEvidence, } from "../domain/evidence.js";
 import { UnknownRegistryError } from "../domain/unknownRegistryError.js";
 /** Build the shared Evidence record for a successful composed binary workflow. */
 export const createWorkflowEvidence = (input) => createEvidence(input.target, REA_WORKFLOW_PROVIDER, {
@@ -14,10 +14,33 @@ export const createWorkflowEvidence = (input) => createEvidence(input.target, RE
         }),
     confidence: "derived",
     limitations: ["Derived by an REA composed workflow."],
+    ...(input.operation === "batch_decompile"
+        ? { locations: batchProcedureLocations(input.result) }
+        : {}),
 });
+const batchProcedureLocations = (result) => {
+    if (result === null ||
+        typeof result !== "object" ||
+        Array.isArray(result) ||
+        !Array.isArray(result.items))
+        return [];
+    const addresses = new Set();
+    for (const item of result.items) {
+        if (item === null || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const procedure = item.procedure;
+        if (procedure !== null &&
+            typeof procedure === "object" &&
+            !Array.isArray(procedure) &&
+            procedure.status === "resolved" &&
+            typeof procedure.address === "string")
+            addresses.add(procedure.address);
+    }
+    return [...addresses].map((address) => ({ kind: "address", address }));
+};
 /** Convert workflow Evidence into its exact replay binding, when it has a profile. */
 export const workflowSnapshotRecord = (evidence, operation) => {
-    if (!("analysis_profile" in evidence))
+    if (evidence.analysis_profile === null)
         return undefined;
     return {
         operation,