rea-agents 3.0.0 → 3.2.0

package/dist/application/CapabilityInventory.js

@@ -1,30 +1,20 @@
 import { z } from "zod";
+import { providerCapability, } from "../contracts/toolOutputSchemaPrimitives.js";
 import { GENERATED_MCP_TOOL_CATALOG } from "../generatedMcpToolCatalog.js";
+import { clientRequirementsFor, NO_CLIENT_FEATURES, } from "./CapabilityClientRequirements.js";
 const statusSchema = z.object({
     open: z.boolean(),
     kind: z.enum(["executable", "database", "archive", "artifact"]).optional(),
     format: z.string().optional(),
-    capabilities: z.array(z.object({
-        operation: z.string(),
-        available: z.boolean(),
-        reason: z.string().nullable(),
-        availability_code: z.string().nullable().optional(),
-    })),
+    capabilities: z.array(providerCapability),
 });
-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"],
-    },
-};
 const ENHANCED_REQUIREMENTS = {
-    swift_classes: ["list_procedures"],
+    trace_native_ui_action: [
+        "decode_interface_builder",
+        "list_names",
+        "procedure_callees",
+    ],
+    inspect_native_dispatch_metadata: ["list_names"],
     get_objc_classes: ["list_names"],
     get_objc_protocols: ["list_names"],
     batch_decompile: ["procedure_pseudo_code"],
@@ -46,24 +36,24 @@ const ENHANCED_REQUIREMENTS = {
         "resolve_containing_procedure",
     ],
 };
-const SESSION_COMPOSITION_REQUIREMENTS = {
-    get_navigation_context: [
-        "current_document",
-        "current_address",
-        "resolve_containing_procedure",
-    ],
-};
+const NAVIGATION_CONTEXT_MODES = [
+    {
+        name: "current_selection",
+        requirements: [
+            "current_document",
+            "current_address",
+            "resolve_containing_procedure",
+        ],
+    },
+    {
+        name: "explicit_document",
+        requirements: ["current_address", "resolve_containing_procedure"],
+    },
+];
 /** Build stable per-operation availability for discovery and tool visibility. */
 export const buildCapabilityInventory = (sessionStatus, policy, clientFeatures = NO_CLIENT_FEATURES) => {
     const status = statusSchema.parse(sessionStatus);
-    const descriptors = new Map(status.capabilities.map((descriptor) => [
-        descriptor.operation,
-        {
-            available: descriptor.available,
-            reason: descriptor.reason,
-            availability_code: descriptor.availability_code ?? null,
-        },
-    ]));
+    const descriptors = new Map(status.capabilities.map((descriptor) => [descriptor.operation, descriptor]));
     return GENERATED_MCP_TOOL_CATALOG.map((contract) => {
         const availability = availabilityFor({
             name: contract.name,
@@ -75,16 +65,15 @@ export const buildCapabilityInventory = (sessionStatus, policy, clientFeatures =
         });
         const clientRequirements = clientRequirementsFor(contract.name, clientFeatures);
         const clientBlocked = clientRequirements.missing_required.length > 0;
-        return {
+        const facts = {
             name: contract.name,
             surface: contract.kind,
-            available: availability.reason === "available" && !clientBlocked,
-            reason: clientBlocked
-                ? "client_capability_missing"
-                : availability.reason,
-            remediation: clientBlocked
-                ? `Use an MCP client that supports: ${clientRequirements.missing_required.join(", ")}.`
-                : availability.remediation,
+            ...(availability.defaultModeAvailable === undefined
+                ? {}
+                : { default_mode_available: availability.defaultModeAvailable }),
+            ...(availability.modes === undefined
+                ? {}
+                : { modes: [...availability.modes] }),
             client_requirements: clientRequirements,
             effects: { ...contract.effects },
             annotations: {
@@ -94,24 +83,31 @@ export const buildCapabilityInventory = (sessionStatus, policy, clientFeatures =
                 open_world: contract.annotations.openWorldHint ?? true,
             },
         };
+        if (clientBlocked)
+            return {
+                ...facts,
+                available: false,
+                reason: "client_capability_missing",
+                remediation: `Use an MCP client that supports: ${clientRequirements.missing_required.join(", ")}.`,
+            };
+        return availability.reason === "available"
+            ? {
+                ...facts,
+                available: true,
+                reason: availability.reason,
+                remediation: null,
+            }
+            : {
+                ...facts,
+                available: false,
+                reason: availability.reason,
+                remediation: availability.remediation,
+            };
     }).sort((left, right) => left.name.localeCompare(right.name));
 };
-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]),
-    };
-};
 const availabilityFor = (context) => {
-    const sessionComposition = SESSION_COMPOSITION_REQUIREMENTS[context.name];
-    if (sessionComposition !== undefined)
-        return composedAvailabilityFor(sessionComposition, context.descriptors);
+    if (context.name === "get_navigation_context")
+        return navigationContextAvailability(context.descriptors);
     const javascriptApplication = javascriptApplicationAvailability(context);
     if (javascriptApplication !== null)
         return javascriptApplication;
@@ -123,14 +119,9 @@ const availabilityFor = (context) => {
         return targetDecision;
     return providerAvailability(context);
 };
-const javascriptApplicationAvailability = ({ name, policy, }) => {
+const javascriptApplicationAvailability = ({ name, }) => {
     if (name === "analyze_javascript_application")
-        return policy.investigationInputRoots === 0
-            ? {
-                reason: "policy_disabled",
-                remediation: "Configure an exact REA_INVESTIGATION_INPUT_ROOTS_JSON root in the MCP registration, then restart the registered MCP server or client.",
-            }
-            : { reason: "available", remediation: null };
+        return { reason: "available", remediation: null };
     return name === "reconcile_javascript_runtime"
         ? { reason: "available", remediation: null }
         : null;
@@ -161,29 +152,37 @@ const policyAvailability = ({ name, kind, policy, }) => {
         return { reason: "available", remediation: null };
     if (kind === "application")
         return { reason: "available", remediation: null };
-    if (name === "import_evidence_bundle" && policy.evidenceFileRoots === 0)
-        return {
-            reason: "policy_disabled",
-            remediation: "Configure or grant an evidence_read root.",
-        };
-    if (kind === "electron-provider")
-        return policy.electronObservationEnabled === true
-            ? { reason: "available", remediation: null }
-            : {
-                reason: "policy_disabled",
-                remediation: "Enable Electron observation and configure a loopback CDP endpoint and canonical file roots.",
-            };
+    const electron = electronPolicyAvailability(name, kind, policy);
+    if (electron !== null)
+        return electron;
     if (kind === "runtime-provider")
         return policy.v8InspectorObservationEnabled === true
             ? { reason: "available", remediation: null }
             : {
                 reason: "policy_disabled",
-                remediation: "Enable V8 Inspector observation and configure exact loopback endpoints plus canonical file roots or exact origins.",
+                remediation: "Enable V8 Inspector observation; pass the user's literal-loopback Inspector endpoint to the tool.",
             };
     if (kind === "session")
         return { reason: "available", remediation: null };
     return null;
 };
+const electronPolicyAvailability = (name, kind, policy) => {
+    if (kind !== "electron-provider")
+        return null;
+    if (name === "capture_electron_scenario")
+        return policy.electronAutomationEnabled === true
+            ? { reason: "available", remediation: null }
+            : {
+                reason: "policy_disabled",
+                remediation: "Enable active Electron automation and configure exact executable and application roots.",
+            };
+    return policy.electronObservationEnabled === true
+        ? { reason: "available", remediation: null }
+        : {
+            reason: "policy_disabled",
+            remediation: "Enable Electron observation; pass the user's literal-loopback CDP endpoint to the tool.",
+        };
+};
 const browserPolicyAvailability = (name, kind, policy) => {
     if (name === "capture_browser_scenario")
         return policy.browserScenarioEnabled === true
@@ -272,3 +271,70 @@ const composedAvailabilityFor = (requirements, descriptors) => {
         };
     return { reason: "available", remediation: null };
 };
+const navigationContextAvailability = (descriptors) => {
+    const modeResults = NAVIGATION_CONTEXT_MODES.map((mode) => {
+        const availability = composedAvailabilityFor(mode.requirements, descriptors);
+        if (availability.reason === "available")
+            return {
+                name: mode.name,
+                available: true,
+                reason: availability.reason,
+                missing_operations: [],
+                remediation: null,
+            };
+        return {
+            name: mode.name,
+            available: false,
+            reason: availability.reason,
+            missing_operations: mode.requirements.filter((operation) => {
+                const descriptor = descriptors.get(operation);
+                return descriptor === undefined || descriptor.available === false;
+            }),
+            remediation: availability.remediation,
+        };
+    });
+    const modes = modeResults.map((mode) => mode.available
+        ? {
+            name: mode.name,
+            available: true,
+            missing_operations: [],
+            remediation: null,
+        }
+        : {
+            name: mode.name,
+            available: false,
+            missing_operations: [...mode.missing_operations],
+            remediation: mode.remediation,
+        });
+    const availableMode = modeResults.find((mode) => mode.available);
+    const failures = modeResults.flatMap((mode) => mode.available ? [] : [mode]);
+    const failure = failures.sort((left, right) => navigationFailurePriority(left.reason) -
+        navigationFailurePriority(right.reason))[0];
+    const specificFailureRemediation = failure?.reason === "provider_missing" ? undefined : failure?.remediation;
+    const facts = {
+        defaultModeAvailable: modes[0]?.available ?? false,
+        modes,
+    };
+    if (availableMode !== undefined)
+        return { ...facts, reason: "available", remediation: null };
+    return {
+        ...facts,
+        reason: failure?.reason ?? "provider_missing",
+        remediation: specificFailureRemediation ??
+            `Configure a provider for one of: ${modes
+                .flatMap((mode) => mode.missing_operations)
+                .join(", ")}.`,
+    };
+};
+const navigationFailurePriority = (reason) => {
+    switch (reason) {
+        case "unsupported_host":
+            return 0;
+        case "provider_unavailable":
+            return 1;
+        case "provider_missing":
+            return 2;
+        default:
+            return 3;
+    }
+};

package/dist/application/ClientConfigurationDocument.js

@@ -0,0 +1,27 @@
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { isDeepStrictEqual } from "node:util";
+import { z } from "zod";
+const objectSchema = z.record(z.string(), z.unknown());
+/** Compare parsed configuration values without depending on parser prototypes. */
+export const clientConfigurationValuesEqual = (left, right) => isDeepStrictEqual(normalizeConfigurationValue(left), normalizeConfigurationValue(right));
+const normalizeConfigurationValue = (value) => {
+    if (Array.isArray(value))
+        return value.map(normalizeConfigurationValue);
+    if (typeof value !== "object" || value === null || value instanceof Date)
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, nested]) => [key, normalizeConfigurationValue(nested)]));
+};
+/** Parse the client format and reject malformed root or server-table values. */
+export const parseClientConfiguration = (text, format) => {
+    const document = objectSchema.parse(format === "toml" ? parseToml(text) : JSON.parse(text));
+    const serversKey = format === "toml" ? "mcp_servers" : "mcpServers";
+    const value = document[serversKey];
+    const servers = value === undefined ? {} : objectSchema.parse(value);
+    return { document, servers, serversKey };
+};
+/** Serialize a validated client document using the selected format. */
+export const serializeClientConfiguration = (document, format) => format === "toml"
+    ? stringifyToml(document)
+    : `${JSON.stringify(document, null, 2)}\n`;

package/dist/application/ClientRegistrationStatus.js

@@ -1,11 +1,10 @@
+import { parseClientConfiguration } from "./ClientConfigurationDocument.js";
 import { access, readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { parse as parseToml } from "smol-toml";
 import { z } from "zod";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { MCP_STARTUP_POLICY } from "../mcpStartupPolicy.js";
 import { supportedClients } from "./SupportedClients.js";
-const objectSchema = z.record(z.string(), z.unknown());
 const registrationSchema = z
     .object({
     command: z.string().min(1),
@@ -21,21 +20,23 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
             continue;
         try {
             const content = await readFile(client.configPath, "utf8");
-            const document = objectSchema.parse(client.format === "toml" ? parseToml(content) : JSON.parse(content));
-            const servers = objectSchema.parse(document[client.format === "toml" ? "mcp_servers" : "mcpServers"] ?? {});
+            const { servers } = parseClientConfiguration(content, client.format);
             const raw = servers[PRODUCT_IDENTITY.mcpServerKey];
             if (raw === undefined) {
-                statuses.push(status(client.name, client.configPath, [], "missing"));
+                statuses.push(unavailableStatus(client.name, client.configPath, "missing"));
                 continue;
             }
             const registration = registrationSchema.parse(raw);
-            const command = [registration.command, ...registration.args];
-            statuses.push(status(client.name, client.configPath, command, registrationAligned(registration, client.name, currentCommandPath)
+            const command = [
+                registration.command,
+                ...registration.args,
+            ];
+            statuses.push(configuredStatus(client.name, client.configPath, command, registrationAligned(registration, client.name, currentCommandPath)
                 ? "aligned"
                 : "stale"));
         }
         catch (cause) {
-            statuses.push(status(client.name, client.configPath, [], isMissing(cause) ? "missing" : "invalid"));
+            statuses.push(unavailableStatus(client.name, client.configPath, isMissing(cause) ? "missing" : "invalid"));
         }
     }
     return statuses.sort((left, right) => left.client.localeCompare(right.client));
@@ -56,14 +57,16 @@ const registrationAligned = (registration, client, currentCommandPath) => {
         command[1] === "mcp" &&
         resolve(command[0] ?? "") === currentCommandPath);
 };
-const status = (client, configPath, command, state) => ({
+const remediation = "Run rea setup to refresh this registration, then restart the client.";
+const configuredStatus = (client, configPath, command, state) => state === "aligned"
+    ? { client, config_path: configPath, command, state, remediation: null }
+    : { client, config_path: configPath, command, state, remediation };
+const unavailableStatus = (client, configPath, state) => ({
     client,
     config_path: configPath,
-    command,
+    command: [],
     state,
-    remediation: state === "aligned"
-        ? null
-        : "Run rea setup to refresh this registration, then restart the client.",
+    remediation,
 });
 const exists = async (path) => {
     if (path === undefined)

package/dist/application/CommandShimReplay.js

@@ -2,6 +2,19 @@ import { createServer } from "node:http";
 import { chmod, mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 const RUNNER = `const command = process.argv[2];
+const maximumTimerDelay = 2147483647;
+const delay = milliseconds => new Promise(resolve => {
+  let remaining = milliseconds;
+  const schedule = () => {
+    const interval = Math.min(remaining, maximumTimerDelay);
+    setTimeout(() => {
+      remaining -= interval;
+      if (remaining === 0) resolve();
+      else schedule();
+    }, interval);
+  };
+  schedule();
+});
 const response = await fetch(process.env.REA_SHIM_LEDGER_URL, {
   method: "POST",
   headers: { "content-type": "application/json" },
@@ -12,7 +25,7 @@ const route = await response.json();
 let elapsed = 0;
 for (const output of route.outputs) {
   const wait = Math.max(0, output.at_ms - elapsed);
-  if (wait > 0) await new Promise((resolve) => setTimeout(resolve, wait));
+  if (wait > 0) await delay(wait);
   elapsed = output.at_ms;
   (output.stream === "stdout" ? process.stdout : process.stderr).write(output.data);
 }

package/dist/application/DirectAnalysis.js

@@ -1,16 +1,17 @@
+import { projectPermissionFailure } from "./PermissionFailure.js";
+import { artifactExtractionPermissionRequest } from "./ArtifactExtractionDestination.js";
 import { parseConfig } from "../config.js";
 import { EnhancedTools } from "./EnhancedTools.js";
 import { createBinarySession } from "./runtime.js";
 import { silentLogger } from "../logger.js";
 import { createEvidence } from "../domain/evidence.js";
-import { EvidenceIntegrityError, AnalysisProtocolError, PermissionRequiredError, projectAnalysisError, } from "../domain/errors.js";
+import { EvidenceIntegrityError, projectAnalysisError, } from "../domain/errors.js";
 import { access } from "node:fs/promises";
 import { readAnalysisSnapshot, writeAnalysisSnapshot, } from "./AnalysisSnapshotFiles.js";
-import { parseBinaryTarget } from "../domain/binaryTarget.js";
+import { parseBinaryTarget } from "./BinaryTargetResolver.js";
 import { snapshotEvidenceForQuery, snapshotMatchesTarget, } from "../domain/analysisSnapshot.js";
 import { err, ok } from "../domain/result.js";
 import { loadConfiguredPermissionAuthority } from "./PermissionConfiguration.js";
-import { authorizeFileReadWithDeferredWrite, } from "./DeferredFileAuthorization.js";
 import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "./InvestigationProviders.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
 export { runCapabilityStatus, runProviderStatus, } from "./DirectAnalysisStatus.js";
@@ -40,26 +41,13 @@ const authorizeAnalysis = async (authority, tool, arguments_) => {
     const requests = [];
     if (tool === "extract_artifact" && typeof arguments_.output_root === "string")
         requests.push({
-            capability: "artifact_extract",
-            path: arguments_.output_root,
+            request: artifactExtractionPermissionRequest(),
             access: "write",
         });
     for (const request of requests) {
-        const result = await authority.authorize({
-            capability: request.capability,
-            roots: [request.path],
-            executables: [],
-            environment_names: [],
-            network: "none",
-            mount: false,
-            operation_identity: `${tool}:${request.capability}:${request.path}`,
-        }, request.access);
+        const result = await authority.authorize(request.request, request.access);
         if (!result.ok)
-            return err(result.error instanceof PermissionRequiredError
-                ? result.error
-                : new AnalysisProtocolError(result.error.message, {
-                    cause: result.error,
-                }));
+            return err(projectPermissionFailure(result.error));
     }
     if (["inventory_artifact", "inspect_artifact"].includes(tool) &&
         arguments_.native_mount_approved === true) {
@@ -73,26 +61,13 @@ const authorizeAnalysis = async (authority, tool, arguments_) => {
             operation_identity: `${tool}:native_mount`,
         }, "read");
         if (!result.ok)
-            return err(result.error instanceof PermissionRequiredError
-                ? result.error
-                : new AnalysisProtocolError(result.error.message, {
-                    cause: result.error,
-                }));
+            return err(projectPermissionFailure(result.error));
     }
     return ok(null);
 };
 const permissionAuthorityFor = (config, supplied) => supplied === undefined
     ? loadConfiguredPermissionAuthority(config)
     : Promise.resolve(ok(supplied));
-const authorizeSnapshotAccess = async (authority, tool, snapshotPath) => snapshotPath === undefined
-    ? ok(undefined)
-    : authorizeFileReadWithDeferredWrite(authority, {
-        path: snapshotPath,
-        readCapability: "snapshot_read",
-        writeCapability: "snapshot_write",
-        operation: tool,
-    });
-const authorizeDeferredWrite = (authorization) => authorization?.authorizeWrite() ?? Promise.resolve(ok(null));
 const authorizeAnalysisRun = async (input) => {
     const authority = await permissionAuthorityFor(input.config, input.suppliedAuthority);
     if (!authority.ok)
@@ -100,7 +75,7 @@ const authorizeAnalysisRun = async (input) => {
     const operation = await authorizeAnalysis(authority.value, input.tool, input.arguments);
     if (!operation.ok)
         return operation;
-    return authorizeSnapshotAccess(authority.value, input.tool, input.snapshotPath);
+    return ok(null);
 };
 const runAnalysis = async (path, tool, arguments_, options) => {
     const { logger, signal, snapshotPath } = options;
@@ -112,7 +87,6 @@ const runAnalysis = async (path, tool, arguments_, options) => {
         suppliedAuthority: options.permissionAuthority,
         tool,
         arguments: arguments_,
-        snapshotPath,
     });
     if (!authorization.ok)
         return cliError(authorization.error);
@@ -121,7 +95,6 @@ const runAnalysis = async (path, tool, arguments_, options) => {
         const prepared = await prepareSnapshot({
             path,
             snapshotPath,
-            policy: config.value.analysisSnapshotFilePolicy,
         });
         if (!prepared.ok)
             return cliError(prepared.error);
@@ -137,7 +110,8 @@ const runAnalysis = async (path, tool, arguments_, options) => {
             return cliError(opened.error);
         const evidenceProfile = analysisProfileForEvidence(session, tool);
         const bindingProfile = session.analysisProfile();
-        if (snapshot !== undefined &&
+        if (tool !== "trace_native_ui_action" &&
+            snapshot !== undefined &&
             evidenceProfile !== undefined &&
             bindingProfile !== undefined) {
             const cached = snapshotEvidenceForQuery(snapshot, {
@@ -151,9 +125,6 @@ const runAnalysis = async (path, tool, arguments_, options) => {
             if (cached !== undefined)
                 return cached;
         }
-        const writable = await authorizeDeferredWrite(authorization.value);
-        if (!writable.ok)
-            return cliError(writable.error);
         const { output, evidence } = await executeAnalysisTool({
             session,
             openedTarget: opened.value,
@@ -164,11 +135,13 @@ const runAnalysis = async (path, tool, arguments_, options) => {
         });
         if (evidence !== undefined)
             session.recordEvidence(evidence);
-        if (snapshotPath !== undefined && evidence !== undefined) {
+        if (tool !== "trace_native_ui_action" &&
+            snapshotPath !== undefined &&
+            evidence !== undefined) {
             const snapshot = session.exportAnalysisSnapshot();
             if (!snapshot.ok)
                 return cliError(snapshot.error);
-            const written = await writeAnalysisSnapshot(snapshot.value, snapshotPath, true, config.value.analysisSnapshotFilePolicy);
+            const written = await writeAnalysisSnapshot(snapshot.value, snapshotPath, true);
             if (!written.ok)
                 return cliError(written.error);
         }
@@ -183,7 +156,9 @@ const executeAnalysisTool = async (input) => {
     if (tool === "binary_overview" ||
         tool === "analyze_function" ||
         tool === "inspect_native_api" ||
-        tool === "trace_feature") {
+        tool === "inspect_native_dispatch_metadata" ||
+        tool === "trace_feature" ||
+        tool === "trace_native_ui_action") {
         const result = await new EnhancedTools(session).execute(tool, input.arguments, signal);
         if (!result.ok)
             return { output: cliError(result.error) };
@@ -235,10 +210,10 @@ const withProcessCancellation = async (suppliedSignal, operation) => {
     }
 };
 const prepareSnapshot = async (options) => {
-    const { path, snapshotPath, policy } = options;
+    const { path, snapshotPath } = options;
     if (snapshotPath === undefined || !(await fileExists(snapshotPath)))
         return ok({});
-    const loaded = await readAnalysisSnapshot(snapshotPath, policy);
+    const loaded = await readAnalysisSnapshot(snapshotPath);
     if (!loaded.ok)
         return loaded;
     const target = await parseBinaryTarget(path);
@@ -259,7 +234,8 @@ const analysisProfileForEvidence = (session, tool) => {
 };
 const isWorkflowEvidenceTool = (tool) => tool === "binary_overview" ||
     tool === "inspect_native_api" ||
-    tool === "trace_feature";
+    tool === "trace_feature" ||
+    tool === "trace_native_ui_action";
 const fileExists = async (path) => {
     try {
         await access(path);

package/dist/application/DirectAnalysisStatus.js

@@ -1,7 +1,7 @@
 import { parseConfig } from "../config.js";
 import { projectAnalysisError } from "../domain/errors.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
-import { createServerIdentity, createServerIdentitySummary, } from "../serverIdentity.js";
+import { createServerIdentity } from "../serverIdentity.js";
 import { silentLogger } from "../logger.js";
 import { createBinarySession } from "./runtime.js";
 const runSessionStatus = async (logger = silentLogger) => {
@@ -21,63 +21,7 @@ const runSessionStatus = async (logger = silentLogger) => {
         await session.close();
     }
 };
-/** List provider identities, selection, and availability without capability bodies. */
-export const runProviderStatus = async (logger = silentLogger, detail = "summary") => {
-    const fullStatus = await runSessionStatus(logger);
-    if (detail === "full")
-        return fullStatus;
-    const parsedStatus = jsonObjectSchema.safeParse(fullStatus);
-    if (!parsedStatus.success || parsedStatus.data.error !== undefined)
-        return fullStatus;
-    const status = parsedStatus.data;
-    return {
-        open: status.open ?? false,
-        provider: status.provider ?? null,
-        providers: status.providers ?? [],
-        analysis_provider_binding: status.analysis_provider_binding ?? null,
-        analysis_provider_candidates: projectJsonObjectArray(status.analysis_provider_candidates, ["provider", "availability", "target_support", "selected"]),
-        server_identity: createServerIdentitySummary({
-            startedAt: new Date().toISOString(),
-        }),
-    };
-};
-/** List concise operation availability, with explicit full descriptor opt-in. */
-export const runCapabilityStatus = async (logger = silentLogger, detail = "summary") => {
-    const fullStatus = await runSessionStatus(logger);
-    if (detail === "full")
-        return fullStatus;
-    const parsedStatus = jsonObjectSchema.safeParse(fullStatus);
-    if (!parsedStatus.success || parsedStatus.data.error !== undefined)
-        return fullStatus;
-    const status = parsedStatus.data;
-    const capabilities = projectJsonObjectArray(status.capabilities, [
-        "operation",
-        "available",
-        "reason",
-    ]);
-    const available = capabilities.filter((candidate) => typeof candidate === "object" &&
-        candidate !== null &&
-        "available" in candidate &&
-        candidate.available === true).length;
-    return {
-        open: status.open ?? false,
-        summary: {
-            total: capabilities.length,
-            available,
-            unavailable: capabilities.length - available,
-        },
-        capabilities,
-        analysis_provider_binding: status.analysis_provider_binding ?? null,
-        server_identity: createServerIdentitySummary({
-            startedAt: new Date().toISOString(),
-        }),
-    };
-};
-const projectJsonObjectArray = (value, keys) => Array.isArray(value)
-    ? value.map((candidate) => {
-        const parsed = jsonObjectSchema.safeParse(candidate);
-        if (!parsed.success)
-            return candidate;
-        return Object.fromEntries(keys.flatMap((key) => parsed.data[key] === undefined ? [] : [[key, parsed.data[key]]]));
-    })
-    : [];
+/** List complete provider identities, capabilities, and availability. */
+export const runProviderStatus = (logger = silentLogger) => runSessionStatus(logger);
+/** List complete operation descriptors and availability. */
+export const runCapabilityStatus = (logger = silentLogger) => runSessionStatus(logger);