rea-agents 1.3.0 → 1.5.0

package/dist/cliProcessCommands.js

@@ -1,22 +1,12 @@
-import { Cli, Errors, z } from "incur";
-import { captureProcessScenarioFile, compareProcessEvidenceFiles, isProcessCliErrorOutput, } from "./application/ProcessCli.js";
+import { Cli, z } from "incur";
+import { captureProcessScenarioFile, compareProcessEvidenceFiles, } from "./application/ProcessCli.js";
 import { logCliCommand } from "./cliLogging.js";
-const requireProcessCommandSuccess = async (execute) => {
-    const value = await execute();
-    if (isProcessCliErrorOutput(value))
-        throw new Errors.IncurError({
-            code: "PROCESS_COMMAND_FAILED",
-            message: value.message,
-            retryable: false,
-        });
-    return value;
-};
 /** Register Process Capture v4 one-shot commands through shared application services. */
 export const registerProcessCommands = (cli, logger) => {
     cli.command("capture-process", {
         description: "Capture one approved Process Capture v4 JSON scenario",
         args: z.object({ scenario: z.string().describe("Scenario JSON path") }),
-        run: ({ args }) => logCliCommand(logger, "capture-process", () => requireProcessCommandSuccess(() => captureProcessScenarioFile(args.scenario))),
+        run: ({ args }) => logCliCommand(logger, "capture-process", () => captureProcessScenarioFile(args.scenario)),
     });
     cli.command("compare-process-captures", {
         description: "Compare two Process Capture v4 Evidence JSON files",
@@ -24,6 +14,6 @@ export const registerProcessCommands = (cli, logger) => {
             left: z.string().describe("Left capture Evidence JSON path"),
             right: z.string().describe("Right capture Evidence JSON path"),
         }),
-        run: ({ args }) => logCliCommand(logger, "compare-process-captures", () => requireProcessCommandSuccess(() => compareProcessEvidenceFiles(args.left, args.right))),
+        run: ({ args }) => logCliCommand(logger, "compare-process-captures", () => compareProcessEvidenceFiles(args.left, args.right)),
     });
 };

package/dist/config.js

@@ -1,20 +1,29 @@
 import { z } from "zod";
 import { ConfigurationError } from "./domain/errors.js";
 import { err, ok } from "./domain/result.js";
+import { browserEndpointSchema, browserOriginSchema, } from "./domain/browserObservation.js";
 const DEFAULT_HOPPER_LAUNCHER_PATH = "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
 const defaultHopperLauncherPath = () => process.platform === "linux"
     ? "/opt/hopper/bin/Hopper"
     : DEFAULT_HOPPER_LAUNCHER_PATH;
-const environmentSchema = z.object({
+const environmentSchema = z
+    .object({
     HOPPER_LAUNCHER_PATH: z.string().min(1).optional(),
     HOPPER_TARGET_PATH: z.string().min(1).optional(),
-    HOPPER_TARGET_KIND: z.enum(["executable", "database"]).default("executable"),
+    HOPPER_TARGET_KIND: z
+        .enum(["executable", "database"])
+        .default("executable"),
     HOPPER_LOADER_ARGS_JSON: z.string().optional(),
     REA_LOG_LEVEL: z
         .enum(["trace", "debug", "info", "warn", "error", "fatal", "silent"])
         .default("info"),
     REA_PROCESS_CAPTURE_ENABLED: z.enum(["true", "false"]).default("false"),
-    REA_ARTIFACT_NATIVE_MOUNT_ENABLED: z.enum(["true", "false"]).default("false"),
+    REA_ARTIFACT_NATIVE_MOUNT_ENABLED: z
+        .enum(["true", "false"])
+        .default("false"),
+    REA_ARTIFACT_INTEGRITY_CONTINUE_ENABLED: z
+        .enum(["true", "false"])
+        .default("false"),
     REA_PROCESS_ALLOW_EXTERNAL_NETWORK: z
         .enum(["true", "false"])
         .default("false"),
@@ -26,6 +35,15 @@ const environmentSchema = z.object({
     REA_ANALYSIS_SNAPSHOT_ROOTS_JSON: z.string().default("[]"),
     REA_REFERENCE_ROOTS_JSON: z.string().default("[]"),
     REA_REFERENCE_SECRET_PATTERNS_JSON: z.string().default("[]"),
+    REA_BROWSER_OBSERVE_ENABLED: z.enum(["true", "false"]).default("false"),
+    REA_BROWSER_CDP_ENDPOINTS_JSON: z.string().default("[]"),
+    REA_BROWSER_ALLOWED_ORIGINS_JSON: z.string().default("[]"),
+    REA_PERMISSION_PROJECT_ROOT: z.string().min(1).optional(),
+    REA_PERMISSION_PROJECT_STORE: z.string().min(1).optional(),
+})
+    .refine((value) => (value.REA_PERMISSION_PROJECT_ROOT === undefined) ===
+    (value.REA_PERMISSION_PROJECT_STORE === undefined), {
+    message: "REA_PERMISSION_PROJECT_ROOT and REA_PERMISSION_PROJECT_STORE must be configured together",
 });
 const parseStringArray = (encoded, name) => {
     try {
@@ -43,6 +61,22 @@ const parseStringArray = (encoded, name) => {
         return err(new ConfigurationError(`${name} must be valid JSON`, { cause }));
     }
 };
+const parseBrowserArray = (encoded, name, itemSchema, maximum) => {
+    try {
+        const parsed = z
+            .array(itemSchema)
+            .max(maximum)
+            .safeParse(JSON.parse(encoded));
+        return parsed.success
+            ? ok([...new Set(parsed.data)].sort())
+            : err(new ConfigurationError(`${name} must encode valid browser scopes`, {
+                cause: parsed.error,
+            }));
+    }
+    catch (cause) {
+        return err(new ConfigurationError(`${name} must be valid JSON`, { cause }));
+    }
+};
 const filePolicy = (roots) => ({
     roots,
     maxBytes: 64 * 1024 * 1024,
@@ -50,6 +84,22 @@ const filePolicy = (roots) => ({
     maxStringLength: 1024 * 1024,
     maxNodes: 1_000_000,
 });
+const permissionScope = (capability, roots, options = {}) => ({
+    capability,
+    roots,
+    executables: options.executables ?? [],
+    environment_names: options.environment_names ?? [],
+    ...(options.origins === undefined ? {} : { origins: options.origins }),
+    network: options.network ?? "none",
+    mount: options.mount ?? false,
+});
+const administratorGrants = (ceilings) => ceilings.map((ceiling) => ({
+    ...ceiling,
+    grant_id: `administrator:${ceiling.capability}`,
+    lifetime: "administrator",
+    operation_identity: null,
+    expires_at: null,
+}));
 const parseLoaderArgs = (encoded) => {
     if (encoded === undefined)
         return ok([]);
@@ -107,6 +157,46 @@ export const parseConfig = (environment) => {
     const secretPatterns = parseStringArray(parsedEnvironment.data.REA_REFERENCE_SECRET_PATTERNS_JSON, "REA_REFERENCE_SECRET_PATTERNS_JSON");
     if (!secretPatterns.ok)
         return secretPatterns;
+    const browserEndpoints = parseBrowserArray(parsedEnvironment.data.REA_BROWSER_CDP_ENDPOINTS_JSON, "REA_BROWSER_CDP_ENDPOINTS_JSON", browserEndpointSchema, 16);
+    if (!browserEndpoints.ok)
+        return browserEndpoints;
+    const browserOrigins = parseBrowserArray(parsedEnvironment.data.REA_BROWSER_ALLOWED_ORIGINS_JSON, "REA_BROWSER_ALLOWED_ORIGINS_JSON", browserOriginSchema, 32);
+    if (!browserOrigins.ok)
+        return browserOrigins;
+    const permissionCeilings = [
+        ...(parsedEnvironment.data.REA_PROCESS_CAPTURE_ENABLED === "true"
+            ? [
+                permissionScope("process_capture", workingRoots.value, {
+                    executables: executableRoots.value,
+                    environment_names: allowedEnvironment.value,
+                    network: parsedEnvironment.data.REA_PROCESS_ALLOW_EXTERNAL_NETWORK ===
+                        "true"
+                        ? "external"
+                        : "none",
+                }),
+            ]
+            : []),
+        permissionScope("evidence_read", evidenceRoots.value),
+        permissionScope("evidence_write", evidenceRoots.value),
+        permissionScope("investigation_input", investigationInputRoots.value),
+        permissionScope("investigation_workspace_read", evidenceRoots.value),
+        permissionScope("investigation_workspace_write", evidenceRoots.value),
+        permissionScope("snapshot_read", analysisSnapshotRoots.value),
+        permissionScope("snapshot_write", analysisSnapshotRoots.value),
+        permissionScope("artifact_extract", ["/"]),
+        permissionScope("reference_read", referenceRoots.value),
+        ...(parsedEnvironment.data.REA_BROWSER_OBSERVE_ENABLED === "true"
+            ? [
+                permissionScope("browser_observe", [], {
+                    origins: [...browserEndpoints.value, ...browserOrigins.value],
+                    network: browserNetworkScope(browserOrigins.value),
+                }),
+            ]
+            : []),
+        ...(parsedEnvironment.data.REA_ARTIFACT_NATIVE_MOUNT_ENABLED === "true"
+            ? [permissionScope("native_mount", [], { mount: true })]
+            : []),
+    ];
     return ok({
         hopperLauncherPath: parsedEnvironment.data.HOPPER_LAUNCHER_PATH ??
             defaultHopperLauncherPath(),
@@ -122,6 +212,7 @@ export const parseConfig = (environment) => {
             allowExternalNetwork: parsedEnvironment.data.REA_PROCESS_ALLOW_EXTERNAL_NETWORK === "true",
         },
         artifactNativeMountEnabled: parsedEnvironment.data.REA_ARTIFACT_NATIVE_MOUNT_ENABLED === "true",
+        artifactIntegrityContinueEnabled: parsedEnvironment.data.REA_ARTIFACT_INTEGRITY_CONTINUE_ENABLED === "true",
         evidenceFilePolicy: filePolicy(evidenceRoots.value),
         investigationInputRoots: investigationInputRoots.value,
         analysisSnapshotFilePolicy: filePolicy(analysisSnapshotRoots.value),
@@ -133,5 +224,18 @@ export const parseConfig = (environment) => {
             maxDepth: 32,
             maxPathBytes: 4_096,
         },
+        browserObservationEnabled: parsedEnvironment.data.REA_BROWSER_OBSERVE_ENABLED === "true",
+        browserCdpEndpoints: browserEndpoints.value,
+        browserAllowedOrigins: browserOrigins.value,
+        permissionCeilings,
+        administratorPermissionGrants: administratorGrants(permissionCeilings),
+        permissionProjectRoot: parsedEnvironment.data.REA_PERMISSION_PROJECT_ROOT,
+        permissionProjectStore: parsedEnvironment.data.REA_PERMISSION_PROJECT_STORE,
     });
 };
+const browserNetworkScope = (origins) => origins.every((origin) => {
+    const hostname = new URL(origin).hostname;
+    return hostname === "127.0.0.1" || hostname === "[::1]";
+})
+    ? "loopback"
+    : "external";

package/dist/contracts/artifactToolContracts.js

@@ -28,10 +28,23 @@ const traversalLimitsInput = {
     max_path_bytes: z.number().int().min(1).max(65_535).default(4_096),
 };
 /** Exact caller boundary for deterministic artifact inventory. */
-export const artifactInventoryInputSchema = z.object({
+export const artifactInventoryInputSchema = z
+    .object({
     native_mount_approved: z.boolean().default(false),
+    integrity_policy: z.enum(["fail", "record-and-continue"]).default("fail"),
+    integrity_continue_approved: z.boolean().default(false),
+    max_integrity_mismatches: z.number().int().min(1).max(100).default(10),
     ...pageInput,
     ...traversalLimitsInput,
+})
+    .superRefine((input, context) => {
+    if (input.integrity_policy === "record-and-continue" &&
+        input.integrity_continue_approved !== true)
+        context.addIssue({
+            code: "custom",
+            path: ["integrity_continue_approved"],
+            message: "record-and-continue requires explicit approval",
+        });
 });
 /** Exact caller boundary for approved artifact extraction. */
 export const artifactExtractionInputSchema = z.object({

package/dist/contracts/browserToolContracts.js

@@ -0,0 +1,80 @@
+import { evidenceSchema } from "../domain/evidence.js";
+import { browserTargetListSchema, inspectWebPageInputSchema, listBrowserTargetsInputSchema, webPageInspectionSchema, } from "../domain/browserObservation.js";
+const evidenceResult = (schema) => evidenceSchema
+    .omit({ normalized_result: true })
+    .extend({ normalized_result: schema });
+const listOutputSchema = evidenceResult(browserTargetListSchema);
+const inspectionOutputSchema = evidenceSchema
+    .omit({ normalized_result: true })
+    .extend({ normalized_result: webPageInspectionSchema });
+const endpoint = "http://127.0.0.1:9222";
+const origin = "https://app.example.test";
+/** Origin-scoped, passive browser reverse-engineering contracts. */
+export const BROWSER_TOOL_CONTRACTS = [
+    {
+        name: "list_browser_targets",
+        description: "List bounded page targets from an approved user-owned loopback Chrome DevTools Protocol endpoint. Only targets whose current URL matches an approved exact origin are returned; URL credentials, query values, and fragments are redacted.",
+        kind: "browser-provider",
+        inputSchema: listBrowserTargetsInputSchema,
+        outputSchema: listOutputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+        examples: [
+            {
+                title: "List approved browser page targets",
+                input: {
+                    cdp_endpoint: endpoint,
+                    allowed_origins: [origin],
+                    approved: true,
+                    offset: 0,
+                    limit: 100,
+                },
+            },
+        ],
+    },
+    {
+        name: "inspect_web_page",
+        description: "Passively inspect one approved page target through CDP without evaluating JavaScript, navigating, clicking, closing, or mutating the page. Returns bounded DOM structure, accessibility, scripts, resources, attach-window network and console metadata, workers, and redacted storage inventory as Evidence v2.",
+        kind: "browser-provider",
+        inputSchema: inspectWebPageInputSchema,
+        outputSchema: inspectionOutputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+        examples: [
+            {
+                title: "Inspect one approved browser page",
+                input: {
+                    cdp_endpoint: endpoint,
+                    allowed_origins: [origin],
+                    approved: true,
+                    target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS",
+                    observation_ms: 500,
+                    include_script_sources: false,
+                    include_storage_keys: false,
+                    limits: {
+                        max_frames: 200,
+                        max_dom_nodes: 2_000,
+                        max_ax_nodes: 2_000,
+                        max_scripts: 200,
+                        max_resources: 2_000,
+                        max_workers: 500,
+                        max_storage_keys: 1_000,
+                        max_script_source_bytes: 1_048_576,
+                        max_total_script_source_bytes: 4_194_304,
+                        max_network_events: 1_000,
+                        max_console_events: 200,
+                        max_websocket_events: 500,
+                    },
+                },
+            },
+        ],
+    },
+];

package/dist/contracts/errorSchemas.js

@@ -0,0 +1,100 @@
+import { z } from "zod";
+const categorySchema = z.enum([
+    "invalid_input",
+    "permission_required",
+    "unsupported_provider",
+    "integrity_mismatch",
+    "truncated",
+    "cancelled",
+    "timeout",
+    "unavailable",
+    "execution_failure",
+]);
+const remediationSchema = z
+    .object({
+    action: z.string().min(1),
+    restart_required: z.boolean(),
+    elicitation_supported: z.boolean().optional(),
+})
+    .strict();
+const common = {
+    category: categorySchema,
+    message: z.string().min(1),
+    retryable: z.boolean(),
+    remediation: remediationSchema,
+};
+const genericDetails = z.record(z.string(), z.json()).optional();
+const generic = (code) => z
+    .object({ code: z.literal(code), ...common, details: genericDetails })
+    .strict();
+const scopeSchema = z
+    .object({
+    capability: z.string(),
+    roots: z.array(z.string()),
+    executables: z.array(z.string()),
+    environment_names: z.array(z.string()),
+    origins: z.array(z.string()).optional(),
+    network: z.enum(["none", "loopback", "external"]),
+    mount: z.boolean(),
+})
+    .strict();
+const missingScopeSchema = z
+    .object({
+    roots: z.array(z.string()).optional(),
+    executables: z.array(z.string()).optional(),
+    environment_names: z.array(z.string()).optional(),
+    origins: z.array(z.string()).optional(),
+    network: z.enum(["none", "loopback", "external"]).optional(),
+    mount: z.literal(true).optional(),
+})
+    .strict();
+/** Stable discriminated schema shared by every CLI and MCP error surface. */
+export const analysisErrorProjectionSchema = z.discriminatedUnion("code", [
+    generic("invalid_request"),
+    generic("unreadable_output"),
+    generic("capability_unavailable"),
+    generic("provider_unavailable"),
+    generic("provider_timeout"),
+    generic("cancelled"),
+    z
+        .object({
+        code: z.literal("artifact_integrity_mismatch"),
+        ...common,
+        details: z
+            .object({
+            logical_path: z.string(),
+            declared_sha256: z.string().nullable(),
+            calculated_sha256: z.string().nullable(),
+            unpacked: z.boolean(),
+        })
+            .strict(),
+    })
+        .strict(),
+    generic("artifact_operation_failed"),
+    generic("evidence_integrity_mismatch"),
+    generic("truncated"),
+    z
+        .object({
+        code: z.literal("permission_required"),
+        ...common,
+        details: z
+            .object({
+            capability: z.string(),
+            requested: scopeSchema,
+            missing: missingScopeSchema,
+            ceiling: scopeSchema.nullable(),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict(),
+    generic("process_capture_failed"),
+    generic("cleanup_incomplete"),
+    generic("revision_conflict"),
+    generic("outside_approved_root"),
+    generic("configuration_invalid"),
+    generic("target_unavailable"),
+    generic("execution_failure"),
+]);
+/** JSON Schema document used by generated API documentation and clients. */
+export const analysisErrorJsonSchema = z.toJSONSchema(analysisErrorProjectionSchema);

package/dist/contracts/toolContracts.js

@@ -14,6 +14,7 @@ import { enhancedOutputSchemas, officialOutputSchemas, requireOutputSchema, sess
 import { TOOL_EXAMPLE_OVERRIDES } from "./toolContractExamples.js";
 import { NATIVE_TOOL_CONTRACTS } from "./nativeToolContracts.js";
 import { ARTIFACT_TOOL_CONTRACTS } from "./artifactToolContracts.js";
+import { BROWSER_TOOL_CONTRACTS } from "./browserToolContracts.js";
 import { closeBinaryInputSchema, openBinaryInputSchema, } from "./sessionLifecycleInputs.js";
 const document = z.string().optional().describe("The document name");
 const address = z.string().describe("A Hopper address");
@@ -158,11 +159,20 @@ export const ENHANCED_TOOL_CONTRACTS = [
     enhanced("analyze_function", "Preferred bounded analysis for one procedure symbol or address. Returns identity, pseudocode, optional assembly, comments, calls, incoming references, and blocks; unsupported outgoing references and CFG edges carry explicit unavailable metadata.", enhancedInputSchemas.analyze_function),
     enhanced("trace_feature", "Trace a bounded literal feature query through matching strings and procedures, xrefs, and truthful containing-procedure resolution. Returns the operation budget, truncation, and residual unknowns; unknown_registry_approved: true records them durably without inferring reference kinds.", enhancedInputSchemas.trace_feature),
 ];
+/** Caller observations used to compare a live server with expected identity. */
+export const binarySessionInputSchema = z.object({
+    expected_package_version: z.string().min(1).optional(),
+    expected_catalog_digest: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .optional(),
+    expected_server_path: z.string().min(1).optional(),
+});
 /** Target lifecycle tools available only on the long-lived MCP adapter. */
 export const SESSION_TOOL_CONTRACTS = [
     session("open_binary", "Open a local executable, application bundle, archive, JavaScript, source map, plist, or Hopper database after validation. An optional provider-neutral snapshot is imported atomically and must match the binary digest, format, and architecture exactly; provider resources may still start before an MCP cache replay.", openBinaryInputSchema),
     session("close_binary", "Optionally write a provider-neutral analysis snapshot atomically, then close the active target and every provider resource started for it. Snapshot files require an operator-approved root and explicit overwrite; a failed save leaves the session open so cached analysis is not lost.", closeBinaryInputSchema),
-    session("binary_session", "Report provider identity, deterministic capability descriptors, and whether a target is open; open targets include canonical path, format, and kind. Use availability, effects, limits, and limitations before selecting analysis operations.", z.object({})),
+    session("binary_session", "Report provider identity, deterministic capability descriptors, and whether a target is open; open targets include canonical path, format, and kind. Use availability, effects, limits, and limitations before selecting analysis operations.", binarySessionInputSchema),
     session("export_evidence_bundle", "Return the session's deterministic Evidence v2 bundle, or atomically write it beneath an operator-approved root. Existing files require overwrite: true; records and manifests use canonical byte-stable ordering.", z.object({
         path: z.string().min(1).optional(),
         overwrite: z.boolean().default(false),
@@ -198,15 +208,12 @@ export const SESSION_TOOL_CONTRACTS = [
     session("update_unknown", "Append one immutable full-state revision and mutation evidence. Requires approved: true and exact expected_revision; stale concurrent writers fail instead of overwriting newer analysis.", updateUnknownInputSchema),
     session("verify_unknown_resolution", "Revalidate the current residual-unknown head against live bundled evidence, exact authority/confidence/environment requirements, and revision integrity. Withdrawn and out-of-scope dispositions are not truth claims.", z.object({ unknown_id: z.string().regex(/^unk_[a-f0-9]{64}$/u) })),
 ];
-/**
- * Complete ordered public inventory used by registration and verification.
- * Keep this collection at 68 tools unless a deliberate contract change updates
- * snapshots, package verification, and real-Hopper verification together.
- */
+/** Complete ordered public inventory used by registration and verification. */
 export const TOOL_CONTRACTS = [
     ...OFFICIAL_TOOL_CONTRACTS,
     ...ENHANCED_TOOL_CONTRACTS,
     ...NATIVE_TOOL_CONTRACTS,
     ...ARTIFACT_TOOL_CONTRACTS,
+    ...BROWSER_TOOL_CONTRACTS,
     ...SESSION_TOOL_CONTRACTS,
 ];

package/dist/contracts/toolOutputSchemas.js

@@ -13,6 +13,7 @@ import { changedBehaviorResultSchema } from "../domain/changedBehavior.js";
 import { callPathResultSchema } from "../domain/callPath.js";
 import { staticRuntimeCorrelationResultSchema } from "../domain/staticRuntimeCorrelation.js";
 import { reconstructionVerificationResultSchema } from "../domain/reconstructionVerification.js";
+import { analysisErrorProjectionSchema } from "./errorSchemas.js";
 const resultOf = (schema) => evidenceSchema
     .omit({ normalized_result: true })
     .extend({ normalized_result: schema });
@@ -78,6 +79,67 @@ const sessionProvider = z.object({
     provider: providerIdentity,
     providers: z.array(providerIdentity),
     capabilities: z.array(providerCapability),
+    tool_availability: z.array(z.object({
+        name: z.string(),
+        surface: z.string(),
+        available: z.boolean(),
+        reason: z.enum([
+            "available",
+            "target_required",
+            "provider_missing",
+            "provider_unavailable",
+            "target_unsupported",
+            "unsupported_host",
+            "policy_disabled",
+        ]),
+        remediation: z.string().nullable(),
+        annotations: z.object({
+            read_only: z.boolean(),
+            destructive: z.boolean(),
+            idempotent: z.boolean(),
+            open_world: z.boolean(),
+        }),
+    })),
+    client_features: z.object({
+        elicitation_form: z.boolean(),
+        elicitation_url: z.boolean(),
+        roots: z.boolean(),
+        sampling: z.boolean(),
+    }),
+    server_identity: z.object({
+        package: z.object({
+            name: z.string(),
+            version: z.string(),
+            root_path: z.string(),
+            build_commit: z.string().nullable(),
+        }),
+        server: z.object({
+            name: z.string(),
+            version: z.string(),
+            started_at: z.string(),
+            command_path: z.string(),
+        }),
+        sdk: z.object({
+            server: z.string(),
+            client_test: z.string(),
+            core: z.string(),
+        }),
+        negotiated_protocol_version: z.string().nullable(),
+        client: z.object({ name: z.string(), version: z.string() }).nullable(),
+        skill: z.object({ name: z.string(), expected_version: z.string() }),
+        catalog: z.record(z.string(), z.json()),
+        protocol_features: z.object({
+            progress: z.boolean(),
+            cancellation: z.boolean(),
+            evidence_resources: z.boolean(),
+            elicitation: z.boolean(),
+        }),
+        alignment: z.object({
+            state: z.enum(["aligned", "mcp_server_restart_required", "unknown"]),
+            reasons: z.array(z.string()),
+            remediation: z.string().nullable(),
+        }),
+    }),
 });
 const nullableText = z.string().nullable();
 const addressList = z.array(z.string());
@@ -149,36 +211,6 @@ const symbolDiscoveryOutput = (property) => resultOf(z.object({
     count: z.number().int().min(0),
     [property]: z.array(addressedEntry),
 }));
-const analysisErrorProjectionSchema = z
-    .object({
-    category: z.enum([
-        "invalid_input",
-        "permission_required",
-        "unsupported_provider",
-        "integrity_mismatch",
-        "truncated",
-        "cancelled",
-        "timeout",
-        "unavailable",
-        "execution_failure",
-    ]),
-    message: z.string(),
-    code: z
-        .enum([
-        "private_display_unavailable",
-        "x11_authorization_failed",
-        "unsupported_hopper_build",
-        "invalid_launch_command",
-        "process_ownership_mismatch",
-        "hopper_exited_during_startup",
-        "unsupported_demo_dialog",
-        "unexpected_display_geometry",
-        "x11_input_failed",
-        "runtime_dependency_unavailable",
-    ])
-        .optional(),
-})
-    .strict();
 const graphNode = z.discriminatedUnion("status", [
     z.object({
         address: z.string(),