rea-agents 2.1.0 → 2.3.0

package/dist/application/SetupSkill.js

@@ -2,7 +2,15 @@ import { mkdir, readFile, rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import writeFileAtomic from "write-file-atomic";
 import { PRODUCT_IDENTITY } from "../identity.js";
-const skillDestination = (home, name) => join(home, ".agents/skills", name, "SKILL.md");
+const SKILL_FILES = [
+    "SKILL.md",
+    "references/native-and-artifacts.md",
+    "references/javascript-applications.md",
+    "references/runtime-observation.md",
+    "references/evidence-workflows.md",
+    "references/controlled-replay.md",
+];
+const skillRoot = (home) => join(home, ".agents/skills", PRODUCT_IDENTITY.skillName);
 const readOptionalText = async (path) => {
     try {
         return await readFile(path, "utf8");
@@ -13,62 +21,58 @@ const readOptionalText = async (path) => {
         throw cause;
     }
 };
-const canonicalSkillFiles = async (home) => ({
-    destination: skillDestination(home, PRODUCT_IDENTITY.skillName),
-    content: await readFile(new URL(`../../skills/${PRODUCT_IDENTITY.skillName}/SKILL.md`, import.meta.url), "utf8"),
-});
-/** Report whether setup would change the managed REA skill. */
+const canonicalSkillFiles = async (home) => Promise.all(SKILL_FILES.map(async (relativePath) => {
+    const destination = join(skillRoot(home), relativePath);
+    return {
+        destination,
+        content: await readFile(new URL(`../../skills/${PRODUCT_IDENTITY.skillName}/${relativePath}`, import.meta.url), "utf8"),
+        original: await readOptionalText(destination),
+    };
+}));
+/** Report whether setup would change any file in the managed REA skill bundle. */
 export const canonicalSkillNeedsInstall = async (home) => {
     try {
-        const { content, destination } = await canonicalSkillFiles(home);
-        return (await readOptionalText(destination)) !== content;
+        return (await canonicalSkillFiles(home)).some(({ content, original }) => original !== content);
     }
     catch {
         return true;
     }
 };
-/** Transactionally install or upgrade the versioned canonical REA skill. */
+const writeText = (path, content) => writeFileAtomic(path, content, { encoding: "utf8", mode: 0o600 });
+const restoreSkillFiles = async (changed) => {
+    for (const { destination, original } of [...changed].reverse()) {
+        if (original === undefined)
+            await rm(destination, { force: true });
+        else
+            await writeText(destination, original);
+    }
+};
+/** Transactionally install or upgrade the canonical REA skill and references. */
 export const installCanonicalSkill = async (home) => {
-    let destination = skillDestination(home, PRODUCT_IDENTITY.skillName);
-    let backup = `${destination}.rea.backup`;
-    let original;
-    let canonicalChanged = false;
+    let changed = [];
     try {
         const canonical = await canonicalSkillFiles(home);
-        destination = canonical.destination;
-        backup = `${destination}.rea.backup`;
-        const { content } = canonical;
-        original = await readOptionalText(destination);
-        if (original === content)
+        changed = canonical.filter(({ content, original }) => original !== content);
+        if (changed.length === 0)
             return "unchanged";
-        await mkdir(dirname(destination), { recursive: true });
-        if (original !== undefined && original !== content)
-            await writeFileAtomic(backup, original, {
-                encoding: "utf8",
-                mode: 0o600,
-            });
-        canonicalChanged = original !== content;
-        if (canonicalChanged)
-            await writeFileAtomic(destination, content, {
-                encoding: "utf8",
-                mode: 0o600,
-            });
-        if ((await readFile(destination, "utf8")) !== content)
-            throw new Error("skill readback mismatch");
+        for (const { destination, original } of changed) {
+            await mkdir(dirname(destination), { recursive: true });
+            if (original !== undefined)
+                await writeText(`${destination}.rea.backup`, original);
+        }
+        for (const { destination, content } of changed)
+            await writeText(destination, content);
+        for (const { destination, content } of changed)
+            if ((await readFile(destination, "utf8")) !== content)
+                throw new Error(`skill readback mismatch: ${destination}`);
         return "installed";
     }
     catch {
         try {
-            if (canonicalChanged && original === undefined)
-                await rm(destination, { force: true });
-            else if (canonicalChanged && original !== undefined)
-                await writeFileAtomic(destination, original, {
-                    encoding: "utf8",
-                    mode: 0o600,
-                });
+            await restoreSkillFiles(changed);
         }
         catch {
-            // The canonical backup remains beside the skill for operator recovery.
+            // Per-file backups remain beside changed files for operator recovery.
         }
         return "failed";
     }

package/dist/application/TerminalRenderer.js

@@ -77,8 +77,9 @@ export class TerminalRenderer {
             return;
         }
         this.#capturedBytes += bytes;
+        const sequence = this.#frames.length;
         this.#frames.push({
-            sequence: this.#frames.length,
+            sequence,
             at_ms: atMs,
             columns: this.#terminal.cols,
             rows: this.#terminal.rows,
@@ -88,5 +89,6 @@ export class TerminalRenderer {
             lines,
             serialized_state: serializedState,
         });
+        this.options.recordEvent?.("rendered_frames", sequence);
     }
 }

package/dist/application/Uninstall.js

@@ -128,7 +128,13 @@ const isOwnedRegistration = (value) => {
         args[0] === "mcp") ||
         (command === "npx" &&
             (JSON.stringify(args) ===
-                JSON.stringify(["-y", PRODUCT_IDENTITY.packageSpecifier, "mcp"]) ||
+                JSON.stringify([
+                    "-y",
+                    PRODUCT_IDENTITY.registrationPackageSpecifier,
+                    "mcp",
+                ]) ||
+                JSON.stringify(args) ===
+                    JSON.stringify(["-y", PRODUCT_IDENTITY.packageSpecifier, "mcp"]) ||
                 JSON.stringify(args) ===
                     JSON.stringify(["-y", PRODUCT_IDENTITY.packageName, "mcp"]))));
 };

package/dist/application/Upgrade.js

@@ -9,6 +9,7 @@ import { PRODUCT_IDENTITY } from "../identity.js";
 const execFileAsync = promisify(execFile);
 const registryResponseSchema = z.object({ version: z.string().min(1) });
 const UPGRADE_COMMAND = "npm install --global rea-agents@latest";
+const CLI_SCRIPT_PATH = fileURLToPath(new URL("../../scripts/rea.mjs", import.meta.url));
 /** Check the npm registry and update the same global REA installation. */
 export const runUpgrade = async (currentVersion, host = systemUpgradeHost(), output = "human") => {
     const latestVersion = await host.latestVersion();
@@ -46,6 +47,12 @@ export const runUpgrade = async (currentVersion, host = systemUpgradeHost(), out
             reason: "install",
             remediation: `REA could not update through npm. Check npm registry access and global install permissions, then run: ${UPGRADE_COMMAND}`,
         };
+    const integrationSyncResult = await host.syncAgentIntegration(output);
+    const integrationSync = integrationSyncResult === undefined
+        ? "deferred"
+        : integrationSyncResult
+            ? "setup_invoked"
+            : "failed";
     return {
         status: "upgraded",
         previousVersion: currentVersion,
@@ -53,8 +60,11 @@ export const runUpgrade = async (currentVersion, host = systemUpgradeHost(), out
         versionCheck: "available",
         installMethod: "npm",
         command: UPGRADE_COMMAND,
+        integrationSync,
         clientRestartRequired: true,
-        remediation: "Rerun rea setup to refresh registrations and the skill, then restart clients that may retain an older MCP server.",
+        remediation: integrationSync === "setup_invoked"
+            ? "The updated setup journey was opened to align registrations and the skill. Restart clients whose approved registration changed."
+            : "Run rea setup --all-detected to align registrations and the skill, then restart clients that may retain an older MCP server.",
     };
 };
 /** Create the npm registry and subprocess effects for a production upgrade. */
@@ -79,6 +89,11 @@ export const systemUpgradeHost = () => ({
         prefix,
         `${PRODUCT_IDENTITY.packageName}@latest`,
     ], output),
+    syncAgentIntegration: (output) => output === "structured" ||
+        process.stdin.isTTY !== true ||
+        process.stderr.isTTY !== true
+        ? Promise.resolve(undefined)
+        : runCommand(process.execPath, [CLI_SCRIPT_PATH, "setup", "--all-detected"], "human"),
 });
 const systemNpmInstallationHost = {
     canonicalPath: realpath,

package/dist/browser/CdpEndpoint.js

@@ -40,25 +40,58 @@ export const discoverCdpEndpoint = async (endpoint, operation, signal) => {
         targets: targets.map((target) => ({
             id: target.id,
             type: target.type,
-            title: sanitizeTargetTitle(target.title),
+            title: sanitizeTargetTitle(target.title, target.url),
             url: target.url,
             attached: target.attached,
             ...targetWebSocket(endpoint, target, operation),
         })),
     };
 };
-const sanitizeTargetTitle = (value) => {
+const sanitizeTargetTitle = (value, targetUrl) => {
     let url;
     try {
         url = new URL(value);
     }
     catch {
-        return value;
+        return sanitizeTargetUrlAlias(value, targetUrl);
     }
     return url.protocol === "http:" || url.protocol === "https:"
         ? sanitizeBrowserUrl(value).url.slice(0, 16_384)
-        : value;
+        : sanitizeTargetUrlAlias(value, targetUrl);
+};
+const sanitizeTargetUrlAlias = (value, targetUrl) => {
+    let parsed;
+    try {
+        parsed = new URL(targetUrl);
+    }
+    catch {
+        return value;
+    }
+    const markers = [parsed.origin, `//${parsed.host}`, parsed.host];
+    if (parsed.pathname !== "/")
+        markers.push(parsed.pathname);
+    const candidatePattern = new RegExp(`(?:${markers.map(escapeRegExp).join("|")})[^\\s<>"']*`, "gu");
+    return value
+        .replace(candidatePattern, (candidate) => sanitizeSameOriginTitleUrl(candidate, parsed))
+        .slice(0, 16_384);
+};
+const sanitizeSameOriginTitleUrl = (candidate, target) => {
+    let parsed;
+    try {
+        parsed = candidate.startsWith("//")
+            ? new URL(`${target.protocol}${candidate}`)
+            : candidate.startsWith(target.host)
+                ? new URL(`${target.protocol}//${candidate}`)
+                : new URL(candidate, target.origin);
+    }
+    catch {
+        return candidate;
+    }
+    return parsed.origin === target.origin && parsed.search !== ""
+        ? sanitizeBrowserUrl(parsed.href).url
+        : candidate;
 };
+const escapeRegExp = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 /** Select a browser attachment socket or a direct socket for one page target. */
 export const cdpTargetWebSocket = (discovery, target, operation) => {
     const webSocket = availableCdpTargetWebSocket(discovery, target);

package/dist/catalogIdentity.js

@@ -26,11 +26,13 @@ const promptCatalog = PROMPT_CONTRACTS.map((contract) => ({
     arguments: contract.arguments,
     steps: contract.steps,
 })).sort((left, right) => left.name.localeCompare(right.name));
-const resourceCatalog = [
+/** Canonical fixed resources exposed by every target-free MCP session. */
+export const MCP_RESOURCE_CATALOG = [
     { name: "server-identity", uri: "rea://server/identity" },
     { name: "active-residual-unknowns", uri: "rea://unknowns/active" },
 ];
-const resourceTemplateCatalog = [
+/** Canonical resource templates exposed by every target-free MCP session. */
+export const MCP_RESOURCE_TEMPLATE_CATALOG = [
     { name: "session-evidence", uri_template: "rea://evidence/{evidenceId}" },
     {
         name: "evidence-section",
@@ -57,6 +59,10 @@ const resourceTemplateCatalog = [
         name: "reconstruction-coverage-revision",
         uri_template: "rea://reconstruction-coverage/{workspaceId}/revision/{revision}",
     },
+    {
+        name: "javascript-application-graph-page",
+        uri_template: "rea://evidence/{evidenceId}/application-graph/{collection}/offset/{offset}/limit/{limit}",
+    },
 ];
 const digest = (value) => {
     const encoded = canonicalize(value);
@@ -70,19 +76,22 @@ export const CATALOG_IDENTITY = {
         cli_commands: CLI_COMMAND_NAMES.length,
         mcp_tools: toolCatalog.length,
         mcp_prompts: promptCatalog.length,
-        mcp_resources: resourceCatalog.length,
-        mcp_resource_templates: resourceTemplateCatalog.length,
+        mcp_resources: MCP_RESOURCE_CATALOG.length,
+        mcp_resource_templates: MCP_RESOURCE_TEMPLATE_CATALOG.length,
     },
     digests: {
         tools_sha256: digest(toolCatalog),
         prompts_sha256: digest(promptCatalog),
-        resources_sha256: digest({ resourceCatalog, resourceTemplateCatalog }),
+        resources_sha256: digest({
+            resourceCatalog: MCP_RESOURCE_CATALOG,
+            resourceTemplateCatalog: MCP_RESOURCE_TEMPLATE_CATALOG,
+        }),
         combined_sha256: digest({
             cli: CLI_COMMAND_NAMES,
             tools: toolCatalog,
             prompts: promptCatalog,
-            resources: resourceCatalog,
-            resource_templates: resourceTemplateCatalog,
+            resources: MCP_RESOURCE_CATALOG,
+            resource_templates: MCP_RESOURCE_TEMPLATE_CATALOG,
         }),
     },
     tools: toolCatalog.map(({ name, surface, effects, annotations }) => ({

package/dist/cli/coreAnalysisCommands.js

@@ -1,8 +1,11 @@
 import { z } from "incur";
+import { stat } from "node:fs/promises";
+import { resolve } from "node:path";
 import { runDirectAnalysis } from "../application/DirectAnalysis.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
 import { directAnalysisOptions, providerSelectionOption } from "./options.js";
+import { runCliJavaScriptApplicationAnalysis } from "./javascriptApplicationAnalysis.js";
 export const registerCoreAnalysisCommands = (cli, logger) => {
     registerCoreCommands(cli, logger);
     registerFunctionCommand(cli, logger);
@@ -30,13 +33,19 @@ const registerCoreCommands = (cli, logger) => {
             .describe("Load and update a local analysis snapshot"),
         provider: providerSelectionOption,
     });
+    const analyzeOptions = overviewOptions.extend({
+        approved: z
+            .boolean()
+            .default(false)
+            .describe("Approve static analysis when the path is a JavaScript directory or ASAR"),
+    });
     cli.command(CLI_COMMANDS.analyze, {
         description: "Get an overview of an app",
         args: z.object({
             path: z.string().describe("App, program, or analysis database path"),
         }),
-        options: overviewOptions,
-        run: ({ args, options }) => logCliCommand(logger, "analyze", () => runDirectAnalysis(args.path, "binary_overview", { detail: options.detail, limit: options.limit }, directAnalysisOptions(logger, options.snapshot, options.provider))),
+        options: analyzeOptions,
+        run: ({ args, options }) => logCliCommand(logger, "analyze", () => runRoutedOverview(args.path, options, logger)),
     });
     cli.command(CLI_COMMANDS.inspect, {
         description: "Inspect an app overview with evidence",
@@ -63,6 +72,29 @@ const registerCoreCommands = (cli, logger) => {
         run: ({ args, options }) => logCliCommand(logger, "decompile", () => runDirectAnalysis(args.path, "procedure_pseudo_code", { procedure: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider))),
     });
 };
+const runRoutedOverview = async (path, options, logger) => {
+    if (options.provider === undefined &&
+        options.snapshot === undefined &&
+        (await isJavaScriptApplicationPath(path)))
+        return runCliJavaScriptApplicationAnalysis({
+            input_path: resolve(path),
+            approved: options.approved,
+        });
+    return runDirectAnalysis(path, "binary_overview", { detail: options.detail, limit: options.limit }, directAnalysisOptions(logger, options.snapshot, options.provider));
+};
+const isJavaScriptApplicationPath = async (path) => {
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".asar"))
+        return true;
+    if (lower.endsWith(".app"))
+        return false;
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
 const registerXrefsCommand = (cli, logger) => {
     cli.command(CLI_COMMANDS.xrefs, {
         description: "List bounded references to an analyzed address",

package/dist/cli/javascriptApplicationAnalysis.js

@@ -0,0 +1,19 @@
+import { analyzeJavaScriptApplication } from "../application/JavaScriptApplicationService.js";
+import { loadConfiguredPermissionAuthority } from "../application/PermissionConfiguration.js";
+import { parseConfig } from "../config.js";
+import { projectAnalysisError } from "../domain/errors.js";
+/** Execute the shared one-shot CLI boundary for static JavaScript analysis. */
+export const runCliJavaScriptApplicationAnalysis = async (input) => {
+    const config = parseConfig(process.env);
+    if (!config.ok)
+        return cliError(config.error);
+    const authority = await loadConfiguredPermissionAuthority(config.value);
+    if (!authority.ok)
+        return cliError(authority.error);
+    const result = await analyzeJavaScriptApplication(authority.value, input);
+    return result.ok ? result.value : cliError(result.error);
+};
+const cliError = (error) => ({
+    error: "JavaScript application analysis failed",
+    ...projectAnalysisError(error),
+});

package/dist/cli/setupCommands.js

@@ -1,6 +1,6 @@
 import { z } from "incur";
-import { runDoctor } from "../application/Doctor.js";
-import { runSetup, systemSetupHost } from "../application/Setup.js";
+import { DOCTOR_PROVIDER_IDS, runDoctor, } from "../application/Doctor.js";
+import { runSetup, systemSetupHost, } from "../application/Setup.js";
 import { runUninstall } from "../application/Uninstall.js";
 import { runUpgrade, systemUpgradeHost } from "../application/Upgrade.js";
 import { conciseSetupResult, confirmInteractiveSetup, renderInteractiveSetupResult, renderSetupProgress, } from "../cliSetup.js";
@@ -8,7 +8,19 @@ import { PRODUCT_IDENTITY } from "../identity.js";
 import { logCliCommand } from "../cliLogging.js";
 import { createSystemDoctorHost } from "../doctorRuntime.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { SUPPORTED_CLIENT_DEFINITIONS } from "../application/SupportedClients.js";
+import { projectDoctorReport } from "../application/DoctorProjection.js";
+const supportedClientIds = SUPPORTED_CLIENT_DEFINITIONS.map(({ name }) => name);
+const supportedClientSchema = z
+    .string()
+    .refine((candidate) => supportedClientIds.some((name) => name === candidate), "Unsupported agent integration");
+/** Register setup, doctor, uninstall, and upgrade CLI commands. */
 export const registerSetupCommands = (cli, logger) => {
+    registerSetupCommand(cli, logger);
+    registerDoctorCommand(cli, logger);
+    registerMaintenanceCommands(cli, logger);
+};
+const registerSetupCommand = (cli, logger) => {
     cli.command(CLI_COMMANDS.setup, {
         description: "Install requirements and configure agents",
         outputPolicy: "agent-only",
@@ -22,14 +34,7 @@ export const registerSetupCommands = (cli, logger) => {
                 .default(false)
                 .describe("Also approve Hopper installation with --yes"),
             client: z
-                .array(z.enum([
-                "claude_code",
-                "claude_desktop",
-                "codex",
-                "cursor",
-                "gemini_cli",
-                "windsurf",
-            ]))
+                .array(supportedClientSchema)
                 .default([])
                 .describe("Agent integration to configure; repeat for multiple agents"),
             allDetected: z
@@ -39,7 +44,7 @@ export const registerSetupCommands = (cli, logger) => {
             skill: z
                 .boolean()
                 .optional()
-                .describe("Install or skip the bundled REA skill"),
+                .describe("Override the bundled skill included with agent integrations"),
             dryRun: z
                 .boolean()
                 .default(false)
@@ -48,17 +53,41 @@ export const registerSetupCommands = (cli, logger) => {
                 .boolean()
                 .default(false)
                 .describe("Use sequential accessible setup prompts"),
+            detail: z
+                .enum(["summary", "full"])
+                .default("summary")
+                .describe("Summary or complete setup and doctor diagnostics"),
         }),
         alias: { yes: "y" },
-        run: ({ options, formatExplicit, agent }) => logCliCommand(logger, "setup", () => runSetupCommand({ options, formatExplicit, agent })),
+        run: ({ options, formatExplicit }) => logCliCommand(logger, "setup", () => runSetupCommand({ options, formatExplicit })),
     });
+};
+const registerDoctorCommand = (cli, logger) => {
     cli.command(CLI_COMMANDS.doctor, {
         description: "Check whether REA is ready",
         options: z.object({
             target: z.string().optional().describe("Optional app path to check"),
+            client: z
+                .array(supportedClientSchema)
+                .default([])
+                .describe("Agent registration whose readiness is required; repeatable"),
+            provider: z
+                .array(z.enum(DOCTOR_PROVIDER_IDS))
+                .default([])
+                .describe("Deep-analysis provider whose readiness is required"),
+            skill: z
+                .boolean()
+                .optional()
+                .describe("Require the installed REA skill identity to be aligned"),
+            detail: z
+                .enum(["summary", "full"])
+                .default("summary")
+                .describe("Summary or complete doctor diagnostics"),
         }),
-        run: ({ options }) => logCliCommand(logger, "doctor", () => runDoctor(options.target, createSystemDoctorHost())),
+        run: ({ options }) => logCliCommand(logger, "doctor", () => runDoctor(options.target, createSystemDoctorHost(), doctorScope(options)).then((report) => projectDoctorReport(report, options.detail))),
     });
+};
+const registerMaintenanceCommands = (cli, logger) => {
     cli.command(CLI_COMMANDS.uninstall, {
         description: "Remove REA-owned agent configuration and skill files",
         options: z.object({
@@ -77,32 +106,57 @@ export const registerSetupCommands = (cli, logger) => {
 };
 const runSetupCommand = async (input) => {
     const { options } = input;
-    const interactive = !options.yes &&
-        !options.dryRun &&
-        !input.formatExplicit &&
-        process.stdin.isTTY === true &&
-        process.stderr.isTTY === true;
+    const interactive = setupIsInteractive(options, input.formatExplicit);
     const hasExplicitScope = setupHasExplicitScope(options);
     if (options.yes && !hasExplicitScope)
-        process.stderr.write("!  Implicit `rea setup --yes` scope is deprecated; use `--all-detected --skill` to retain it.\n");
-    const result = await runSetup({
+        process.stderr.write("!  Implicit `rea setup --yes` scope is deprecated; use `--all-detected` to retain it.\n");
+    const result = await runSetup(setupRunOptions(input, interactive, hasExplicitScope), systemSetupHost(createSystemDoctorHost()), interactive
+        ? (actions) => confirmInteractiveSetup(actions, options.accessible)
+        : undefined);
+    if (interactive)
+        renderInteractiveSetupResult(result);
+    return options.detail === "full" ? result : conciseSetupResult(result);
+};
+const setupRunOptions = (input, interactive, hasExplicitScope) => {
+    const { options } = input;
+    const agentIntegrationSelected = options.allDetected || options.client.length > 0;
+    const hasSelectedClients = hasExplicitScope && !options.allDetected;
+    return {
         approved: options.yes && !options.dryRun,
         installHopper: options.installHopper,
         structured: input.formatExplicit || options.dryRun,
         proposeHopper: !hasExplicitScope || options.installHopper,
-        ...(!hasExplicitScope || options.allDetected
-            ? {}
-            : { clientIds: options.client }),
-        ...(!hasExplicitScope ? {} : { installSkill: options.skill ?? false }),
+        ...(hasSelectedClients ? { clientIds: options.client } : {}),
+        ...(hasExplicitScope
+            ? { installSkill: options.skill ?? agentIntegrationSelected }
+            : {}),
         ...(interactive ? { onProgress: renderSetupProgress } : {}),
-    }, systemSetupHost(createSystemDoctorHost()), interactive
-        ? (actions) => confirmInteractiveSetup(actions, options.accessible)
-        : undefined);
-    if (interactive)
-        renderInteractiveSetupResult(result);
-    return input.formatExplicit ? result : conciseSetupResult(result);
+        ...(hasSelectedClients
+            ? {
+                readinessScope: {
+                    clients: options.client,
+                    providers: options.installHopper ? ["hopper"] : [],
+                    skill: options.skill ?? agentIntegrationSelected,
+                },
+            }
+            : {}),
+    };
 };
+const setupIsInteractive = (options, formatExplicit) => !options.yes &&
+    !options.dryRun &&
+    !formatExplicit &&
+    process.stdin.isTTY === true &&
+    process.stderr.isTTY === true;
 const setupHasExplicitScope = (options) => options.allDetected ||
     options.client.length > 0 ||
     options.skill !== undefined ||
     options.installHopper;
+const doctorScope = (options) => options.client.length === 0 &&
+    options.provider.length === 0 &&
+    options.skill === undefined
+    ? undefined
+    : {
+        clients: options.client,
+        providers: options.provider,
+        skill: options.skill === true,
+    };

package/dist/cli/utilityCommands.js

@@ -1,5 +1,5 @@
 import { z } from "incur";
-import { runProviderAnalysis, runSessionStatus, } from "../application/DirectAnalysis.js";
+import { runCapabilityStatus, runProviderAnalysis, runProviderStatus, } from "../application/DirectAnalysis.js";
 import { importReferenceSource } from "../application/ReferenceSourceImport.js";
 import { projectReferenceSourceImportError } from "../application/ReferenceSourceImportTypes.js";
 import { loadConfiguredPermissionAuthority } from "../application/PermissionConfiguration.js";
@@ -22,7 +22,15 @@ const registerCapabilityCommands = (cli, logger) => {
             description: command === "capabilities"
                 ? "List provider capabilities and side effects"
                 : "List configured analysis providers",
-            run: () => logCliCommand(logger, command, () => runSessionStatus(logger)),
+            options: z.object({
+                detail: z
+                    .enum(["summary", "full"])
+                    .default("summary")
+                    .describe("Summary or complete provider descriptors"),
+            }),
+            run: ({ options }) => logCliCommand(logger, command, () => command === CLI_COMMANDS.providers
+                ? runProviderStatus(logger, options.detail)
+                : runCapabilityStatus(logger, options.detail)),
         });
     }
 };