rea-agents 3.0.0 → 3.2.0

package/dist/domain/electronObservation.js

@@ -1,82 +1,30 @@
-import { isAbsolute } from "node:path";
 import { z } from "zod";
 import { browserCompletenessSchema } from "./browserCompleteness.js";
 import { browserEndpointSchema } from "./browserObservation.js";
 import { webTextArtifactSchema } from "./webContentArtifact.js";
-/** Absolute operator-approved filesystem roots for Electron file pages. */
-export const electronFileRootsSchema = z
-    .array(z
-    .string()
-    .min(1)
-    .max(16_384)
-    .refine(isAbsolute, "Electron file roots must be absolute paths"))
-    .min(1)
-    .max(32)
-    .transform((roots) => [...new Set(roots)].sort());
 const approvedElectronInput = {
     cdp_endpoint: browserEndpointSchema,
-    allowed_file_roots: electronFileRootsSchema,
-    approved: z.literal(true),
 };
-/** Input for listing root-confined file:// page targets from Electron CDP. */
-export const listElectronTargetsInputSchema = z.object({
+/** Input for listing local file:// page targets from an explicit Electron CDP endpoint. */
+export const listElectronTargetsInputSchema = z.strictObject({
     ...approvedElectronInput,
-    offset: z.number().int().min(0).default(0),
-    limit: z.number().int().min(1).max(200).default(100),
 });
 /** Input for passive structural inspection of one Electron file page. */
-export const inspectElectronPageInputSchema = z
-    .object({
+const inspectElectronPageFacts = {
     ...approvedElectronInput,
-    target_id: z.string().trim().min(1).max(256),
-    observation_ms: z.number().int().min(0).max(10_000).default(100),
-    include_script_sources: z.boolean().default(false),
-    source_capture_approved: z.boolean().default(false),
-    limits: z
-        .object({
-        max_frames: z.number().int().min(1).max(1_000).default(200),
-        max_dom_nodes: z.number().int().min(1).max(10_000).default(2_000),
-        max_scripts: z.number().int().min(1).max(2_000).default(500),
-        max_resources: z.number().int().min(1).max(10_000).default(2_000),
-        max_workers: z.number().int().min(1).max(5_000).default(500),
-        max_script_source_bytes: z
-            .number()
-            .int()
-            .min(1)
-            .max(4 * 1_024 * 1_024)
-            .default(1_024 * 1_024),
-        max_total_script_source_bytes: z
-            .number()
-            .int()
-            .min(1)
-            .max(16 * 1_024 * 1_024)
-            .default(4 * 1_024 * 1_024),
-    })
-        .default({
-        max_frames: 200,
-        max_dom_nodes: 2_000,
-        max_scripts: 500,
-        max_resources: 2_000,
-        max_workers: 500,
-        max_script_source_bytes: 1_024 * 1_024,
-        max_total_script_source_bytes: 4 * 1_024 * 1_024,
+    target_id: z.string().trim().min(1),
+    observation_ms: z.number().int().min(0).default(100),
+};
+export const inspectElectronPageInputSchema = z.union([
+    z.strictObject({
+        ...inspectElectronPageFacts,
+        include_script_sources: z.literal(false).default(false),
     }),
-})
-    .superRefine((input, context) => {
-    if (input.include_script_sources && !input.source_capture_approved)
-        context.addIssue({
-            code: "custom",
-            path: ["source_capture_approved"],
-            message: "Electron script source capture requires separate approval",
-        });
-    if (input.limits.max_script_source_bytes >
-        input.limits.max_total_script_source_bytes)
-        context.addIssue({
-            code: "custom",
-            path: ["limits", "max_script_source_bytes"],
-            message: "Per-script source limit cannot exceed the total source limit",
-        });
-});
+    z.strictObject({
+        ...inspectElectronPageFacts,
+        include_script_sources: z.literal(true),
+    }),
+]);
 const browserVersionSchema = z.object({
     product: z.string(),
     protocol_version: z.string(),
@@ -91,20 +39,11 @@ const electronTargetSchema = z.object({
     file_path: z.string(),
     attached: z.boolean(),
 });
-/** Root-filtered Electron file target inventory. */
+/** Complete local file target inventory from one Electron CDP endpoint. */
 export const electronTargetListSchema = z.object({
-    schema_version: z.literal(1),
     browser: browserVersionSchema,
-    targets: z.object({
-        items: z.array(electronTargetSchema),
-        offset: z.number().int().min(0),
-        limit: z.number().int().min(1),
-        total: z.number().int().min(0),
-        next_offset: z.number().int().min(0).nullable(),
-        has_more: z.boolean(),
-    }),
+    targets: z.array(electronTargetSchema),
     excluded: z.object({
-        outside_root: z.number().int().min(0),
         unsupported_url: z.number().int().min(0),
         non_page: z.number().int().min(0),
     }),
@@ -116,7 +55,6 @@ const electronSourceSchema = z.discriminatedUnion("included", [
 ]);
 /** Provider-neutral passive Electron file-page structure and script inventory. */
 export const electronPageInspectionSchema = z.object({
-    schema_version: z.literal(1),
     browser: browserVersionSchema,
     target: electronTargetSchema,
     capture_window: z.object({
@@ -163,12 +101,12 @@ export const electronPageInspectionSchema = z.object({
     })),
     workers: z
         .array(z.object({
-        target_id: z.string().min(1).max(256),
-        type: z.string().min(1).max(100),
+        target_id: z.string().min(1),
+        type: z.string().min(1),
         file_path: z.string(),
         attached: z.boolean(),
-        opener_target_id: z.string().min(1).max(256).nullable(),
-        parent_frame_id: z.string().min(1).max(256).nullable(),
+        opener_target_id: z.string().min(1).nullable(),
+        parent_frame_id: z.string().min(1).nullable(),
     }))
         .default([]),
     limitations: z.array(z.string()),

package/dist/domain/electronStaticAnalysisBrowser.js

@@ -2,7 +2,6 @@ import * as t from "@babel/types";
 import { boundedExpression, collectContextBridgeMembers, electronStaticValue, objectProperty, } from "./electronStaticAnalysisValues.js";
 import { addLocatedFinding } from "./javascriptStaticAnalysisFindings.js";
 import { argumentNode, calleeName, compareCodePoints, propertyName, range, staticPath, staticPathResolutionContext, } from "./javascriptStaticAnalysisHelpers.js";
-const MAX_WEB_PREFERENCES = 64;
 /** Inspect BrowserWindow, contextBridge, and utility-process syntax. */
 export const inspectElectronBrowserNode = (node, context) => {
     if (t.isNewExpression(node))
@@ -18,7 +17,7 @@ const inspectBrowserWindow = (node, context) => {
         return;
     const options = argumentNode(node.arguments[0]);
     const collected = collectWindowOptions(context.source, options);
-    accountForStructure(context, collected.unknown, collected.omitted);
+    context.accumulator.unknownFindings += collected.unknown;
     const finding = {
         options_status: options === undefined
             ? "missing"
@@ -27,9 +26,7 @@ const inspectBrowserWindow = (node, context) => {
                 : "dynamic",
         web_preferences_status: collected.status,
         web_preferences: collected.preferences,
-        omitted_web_preferences: collected.omitted,
-        preload_path: collected.preloadPath,
-        preload_resolution_context: collected.preloadResolutionContext,
+        ...collected.preload,
         module_key: null,
         location: range(node),
     };
@@ -45,37 +42,33 @@ const collectWindowOptions = (source, options) => {
         return {
             status: options === undefined ? "missing" : "dynamic",
             preferences: [],
-            preloadPath: null,
-            preloadResolutionContext: null,
+            preload: { preload_path: null, preload_resolution_context: null },
             unknown: options === undefined ? 0 : 1,
-            omitted: 0,
         };
     const property = objectProperty(options, "webPreferences");
     if (property === undefined)
         return {
             status: "missing",
             preferences: [],
-            preloadPath: null,
-            preloadResolutionContext: null,
+            preload: { preload_path: null, preload_resolution_context: null },
             unknown: 0,
-            omitted: 0,
         };
     if (!t.isObjectExpression(property.value))
         return {
             status: "dynamic",
             preferences: [],
-            preloadPath: null,
-            preloadResolutionContext: null,
+            preload: { preload_path: null, preload_resolution_context: null },
             unknown: 1,
-            omitted: 0,
         };
     return collectWebPreferences(source, property.value);
 };
 const collectWebPreferences = (source, object) => {
     const preferences = [];
     let unknown = 0;
-    let preloadPath = null;
-    let preloadResolutionContext = null;
+    let preload = {
+        preload_path: null,
+        preload_resolution_context: null,
+    };
     for (const property of object.properties) {
         if (t.isSpreadElement(property)) {
             unknown += 1;
@@ -103,10 +96,11 @@ const collectWebPreferences = (source, object) => {
             continue;
         }
         const path = name === "preload" ? staticPath(property.value) : undefined;
-        if (path !== undefined) {
-            preloadPath = path;
-            preloadResolutionContext = staticPathResolutionContext(property.value);
-        }
+        if (path !== undefined)
+            preload = {
+                preload_path: path,
+                preload_resolution_context: staticPathResolutionContext(property.value),
+            };
         const value = path === undefined
             ? electronStaticValue(source, property.value)
             : { status: "literal", value: path, expression: null };
@@ -117,11 +111,9 @@ const collectWebPreferences = (source, object) => {
     preferences.sort((left, right) => compareCodePoints(left.name, right.name));
     return {
         status: "object-literal",
-        preferences: preferences.slice(0, MAX_WEB_PREFERENCES),
-        preloadPath,
-        preloadResolutionContext,
+        preferences,
+        preload,
         unknown,
-        omitted: Math.max(0, preferences.length - MAX_WEB_PREFERENCES),
     };
 };
 const inspectContextBridge = (node, context) => {
@@ -142,18 +134,19 @@ const inspectContextBridge = (node, context) => {
     const unknown = (key.status === "dynamic" ? 1 : 0) +
         (worldId?.status === "dynamic" ? 1 : 0) +
         api.unknown;
-    accountForStructure(context, unknown, api.omitted);
+    context.accumulator.unknownFindings += unknown;
+    const apiKey = key.status === "dynamic"
+        ? { api_key: null, api_key_expression: key.expression }
+        : typeof key.value === "string"
+            ? { api_key: key.value, api_key_expression: null }
+            : { api_key: null, api_key_expression: null };
     const finding = {
+        ...apiKey,
         world: isolated ? "isolated" : "main",
         world_id: worldId,
-        api_key: key.status === "literal" && typeof key.value === "string"
-            ? key.value
-            : null,
-        api_key_expression: key.status === "dynamic" ? key.expression : null,
         api_status: api.status,
         members: api.members,
         unknown_members: api.unknown,
-        omitted_members: api.omitted,
         module_key: null,
         location: range(node),
     };
@@ -170,9 +163,6 @@ const inspectUtilityProcess = (node, context) => {
         return;
     const moduleNode = argumentNode(node.arguments[0]);
     const modulePath = moduleNode === undefined ? undefined : staticPath(moduleNode);
-    const moduleResolutionContext = modulePath === undefined || moduleNode === undefined
-        ? null
-        : staticPathResolutionContext(moduleNode);
     const options = argumentNode(node.arguments[2]);
     const serviceName = t.isObjectExpression(options) &&
         objectProperty(options, "serviceName") !== undefined
@@ -180,27 +170,27 @@ const inspectUtilityProcess = (node, context) => {
         : undefined;
     if (modulePath === undefined)
         context.accumulator.unknownFindings += 1;
+    const moduleReference = modulePath === undefined || moduleNode === undefined
+        ? {
+            module_path: null,
+            module_resolution_context: null,
+            module_expression: boundedExpression(context.source, moduleNode),
+        }
+        : {
+            module_path: modulePath,
+            module_resolution_context: staticPathResolutionContext(moduleNode),
+            module_expression: null,
+        };
     const finding = {
-        module_path: modulePath ?? null,
-        module_resolution_context: moduleResolutionContext,
-        module_expression: modulePath === undefined
-            ? boundedExpression(context.source, moduleNode)
-            : null,
+        ...moduleReference,
         service_name: serviceName ?? null,
         module_key: null,
         location: range(node),
     };
     addLocatedFinding(context, {
         collection: context.accumulator.utilityProcesses,
-        key: `electron-utility\0${modulePath ?? finding.module_expression ?? "[missing]"}`,
+        key: `electron-utility\0${finding.module_path ?? finding.module_expression}`,
         node,
         value: finding,
     });
 };
-const accountForStructure = (context, unknown, omitted) => {
-    context.accumulator.unknownFindings += unknown;
-    if (omitted === 0)
-        return;
-    context.accumulator.structuralTruncation = true;
-    context.accumulator.droppedFindings += omitted;
-};

package/dist/domain/electronStaticAnalysisIpc.js

@@ -21,29 +21,53 @@ const inspectIpcCall = (node, context) => {
     const channel = channelValue.status === "literal" && typeof channelValue.value === "string"
         ? channelValue.value
         : null;
-    const channelExpression = channel === null
-        ? channelValue.status === "dynamic"
-            ? channelValue.expression
-            : boundedExpression(context.source, channelNode)
-        : null;
-    const hasHandler = descriptor.mode === "listen" || descriptor.mode === "handle";
-    const handlerNode = hasHandler ? argumentNode(node.arguments[1]) : undefined;
+    const channelReference = channel === null
+        ? {
+            channel: null,
+            channel_expression: channelValue.status === "dynamic"
+                ? channelValue.expression
+                : boundedExpression(context.source, channelNode),
+        }
+        : { channel, channel_expression: null };
+    const handlerNode = descriptor.mode === "listen" || descriptor.mode === "handle"
+        ? argumentNode(node.arguments[1])
+        : undefined;
+    const findingState = descriptor.mode === "send"
+        ? {
+            ...descriptor,
+            handler_kind: null,
+            handler_location: null,
+        }
+        : descriptor.mode === "invoke"
+            ? {
+                ...descriptor,
+                handler_kind: null,
+                handler_location: null,
+            }
+            : handlerNode === undefined
+                ? {
+                    ...descriptor,
+                    handler_kind: "missing",
+                    handler_location: null,
+                }
+                : {
+                    ...descriptor,
+                    handler_kind: handlerKind(handlerNode),
+                    handler_location: range(handlerNode),
+                };
     if (channel === null)
         context.accumulator.unknownFindings += 1;
-    if (hasHandler && handlerNode === undefined)
+    if (findingState.handler_kind === "missing")
         context.accumulator.unknownFindings += 1;
     const finding = {
-        ...descriptor,
-        channel,
-        channel_expression: channelExpression,
-        handler_kind: hasHandler ? handlerKind(handlerNode) : null,
-        handler_location: handlerNode === undefined ? null : range(handlerNode),
+        ...findingState,
+        ...channelReference,
         module_key: null,
         location: range(node),
     };
     addLocatedFinding(context, {
         collection: context.accumulator.ipc,
-        key: `electron-ipc\0${descriptor.side}\0${descriptor.operation}\0${channel ?? channelExpression ?? "[missing]"}`,
+        key: `electron-ipc\0${descriptor.side}\0${descriptor.operation}\0${channelReference.channel ?? channelReference.channel_expression}`,
         node,
         value: finding,
     });

package/dist/domain/electronStaticAnalysisNative.js

@@ -1,7 +1,6 @@
 import * as t from "@babel/types";
 import { addLocatedFinding } from "./javascriptStaticAnalysisFindings.js";
 import { argumentNode, calleeName, compareCodePoints, propertyName, range, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
-const MAX_NATIVE_MEMBERS = 64;
 /** Inspect JavaScript-side imports and re-exports of native .node addons. */
 export const inspectElectronNativeNode = (node, context) => {
     if (t.isImportDeclaration(node))
@@ -91,12 +90,7 @@ const addBinding = (input) => {
     const unique = [
         ...new Set(input.members.filter((member) => member !== "")),
     ].sort(compareCodePoints);
-    const members = (unique.length === 0 ? ["*"] : unique).slice(0, MAX_NATIVE_MEMBERS);
-    const omitted = Math.max(0, unique.length - MAX_NATIVE_MEMBERS);
-    if (omitted > 0) {
-        context.accumulator.structuralTruncation = true;
-        context.accumulator.droppedFindings += omitted;
-    }
+    const members = unique.length === 0 ? ["*"] : unique;
     addLocatedFinding(context, {
         collection: context.accumulator.nativeAddonBindings,
         key: `native-addon-binding\0${kind}\0${specifier}\0${members.join("\0")}`,
@@ -105,7 +99,6 @@ const addBinding = (input) => {
             specifier,
             binding_kind: kind,
             members,
-            members_truncated: omitted > 0,
             module_key: null,
             location: range(node),
         },

package/dist/domain/electronStaticAnalysisValues.js

@@ -1,7 +1,6 @@
 import * as t from "@babel/types";
 import { compareCodePoints, propertyName, sourceSlice, } from "./javascriptStaticAnalysisHelpers.js";
-const MAX_EXPRESSION_CHARACTERS = 4_096;
-/** Preserve one literal value or the exact bounded inert expression. */
+/** Preserve one literal value or the exact inert expression. */
 export const electronStaticValue = (source, node) => {
     const literal = literalValue(node);
     return literal.found
@@ -12,17 +11,16 @@ export const electronStaticValue = (source, node) => {
             expression: boundedExpression(source, node),
         };
 };
-/** Return an actionable bounded expression without evaluating it. */
+/** Return an actionable expression without evaluating it. */
 export const boundedExpression = (source, node) => {
     if (node === null || node === undefined)
         return "[missing-expression]";
     const expression = sourceSlice(source, node).trim();
-    return (expression === "" ? `[${node.type}]` : expression).slice(0, MAX_EXPRESSION_CHARACTERS);
+    return expression === "" ? `[${node.type}]` : expression;
 };
 /** Read one named object property without following spreads or bindings. */
 export const objectProperty = (object, name) => object.properties.find((property) => t.isObjectProperty(property) && propertyName(property.key) === name);
-/** Classify a handler argument while retaining its exact source range. */
-export const handlerKind = (node) => {
+export function handlerKind(node) {
     if (node === null || node === undefined)
         return "missing";
     if (t.isArrowFunctionExpression(node) ||
@@ -34,31 +32,31 @@ export const handlerKind = (node) => {
     if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node))
         return "member-expression";
     return "dynamic-expression";
-};
-/** Collect bounded dotted keys from one literal contextBridge API object. */
-export const collectContextBridgeMembers = (node, maximum = 128) => {
+}
+/** Collect statically visible dotted keys from one literal contextBridge API object. */
+export const collectContextBridgeMembers = (node) => {
     if (node === null || node === undefined)
         return {
             status: "missing",
             members: [],
             unknown: 0,
-            omitted: 0,
         };
     if (!t.isObjectExpression(node))
         return {
             status: "dynamic",
             members: [],
             unknown: 1,
-            omitted: 0,
         };
-    const state = { members: [], unknown: 0 };
+    const state = {
+        members: [],
+        unknown: 0,
+    };
     collectMembersAt(node, "", 0, state);
     const members = [...new Set(state.members)].sort(compareCodePoints);
     return {
         status: "object-literal",
-        members: members.slice(0, maximum),
+        members,
         unknown: state.unknown,
-        omitted: Math.max(0, members.length - maximum),
     };
 };
 const collectMembersAt = (object, prefix, depth, state) => {
@@ -76,7 +74,7 @@ const collectMembersAt = (object, prefix, depth, state) => {
             state.unknown += 1;
             continue;
         }
-        const path = (prefix === "" ? name : `${prefix}.${name}`).slice(0, MAX_EXPRESSION_CHARACTERS);
+        const path = prefix === "" ? name : `${prefix}.${name}`;
         state.members.push(path);
         if (t.isObjectProperty(property) && t.isObjectExpression(property.value))
             collectMembersAt(property.value, path, depth + 1, state);
@@ -92,9 +90,7 @@ const literalValue = (node) => {
     if (t.isTemplateLiteral(node) && node.expressions.length === 0)
         return {
             found: true,
-            value: (node.quasis[0]?.value.cooked ??
-                node.quasis[0]?.value.raw ??
-                "").slice(0, MAX_EXPRESSION_CHARACTERS),
+            value: node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? "",
         };
     if (t.isUnaryExpression(node, { operator: "-" }) &&
         t.isNumericLiteral(node.argument))

package/dist/domain/errors.js

@@ -15,9 +15,7 @@ const ANALYSIS_ERROR_TAGS = [
     "ArtifactOperationError",
     "ProcessCaptureError",
     "EvidenceIntegrityError",
-    "EvidenceLimitError",
     "EvidenceFileError",
-    "InvestigationWorkspaceError",
     "UnknownRegistryError",
     "HopperTimeoutError",
     "HopperCancelledError",
@@ -109,20 +107,9 @@ export class ProviderSelectionError extends AnalysisError {
     candidateIds;
     rejections;
     userMessage;
-    constructor(input) {
-        const legacy = typeof input === "string";
-        const options = legacy
-            ? {
-                operation: input,
-                reason: "provider_unavailable",
-                requestedProviderId: "auto",
-                candidateIds: [],
-            }
-            : input;
+    constructor(options) {
         const operation = options.operation ?? "open_binary";
-        super(legacy
-            ? `No configured provider can execute ${operation}`
-            : providerSelectionDiagnostic(options));
+        super(providerSelectionDiagnostic(options));
         this.operation = operation;
         this.reason = options.reason;
         this.requestedProviderId = options.requestedProviderId;
@@ -214,17 +201,6 @@ export class EvidenceReferenceError extends EvidenceIntegrityError {
         this.actual = actual;
     }
 }
-/** A bounded evidence ledger cannot accept more records or serialized bytes. */
-export class EvidenceLimitError extends AnalysisError {
-    limit;
-    maximum;
-    _tag = "EvidenceLimitError";
-    constructor(limit, maximum) {
-        super(`Evidence ledger ${limit} limit exceeded (${String(maximum)})`);
-        this.limit = limit;
-        this.maximum = maximum;
-    }
-}
 /** Evidence bundle filesystem access failed within the configured policy. */
 export class EvidenceFileError extends AnalysisError {
     operation;
@@ -236,17 +212,6 @@ export class EvidenceFileError extends AnalysisError {
         this.reason = reason;
     }
 }
-/** Persistent investigation workspace access or CAS validation failed. */
-export class InvestigationWorkspaceError extends AnalysisError {
-    operation;
-    reason;
-    _tag = "InvestigationWorkspaceError";
-    constructor(operation, reason, options) {
-        super(`Investigation workspace ${operation} failed: ${reason}`, options);
-        this.operation = operation;
-        this.reason = reason;
-    }
-}
 /** Residual-unknown mutation failed a lifecycle, reference, or CAS invariant. */
 export class UnknownRegistryError extends AnalysisError {
     reason;
@@ -259,10 +224,16 @@ export class UnknownRegistryError extends AnalysisError {
 /** Hopper did not respond within the configured operation deadline. */
 export class HopperTimeoutError extends HopperError {
     timeoutMs;
+    operation;
+    requestId;
+    providerState;
     _tag = "HopperTimeoutError";
-    constructor(timeoutMs) {
-        super(`Hopper did not respond within ${String(timeoutMs)}ms`);
+    constructor(timeoutMs, operation, requestId, providerState = "not_started") {
+        super(`Hopper ${operation === undefined ? "startup" : operation} timed out after ${String(timeoutMs)}ms`);
         this.timeoutMs = timeoutMs;
+        this.operation = operation;
+        this.requestId = requestId;
+        this.providerState = providerState;
     }
 }
 /** The caller cancelled a Hopper operation before it completed. */
@@ -276,30 +247,37 @@ export class HopperCancelledError extends HopperError {
 export class HopperProtocolError extends HopperError {
     _tag = "HopperProtocolError";
 }
-/** Hopper's JSON-RPC endpoint returned an expected remote error response. */
 export class HopperRemoteError extends HopperError {
     code;
     safeMessage;
-    diagnosticType;
     _tag = "HopperRemoteError";
-    constructor(code, safeMessage, diagnosticType = "remote") {
+    diagnosticType;
+    operation;
+    requestId;
+    constructor(code, safeMessage, context = {}) {
         super(`Hopper request failed (${String(code)}): ${safeMessage}`);
         this.code = code;
         this.safeMessage = safeMessage;
-        this.diagnosticType = diagnosticType;
+        this.diagnosticType = context.diagnosticType ?? "remote";
+        this.operation = context.operation;
+        this.requestId = context.requestId;
     }
 }
 /** The owned Hopper bridge stopped before its client was closed. */
 export class HopperProcessError extends HopperError {
     exitCode;
     diagnostic;
+    operation;
+    requestId;
     _tag = "HopperProcessError";
     failureCode;
     userMessage;
-    constructor(exitCode, diagnostic) {
+    constructor(exitCode, diagnostic, operation, requestId) {
         super(`Hopper bridge stopped unexpectedly with code ${String(exitCode)}`);
         this.exitCode = exitCode;
         this.diagnostic = diagnostic;
+        this.operation = operation;
+        this.requestId = requestId;
         const failure = hopperStartupFailure(exitCode);
         this.failureCode = failure?.code;
         this.userMessage = failure?.message;
@@ -308,8 +286,12 @@ export class HopperProcessError extends HopperError {
 /** Hopper or the repository bridge could not be started. */
 export class HopperStartError extends HopperError {
     _tag = "HopperStartError";
+    userMessage;
+    ownerRunId;
     constructor(options) {
         super("Hopper application bridge could not be started", options);
+        this.userMessage = options?.userMessage;
+        this.ownerRunId = options?.ownerRunId;
     }
 }
 /** Runtime configuration could not be parsed safely. */
@@ -338,16 +320,13 @@ export class PermissionRequiredError extends AnalysisError {
     requested;
     missing;
     ceiling;
-    elicitationSupported;
-    restartRequired;
-    constructor(...args) {
-        const [requested, missing, ceiling, elicitationSupported, restartRequired] = args;
-        super(`Permission required for ${requested.capability}`);
-        this.requested = requested;
-        this.missing = missing;
-        this.ceiling = ceiling;
-        this.elicitationSupported = elicitationSupported;
-        this.restartRequired = restartRequired;
+    remediation;
+    constructor(context) {
+        super(`Permission required for ${context.requested.capability}`);
+        this.requested = context.requested;
+        this.missing = context.missing;
+        this.ceiling = context.ceiling;
+        this.remediation = context.remediation;
     }
 }
 /** Approved replay commitment no longer matches the immediately rebuilt plan. */