rea-agents 3.0.0 → 3.2.0

package/dist/application/BinarySessionStatus.js

@@ -1,14 +1,21 @@
 /** Project internal provider routing state into the caller-visible session status. */
-export const binarySessionStatus = ({ target, route, router, runtimeAvailability, runId, runtimeLineageSnapshots, requestActivitySnapshots, }) => {
+export const binarySessionStatus = ({ target, route, router, runtimeUnavailability, runId, runtimeLineageSnapshots, requestActivitySnapshots, }) => {
     const configuredProvider = router.configuredIdentity();
     const provider = providerSummary(configuredProvider);
     const providers = router.providerIdentities(route).map(providerSummary);
     const capabilities = [...(route.capabilities?.values() ?? [])]
+        .filter(({ operation }) => operation !== "inventory_artifact")
         .sort((left, right) => left.operation.localeCompare(right.operation))
-        .map((descriptor) => ({
-        ...descriptor,
-        ...runtimeAvailability.get(descriptor.operation),
-    }))
+        .map((descriptor) => {
+        const unavailable = runtimeUnavailability.get(descriptor.operation);
+        return unavailable === undefined
+            ? descriptor
+            : {
+                ...descriptor,
+                available: false,
+                reason: unavailable.reason,
+            };
+    })
         .map(capabilityStatus);
     const analysisProviderBinding = route.binding === null
         ? null
@@ -26,6 +33,7 @@ export const binarySessionStatus = ({ target, route, router, runtimeAvailability
         selected: candidate.selected,
         capabilities: candidate.capabilities
             .slice()
+            .filter(({ operation }) => operation !== "inventory_artifact")
             .sort((left, right) => left.operation.localeCompare(right.operation))
             .map(capabilityStatus),
     }));
@@ -67,7 +75,6 @@ const requestActivityStatus = (snapshots) => {
                 request_id: active.requestId,
                 operation: active.operation,
                 elapsed_ms: active.elapsedMs,
-                timeout_ms: active.timeoutMs,
                 caller_state: active.callerState,
             },
         queued_requests: queuedRequests,
@@ -76,11 +83,9 @@ const requestActivityStatus = (snapshots) => {
     return {
         status: snapshots.length === 0
             ? "not_observed"
-            : active.some(({ callerState }) => callerState === "timed_out")
-                ? "timed_out_busy"
-                : active.length > 0
-                    ? "busy"
-                    : "idle",
+            : active.length > 0
+                ? "busy"
+                : "idle",
         providers,
     };
 };
@@ -105,7 +110,6 @@ const processLineageStatus = (snapshots) => snapshots.length === 0
                 : {
                     status: observation.status,
                     observed_at: observation.observedAt,
-                    schema_version: observation.lineage.schemaVersion,
                     launcher_pid: observation.lineage.launcherPid,
                     launcher_parent_pid: observation.lineage.launcherParentPid,
                     process_group_id: observation.lineage.processGroupId,
@@ -122,10 +126,6 @@ const capabilityStatus = (descriptor) => ({
     available: descriptor.available,
     reason: descriptor.reason,
     availability_code: descriptor.availabilityCode ?? null,
-    input_contract_version: descriptor.inputContractVersion,
-    output_contract_version: descriptor.outputContractVersion,
-    pagination: descriptor.pagination,
-    exhaustive: descriptor.exhaustive,
     effects: {
         mutates_artifact: descriptor.effects.mutatesArtifact,
         launches_process: descriptor.effects.launchesProcess,
@@ -135,10 +135,5 @@ const capabilityStatus = (descriptor) => ({
         changes_permissions: descriptor.effects.changesPermissions,
         requires_root: descriptor.effects.requiresRoot,
     },
-    limits: {
-        max_results: descriptor.limits.maxResults,
-        max_payload_bytes: descriptor.limits.maxPayloadBytes,
-        timeout_ms: descriptor.limits.timeoutMs,
-    },
     limitations: [...descriptor.limitations],
 });

package/dist/application/BinaryTargetResolver.js

@@ -0,0 +1,216 @@
+import { constants } from "node:fs";
+import { createHash } from "node:crypto";
+import { access, open, readFile, realpath, stat, } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { extname, isAbsolute, join, resolve } from "node:path";
+import { promisify } from "node:util";
+import { isPathWithinRoot } from "../domain/localPath.js";
+import { BinaryTargetError } from "../domain/errors.js";
+import { err, ok } from "../domain/result.js";
+import { hasZipSignature, zipPackageFormatForPath, } from "../domain/zipPackageFormat.js";
+import { parseExecutableHeader, parsePeRecord, } from "../domain/binaryTarget.js";
+const execFileAsync = promisify(execFile);
+/**
+ * Resolve and classify a readable local target before a provider is selected.
+ * FAT Mach-O inputs select only a host-compatible architecture so setup remains
+ * non-interactive; unsupported or ambiguous inputs are returned as typed errors.
+ */
+export const parseBinaryTarget = async (input, cwd = process.cwd(), hostArchitecture = process.arch, targetKind) => {
+    const candidate = isAbsolute(input) ? input : resolve(cwd, input);
+    try {
+        await access(candidate, constants.R_OK);
+        const canonical = await realpath(candidate);
+        const resolved = await resolveAppBundle(canonical);
+        if (!resolved.ok)
+            return err(resolved.error);
+        const path = resolved.value;
+        const handle = await open(path, "r");
+        try {
+            if (!(await handle.stat()).isFile())
+                return err(new BinaryTargetError(path, "target is not a regular file"));
+            if (targetKind === "database" ||
+                (targetKind === undefined && path.toLowerCase().endsWith(".hop")))
+                return ok({
+                    path,
+                    sourcePath: canonical,
+                    sha256: await sha256Handle(handle),
+                    kind: "database",
+                    format: "analysis-database",
+                });
+            const artifactFormat = await detectArtifactFormat(path, handle);
+            if (artifactFormat !== undefined) {
+                const identity = {
+                    path,
+                    sourcePath: canonical,
+                    sha256: await sha256Handle(handle),
+                };
+                return isArchiveFormat(artifactFormat)
+                    ? ok({ ...identity, kind: "archive", format: artifactFormat })
+                    : ok({ ...identity, kind: "artifact", format: artifactFormat });
+            }
+            const detected = await readExecutableMetadata(handle, hostArchitecture);
+            if (!detected.ok)
+                return err(new BinaryTargetError(path, detected.error));
+            return ok({
+                path,
+                sourcePath: canonical,
+                sha256: await sha256Handle(handle),
+                kind: "executable",
+                ...detected.value,
+            });
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (cause) {
+        return err(new BinaryTargetError(candidate, "path is not readable", { cause }));
+    }
+};
+const detectArtifactFormat = async (path, handle) => {
+    const lower = path.toLowerCase();
+    const magic = Buffer.alloc(8);
+    const observed = await handle.read(magic, 0, magic.length, 0);
+    if (hasZipSignature(magic.subarray(0, observed.bytesRead))) {
+        return zipPackageFormatForPath(lower) ?? "zip";
+    }
+    const named = namedArtifactFormat(lower);
+    if (named !== undefined)
+        return named;
+    if (lower.endsWith(".pkg") &&
+        observed.bytesRead >= 4 &&
+        magic.subarray(0, 4).toString("ascii") === "xar!")
+        return "pkg";
+    if (lower.endsWith(".dmg")) {
+        const size = (await handle.stat()).size;
+        if (size >= 512) {
+            const trailer = Buffer.alloc(4);
+            const read = await handle.read(trailer, 0, trailer.length, size - 512);
+            if (read.bytesRead === 4 && trailer.toString("ascii") === "koly")
+                return "dmg";
+        }
+    }
+    return undefined;
+};
+const namedArtifactFormat = (lowerPath) => {
+    if (lowerPath.endsWith(".asar"))
+        return "asar";
+    if (lowerPath.endsWith(".plist"))
+        return "plist";
+    if (lowerPath.endsWith(".map"))
+        return "source-map";
+    return /\.(?:m?js|cjs)$/u.test(lowerPath) ? "javascript" : undefined;
+};
+const isArchiveFormat = (format) => ["zip", "ipa", "apk", "msix", "appx", "asar", "dmg", "pkg"].includes(format);
+const sha256Handle = async (handle) => {
+    const hash = createHash("sha256");
+    const chunk = Buffer.allocUnsafe(64 * 1024);
+    let position = 0;
+    while (true) {
+        const observed = await handle.read(chunk, 0, chunk.length, position);
+        if (observed.bytesRead === 0)
+            break;
+        hash.update(chunk.subarray(0, observed.bytesRead));
+        position += observed.bytesRead;
+    }
+    return hash.digest("hex");
+};
+const resolveAppBundle = async (path) => {
+    const metadata = await stat(path);
+    if (!metadata.isDirectory())
+        return ok(path);
+    if (extname(path).toLowerCase() !== ".app")
+        return err(new BinaryTargetError(path, "target is not an app or file"));
+    const plistPath = join(path, "Contents", "Info.plist");
+    let name;
+    try {
+        const plist = await readFile(plistPath);
+        name =
+            plist.subarray(0, 6).toString("ascii") === "bplist"
+                ? await readBinaryPlistExecutable(plistPath)
+                : parseXmlPlistExecutable(plist.toString("utf8"));
+    }
+    catch (cause) {
+        return err(new BinaryTargetError(path, "app has no readable CFBundleExecutable", {
+            cause,
+        }));
+    }
+    if (!isSafeExecutableName(name))
+        return err(new BinaryTargetError(path, "app has an unsafe CFBundleExecutable"));
+    const programs = join(path, "Contents", "MacOS");
+    const executable = join(programs, name);
+    try {
+        const [canonicalPrograms, canonicalExecutable] = await Promise.all([
+            realpath(programs),
+            realpath(executable),
+        ]);
+        if (!isPathWithinRoot(canonicalPrograms, canonicalExecutable))
+            return err(new BinaryTargetError(path, "app program file leaves Contents/MacOS"));
+        return ok(canonicalExecutable);
+    }
+    catch (cause) {
+        return err(new BinaryTargetError(path, "app program file is missing", { cause }));
+    }
+};
+const parseXmlPlistExecutable = (plist) => {
+    const match = /<key>\s*CFBundleExecutable\s*<\/key>\s*<string>([^<]+)<\/string>/u.exec(plist);
+    if (match?.[1] === undefined)
+        throw new Error("CFBundleExecutable is missing");
+    return decodeXml(match[1].trim());
+};
+const readBinaryPlistExecutable = async (plistPath) => (await execFileAsync("/usr/bin/plutil", [
+    "-extract",
+    "CFBundleExecutable",
+    "raw",
+    "-o",
+    "-",
+    plistPath,
+])).stdout.trim();
+const isSafeExecutableName = (name) => name.length > 0 &&
+    name !== "." &&
+    name !== ".." &&
+    !name.includes("\0") &&
+    !/[/\\]/u.test(name);
+const decodeXml = (value) => value
+    .replaceAll("&amp;", "&")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&gt;", ">")
+    .replaceAll("&quot;", '"')
+    .replaceAll("&apos;", "'");
+const readExecutableMetadata = async (handle, hostArchitecture) => {
+    const prefix = Buffer.alloc(4096);
+    const prefixRead = await handle.read(prefix, 0, prefix.length, 0);
+    const bytes = prefix.subarray(0, prefixRead.bytesRead);
+    if (bytes.length >= 64 && bytes[0] === 0x4d && bytes[1] === 0x5a) {
+        const offset = bytes.readUInt32LE(0x3c);
+        return readPeMetadata(handle, offset);
+    }
+    if (bytes.length >= 8) {
+        const magic = bytes.readUInt32BE(0);
+        if ([0xcafebabf, 0xbfbafeca].includes(magic)) {
+            const little = magic === 0xbfbafeca;
+            const count = little ? bytes.readUInt32LE(4) : bytes.readUInt32BE(4);
+            const required = 8 + count * 32;
+            if (count <= 128 && required > bytes.length) {
+                const header = Buffer.alloc(required);
+                const headerRead = await handle.read(header, 0, header.length, 0);
+                return parseExecutableHeader(header.subarray(0, headerRead.bytesRead), hostArchitecture);
+            }
+        }
+    }
+    return parseExecutableHeader(bytes, hostArchitecture);
+};
+const readPeMetadata = async (handle, offset) => {
+    const fileHeader = Buffer.alloc(24);
+    const fileHeaderRead = await handle.read(fileHeader, 0, fileHeader.length, offset);
+    if (fileHeaderRead.bytesRead !== fileHeader.length)
+        return err("invalid or truncated PE header");
+    const optionalHeaderSize = fileHeader.readUInt16LE(20);
+    if (optionalHeaderSize > 4096)
+        return err("invalid PE optional header size");
+    const record = Buffer.alloc(24 + optionalHeaderSize);
+    const recordRead = await handle.read(record, 0, record.length, offset);
+    return recordRead.bytesRead === record.length
+        ? parsePeRecord(record)
+        : err("invalid or truncated PE header");
+};

package/dist/application/BrowserEvidence.js

@@ -1,7 +1,7 @@
 import { createEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { commitBrowserScenarioNormalization } from "../domain/browserScenarioNormalization.js";
-/** Create Evidence v2 for a policy-scoped external browser observation. */
+/** Create Evidence for a policy-scoped external browser observation. */
 export const createBrowserEvidence = (operation, input, result, provider) => createEvidence(undefined, provider, {
     predicateType: browserPredicate(operation),
     operation,
@@ -30,92 +30,74 @@ const browserParameters = (input) => {
                 after_browser: input.after_scenario.browser,
                 before_start_origin: input.before_scenario.scenario.start_origin,
                 after_start_origin: input.after_scenario.scenario.start_origin,
-                max_changes: input.max_changes,
-                normalization_sha256: commitBrowserScenarioNormalization(input.normalization).sha256,
+                normalization_sha256: commitBrowserScenarioNormalization(input.normalization ?? { rules: [] }).sha256,
             };
-        if ("max_changes" in input)
+        if (input.before !== undefined &&
+            input.after !== undefined &&
+            "inspection" in input.before &&
+            "inspection" in input.after)
             return {
                 before_target_id: input.before.inspection.target.target_id,
                 before_capture_ended_at: input.before.inspection.capture_window.ended_at,
                 after_target_id: input.after.inspection.target.target_id,
                 after_capture_ended_at: input.after.inspection.capture_window.ended_at,
-                max_changes: input.max_changes,
             };
-        return {
-            before_artifact_uri: input.before.uri,
-            after_artifact_uri: input.after.uri,
-            channel_threshold: input.channel_threshold,
-            maximum_pixels: input.maximum_pixels,
-        };
+        if (isScreenshotComparison(input))
+            return {
+                before_artifact_sha256: input.before.sha256,
+                after_artifact_sha256: input.after.sha256,
+                channel_threshold: input.channel_threshold,
+            };
+        throw new Error("Browser comparison input did not match a comparison type");
     }
     const scope = {
         cdp_endpoint: input.cdp_endpoint,
         allowed_origins: input.allowed_origins,
     };
     if (!("target_id" in input))
-        return { ...scope, offset: input.offset, limit: input.limit };
-    if ("screenshot_approved" in input)
-        return {
-            ...scope,
-            target_id: input.target_id,
-            maximum_image_bytes: input.maximum_image_bytes,
-        };
-    if ("max_tools" in input)
-        return {
-            ...scope,
-            target_id: input.target_id,
-            observation_ms: input.observation_ms,
-            max_tools: input.max_tools,
-            max_schema_bytes: input.max_schema_bytes,
-            max_schema_nodes: input.max_schema_nodes,
-            max_schema_depth: input.max_schema_depth,
-        };
-    if (!("include_accessibility_text" in input))
-        return {
-            ...scope,
-            target_id: input.target_id,
-            observation_ms: input.observation_ms,
-            max_timeline_events: input.max_timeline_events,
-        };
+        return scope;
     return {
         ...scope,
         target_id: input.target_id,
-        observation_ms: input.observation_ms,
-        include_accessibility_text: input.include_accessibility_text,
-        include_console_text: input.include_console_text,
-        include_json_body_shapes: input.include_json_body_shapes,
-        include_websocket_shapes: input.include_websocket_shapes,
-        include_script_sources: input.include_script_sources,
-        include_storage_keys: input.include_storage_keys,
-        include_storage_fingerprints: input.include_storage_fingerprints,
-        limits: input.limits,
-        ...(input.include_script_sources && "source_capture_approved" in input
+        ...("observation_ms" in input
+            ? { observation_ms: input.observation_ms }
+            : {}),
+        ...("include_accessibility_text" in input
             ? {
-                source_capture_approved: input.source_capture_approved,
-                fetch_source_maps: input.fetch_source_maps,
-                source_map_fetch_approved: input.source_map_fetch_approved,
-                analysis_limits: input.analysis_limits,
+                include_accessibility_text: input.include_accessibility_text,
+                include_console_text: input.include_console_text,
+                include_json_body_shapes: input.include_json_body_shapes,
+                include_websocket_shapes: input.include_websocket_shapes,
+                include_storage_keys: input.include_storage_keys,
+                include_storage_fingerprints: input.include_storage_fingerprints,
+                ...("include_script_sources" in input
+                    ? { include_script_sources: input.include_script_sources }
+                    : {}),
             }
             : {}),
+        ...("fetch_source_maps" in input
+            ? { fetch_source_maps: input.fetch_source_maps }
+            : {}),
     };
 };
+const isScreenshotComparison = (input) => "channel_threshold" in input;
 const browserPredicate = (operation) => {
     switch (operation) {
         case "list_browser_targets":
-            return "rea.browser-target-list/v1";
+            return "rea.browser-target-list";
         case "inspect_web_page":
-            return "rea.web-page-inspection/v2";
+            return "rea.web-page-inspection";
         case "analyze_web_bundle":
-            return "rea.web-bundle-analysis/v1";
+            return "rea.web-bundle-analysis";
         case "observe_web_session":
-            return "rea.web-observation-session/v1";
+            return "rea.web-observation-session";
         case "discover_webmcp_tools":
-            return "rea.webmcp-discovery/v1";
+            return "rea.webmcp-discovery";
         case "compare_web_captures":
-            return "rea.web-capture-diff/v1";
+            return "rea.web-capture-diff";
         case "capture_web_screenshot":
-            return "rea.web-screenshot/v1";
+            return "rea.web-screenshot";
         case "compare_web_screenshots":
-            return "rea.web-screenshot-diff/v1";
+            return "rea.web-screenshot-diff";
     }
 };

package/dist/application/BrowserObservationService.js

@@ -1,5 +1,6 @@
+import { projectPermissionFailure } from "./PermissionFailure.js";
 import { isLiteralLoopbackHostname, } from "../domain/browserObservation.js";
-import { AnalysisCapabilityUnavailableError, AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { createBrowserEvidence } from "./BrowserEvidence.js";
 /** Authorize and execute one policy-scoped target discovery observation. */
@@ -96,11 +97,7 @@ const prepare = async (browser, authority, input, operation) => {
         operation_identity: `${operation}:${input.target_id ?? input.cdp_endpoint}`,
     }, "read");
     if (!authorized.ok)
-        return err(authorized.error instanceof PermissionRequiredError
-            ? authorized.error
-            : new AnalysisProtocolError(authorized.error.message, {
-                cause: authorized.error,
-            }));
+        return err(projectPermissionFailure(authorized.error));
     return browser === undefined
         ? err(new AnalysisCapabilityUnavailableError("rea-cdp-browser", operation, "browser observation provider is not configured"))
         : ok(browser);

package/dist/application/BrowserScenarioCaptureService.js

@@ -1,6 +1,7 @@
+import { projectPermissionFailure } from "./PermissionFailure.js";
 import { createBrowserScenarioEvidence } from "./BrowserScenarioEvidence.js";
 import { digestJson } from "./JavaScriptReplayPlanning.js";
-import { AnalysisCapabilityUnavailableError, AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError, } from "../domain/errors.js";
 import { isLiteralLoopbackHostname } from "../domain/browserObservation.js";
 import { err } from "../domain/result.js";
 const OPERATION = "capture_browser_scenario";
@@ -29,11 +30,7 @@ const authorizeScenario = async (authority, scenario) => {
         operation_identity: `${OPERATION}:${digestJson(scenario)}`,
     }, "write");
     if (!authorized.ok)
-        return err(authorized.error instanceof PermissionRequiredError
-            ? authorized.error
-            : new AnalysisProtocolError(authorized.error.message, {
-                cause: authorized.error,
-            }));
+        return err(projectPermissionFailure(authorized.error));
     return { ok: true, value: true };
 };
 /** Authorize and execute one controlled browser scenario. */

package/dist/application/BrowserScenarioEvidence.js

@@ -11,6 +11,7 @@ const browserScenarioParameters = (scenario) => ({
         step_id,
         action,
     })),
+    action_timeouts_ms: scenario.actions.map((item) => "timeout_ms" in item ? (item.timeout_ms ?? null) : null),
     secret_declarations: scenario.secrets.map(({ secret_id, environment_variable, purpose, redaction }) => ({
         secret_id,
         environment_variable,
@@ -18,11 +19,10 @@ const browserScenarioParameters = (scenario) => ({
         redaction,
     })),
     capture: scenario.capture,
-    limits: scenario.limits,
 });
-/** Create Evidence v2 without retaining resolved scenario secret values. */
+/** Create Evidence without retaining resolved scenario secret values. */
 export const createBrowserScenarioEvidence = (scenario, capture, provider) => createEvidence(undefined, provider, {
-    predicateType: "rea.browser-scenario-capture/v1",
+    predicateType: "rea.browser-scenario-capture",
     operation: "capture_browser_scenario",
     parameters: browserScenarioParameters(scenario),
     result: jsonValueSchema.parse(capture),

package/dist/application/CallPathTracing.js

@@ -1,7 +1,7 @@
 import { projectAnalysisError } from "../domain/errors.js";
 import { parseRelatedAddresses } from "../domain/hopperValues.js";
 import { ok } from "../domain/result.js";
-/** Trace one deterministic bounded direct caller/callee path. */
+/** Trace direct caller/callee relationships until the graph is exhausted or the goal is reached. */
 export const traceCallPath = async (call, input, signal) => {
     const state = createTraceState(input);
     while (state.queueIndex < state.queue.length &&
@@ -12,17 +12,6 @@ export const traceCallPath = async (call, input, signal) => {
         const current = state.visited.get(address);
         if (current === undefined)
             continue;
-        if (current.depth >= input.max_depth) {
-            state.frontier.add(address);
-            state.residual.add("Call-path traversal reached the depth limit.");
-            continue;
-        }
-        if (state.operations >= input.max_operations) {
-            recordPendingFrontier(state, input);
-            state.residual.add("Call-path traversal reached the operation budget.");
-            break;
-        }
-        state.operations += 1;
         const found = await expandAddress(call, {
             input,
             state,
@@ -40,9 +29,7 @@ const createTraceState = (input) => ({
     queue: [input.start],
     edges: new Map(),
     failures: [],
-    frontier: new Set(),
     residual: new Set(),
-    operations: 0,
     queueIndex: 0,
     traversalPath: input.goal === input.start ? [input.start] : [],
 });
@@ -85,12 +72,6 @@ const expandAddress = async (call, expansion) => {
             }
             continue;
         }
-        if (state.visited.size >= input.max_nodes) {
-            if (state.frontier.size < input.max_nodes)
-                state.frontier.add(relatedAddress);
-            state.residual.add("Call-path traversal reached the node limit.");
-            continue;
-        }
         state.visited.set(relatedAddress, {
             depth: current.depth + 1,
             path,
@@ -109,21 +90,12 @@ const recordEdge = (input, state, edge) => {
     const edgeKey = `${sourceAddress}\u0000${targetAddress}`;
     if (state.edges.has(edgeKey))
         return;
-    if (state.edges.size >= input.max_nodes) {
-        state.residual.add("Call-path traversal reached the edge limit.");
-        return;
-    }
     state.edges.set(edgeKey, {
         source_address: sourceAddress,
         target_address: targetAddress,
         discovery_depth: edge.discoveryDepth,
     });
 };
-const recordPendingFrontier = (state, input) => {
-    for (const pending of state.queue.slice(state.queueIndex - 1))
-        if (state.frontier.size < input.max_nodes)
-            state.frontier.add(pending);
-};
 const projectTrace = (input, state) => ({
     start: input.start,
     goal: input.goal ?? null,
@@ -141,19 +113,13 @@ const projectTrace = (input, state) => ({
         compareAddress(left.target_address, right.target_address)),
     traversal_path: state.traversalPath,
     failures: state.failures,
-    frontier: [...state.frontier].sort(compareAddress),
-    limits: {
-        max_depth: input.max_depth,
-        max_nodes: input.max_nodes,
-        max_operations: input.max_operations,
+    traversal: {
         nodes_visited: state.visited.size,
-        operations_used: state.operations,
     },
     truncated: state.residual.size > 0,
     residual_unknowns: [...state.residual],
     limitations: [
         "Direct provider call relationships may omit unresolved indirect calls.",
-        "A not_reached goal is only absent from this bounded traversal, not from the complete program.",
     ],
 });
 const compareAddress = (left, right) => left < right ? -1 : left > right ? 1 : 0;

package/dist/application/CapabilityClientRequirements.js

@@ -0,0 +1,26 @@
+/** Empty MCP client feature declaration used when the caller supplies none. */
+export const NO_CLIENT_FEATURES = {
+    elicitation_form: false,
+    elicitation_url: false,
+    roots: false,
+    sampling: false,
+};
+const CLIENT_FEATURE_REQUIREMENTS = {
+    capture_process_scenario: {
+        required: [],
+        optional: ["elicitation_form"],
+    },
+};
+/** Project a tool's client requirements against the negotiated feature set. */
+export const clientRequirementsFor = (name, clientFeatures) => {
+    const requirements = CLIENT_FEATURE_REQUIREMENTS[name] ?? {
+        required: [],
+        optional: [],
+    };
+    return {
+        required: [...requirements.required],
+        optional: [...requirements.optional],
+        missing_required: requirements.required.filter((feature) => !clientFeatures[feature]),
+        missing_optional: requirements.optional.filter((feature) => !clientFeatures[feature]),
+    };
+};