rea-agents 3.0.0 → 3.1.0

package/dist/generatedPackageMetadata.js

@@ -1,7 +1,7 @@
 /** Generated from package.json and package-lock.json; do not edit. */
 export const PACKAGE_METADATA = {
     name: "rea-agents",
-    version: "3.0.0", // x-release-please-version
+    version: "3.1.0", // x-release-please-version
     serverSdkVersion: "2.0.0",
     clientSdkVersion: "2.0.0",
     coreSdkVersion: "2.0.0",

package/dist/ghidra/GhidraClient.js

@@ -369,7 +369,7 @@ export class GhidraClient {
         return err(failure);
     }
     #interruptionFailure(deadline) {
-        return deadline.cancelled
+        return deadline.interruption === "cancelled"
             ? this.#failure("cancelled", "Ghidra startup was cancelled")
             : this.#failure("timeout", "Ghidra startup deadline elapsed", undefined, {
                 timeoutMs: deadline.timeoutMs,

package/dist/ghidra/GhidraClientStartup.js

@@ -22,7 +22,7 @@ export async function completeGhidraStartupHandshake(options) {
     }
     return parsed;
 }
-const interruptionFailure = (options) => options.deadline.cancelled
+const interruptionFailure = (options) => options.deadline.interruption === "cancelled"
     ? options.failure("cancelled", "Ghidra startup was cancelled")
     : options.failure("timeout", "Ghidra startup deadline elapsed", undefined, {
         timeoutMs: options.startupTimeoutMs,

package/dist/ghidra/GhidraFunctionValues.js

@@ -1,7 +1,6 @@
 import { z } from "zod";
 import { AnalysisInputError, AnalysisOutputError } from "../domain/errors.js";
 import { functionInstructionWindowSchema, functionDossierSchema, } from "../domain/hopperValues.js";
-import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
 import { nativeApiBoundarySchema } from "../domain/nativeApiBoundary.js";
 import { err, ok } from "../domain/result.js";
 import { ghidraBoundedIdentifierSchema, ghidraCanonicalAddressSchema, } from "./GhidraInventoryValues.js";
@@ -90,7 +89,7 @@ const inputSchemas = {
 export const parseGhidraFunctionInput = (operation, value) => {
     const parsed = inputSchemas[operation].safeParse(value);
     return parsed.success
-        ? ok(jsonObjectSchema.parse(parsed.data))
+        ? ok(parsed.data)
         : err(new AnalysisInputError(operation, { cause: parsed.error }));
 };
 const classification = z
@@ -143,15 +142,24 @@ const referenceEdge = z
     kind: referenceKind,
 })
     .strict();
-const boundedReferences = z
-    .object({
+const boundedReferenceFacts = {
     items: z.array(referenceEdge),
     total: z.number().int().min(0).nullable(),
     returned: z.number().int().min(0),
-    truncated: z.boolean(),
-    next_offset: z.number().int().min(0).nullable(),
-})
-    .strict()
+};
+const boundedReferences = z
+    .discriminatedUnion("truncated", [
+    z.strictObject({
+        ...boundedReferenceFacts,
+        truncated: z.literal(false),
+        next_offset: z.null(),
+    }),
+    z.strictObject({
+        ...boundedReferenceFacts,
+        truncated: z.literal(true),
+        next_offset: z.number().int().min(0).nullable(),
+    }),
+])
     .superRefine((value, context) => {
     if (value.returned !== value.items.length)
         context.addIssue({
@@ -165,12 +173,6 @@ const boundedReferences = z
             path: ["total"],
             message: "total cannot be smaller than returned",
         });
-    if (value.next_offset !== null && !value.truncated)
-        context.addIssue({
-            code: "custom",
-            path: ["next_offset"],
-            message: "a continuation requires truncated output",
-        });
 });
 const procedureReferences = z
     .object({
@@ -287,7 +289,7 @@ const resultSchemas = {
 export const parseGhidraFunctionResult = (operation, value) => {
     const parsed = resultSchemas[operation].safeParse(value);
     return parsed.success
-        ? ok(jsonValueSchema.parse(parsed.data))
+        ? ok(parsed.data)
         : err(new AnalysisOutputError(operation, "Ghidra bridge output did not match the function-analysis contract", { cause: parsed.error }));
 };
 const referenceAddresses = (edge) => [

package/dist/ghidra/GhidraInventoryValues.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { AnalysisInputError, AnalysisOutputError } from "../domain/errors.js";
-import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
 /** Read-only direct operations admitted by the Ghidra v1 adapter. */
 export const GHIDRA_INVENTORY_OPERATIONS = [
@@ -60,7 +59,7 @@ export const parseGhidraInventoryInput = (operation, value) => {
     const parsed = inputSchemas[operation].safeParse(value);
     if (!parsed.success)
         return err(new AnalysisInputError(operation, { cause: parsed.error }));
-    return ok(jsonObjectSchema.parse(parsed.data));
+    return ok(parsed.data);
 };
 export const ghidraCanonicalAddressSchema = z
     .string()
@@ -104,50 +103,61 @@ const procedureItem = z
     .strict();
 const stringItem = z.object({ ...baseItem, string: stringFacts }).strict();
 const searchItem = z.object(baseItem).strict();
-const pageSchema = (item, maximumLimit) => z
-    .object({
-    items: z.array(item),
-    offset: z.number().int().min(0),
-    limit: z.number().int().min(1).max(maximumLimit),
-    total: z.number().int().min(0),
-    next_offset: z.number().int().min(0).nullable(),
-    has_more: z.boolean(),
-})
-    .strict()
-    .superRefine((page, context) => {
-    const next = page.offset + page.items.length;
-    const hasMore = next < page.total;
-    if (page.items.length > page.limit)
-        context.addIssue({
-            code: "custom",
-            path: ["items"],
-            message: "page exceeds its declared limit",
-        });
-    if (page.items.length > 0 && next > page.total)
-        context.addIssue({
-            code: "custom",
-            path: ["total"],
-            message: "page items exceed its exact total",
-        });
-    if (hasMore && page.items.length === 0)
-        context.addIssue({
-            code: "custom",
-            path: ["items"],
-            message: "page continuation must advance its offset",
-        });
-    if (page.has_more !== hasMore)
-        context.addIssue({
-            code: "custom",
-            path: ["has_more"],
-            message: "page continuation does not match its exact total",
-        });
-    if (page.next_offset !== (hasMore ? next : null))
-        context.addIssue({
-            code: "custom",
-            path: ["next_offset"],
-            message: "page continuation offset is inconsistent",
-        });
-});
+const pageSchema = (item, maximumLimit) => {
+    const pageFacts = {
+        items: z.array(item),
+        offset: z.number().int().min(0),
+        limit: z.number().int().min(1).max(maximumLimit),
+        total: z.number().int().min(0),
+    };
+    return z
+        .discriminatedUnion("has_more", [
+        z.strictObject({
+            ...pageFacts,
+            has_more: z.literal(true),
+            next_offset: z.number().int().min(0),
+        }),
+        z.strictObject({
+            ...pageFacts,
+            has_more: z.literal(false),
+            next_offset: z.null(),
+        }),
+    ])
+        .superRefine((page, context) => {
+        const next = page.offset + page.items.length;
+        const hasMore = next < page.total;
+        if (page.items.length > page.limit)
+            context.addIssue({
+                code: "custom",
+                path: ["items"],
+                message: "page exceeds its declared limit",
+            });
+        if (page.items.length > 0 && next > page.total)
+            context.addIssue({
+                code: "custom",
+                path: ["total"],
+                message: "page items exceed its exact total",
+            });
+        if (hasMore && page.items.length === 0)
+            context.addIssue({
+                code: "custom",
+                path: ["items"],
+                message: "page continuation must advance its offset",
+            });
+        if (page.has_more !== hasMore)
+            context.addIssue({
+                code: "custom",
+                path: ["has_more"],
+                message: "page continuation does not match its exact total",
+            });
+        if (page.next_offset !== (hasMore ? next : null))
+            context.addIssue({
+                code: "custom",
+                path: ["next_offset"],
+                message: "page continuation offset is inconsistent",
+            });
+    });
+};
 const availablePermissions = z
     .object({
     available: z.literal(true),
@@ -212,6 +222,6 @@ const resultSchemas = {
 export const parseGhidraInventoryResult = (operation, value) => {
     const parsed = resultSchemas[operation].safeParse(value);
     return parsed.success
-        ? ok(jsonValueSchema.parse(parsed.data))
+        ? ok(parsed.data)
         : err(new AnalysisOutputError(operation, "Ghidra bridge output did not match the inventory contract", { cause: parsed.error }));
 };

package/dist/ghidra/GhidraProvider.js

@@ -1,5 +1,6 @@
 import { fileURLToPath } from "node:url";
 import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
+import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisTimeoutError, ProviderAdapterError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { GhidraClient } from "./GhidraClient.js";
@@ -10,9 +11,9 @@ import { ghidraInstallationDiagnostics, inspectGhidraInstallation, } from "./Ghi
 import { GhidraHeadlessLauncher } from "./GhidraLauncher.js";
 import { resolveGhidraAnalysisProfile } from "./GhidraAnalysisProfile.js";
 import { CAPABILITIES, WINDOWS_P0_CAPABILITIES, GHIDRA_PROVIDER_IDENTITY, GHIDRA_PROVIDER_TOOL_CONTRACTS, healthLimitations, windowsP0Limitations, limitationsFor, } from "./GhidraProviderCapabilities.js";
+import { WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON, hasWindowsNativeAuthority, windowsNativeCapabilities, } from "../process/WindowsAuthority.js";
 export { GHIDRA_PROVIDER_IDENTITY, GHIDRA_PROVIDER_TOOL_CONTRACTS };
 const SUPPORTED_ARCHITECTURES = new Set(["x86", "x86_64", "arm", "arm64"]);
-const SUPPORTED_FORMATS = new Set(["elf", "pe", "mach-o"]);
 /** Ghidra candidate backed by an isolated read-only headless import. */
 export class GhidraProvider {
     config;
@@ -37,6 +38,18 @@ export class GhidraProvider {
     inspectAvailability() {
         const installation = this.#inspectInstallation();
         const diagnostics = ghidraInstallationDiagnostics(installation);
+        if (installation.available &&
+            installation.platform === "win32" &&
+            !hasWindowsNativeAuthority(installation.platform))
+            return {
+                status: "unavailable",
+                code: "unsupported_host",
+                reason: WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON,
+                diagnostics: {
+                    ...diagnostics,
+                    windows_security: jsonObjectSchema.parse(windowsNativeCapabilities(installation.platform)),
+                },
+            };
         return installation.available
             ? {
                 status: "available",
@@ -70,15 +83,7 @@ export class GhidraProvider {
             };
         if (hostPlatform === "win32")
             return inspectWindowsP0TargetSupport(target, diagnostics);
-        if (!SUPPORTED_FORMATS.has(target.format))
-            return {
-                status: "unsupported",
-                code: "target_format_unsupported",
-                reason: `Ghidra v1 does not import ${target.format} through this adapter.`,
-                diagnostics,
-            };
-        if (target.architecture === undefined ||
-            !SUPPORTED_ARCHITECTURES.has(target.architecture))
+        if (!SUPPORTED_ARCHITECTURES.has(target.architecture))
             return {
                 status: "unsupported",
                 code: "architecture_unsupported",
@@ -237,6 +242,9 @@ const ghidraClientPrerequisites = (target, profile, installation) => {
         return err(new ProviderAdapterError("ghidra", "health", {
             diagnostics: ghidraInstallationDiagnostics(installation),
         }));
+    if (installation.platform === "win32" &&
+        !hasWindowsNativeAuthority(installation.platform))
+        return err(new AnalysisCapabilityUnavailableError("ghidra", "health", WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON));
     if (profile === undefined || profile.provider.id !== "ghidra")
         return err(new ProviderAdapterError("ghidra", "health"));
     return ok({

package/dist/ghidra/GhidraProviderCapabilities.js

@@ -1,3 +1,4 @@
+import { WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON } from "../process/WindowsAuthority.js";
 import { GENERATED_MCP_TOOL_CATALOG } from "../generatedMcpToolCatalog.js";
 import { GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS, GHIDRA_MAX_LINE_BYTES, GHIDRA_REQUEST_TIMEOUT_MS, } from "./GhidraDefaults.js";
 import { GHIDRA_FUNCTION_OPERATIONS } from "./GhidraFunctionValues.js";
@@ -43,7 +44,7 @@ export const healthLimitations = Object.freeze([
 export const windowsP0Limitations = Object.freeze([
     "Windows Ghidra P0 accepts approved native x86-64 PE applications only; DLL, managed, hostile, sensitive, and mutable-path targets are unsupported.",
     "The Windows bridge uses authenticated IPv4 loopback because Node path-based IPC does not expose Java AF_UNIX sockets; the endpoint file contains no bearer token.",
-    "Windows P0 process-tree cleanup uses bounded taskkill termination and does not claim Job Object ownership, private DACL enforcement, or reparse-point-safe path authority.",
+    "Windows P0 is not admitted until a native authority proves Job Object ownership, private DACL enforcement, and reparse-safe path admission; bounded taskkill cleanup and chmod(0700) do not prove those controls.",
 ]);
 /** Limitation text for one admitted operation, including the common base. */
 export const limitationsFor = (operation) => {
@@ -175,6 +176,9 @@ export const CAPABILITIES = Object.freeze(GHIDRA_PROVIDER_TOOL_CONTRACTS.map((co
 /** Capabilities advertised for the experimental Windows x64 P0 boundary. */
 export const WINDOWS_P0_CAPABILITIES = Object.freeze(CAPABILITIES.map((capability) => Object.freeze({
     ...capability,
+    available: false,
+    reason: WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON,
+    availabilityCode: "unsupported_host",
     limitations: Object.freeze([
         ...capability.limitations,
         ...windowsP0Limitations,

package/dist/ghidra/GhidraSocketConnection.js

@@ -76,7 +76,7 @@ const connectGhidraSocketOnce = (target, signal) => new Promise((resolve) => {
     if (signal.aborted)
         onAbort();
 });
-const interruptionFailure = (options) => options.deadline.cancelled
+const interruptionFailure = (options) => options.deadline.interruption === "cancelled"
     ? options.failure("cancelled", "Ghidra startup was cancelled")
     : options.failure("timeout", "Ghidra startup deadline elapsed", undefined, {
         timeoutMs: options.startupTimeoutMs,

package/dist/ghidra/protocol.js

@@ -1,46 +1,23 @@
 import { z } from "zod";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
-const responseSchema = z
-    .object({
-    id: z.number().int().positive(),
-    ok: z.boolean(),
-    result: jsonValueSchema.optional(),
-    error: z
-        .object({
-        code: z.string().min(1).max(128),
-        message: z.string().min(1).max(4_096),
-    })
-        .strict()
-        .optional(),
-})
-    .strict()
-    .superRefine((value, context) => {
-    if (value.ok && value.result === undefined)
-        context.addIssue({
-            code: "custom",
-            path: ["result"],
-            message: "Successful Ghidra response requires a result",
-        });
-    if (!value.ok && value.error === undefined)
-        context.addIssue({
-            code: "custom",
-            path: ["error"],
-            message: "Failed Ghidra response requires an error",
-        });
-    if (!value.ok && value.result !== undefined)
-        context.addIssue({
-            code: "custom",
-            path: ["result"],
-            message: "Failed Ghidra response cannot include a result",
-        });
-    if (value.ok && value.error !== undefined)
-        context.addIssue({
-            code: "custom",
-            path: ["error"],
-            message: "Successful Ghidra response cannot include an error",
-        });
-});
+const responseSchema = z.discriminatedUnion("ok", [
+    z.strictObject({
+        id: z.number().int().positive(),
+        ok: z.literal(true),
+        result: jsonValueSchema,
+    }),
+    z.strictObject({
+        id: z.number().int().positive(),
+        ok: z.literal(false),
+        error: z
+            .object({
+            code: z.string().min(1).max(128),
+            message: z.string().min(1).max(4_096),
+        })
+            .strict(),
+    }),
+]);
 /** Expected operation failure returned by the authenticated Java bridge. */
 export class GhidraRemoteError extends Error {
     code;
@@ -65,5 +42,5 @@ export const parseGhidraResponseLine = (line) => {
 };
 /** Project one validated response into its result or remote failure. */
 export const ghidraResponseResult = (response) => response.ok
-    ? ok(response.result ?? null)
-    : err(new GhidraRemoteError(response.error?.code ?? "bridge_error", response.error?.message ?? "Ghidra bridge request failed"));
+    ? ok(response.result)
+    : err(new GhidraRemoteError(response.error.code, response.error.message));

package/dist/hopper/BridgeLauncher.js

@@ -99,7 +99,9 @@ export class HopperApplicationLauncher {
                 process: child,
                 ownsProcessLifetime: true,
                 ownership: started.ownership,
-                shutdownByCleanup: ownsProcessLifetime,
+                shutdownMode: ownsProcessLifetime
+                    ? "process-cleanup"
+                    : "bridge-request",
                 cleanup: () => cleanupOwnedProcessGroup(started.ownership),
             });
         }

package/dist/hopper/HopperAnalysisProfile.js

@@ -49,9 +49,9 @@ export const resolveHopperAnalysisProfile = async (target, options) => {
 export const hopperLoaderArgsForTarget = (target) => {
     if (target.kind === "database")
         return ok([]);
-    const architecture = target.architecture;
-    if (architecture === undefined)
+    if (target.kind !== "executable")
         return err(new ProviderAdapterError("hopper", "resolve_analysis_profile"));
+    const architecture = target.architecture;
     const flag = hopperArchitectureFlag(architecture);
     switch (target.format) {
         case "mach-o":
@@ -62,8 +62,6 @@ export const hopperLoaderArgsForTarget = (target) => {
             return ok(["-l", "ELF", flag]);
         case "pe":
             return ok(["-l", "WinPE", flag]);
-        default:
-            return err(new ProviderAdapterError("hopper", "resolve_analysis_profile"));
     }
 };
 const hopperArchitectureFlag = (architecture) => {

package/dist/hopper/HopperCleanup.js

@@ -10,7 +10,6 @@ export const cleanupHopperSession = async (input) => {
         resources: new Set(),
         cleanupResult: undefined,
         shutdownConfirmed: false,
-        ownedProcessStopped: false,
     };
     await report(input.progress, 0, "requesting Hopper document shutdown");
     await requestShutdown(input, state);
@@ -38,8 +37,7 @@ const requestShutdown = async (input, state) => {
         .catch(() => err(new HopperProcessError(null)));
     if (shutdown.ok &&
         isHopperCleanupRequired(shutdown.value) &&
-        input.launch?.shutdownByCleanup === true &&
-        input.launch.cleanup !== undefined) {
+        input.launch?.shutdownMode === "process-cleanup") {
         state.cleanupResult = await input.launch
             .cleanup()
             .catch(providerCleanupFailure);
@@ -82,7 +80,9 @@ const stopProcess = async (input, state) => {
     }
     input.logger.info(diagnostic, "Owned Hopper launcher shutdown completed");
     if (stopped.status !== "incomplete") {
-        state.ownedProcessStopped = stopped.status !== "not-owned";
+        if (input.launch?.shutdownMode === "process-cleanup" &&
+            stopped.status !== "not-owned")
+            state.shutdownConfirmed = true;
         return;
     }
     const processGroupId = supervisor.launch.ownership?.processGroupId;
@@ -95,8 +95,7 @@ const stopProcess = async (input, state) => {
 };
 const recordUnconfirmedDocument = (input, state) => {
     if ((input.socket === undefined && input.launch === undefined) ||
-        state.shutdownConfirmed ||
-        state.ownedProcessStopped)
+        state.shutdownConfirmed)
         return;
     state.resources.add("hopper-document");
     state.issues.push({

package/dist/hopper/HopperClient.js

@@ -399,6 +399,6 @@ export class HopperClient {
     }
 }
 const isAborted = (signal) => signal?.aborted === true;
-const startupInterruption = (deadline) => deadline.cancelled
+const startupInterruption = (deadline) => deadline.interruption === "cancelled"
     ? new HopperCancelledError()
     : new HopperTimeoutError(deadline.timeoutMs);

package/dist/hopper/HopperProvider.js

@@ -129,20 +129,6 @@ export class HopperProvider {
                 reason: null,
                 diagnostics,
             };
-        if (!["mach-o", "elf", "pe"].includes(target.format))
-            return {
-                status: "unsupported",
-                code: "target_format_unsupported",
-                reason: `Hopper cannot open ${target.format} through this adapter.`,
-                diagnostics,
-            };
-        if (target.architecture === undefined)
-            return {
-                status: "unsupported",
-                code: "architecture_unsupported",
-                reason: "Hopper requires a supported concrete target architecture.",
-                diagnostics,
-            };
         return {
             status: "supported",
             code: null,

package/dist/hopper/LinuxPrivateDisplayProbe.js

@@ -42,7 +42,7 @@ export const selectLinuxPrivateDisplayStrategy = async (options) => {
 /** Run one helper probe in an owned process group with a hard output bound. */
 export const runLinuxPrivateDisplayProbe = async (strategy, options) => {
     if (options.signal?.aborted === true)
-        return emptyProcessResult({ cancelled: true });
+        return emptyProcessResult("cancelled");
     const command = privateDisplayProbeCommand(options.helperPath, strategy);
     let started;
     try {
@@ -54,7 +54,7 @@ export const runLinuxPrivateDisplayProbe = async (strategy, options) => {
         });
     }
     catch {
-        return emptyProcessResult();
+        return emptyProcessResult("launch-failed");
     }
     const launch = {
         process: started.process,
@@ -74,12 +74,15 @@ export const runLinuxPrivateDisplayProbe = async (strategy, options) => {
         supervisor.dispose();
     const snapshot = supervisor.snapshot();
     return {
+        outcome: outcome === "exit"
+            ? "exited"
+            : outcome === "timeout"
+                ? "timed-out"
+                : "cancelled",
         exitCode: snapshot.exitCode,
         stderr: snapshot.stderr.text,
         stderrBytes: snapshot.stderr.bytes,
         stderrTruncated: snapshot.stderr.truncated,
-        timedOut: outcome === "timeout",
-        cancelled: outcome === "cancelled",
         cleanupIncomplete,
     };
 };
@@ -119,16 +122,21 @@ const evaluatedProbe = async (strategy, options, timeoutMs, runner) => {
             diagnostic: syntheticDiagnostic(strategy, "probe_failed"),
         };
     }
-    if (processResult.cancelled)
+    if (processResult.outcome === "cancelled")
         return {
             ok: false,
             diagnostic: syntheticDiagnostic(strategy, "cancelled"),
         };
-    if (processResult.timedOut)
+    if (processResult.outcome === "timed-out")
         return {
             ok: false,
             diagnostic: syntheticDiagnostic(strategy, "probe_timeout"),
         };
+    if (processResult.outcome === "launch-failed")
+        return {
+            ok: false,
+            diagnostic: syntheticDiagnostic(strategy, "probe_failed"),
+        };
     if (processResult.cleanupIncomplete)
         return {
             ok: false,
@@ -182,15 +190,13 @@ const unavailable = (diagnostic) => ({
         : (hopperStartupExitCode(diagnostic.failure_code) ?? 70),
     diagnostic: { ...diagnostic, strategy: "unavailable" },
 });
-const emptyProcessResult = (overrides = {}) => ({
+const emptyProcessResult = (outcome) => ({
+    outcome,
     exitCode: undefined,
     stderr: "",
     stderrBytes: 0,
     stderrTruncated: false,
-    timedOut: false,
-    cancelled: false,
     cleanupIncomplete: false,
-    ...overrides,
 });
 const waitForProbeExit = async (supervisor, timeoutMs, signal) => {
     if (signal?.aborted === true)

package/dist/main/reload.js

@@ -2,7 +2,7 @@ import { parseConfig } from "../config.js";
 import { readProjectPermissionStore } from "../application/ProjectPermissionStore.js";
 import { MCP_PERMISSION_RELOAD_FAILED } from "./messages.js";
 export const registerConfigReload = (input) => {
-    const { dependencies, permissionAuthority, runtimeState, liveServers, serverLogger, } = input;
+    const { dependencies, permissionAuthority, runtimeState, serverLogger } = input;
     let reloadQueue = Promise.resolve();
     return (dependencies.registerReload?.(() => {
         const refreshed = parseConfig(dependencies.env);
@@ -33,14 +33,9 @@ export const registerConfigReload = (input) => {
                 return;
             }
             runtimeState.currentConfig = refreshed.value;
-            Object.assign(runtimeState.processPolicy, refreshed.value.processExecutionPolicy);
             Object.assign(runtimeState.evidencePolicy, refreshed.value.evidenceFilePolicy);
             Object.assign(runtimeState.snapshotPolicy, refreshed.value.analysisSnapshotFilePolicy);
             runtimeState.investigationRoots.splice(0, runtimeState.investigationRoots.length, ...refreshed.value.investigationInputRoots);
-            Object.assign(runtimeState.javascriptReplayPolicy, refreshed.value.javascriptReplayPolicy);
-            Object.assign(runtimeState.managedRuntimePolicy, refreshed.value.managedRuntimePolicy);
-            for (const server of liveServers)
-                server.sendToolListChanged();
         })
             .catch(() => {
             serverLogger.error(MCP_PERMISSION_RELOAD_FAILED);

package/dist/main/state.js

@@ -1,11 +1,5 @@
 export const createRuntimeState = (config) => ({
     currentConfig: config,
-    processPolicy: {
-        ...config.processExecutionPolicy,
-        executableRoots: [...config.processExecutionPolicy.executableRoots],
-        workingRoots: [...config.processExecutionPolicy.workingRoots],
-        allowedEnvironment: [...config.processExecutionPolicy.allowedEnvironment],
-    },
     evidencePolicy: {
         ...config.evidenceFilePolicy,
         roots: [...config.evidenceFilePolicy.roots],
@@ -15,12 +9,4 @@ export const createRuntimeState = (config) => ({
         roots: [...config.analysisSnapshotFilePolicy.roots],
     },
     investigationRoots: [...config.investigationInputRoots],
-    javascriptReplayPolicy: {
-        ...config.javascriptReplayPolicy,
-        roots: [...config.javascriptReplayPolicy.roots],
-    },
-    managedRuntimePolicy: {
-        ...config.managedRuntimePolicy,
-        roots: [...config.managedRuntimePolicy.roots],
-    },
 });