rea-agents 6.5.0 → 6.7.0

package/dist/cli/cutterCommands.js

@@ -3,15 +3,53 @@ import { CutterBridgeClient } from "../cutter/CutterBridgeClient.js";
 import { CutterBridgeService } from "../cutter/CutterBridgeService.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
+import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
+import { err } from "../domain/result.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { cliIntegerArgument } from "./options.js";
 /** Register commands that control an already-running Cutter instance. */
 export const registerCutterCommands = (cli, logger, environment) => {
-    const cutter = new CutterBridgeService(new CutterBridgeClient(environment));
+    const createCutter = () => new CutterBridgeService(new CutterBridgeClient(environment));
     cli.command(CLI_COMMANDS.listCutterSessions, {
         description: "List live Cutter instances connected through the REA Python plugin bridge",
         args: z.object({}),
-        run: () => logCliCommand(logger, CLI_COMMANDS.listCutterSessions, () => cutter.listSessions()),
+        run: () => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.listCutterSessions, async () => {
+            const cutter = createCutter();
+            let result;
+            try {
+                result = await cutter.listSessions({ signal });
+            }
+            catch (cause) {
+                result = err(cause instanceof AnalysisError
+                    ? cause
+                    : new ProviderAdapterError("cutter", "list_cutter_sessions", {
+                        cause,
+                    }));
+            }
+            try {
+                await cutter.close();
+            }
+            catch (cause) {
+                const cleanup = cause instanceof AnalysisError
+                    ? cause
+                    : new ProviderAdapterError("cutter", "list_cutter_sessions", {
+                        cause,
+                    });
+                result = err(result.ok
+                    ? cleanup
+                    : analysisErrorWithCleanupFailure(result.error, cleanup, "list_cutter_sessions"));
+            }
+            if (result.ok && signal.aborted)
+                result = err(new AnalysisCancelledError("list_cutter_sessions", {
+                    cause: signal.reason,
+                }));
+            return result.ok ? result.value : projectAnalysisError(result.error);
+        })),
     });
     cli.command(CLI_COMMANDS.cutterCommand, {
         description: "Execute one Rizin command in a selected live Cutter instance",
@@ -20,11 +58,7 @@ export const registerCutterCommands = (cli, logger, environment) => {
                 .string()
                 .uuid()
                 .describe("Session ID copied from list-cutter-sessions."),
-            expectedGeneration: z.coerce
-                .number()
-                .int()
-                .nonnegative()
-                .describe("Session generation returned by list-cutter-sessions."),
+            expectedGeneration: cliIntegerArgument(0).describe("Session generation returned by list-cutter-sessions."),
             command: z
                 .string()
                 .min(1)
@@ -32,19 +66,23 @@ export const registerCutterCommands = (cli, logger, environment) => {
                 .refine((value) => !/[\r\n]/u.test(value)),
         }),
         options: z.object({
+            jsonOutput: z
+                .boolean()
+                .optional()
+                .describe("Return command-specific JSON output when available (independent of CLI output formatting)."),
             json: z
                 .boolean()
-                .default(false)
-                .describe("Return command-specific JSON output when available."),
+                .optional()
+                .describe("Deprecated compatibility input: use --json-output; pass --json=true or --json=false (bare --json formats CLI output)."),
         }),
         run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.cutterCommand, async () => {
-            const result = await cutter.execute({
+            const cutter = createCutter();
+            return finishAnalysisCommand(() => cutter.execute({
                 session_id: args.sessionId,
                 expected_generation: args.expectedGeneration,
                 command: args.command,
-                json: options.json,
-            }, { signal });
-            return result.ok ? result.value : projectAnalysisError(result.error);
+                json: options.jsonOutput ?? options.json ?? false,
+            }, { signal }), cutter, "cutter", "cutter_command", signal);
         })),
     });
 };

package/dist/cli/electronCommands.js

@@ -12,6 +12,7 @@ import { parseCliJsonInput, resolveCliJsonPaths } from "../cliJsonInput.js";
 import { electronPageInspectionOptions, javascriptApplicationOptions, } from "../cliObservationOptions.js";
 import { runCliJavaScriptApplicationAnalysis } from "./javascriptApplicationAnalysis.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 /** Register CLI equivalents of the Electron MCP tools. */
 export const registerElectronCommands = (cli, logger, environment) => {
     registerElectronObservationCommands(cli, logger);
@@ -21,7 +22,6 @@ export const registerElectronCommands = (cli, logger, environment) => {
     registerJavaScriptRuntimeReconciliationCommand(cli, logger);
 };
 const registerElectronFuseCommand = (cli, logger) => {
-    const service = createElectronFuseService();
     cli.command(CLI_COMMANDS.inspectElectronFuses, {
         description: "Inspect packaged Electron fuse bytes without launching the application",
         args: z.object({
@@ -30,8 +30,8 @@ const registerElectronFuseCommand = (cli, logger) => {
                 .describe("Local Electron .app, Electron Framework binary, PE executable, or ELF executable"),
         }),
         run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.inspectElectronFuses, async () => {
-            const result = await service.inspect({ path: absoluteElectronFusePath(args.path) }, { signal });
-            return result.ok ? result.value : projectAnalysisError(result.error);
+            const service = createElectronFuseService();
+            return finishAnalysisCommand(() => service.inspect({ path: absoluteElectronFusePath(args.path) }, { signal }), service, service.provider.identity.id, "inspect_electron_fuses", signal);
         })),
     });
 };
@@ -68,8 +68,15 @@ const registerElectronActiveCommand = (cli, logger, environment) => {
                 return inputError("capture_electron_scenario", parsed.error.issues, input.value);
             const { captureElectronScenario } = await import("../application/javascript/ElectronActiveObservationService.js");
             const { createElectronScenarioProvider } = await import("../composition/electronScenario.js");
-            const result = await captureElectronScenario(createElectronScenarioProvider(environment), parsed.data, { signal });
-            return result.ok ? result.value : cliError(result.error);
+            const provider = createElectronScenarioProvider(environment);
+            const result = await finishAnalysisCommand(() => captureElectronScenario(provider, parsed.data, { signal }), {
+                close: async () => {
+                    await provider.close?.();
+                },
+            }, provider.identity().id, "capture_electron_scenario", signal);
+            return "code" in result
+                ? { error: "Electron analysis failed", ...result }
+                : result;
         })),
     });
 };
@@ -101,7 +108,7 @@ const registerElectronTargetList = (cli, logger) => {
         args: z.object({
             endpoint: z.string().describe("Literal-loopback Electron CDP endpoint"),
         }),
-        run: ({ args }) => logCliCommand(logger, "list-electron-targets", async () => {
+        run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, "list-electron-targets", async () => {
             const context = await electronObservationContext();
             const parsed = listElectronTargetsInputSchema.safeParse({
                 cdp_endpoint: args.endpoint,
@@ -109,9 +116,12 @@ const registerElectronTargetList = (cli, logger) => {
             if (!parsed.success)
                 return inputError("list_electron_targets");
             const { listElectronTargets } = await import("../application/javascript/ElectronObservationService.js");
-            const result = await listElectronTargets(context.provider, parsed.data);
-            return result.ok ? result.value : cliError(result.error);
-        }),
+            return await finishAnalysisCommand(() => listElectronTargets(context.provider, parsed.data, { signal }), {
+                close: async () => {
+                    await context.provider.close?.();
+                },
+            }, "rea-cdp-electron", "list_electron_targets", signal);
+        })),
     });
 };
 const registerElectronPageInspection = (cli, logger) => {
@@ -122,7 +132,7 @@ const registerElectronPageInspection = (cli, logger) => {
             targetId: z.string().describe("Target ID from list-electron-targets"),
         }),
         options: electronPageInspectionOptions,
-        run: ({ args, options }) => logCliCommand(logger, "inspect-electron-page", async () => {
+        run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, "inspect-electron-page", async () => {
             const context = await electronObservationContext();
             const parsed = inspectElectronPageInputSchema.safeParse({
                 cdp_endpoint: args.endpoint,
@@ -133,9 +143,12 @@ const registerElectronPageInspection = (cli, logger) => {
             if (!parsed.success)
                 return inputError("inspect_electron_page");
             const { inspectElectronPage } = await import("../application/javascript/ElectronObservationService.js");
-            const result = await inspectElectronPage(context.provider, parsed.data);
-            return result.ok ? result.value : cliError(result.error);
-        }),
+            return await finishAnalysisCommand(() => inspectElectronPage(context.provider, parsed.data, { signal }), {
+                close: async () => {
+                    await context.provider.close?.();
+                },
+            }, "rea-cdp-electron", "inspect_electron_page", signal);
+        })),
     });
 };
 const registerJavaScriptApplicationCommand = (cli, logger) => {
@@ -157,6 +170,14 @@ const registerJavaScriptApplicationCommand = (cli, logger) => {
                 : {
                     max_semantic_nodes_per_file: options.maxSemanticNodesPerFile,
                 }),
+            ...(options.maxSemanticUnknowns === undefined
+                ? {}
+                : { max_semantic_unknowns: options.maxSemanticUnknowns }),
+            ...(options.maxSemanticUnknownsPerFile === undefined
+                ? {}
+                : {
+                    max_semantic_unknowns_per_file: options.maxSemanticUnknownsPerFile,
+                }),
             ...(options.sourcePath === undefined
                 ? {}
                 : { source_paths: options.sourcePath }),

package/dist/cli/evmCommands.js

@@ -1,9 +1,9 @@
 import { z } from "incur";
-import { resolve } from "node:path";
 import { evmInterfaceModule } from "../composition/evm.js";
 import { logCliCommand } from "../cliLogging.js";
-import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { absoluteCallerPath } from "../filesystem/callerPath.js";
+import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 /** Resolve operator paths and preserve explicit encoding through the shared workflow. */
 export const registerEvmCommands = (cli, logger, environment) => {
     const service = evmInterfaceModule.create(environment);
@@ -15,18 +15,9 @@ export const registerEvmCommands = (cli, logger, environment) => {
                 .enum(["raw", "hex"])
                 .describe("Selected carrier representation"),
         }),
-        run: ({ args }) => withCommandCancellation(async (signal) => {
-            try {
-                return await logCliCommand(logger, evmInterfaceModule.cliCommand, async () => {
-                    const result = await service.inspect({ path: resolve(args.path), encoding: args.encoding }, { signal });
-                    return result.ok
-                        ? result.value
-                        : projectAnalysisError(result.error);
-                });
-            }
-            finally {
-                await service.close();
-            }
-        }),
+        run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, evmInterfaceModule.cliCommand, () => finishAnalysisCommand(() => service.inspect({
+            path: absoluteCallerPath(args.path),
+            encoding: args.encoding,
+        }, { signal }), service, "evmole-interface", "inspect_evm_interface", signal))),
     });
 };

package/dist/cli/finishAnalysisCommand.js

@@ -1,11 +1,12 @@
 import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
 import { AnalysisError, } from "../domain/analysisErrorBase.js";
 import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { ProviderCleanupError } from "../domain/providerCleanupError.js";
-/** Finish a one-shot CLI operation without discarding its primary result on close failure. */
-export const finishAnalysisCommand = async (run, service, providerId, canonicalOperation, fallbackResource) => {
+/** Finish a one-shot CLI operation while retaining primary results through close. */
+export const finishAnalysisCommand = async (run, service, providerId, canonicalOperation, signal, fallbackResource) => {
     let result;
     try {
         result = await run();
@@ -19,6 +20,8 @@ export const finishAnalysisCommand = async (run, service, providerId, canonicalO
         };
     }
     try {
+        // Resource owners may resolve their retained errors during close. This
+        // adapter cannot infer resolution of a producer's earlier cleanup failure.
         await service.close();
     }
     catch (cause) {
@@ -40,5 +43,10 @@ export const finishAnalysisCommand = async (run, service, providerId, canonicalO
             ? cleanup
             : analysisErrorWithCleanupFailure(result.error, cleanup, canonicalOperation));
     }
+    if (result.ok && signal.aborted)
+        return projectAnalysisError(new AnalysisCancelledError(canonicalOperation, {
+            cause: signal.reason,
+            partialObservation: result.value,
+        }));
     return result.ok ? result.value : projectAnalysisError(result.error);
 };

package/dist/cli/firmwareCommands.js

@@ -1,34 +1,26 @@
 import { z } from "incur";
-import { resolve } from "node:path";
 import { FirmwareAnalysisService } from "../application/firmware/FirmwareAnalysisService.js";
 import { createFirmwareAnalysisProvider } from "../composition/firmware.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
 import { firmwareInputSchemas } from "../domain/firmware/firmwareAnalysis.js";
 import { localPathStringSchema } from "../domain/localPath.js";
-import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { absoluteCallerPath } from "../filesystem/callerPath.js";
+import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 /** One-shot firmware CLI commands backed by the same workflows as MCP. */
 export const registerFirmwareCommands = (cli, logger, environment) => {
     const service = new FirmwareAnalysisService(createFirmwareAnalysisProvider(environment));
     const extractInput = firmwareInputSchemas.extract_firmware.shape;
     const range = extractInput.range.unwrap().shape;
-    const execute = (name, operation, input) => withCommandCancellation((signal) => logCliCommand(logger, name, async () => {
-        try {
-            const result = await service.execute(operation, input, { signal });
-            return result.ok ? result.value : projectAnalysisError(result.error);
-        }
-        finally {
-            await service.close();
-        }
-    }));
+    const execute = (name, operation, input) => withCommandCancellation((signal) => logCliCommand(logger, name, () => finishAnalysisCommand(() => service.execute(operation, input, { signal }), service, operation === "inspect_firmware_regions" ? "binwalk" : "unblob", operation, signal)));
     const path = localPathStringSchema.describe("Local firmware path; never executed");
     cli.command(CLI_COMMANDS.inspectFirmwareRegions, {
         description: "Inspect firmware signature candidates without extracting them",
         args: z.object({ path }),
         run: ({ args }) => execute(CLI_COMMANDS.inspectFirmwareRegions, "inspect_firmware_regions", 
         // CLI paths are operator-relative; resolve before shared validation.
-        { path: resolve(args.path) }),
+        { path: absoluteCallerPath(args.path) }),
     });
     cli.command(CLI_COMMANDS.extractFirmware, {
         description: "Extract selected firmware bytes and return verified files and provenance",
@@ -48,8 +40,8 @@ export const registerFirmwareCommands = (cli, logger, environment) => {
             maxOutputFiles: extractInput.max_output_files,
         }),
         run: ({ args, options }) => execute(CLI_COMMANDS.extractFirmware, "extract_firmware", {
-            path: resolve(args.path),
-            output_directory: resolve(args.outputDirectory),
+            path: absoluteCallerPath(args.path),
+            output_directory: absoluteCallerPath(args.outputDirectory),
             ...(options.offset === undefined && options.length === undefined
                 ? {}
                 : { range: { offset: options.offset, length: options.length } }),

package/dist/cli/flutterCommands.js

@@ -1,11 +1,10 @@
 import { z } from "incur";
-import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { FlutterBuildAnalysisService } from "../application/flutter/FlutterBuildAnalysisService.js";
 import { createFlutterBuildAnalysisProvider } from "../composition/flutter.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
-import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 /** Expose the same explicit Flutter requests through one-shot CLI commands. */
 export const registerFlutterCommands = (cli, logger, provider = createFlutterBuildAnalysisProvider()) => {
     const specs = [
@@ -48,22 +47,7 @@ export const registerFlutterCommands = (cli, logger, provider = createFlutterBui
             ...(spec.optionSchema === undefined
                 ? { args: spec.argumentSchema }
                 : { args: spec.argumentSchema, options: spec.optionSchema }),
-            run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, spec.command, async () => {
-                const settled = await new FlutterBuildAnalysisService(provider).execute(spec.operation, spec.toInput(args, options ?? {}), {
-                    signal,
-                });
-                try {
-                    await provider.close();
-                }
-                catch (cause) {
-                    if (cause instanceof AnalysisError)
-                        return projectAnalysisError(cause);
-                    throw cause;
-                }
-                return settled.ok
-                    ? settled.value
-                    : projectAnalysisError(settled.error);
-            })),
+            run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, spec.command, () => finishAnalysisCommand(() => new FlutterBuildAnalysisService(provider).execute(spec.operation, spec.toInput(args, options ?? {}), { signal }), { close: () => provider.close() }, "flutter", spec.operation, signal))),
         });
     }
 };

package/dist/cli/fridaCommands.js

@@ -152,6 +152,14 @@ export const registerFridaCommands = (cli, logger, provider = new FridaInstrumen
             .refine((options) => options.remoteAddress === undefined || options.deviceId === undefined, "Choose either deviceId or remoteAddress, not both")
             .refine(remoteAddressRequired, "Remote credentials and connection options require remoteAddress"),
         run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.instrumentWithFrida, async () => {
+            if (args.mode === "attach" && options.argument !== undefined)
+                return projectAnalysisError(new AnalysisInputError(CLI_COMMANDS.instrumentWithFrida, undefined, [
+                    {
+                        path: ["argument"],
+                        reason: "invalid_value",
+                        message: "--argument is only valid in spawn mode; remove it when attaching to a process.",
+                    },
+                ]));
             if ((options.script === undefined) ===
                 (options.scriptFile === undefined))
                 return projectAnalysisError(new AnalysisInputError(CLI_COMMANDS.instrumentWithFrida, undefined, [

package/dist/cli/goCommands.js

@@ -1,10 +1,10 @@
 import { z } from "incur";
-import { resolve } from "node:path";
 import { createGoBinaryService } from "../composition/go.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
 import { withCommandCancellation } from "./commandCancellation.js";
 import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
+import { absoluteCallerPath } from "../filesystem/callerPath.js";
 /** Resolve caller paths and inspect static build metadata through the shared workflow. */
 export const registerGoCommands = (cli, logger) => {
     cli.command(CLI_COMMANDS.inspectGoBinary, {
@@ -14,7 +14,7 @@ export const registerGoCommands = (cli, logger) => {
         }),
         run: ({ args }) => withCommandCancellation(async (signal) => {
             const service = createGoBinaryService();
-            return await logCliCommand(logger, CLI_COMMANDS.inspectGoBinary, async () => finishAnalysisCommand(() => service.inspect({ path: resolve(args.path) }, { signal }), service, "go-build-info", "inspect_go_binary"));
+            return await logCliCommand(logger, CLI_COMMANDS.inspectGoBinary, async () => finishAnalysisCommand(() => service.inspect({ path: absoluteCallerPath(args.path) }, { signal }), service, "go-build-info", "inspect_go_binary", signal));
         }),
     });
 };

package/dist/cli/javascriptRecoveryCommands.js

@@ -3,8 +3,8 @@ import { JavaScriptRecoveryService } from "../application/javascript/JavaScriptR
 import { createJavaScriptRecoveryProvider } from "../composition/javascriptRecovery.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
-import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 /** Share source recovery with MCP while keeping CLI spelling at this boundary. */
 export const registerJavaScriptRecoveryCommands = (cli, logger, environment) => {
     const service = new JavaScriptRecoveryService(createJavaScriptRecoveryProvider(environment));
@@ -30,30 +30,18 @@ export const registerJavaScriptRecoveryCommands = (cli, logger, environment) =>
                 .optional()
                 .describe("Upstream syntax recovery level; runtime equivalence remains unknown"),
         }),
-        run: ({ args, options }) => withCommandCancellation(async (signal) => {
-            try {
-                return await logCliCommand(logger, CLI_COMMANDS.recoverJavaScriptSources, async () => {
-                    const result = await service.recover({
-                        path: args.path,
-                        output_directory: args.outputDirectory,
-                        ...(options.additionalPath === undefined
-                            ? {}
-                            : { additional_paths: options.additionalPath }),
-                        ...(options.extractionMode === undefined
-                            ? {}
-                            : { extraction_mode: options.extractionMode }),
-                        ...(options.rewriteLevel === undefined
-                            ? {}
-                            : { rewrite_level: options.rewriteLevel }),
-                    }, { signal });
-                    return result.ok
-                        ? result.value
-                        : projectAnalysisError(result.error);
-                });
-            }
-            finally {
-                await service.close();
-            }
-        }),
+        run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.recoverJavaScriptSources, () => finishAnalysisCommand(() => service.recover({
+            path: args.path,
+            output_directory: args.outputDirectory,
+            ...(options.additionalPath === undefined
+                ? {}
+                : { additional_paths: options.additionalPath }),
+            ...(options.extractionMode === undefined
+                ? {}
+                : { extraction_mode: options.extractionMode }),
+            ...(options.rewriteLevel === undefined
+                ? {}
+                : { rewrite_level: options.rewriteLevel }),
+        }, { signal }), service, "wakaru", "recover_javascript_sources", signal))),
     });
 };

package/dist/cli/jebCommands.js

@@ -1,26 +1,14 @@
 import { z } from "incur";
-import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { JebAnalysisService } from "../application/jeb/JebAnalysisService.js";
 import { createJebAnalysisProvider } from "../composition/jeb.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
-import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 /** Expose the same explicit JEB requests through one-shot CLI commands. */
 export const registerJebCommands = (cli, logger, environment, provider = createJebAnalysisProvider(environment)) => {
     const service = new JebAnalysisService(provider);
-    const execute = (name, operation, input) => withCommandCancellation((signal) => logCliCommand(logger, name, async () => {
-        const result = await service.execute(operation, input, { signal });
-        try {
-            await provider.close();
-        }
-        catch (cause) {
-            if (cause instanceof AnalysisError)
-                return projectAnalysisError(cause);
-            throw cause;
-        }
-        return result.ok ? result.value : projectAnalysisError(result.error);
-    }));
+    const execute = (name, operation, input) => withCommandCancellation((signal) => logCliCommand(logger, name, () => finishAnalysisCommand(() => service.execute(operation, input, { signal }), { close: () => provider.close() }, "jeb", operation, signal)));
     cli.command(CLI_COMMANDS.inspectJebClient, {
         description: "Inspect the running JEB MCP client without opening a target",
         args: z.object({}),

package/dist/cli/options.js

@@ -1,6 +1,12 @@
+import { z } from "incur";
 import { executableFormatHintSchema, } from "../domain/dosCom.js";
 import { binaryArchitectureSchema, rawBinaryEntryPointSchema, } from "../domain/rawBinary.js";
 import { analysisProviderSelectorSchema } from "../contracts/providerSelection.js";
+/** Parse decimal integer tokens before Number coercion can erase their syntax. */
+export const cliIntegerArgument = (min) => z
+    .string()
+    .regex(/^[0-9]+$/u, "Expected a decimal integer")
+    .pipe(z.coerce.number().safe().min(min));
 export const providerSelectionOption = analysisProviderSelectorSchema
     .optional()
     .describe("Bind deep analysis to a provider ID or use deterministic auto selection");

package/dist/cli/pcapCommands.js

@@ -1,32 +1,14 @@
 import { z } from "incur";
-import { AnalysisError } from "../domain/analysisErrorBase.js";
-import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
 import { PcapAnalysisService } from "../application/pcap/PcapAnalysisService.js";
 import { createPcapAnalysisProvider } from "../composition/pcap.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
-import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 /** Expose the same explicit pcap requests through one-shot CLI commands. */
 export const registerPcapCommands = (cli, logger, environment, provider = createPcapAnalysisProvider(environment)) => {
     const service = new PcapAnalysisService(provider);
-    const execute = (name, operation, input) => withCommandCancellation((signal) => logCliCommand(logger, name, async () => {
-        const result = await service.execute(operation, input, { signal });
-        try {
-            await provider.close();
-        }
-        catch (cause) {
-            if (cause instanceof AnalysisError) {
-                if (result.ok)
-                    cause.retainPartialObservation(result.value);
-                return projectAnalysisError(result.ok
-                    ? cause
-                    : analysisErrorWithCleanupFailure(result.error, cause, operation));
-            }
-            throw cause;
-        }
-        return result.ok ? result.value : projectAnalysisError(result.error);
-    }));
+    const execute = (name, operation, input) => withCommandCancellation((signal) => logCliCommand(logger, name, () => finishAnalysisCommand(() => service.execute(operation, input, { signal }), { close: () => provider.close() }, "pcap", operation, signal)));
     cli.command(CLI_COMMANDS.inspectPcapClient, {
         description: "Inspect the caller-selected tshark and capinfos binaries without reading a capture",
         args: z.object({}),

package/dist/cli/rustCommands.js

@@ -1,21 +1,20 @@
 import { z } from "incur";
-import { resolve } from "node:path";
 import { createRustBinaryService } from "../composition/rust.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
-import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { absoluteCallerPath } from "../filesystem/callerPath.js";
 /** Resolve caller paths and inspect embedded Rust dependencies through the shared workflow. */
 export const registerRustCommands = (cli, logger) => {
-    const service = createRustBinaryService();
     cli.command(CLI_COMMANDS.inspectRustBinary, {
         description: "Inspect an embedded cargo-auditable Rust dependency list without target execution",
         args: z.object({
             path: z.string().describe("Local ELF, PE or thin Mach-O image"),
         }),
-        run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.inspectRustBinary, async () => {
-            const result = await service.inspect({ path: resolve(args.path) }, { signal });
-            return result.ok ? result.value : projectAnalysisError(result.error);
-        })),
+        run: ({ args }) => withCommandCancellation((signal) => {
+            const service = createRustBinaryService();
+            return logCliCommand(logger, CLI_COMMANDS.inspectRustBinary, () => finishAnalysisCommand(() => service.inspect({ path: absoluteCallerPath(args.path) }, { signal }), service, "rust-auditable", "inspect_rust_binary", signal));
+        }),
     });
 };

package/dist/cli/setupCommands.js

@@ -1,3 +1,4 @@
+import { withCommandCancellation } from "./commandCancellation.js";
 import { z } from "incur";
 import { DOCTOR_PROVIDER_IDS } from "../application/DoctorProviderIds.js";
 import { isSetupFailure, } from "../application/SetupTypes.js";
@@ -80,13 +81,13 @@ const registerDoctorCommand = (cli, logger, environment) => {
                 .optional()
                 .describe("Require the installed REA skill identity to be aligned"),
         }),
-        run: ({ options }) => logCliCommand(logger, "doctor", async () => {
+        run: ({ options }) => withCommandCancellation((signal) => logCliCommand(logger, "doctor", async () => {
             const [{ runDoctorOwned }, { createSystemDoctorHost }] = await Promise.all([
                 import("../application/Doctor.js"),
                 import("../doctorRuntime.js"),
             ]);
-            return runDoctorOwned(options.target, createSystemDoctorHost(environment), doctorScope(options));
-        }),
+            return runDoctorOwned(options.target, createSystemDoctorHost(environment, signal), doctorScope(options));
+        })),
     });
 };
 const registerMaintenanceCommands = (cli, logger, environment) => {

package/dist/cli/signalCommands.js

@@ -1,12 +1,12 @@
 import { inspectSignalDecodersInputSchema } from "../domain/signals/signalDecoders.js";
 import { z } from "incur";
-import { resolve } from "node:path";
 import { createSignalRecordingService } from "../composition/signals.js";
 import { signalRecordingOptionsSchema, signalRecordingSelectorBudgetIssue, withinSignalRecordingSelectorBudget, } from "../domain/signals/signalRecording.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
 import { withCommandCancellation } from "./commandCancellation.js";
 import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
+import { absoluteCallerPath } from "../filesystem/callerPath.js";
 export const registerSignalCommands = (cli, logger, environment, service = createSignalRecordingService(environment)) => {
     cli.command(CLI_COMMANDS.inspectSignalDecoders, {
         description: "Search installed sigrok decoders or selected decoder help",
@@ -33,7 +33,7 @@ export const registerSignalCommands = (cli, logger, environment, service = creat
                     message: "all and limit are mutually exclusive",
                 });
         }),
-        run: ({ options: { all, ...options } }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.inspectSignalDecoders, async () => finishAnalysisCommand(() => service.inspectDecoders({ ...options, ...(all ? { limit: null } : {}) }, { signal }), service, "sigrok-recording", "inspect_signal_decoders"))),
+        run: ({ options: { all, ...options } }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.inspectSignalDecoders, async () => finishAnalysisCommand(() => service.inspectDecoders({ ...options, ...(all ? { limit: null } : {}) }, { signal }), service, "sigrok-recording", "inspect_signal_decoders", signal))),
     });
     cli.command(CLI_COMMANDS.decodeSignalRecording, {
         description: "Decode an existing signal recording with caller-supplied sigrok",
@@ -65,8 +65,8 @@ export const registerSignalCommands = (cli, logger, environment, service = creat
             return finishAnalysisCommand(() => service.decode({
                 ...options,
                 ...(all_lines ? { line_limit: null } : {}),
-                path: resolve(args.path),
-            }, { signal }), service, "sigrok-recording", "decode_signal_recording");
+                path: absoluteCallerPath(args.path),
+            }, { signal }), service, "sigrok-recording", "decode_signal_recording", signal);
         })),
     });
 };