rea-agents 6.5.0 → 6.7.0

package/dist/cli/apktoolCommands.js

@@ -1,27 +1,15 @@
 import { z } from "incur";
-import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { ApktoolResourceAnalysisService } from "../application/apktool/ApktoolResourceAnalysisService.js";
 import { createApktoolResourceAnalysisProvider } from "../composition/apktool.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
-import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { apktoolInputSchemas, } from "../domain/apktool/apktoolResourceAnalysis.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 /** Expose the same explicit Apktool requests through one-shot CLI commands. */
 export const registerApktoolCommands = (cli, logger, environment, provider = createApktoolResourceAnalysisProvider(environment)) => {
     const service = new ApktoolResourceAnalysisService(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() }, "apktool", operation, signal)));
     cli.command(CLI_COMMANDS.inspectApktoolClient, {
         description: "Inspect the caller-selected apktool launcher without decoding anything",
         args: z.object({}),
@@ -38,6 +26,7 @@ export const registerApktoolCommands = (cli, logger, environment, provider = cre
         // `b+zh+Hans+CN` form at the CLI boundary.
         options: z.object({
             locale: apktoolInputSchemas.decode_android_resources.shape.locale,
+            locales: apktoolInputSchemas.decode_android_resources.shape.locales.describe("Repeat to project multiple localized string tables, e.g. --locales de --locales pt-BR"),
             strings: z
                 .boolean()
                 .default(apktoolInputSchemas.decode_android_resources.shape.include_strings.parse(undefined))
@@ -47,6 +36,7 @@ export const registerApktoolCommands = (cli, logger, environment, provider = cre
             path: args.path,
             include_strings: options.strings,
             ...(options.locale === undefined ? {} : { locale: options.locale }),
+            ...(options.locales === undefined ? {} : { locales: options.locales }),
         }),
     });
 };

package/dist/cli/binaryDiagnosticsCommands.js

@@ -1,5 +1,4 @@
 import { z } from "incur";
-import { resolve } from "node:path";
 import { createRecordedCrashService, createBinaryLayoutService, createPeResourcesService, } from "../composition/binaryDiagnostics.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
@@ -7,6 +6,7 @@ import { withCommandCancellation } from "./commandCancellation.js";
 import { inspectPeResourcesInputSchema } from "../domain/native/peResources.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
+import { absoluteCallerPath } from "../filesystem/callerPath.js";
 /** Inspect operator-selected files through the same shared workflow as MCP. */
 export const registerBinaryDiagnosticsCommands = (cli, logger, environment) => {
     cli.command(CLI_COMMANDS.inspectPeResources, {
@@ -19,10 +19,10 @@ export const registerBinaryDiagnosticsCommands = (cli, logger, environment) => {
         run: ({ args, options }) => withCommandCancellation(async (signal) => {
             const pe = createPeResourcesService();
             return await logCliCommand(logger, CLI_COMMANDS.inspectPeResources, async () => finishAnalysisCommand(() => pe.inspect({
-                path: resolve(args.path),
+                path: absoluteCallerPath(args.path),
                 max_file_bytes: options.maxFileBytes,
                 max_entries: options.maxEntries,
-            }, { signal }), pe, "rea-pe-resources", "inspect_pe_resources"));
+            }, { signal }), pe, "rea-pe-resources", "inspect_pe_resources", signal));
         }),
     });
     const service = createBinaryLayoutService(environment);
@@ -32,7 +32,7 @@ export const registerBinaryDiagnosticsCommands = (cli, logger, environment) => {
             path: z.string().describe("Local ELF binary or relocatable object"),
         }),
         run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.inspectBinaryLayout, async () => {
-            const result = await service.inspectAndClose({ path: resolve(args.path) }, { signal });
+            const result = await service.inspectAndClose({ path: absoluteCallerPath(args.path) }, { signal });
             return result.ok ? result.value : projectAnalysisError(result.error);
         })),
     });
@@ -52,7 +52,7 @@ export const registerBinaryDiagnosticsCommands = (cli, logger, environment) => {
         }),
         run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.inspectRecordedCrash, async () => {
             const result = await recorded.inspectAndClose({
-                path: resolve(args.path),
+                path: absoluteCallerPath(args.path),
                 include_debugger_context: options.debuggerContext,
             }, { signal });
             return result.ok ? result.value : projectAnalysisError(result.error);

package/dist/cli/browserAdvancedCommands.js

@@ -14,6 +14,7 @@ import { captureWebScreenshotInputSchema, compareWebScreenshotsInputSchema, } fr
 import { parseCliJsonInput } from "../cliJsonInput.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 /** Register WebMCP, capture-diff, and screenshot CLI equivalents. */
 export const registerAdvancedBrowserCommands = (cli, logger) => {
     registerWebMcp(cli, logger);
@@ -50,8 +51,11 @@ const registerWebMcp = (cli, logger) => {
             const parsed = discoverWebMcpToolsInputSchema.safeParse(input);
             if (!parsed.success)
                 return inputError("discover_webmcp_tools", projectInputIssues(parsed.error.issues, input));
-            const result = await discoverWebMcpTools(context.provider, parsed.data, { signal });
-            return result.ok ? result.value : browserCliError(result.error);
+            return await finishAnalysisCommand(() => discoverWebMcpTools(context.provider, parsed.data, { signal }), {
+                close: async () => {
+                    await context.provider.close?.();
+                },
+            }, context.provider.identity().id, "discover_webmcp_tools", signal);
         })),
     });
 };
@@ -122,8 +126,11 @@ const registerScreenshot = (cli, logger) => {
             const parsed = captureWebScreenshotInputSchema.safeParse(input);
             if (!parsed.success)
                 return inputError("capture_web_screenshot", projectInputIssues(parsed.error.issues, input));
-            const result = await captureWebScreenshot(context.provider, parsed.data, { signal });
-            return result.ok ? result.value : browserCliError(result.error);
+            return await finishAnalysisCommand(() => captureWebScreenshot(context.provider, parsed.data, { signal }), {
+                close: async () => {
+                    await context.provider.close?.();
+                },
+            }, context.provider.identity().id, "capture_web_screenshot", signal);
         })),
     });
 };

package/dist/cli/browserCommands.js

@@ -9,6 +9,7 @@ import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js"
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { browserPageInspectionOptions, browserScopeOptions, observationDuration, } from "../cliObservationOptions.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 /** Register CLI equivalents of the passive browser MCP tools. */
 export const registerBrowserCommands = (cli, logger) => {
     registerTargetList(cli, logger);
@@ -34,8 +35,11 @@ const registerTargetList = (cli, logger) => {
             const parsed = listBrowserTargetsInputSchema.safeParse(input);
             if (!parsed.success)
                 return browserCliError(analysisInputErrorFromIssues("list_browser_targets", parsed.error.issues, input));
-            const result = await listBrowserTargets(context.provider, parsed.data, { signal });
-            return result.ok ? result.value : browserCliError(result.error);
+            return await finishAnalysisCommand(() => listBrowserTargets(context.provider, parsed.data, { signal }), {
+                close: async () => {
+                    await context.provider.close?.();
+                },
+            }, context.provider.identity().id, "list_browser_targets", signal);
         })),
     });
 };
@@ -67,10 +71,11 @@ const registerPageInspection = (cli, logger) => {
             const parsed = inspectWebPageInputSchema.safeParse(input);
             if (!parsed.success)
                 return browserCliError(analysisInputErrorFromIssues("inspect_web_page", parsed.error.issues, input));
-            const result = await inspectWebPage(context.provider, parsed.data, {
-                signal,
-            });
-            return result.ok ? result.value : browserCliError(result.error);
+            return await finishAnalysisCommand(() => inspectWebPage(context.provider, parsed.data, { signal }), {
+                close: async () => {
+                    await context.provider.close?.();
+                },
+            }, context.provider.identity().id, "inspect_web_page", signal);
         })),
     });
 };
@@ -104,10 +109,11 @@ const registerBundleAnalysis = (cli, logger) => {
             const parsed = analyzeWebBundleInputSchema.safeParse(input);
             if (!parsed.success)
                 return browserCliError(analysisInputErrorFromIssues("analyze_web_bundle", parsed.error.issues, input));
-            const result = await analyzeWebBundle(context.provider, parsed.data, {
-                signal,
-            });
-            return result.ok ? result.value : browserCliError(result.error);
+            return await finishAnalysisCommand(() => analyzeWebBundle(context.provider, parsed.data, { signal }), {
+                close: async () => {
+                    await context.provider.close?.();
+                },
+            }, context.provider.identity().id, "analyze_web_bundle", signal);
         })),
     });
 };
@@ -135,8 +141,11 @@ const registerObservationSession = (cli, logger) => {
             const parsed = observeWebSessionInputSchema.safeParse(input);
             if (!parsed.success)
                 return browserCliError(analysisInputErrorFromIssues("observe_web_session", parsed.error.issues, input));
-            const result = await observeWebSession(context.provider, parsed.data, { signal });
-            return result.ok ? result.value : browserCliError(result.error);
+            return await finishAnalysisCommand(() => observeWebSession(context.provider, parsed.data, { signal }), {
+                close: async () => {
+                    await context.provider.close?.();
+                },
+            }, context.provider.identity().id, "observe_web_session", signal);
         })),
     });
 };

package/dist/cli/captureCommands.js

@@ -1,12 +1,12 @@
 import { inspectPacketFieldsInputSchema } from "../domain/captures/packetFields.js";
 import { z } from "incur";
-import { resolve } from "node:path";
 import { createPacketCaptureService } from "../composition/captures.js";
 import { packetCaptureOptionsSchema, packetCaptureSelectorBudgetIssue, withinPacketCaptureSelectorBudget, } from "../domain/captures/packetCapture.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 registerCaptureCommands = (cli, logger, environment, service = createPacketCaptureService(environment)) => {
     cli.command(CLI_COMMANDS.inspectPacketFields, {
         description: "Search installed TShark protocol and field definitions",
@@ -33,7 +33,7 @@ export const registerCaptureCommands = (cli, logger, environment, service = crea
                     message: "all and limit are mutually exclusive",
                 });
         }),
-        run: ({ options: { all, ...options } }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.inspectPacketFields, async () => finishAnalysisCommand(() => service.inspectFields({ ...options, ...(all ? { limit: null } : {}) }, { signal }), service, "tshark-capture", "inspect_packet_fields"))),
+        run: ({ options: { all, ...options } }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.inspectPacketFields, async () => finishAnalysisCommand(() => service.inspectFields({ ...options, ...(all ? { limit: null } : {}) }, { signal }), service, "tshark-capture", "inspect_packet_fields", signal))),
     });
     cli.command(CLI_COMMANDS.inspectPacketCapture, {
         description: "Inspect an existing packet capture with caller-supplied TShark",
@@ -65,8 +65,8 @@ export const registerCaptureCommands = (cli, logger, environment, service = crea
             return finishAnalysisCommand(() => service.inspect({
                 ...options,
                 ...(all_matches ? { match_limit: null } : {}),
-                path: resolve(args.path),
-            }, { signal }), service, "tshark-capture", "inspect_packet_capture");
+                path: absoluteCallerPath(args.path),
+            }, { signal }), service, "tshark-capture", "inspect_packet_capture", signal);
         })),
     });
 };

package/dist/cli/cliResultOutput.js

@@ -2,7 +2,7 @@ import { constants } from "node:buffer";
 import { Cli, Filter, Formatter } from "incur";
 import { estimateTokenCount, sliceByTokens } from "tokenx";
 import { parseCliOutputArguments, validateCliOutputArguments, } from "../cliOutput.js";
-import { cliOperationFailurePayload } from "../cliLogging.js";
+import { cliOperationFailureIdentity, cliOperationFailurePayload, } from "../cliLogging.js";
 import { AnalysisResourceConstraintError } from "../domain/analysisErrorCore.js";
 import { projectAnalysisError, } from "../domain/analysisErrorProjection.js";
 import { jsonOutputParts, writeJsonOutput, writeOutputText, } from "./jsonOutput.js";
@@ -64,6 +64,64 @@ export const createCliResultOutput = (arguments_, destination) => {
     let handled = false;
     let failed = false;
     let error;
+    let completed;
+    const recoverFormattingFailure = async (cause) => {
+        // A rejected command never reaches write(). Destination failures retain
+        // handled ownership. Only a completed, unwritten result can be replaced.
+        if (completed === undefined ||
+            handled ||
+            !(cause instanceof RangeError) ||
+            cause.message !== "Invalid string length")
+            return false;
+        const { originalFailure } = completed;
+        error = projectAnalysisError(new AnalysisResourceConstraintError(completed.metadata.command, "memory", `The ${format} result could not fit in a runtime string. The original result was not written.`, {
+            format,
+            formatted_characters: null,
+            max_string_characters: constants.MAX_STRING_LENGTH,
+            ...(originalFailure === undefined
+                ? {}
+                : { original_failure: originalFailure }),
+        }, {
+            cause,
+            retryable: false,
+            remediationAction: "Use --format json to stream the complete result, or narrow it with --filter-output. Token limits are applied after formatting and cannot avoid this constraint.",
+        }));
+        const document = options.fullOutput
+            ? {
+                ok: false,
+                error,
+                meta: {
+                    command: completed.metadata.command,
+                    duration: completed.metadata.duration,
+                },
+            }
+            : error;
+        // Recovery must remain actionable even when a token window/count was
+        // requested. Do not apply those controls to this small typed failure.
+        const text = Formatter.format(document, format);
+        handled = true;
+        try {
+            await writeOutputText(destination, `${text}\n`);
+        }
+        catch (writeFailure) {
+            failed = true;
+            throw writeFailure;
+        }
+        return true;
+    };
+    const write = async (value, metadata) => {
+        completed = undefined;
+        if (metadata.format !== format)
+            return false;
+        try {
+            return await writeResult(value, metadata);
+        }
+        catch (cause) {
+            if (await recoverFormattingFailure(cause))
+                return true;
+            throw cause;
+        }
+    };
     return {
         get handled() {
             return handled;
@@ -74,100 +132,112 @@ export const createCliResultOutput = (arguments_, destination) => {
         get error() {
             return error;
         },
-        async write(value, metadata) {
-            if (metadata.format !== format)
-                return false;
-            const failure = options.fullOutput
-                ? cliOperationFailurePayload(value)
-                : undefined;
-            const filtered = options.filterOutput
-                ? Filter.apply(value, Filter.parse(options.filterOutput))
-                : value;
-            // Leave successful YAML and bare YAML rendering to Incur. The custom
-            // boundary is needed only for a full failure envelope, whose error
-            // sentinel otherwise drops category, remediation, and details.
-            if (format !== "json" && format !== "jsonl" && failure === undefined)
-                return false;
-            if (options.tokenCount) {
-                // Incur/tokenx materialize JSON. Measure its UTF-16 expansion before
-                // allowing that allocation, independently of UTF-8 bytes. Other formats
-                // retain Incur's materializing behavior.
-                const tokenValue = failure ?? filtered;
-                let characters = 0;
-                if (tokenValue !== undefined &&
-                    tokenValue !== null &&
-                    typeof tokenValue !== "function" &&
-                    typeof tokenValue !== "symbol") {
-                    if (format === "json" || format === "jsonl") {
-                        for (const part of jsonOutputParts(tokenValue, format, format === "json"))
-                            characters += part.length;
-                        characters = Math.max(0, characters - 1);
-                    }
-                }
-                if (characters <= constants.MAX_STRING_LENGTH) {
-                    if (failure === undefined)
-                        return false;
-                    handled = true;
-                    try {
-                        await writeOutputText(destination, `${estimateTokenCount(Formatter.format(failure, format))}\n`);
-                        return true;
-                    }
-                    catch (cause) {
-                        failed = true;
-                        throw cause;
-                    }
+        write,
+        recoverFormattingFailure,
+    };
+    async function writeResult(value, metadata) {
+        const failure = options.fullOutput
+            ? cliOperationFailurePayload(value)
+            : undefined;
+        completed = {
+            metadata,
+            originalFailure: cliOperationFailureIdentity(value),
+        };
+        const filterPaths = options.filterOutput
+            ? Filter.parse(options.filterOutput)
+            : undefined;
+        const filtered = filterPaths === undefined ? value : Filter.apply(value, filterPaths);
+        if (filterPaths !== undefined &&
+            filterPaths.length > 0 &&
+            (format === "json" || format === "jsonl") &&
+            Array.isArray(filtered))
+            normalizeFilteredJsonArrays(filtered);
+        // Leave successful YAML and bare YAML rendering to Incur. The custom
+        // boundary is needed only for a full failure envelope, whose error
+        // sentinel otherwise drops category, remediation, and details.
+        if (format !== "json" && format !== "jsonl" && failure === undefined)
+            return false;
+        if (options.tokenCount) {
+            // Incur/tokenx materialize JSON. Measure its UTF-16 expansion before
+            // allowing that allocation, independently of UTF-8 bytes. Other formats
+            // retain Incur's materializing behavior.
+            const tokenValue = failure ?? filtered;
+            let characters = 0;
+            if (tokenValue !== undefined &&
+                tokenValue !== null &&
+                typeof tokenValue !== "function" &&
+                typeof tokenValue !== "symbol") {
+                if (format === "json" || format === "jsonl") {
+                    for (const part of jsonOutputParts(tokenValue, format, format === "json"))
+                        characters += part.length;
+                    characters = Math.max(0, characters - 1);
                 }
-                error = projectAnalysisError(new AnalysisResourceConstraintError(metadata.command, "memory", "Token counting requires a formatted string larger than the runtime permits.", {
-                    formatted_characters: characters,
-                    max_string_characters: constants.MAX_STRING_LENGTH,
-                }, {
-                    remediationAction: "Remove --token-count to stream the complete JSON result, or narrow it with --filter-output.",
-                }));
             }
-            const meta = {
-                command: metadata.command,
-                duration: metadata.duration,
-            };
-            const errorDocument = options.fullOutput && failure !== undefined
-                ? fullFailureEnvelope(failure, meta, format, options.tokenLimit, options.tokenOffset)
-                : undefined;
-            const document = options.fullOutput
-                ? failure !== undefined
-                    ? errorDocument
-                    : filtered === undefined
-                        ? { ok: true, meta }
-                        : { ok: true, data: filtered, meta }
-                : // A selected null is a value; only a selection with no JSON value
-                    // falls back to the empty document.
-                    filtered === undefined ||
-                        typeof filtered === "function" ||
-                        typeof filtered === "symbol"
-                        ? {}
-                        : filtered;
-            // Once writing starts, a failed destination must not receive a second
-            // document from Incur's error formatter.
-            handled = true;
-            try {
-                if (failure !== undefined && format !== "json" && format !== "jsonl") {
-                    // Incur's error sentinel only carries code/message/retryable. Render
-                    // the full caller-visible failure at this output boundary.
-                    await writeOutputText(destination, `${Formatter.format(document, format)}\n`);
+            if (characters <= constants.MAX_STRING_LENGTH) {
+                const count = estimateTokenCount(Formatter.format(tokenValue, format));
+                handled = true;
+                try {
+                    await writeOutputText(destination, `${count}\n`);
+                    return true;
                 }
-                else {
-                    await writeJsonOutput(error === undefined
-                        ? document
-                        : options.fullOutput
-                            ? { ok: false, error, meta }
-                            : error, destination, format);
+                catch (cause) {
+                    failed = true;
+                    throw cause;
                 }
             }
-            catch (cause) {
-                failed = true;
-                throw cause;
+            error = projectAnalysisError(new AnalysisResourceConstraintError(metadata.command, "memory", "Token counting requires a formatted string larger than the runtime permits.", {
+                formatted_characters: characters,
+                max_string_characters: constants.MAX_STRING_LENGTH,
+            }, {
+                remediationAction: "Remove --token-count to stream the complete JSON result, or narrow it with --filter-output.",
+            }));
+        }
+        const meta = {
+            command: metadata.command,
+            duration: metadata.duration,
+        };
+        const errorDocument = options.fullOutput && failure !== undefined
+            ? fullFailureEnvelope(failure, meta, format, options.tokenLimit, options.tokenOffset)
+            : undefined;
+        const document = options.fullOutput
+            ? failure !== undefined
+                ? errorDocument
+                : filtered === undefined
+                    ? { ok: true, meta }
+                    : { ok: true, data: filtered, meta }
+            : // A selected null is a value; only a selection with no JSON value
+                // falls back to the empty document.
+                filtered === undefined ||
+                    typeof filtered === "function" ||
+                    typeof filtered === "symbol"
+                    ? {}
+                    : filtered;
+        // Once writing starts, a failed destination must not receive a second
+        // document from Incur's error formatter.
+        const failureText = failure !== undefined && format !== "json" && format !== "jsonl"
+            ? Formatter.format(document, format)
+            : undefined;
+        handled = true;
+        try {
+            if (failureText !== undefined) {
+                // Incur's error sentinel only carries code/message/retryable. Render
+                // the full caller-visible failure at this output boundary.
+                await writeOutputText(destination, `${failureText}\n`);
             }
-            return true;
-        },
-    };
+            else {
+                await writeJsonOutput(error === undefined
+                    ? document
+                    : options.fullOutput
+                        ? { ok: false, error, meta }
+                        : error, destination, format);
+            }
+        }
+        catch (cause) {
+            failed = true;
+            throw cause;
+        }
+        return true;
+    }
 };
 const fullFailureEnvelope = (failure, meta, format, tokenLimit, tokenOffset) => {
     if (tokenLimit === undefined && tokenOffset === undefined)
@@ -186,3 +256,19 @@ const fullFailureEnvelope = (failure, meta, format, tokenLimit, tokenOffset) =>
         meta: { ...meta, ...(nextOffset === undefined ? {} : { nextOffset }) },
     };
 };
+/** Filter.apply owns these mapped arrays; an empty path list returns the source. */
+const normalizeFilteredJsonArrays = (selection) => {
+    const pending = [selection];
+    while (pending.length > 0) {
+        const array = pending.pop();
+        for (let index = 0; index < array.length; index += 1) {
+            const value = array[index];
+            if (value === undefined ||
+                typeof value === "function" ||
+                typeof value === "symbol")
+                array[index] = null;
+            else if (Array.isArray(value))
+                pending.push(value);
+        }
+    }
+};

package/dist/cli/coreBinaryCommands.js

@@ -1,6 +1,5 @@
 import { z } from "incur";
 import { stat } from "node:fs/promises";
-import { resolve } from "node:path";
 import { resolveCliAnalysisSelector } from "./analysisSelector.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
@@ -9,6 +8,7 @@ import { runCliJavaScriptApplicationAnalysis } from "./javascriptApplicationAnal
 import { withCommandCancellation } from "./commandCancellation.js";
 import { javascriptApplicationOptions } from "../cliObservationOptions.js";
 import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { absoluteCallerPath } from "../filesystem/callerPath.js";
 /** Register provider-neutral binary overview and procedure CLI commands. */
 export const registerCoreBinaryCommands = (cli, logger, runDirectAnalysis) => {
     registerOverviewCommands(cli, logger, runDirectAnalysis);
@@ -62,7 +62,7 @@ const registerOverviewCommands = (cli, logger, runDirectAnalysis) => {
             // code is not replaced by the logged failure status.
             if (await routesToJavaScriptAnalysis(args.path, options))
                 return withCommandCancellation((signal) => logCliCommand(logger, "analyze", () => runCliJavaScriptApplicationAnalysis({
-                    input_path: resolve(args.path),
+                    input_path: absoluteCallerPath(args.path),
                     integrity_policy: options.integrityPolicy ?? defaultIntegrityPolicy,
                     ...(options.sourcePath === undefined
                         ? {}
@@ -147,7 +147,8 @@ const isJavaScriptApplicationPath = async (path) => {
     const lower = path.toLowerCase();
     if (lower.endsWith(".asar"))
         return true;
-    if (lower.endsWith(".app"))
+    // `A.app/` and `A.app/.` name the same bundle as `A.app`.
+    if (lower.replace(/(?:\/\.?)+$/u, "").endsWith(".app"))
         return false;
     try {
         return (await stat(path)).isDirectory();