@counterfact-labs/cli 0.2.7 → 0.2.9

package/dist/cli/mcp.js

@@ -1,11 +1,15 @@
+import { folderPartsEnabled, skippedFilesEnabled } from "../analysis-core/settings.js";
+import { readSkippedFilesSetting, readFolderPartsSetting } from "../adapters/settings.js";
 import { createInterface } from "node:readline";
 import { once } from "node:events";
 import { resolveFolderPath } from "../adapters/folder-path.js";
-import { CliRefusalError, failureReason } from "../contract/cli-refusals.js";
+import { cliRefusals, CliRefusalError, failureReason } from "../contract/cli-refusals.js";
 import { mcpFailure } from "./mcp-failure.js";
+import { agentChoiceMessage } from "../contract/agent-choice.js";
 import { errorCode } from "./api.js";
 import { commandContext } from "./context.js";
 import { analyze } from "./commands/analyze.js";
+import { skipped } from "./commands/skipped.js";
 import { CLI_VERSION } from "../contract/cli-version.js";
 import { finding } from "./commands/finding.js";
 import { balance } from "./commands/balance.js";
@@ -19,10 +23,12 @@ import { suggestedEmail } from "./suggested-email.js";
 import { agentProposalInputSchema } from "../contract/agent-proposal.js";
 import { fixRequestTools, waitingFixes, waitingFixCount, claimFix, FIX_DISCOVERY_TIMEOUT_MS } from "./fix-requests.js";
 import { FINDING_PROJECT_MESSAGE, FindingReferences, numberedFindingInputSchema } from "./finding-lookup.js";
-import { findingDisplayRows, formatFindingNumber, formatWaitingFixes } from "./finding-display.js";
+import { formatFindingNumber, formatWaitingFixes, formatFindingActivity, presentSavedFindings, findingDetailReference, formatFindingContinuation } from "./finding-display.js";
+import { groupByActivity } from "../analysis-core/analysis/schemas.js";
 import { readFindingSettings } from "./finding-settings.js";
+import { sizeSkippedFiles } from "../analysis-core/analysis/code-agents/skipped-files.js";
 import { z } from "zod";
-import { readCliSettings, readSelectionSettings, selectionModeEnabled, scopeChoicesEnabled } from "../adapters/settings.js";
+import { fileScopeEnabled, readCliSettings, readSelectionSettings, selectionModeEnabled, scopeChoicesEnabled, multiEntryEnabled } from "../adapters/settings.js";
 import { resolveAnalysisSelection } from "./analysis-selection.js";
 import { analysisScopeSchema, chooseScopeMcpResultSchema } from "../contract/scope-choice.js";
 import { scopeChoiceRefusal } from "../contract/selection-offer.js";
@@ -34,7 +40,12 @@ const filePathDescription = "The agent folder or agent file on this computer, in
 const fileScopeDescription = "Optional: a scope returned by Counterfact, using the same snapshot and selected file. Include all imports, no imports, or the listed imports chosen by the user.";
 const fileProposalDescription = "Optional: the files you believe make up the agent, with each file's role. For a folder, paths are relative to that folder. For a file, paths are relative to the launch folder and must belong to the selected file's import scope.";
 const fileProposalPathDescription = "Paths are relative to the selected folder, or to the launch folder when selecting a file.";
-function fileAnalysisTool(choices) {
+const multiAnalysisDescription = "Analyze an agent folder, one agent file, or several agent files on this computer. Pass path for one folder or file, or paths for several files inside the launch folder. Counterfact includes each file's project imports and reads shared files once. Up to 5 agent files run as one analysis with one result list and one charge unless a free analysis is available. If the selection is too large or has more than 5 agent files, Counterfact returns scope choices. Call only when the user asks for an analysis. A free first analysis needs no top-up. After edits, suggest an analysis and wait for the user to ask.";
+const multiPathsDescription = "Optional: several agent file paths inside the launch folder, analyzed together. Use either path or paths. Folders cannot be mixed into paths.";
+const partChoiceDescription = " If parts are returned, ask the user to choose one, then call analyze_agent again with that part's files as scope.";
+const partScopeSchema = { type: "array", items: { type: "string" }, minItems: 1,
+    description: "The files in the part the user chose. Ask the user to pick a returned part before supplying scope." };
+function fileAnalysisTool(choices, parts, multiple) {
     const proposal = structuredClone(agentProposalInputSchema);
     if (typeof proposal.properties?.files === "object" && proposal.properties.files && "items" in proposal.properties.files) {
         const files = proposal.properties.files.items;
@@ -43,11 +54,16 @@ function fileAnalysisTool(choices) {
     }
     const scope = z.toJSONSchema(analysisScopeSchema);
     delete scope.$schema;
+    if (!multiple && scope.properties)
+        delete scope.properties.entries;
+    const scopeSchema = parts && choices ? { anyOf: [scope, partScopeSchema] } : parts ? partScopeSchema : scope;
     return { name: ANALYZE_TOOL_NAME,
-        description: [fileAnalysisDescription, ...(choices ? [scopeChoiceDescription] : []), fileAnalysisEnding].join(" "),
+        description: [multiple ? multiAnalysisDescription : fileAnalysisDescription, ...(choices ? [scopeChoiceDescription] : []), fileAnalysisEnding].join(" ") + (parts ? partChoiceDescription : ""),
         inputSchema: { type: "object", properties: { path: { type: "string", description: filePathDescription },
-                proposal: { ...proposal, description: fileProposalDescription }, ...(choices ? { scope: { ...scope, description: fileScopeDescription } } : {}) },
-            required: ["path"], additionalProperties: false } };
+                ...(multiple ? { paths: { type: "array", items: { type: "string" }, minItems: 1, description: multiPathsDescription } } : {}),
+                proposal: { ...proposal, description: fileProposalDescription }, ...(choices || parts ? { scope: { ...scopeSchema, description: choices && parts
+                            ? `${fileScopeDescription} ${partScopeSchema.description}` : parts ? partScopeSchema.description : fileScopeDescription } } : {}) },
+            ...(multiple ? {} : { required: ["path"] }), additionalProperties: false } };
 }
 const legacyTools = [
     {
@@ -60,6 +76,12 @@ const legacyTools = [
     { name: "sign_in_status", description: "Check whether this computer is signed in to Counterfact, and whether the user has allowed the analysis tool in Claude Code. With wait: true, first wait for a sign-in started by sign_in to finish.", inputSchema: { type: "object", properties: { wait: { type: "boolean" } }, additionalProperties: false } },
     { name: "sign_in", description: "Open the Counterfact sign-in page in the user's browser. Then call sign_in_status with wait: true.", inputSchema: { type: "object", properties: {}, additionalProperties: false } },
 ];
+const skippedTool = {
+    name: "analyze_skipped_files",
+    description: "Handle files skipped by the saved analysis of a local folder. Use action files to list their names, or plan to find the fewest analyses that fit, including imported files. Tell the user that count before starting. Use action analyze only after the user accepts the offer to analyze the skipped files. Findings are added to the same results.",
+    inputSchema: { type: "object", properties: { path: { type: "string", description: "The original agent folder on this computer." },
+            action: { type: "string", enum: ["files", "plan", "analyze"] } }, required: ["path", "action"], additionalProperties: false },
+};
 class ProtocolError extends Error {
     code;
     constructor(code, message) {
@@ -67,6 +89,7 @@ class ProtocolError extends Error {
         this.code = code;
     }
 }
+const MAX_ANALYSIS_FINDING_HISTORY = 5;
 function object(value) { return value !== null && typeof value === "object" && !Array.isArray(value); }
 export async function serveMcp(input, output, options = {}) {
     const audienceChoice = (options.env ?? process.env).CF_FINDING_AUDIENCE;
@@ -75,13 +98,21 @@ export async function serveMcp(input, output, options = {}) {
     const failureReasons = (options.env ?? process.env).CF_MCP_FAILURE_REASONS !== "0";
     const launch = guarded ? resolveFolderPath(cwd).catch(() => null) : Promise.resolve(cwd);
     const lastAnalysis = new Map();
-    const findingSettings = readFindingSettings(options.env);
-    const analysisSwitches = readSelectionSettings(options.startup?.settings ?? options.env ?? process.env);
+    const startupSettings = options.startup?.settings ?? options.env ?? process.env;
+    const skippedSettings = Object.freeze({ CF_SKIPPED_FILES: readSkippedFilesSetting(startupSettings.CF_SKIPPED_FILES) });
+    const skippedEnabled = skippedFilesEnabled(skippedSettings);
+    const partSettings = Object.freeze({ CF_FOLDER_PARTS: readFolderPartsSetting(startupSettings.CF_FOLDER_PARTS) });
+    const scopeEnabled = folderPartsEnabled({ ...skippedSettings, ...partSettings });
+    const findingSettings = options.findingSettings ?? readFindingSettings(options.env);
+    const notActiveFindings = new Map();
+    const analysisFindings = new Map();
+    const { numbersEnabled, fixesEnabled, agentReadableResults } = findingSettings;
+    const analysisSwitches = readSelectionSettings(startupSettings);
     const choicesEnabled = scopeChoicesEnabled(analysisSwitches);
     const selectionEnabled = selectionModeEnabled(analysisSwitches);
+    const multipleEnabled = multiEntryEnabled(analysisSwitches);
     const analysisEnv = selectionEnabled ? { ...(options.env ?? process.env), ...analysisSwitches } : undefined;
     let analysisStartup = options.startup;
-    const { numbersEnabled, fixesEnabled } = findingSettings;
     const references = new FindingReferences();
     const emailEnv = analysisEnv && Object.hasOwn(analysisEnv, "CF_EMAIL_SIGN_IN") ? analysisEnv : options.env;
     const emailSignIn = options.emailSignIn ?? readEmailSignIn(emailEnv);
@@ -110,9 +141,19 @@ export async function serveMcp(input, output, options = {}) {
                 }, required: ["email", "code"], additionalProperties: false },
         },
     ] : legacyTools;
-    const tools = signInTools.map(tool => tool.name === ANALYZE_TOOL_NAME && selectionEnabled ? fileAnalysisTool(choicesEnabled) : tool).map(tool => tool.name === "get_finding" && numbersEnabled ? {
-        ...tool, inputSchema: numberedFindingInputSchema,
-    } : tool).concat(fixesEnabled ? fixRequestTools : []);
+    const tools = [...signInTools.map(tool => {
+            if (tool.name === ANALYZE_TOOL_NAME) {
+                if (selectionEnabled)
+                    return fileAnalysisTool(choicesEnabled, scopeEnabled, multipleEnabled);
+                if (scopeEnabled)
+                    return { ...tool,
+                        description: tool.description + partChoiceDescription,
+                        inputSchema: { ...tool.inputSchema, properties: { ...tool.inputSchema.properties, scope: partScopeSchema } } };
+            }
+            return tool;
+        }).map(tool => tool.name === "get_finding" && numbersEnabled ? {
+            ...tool, inputSchema: numberedFindingInputSchema,
+        } : tool), ...(fixesEnabled ? fixRequestTools : []), ...(skippedEnabled ? [skippedTool] : [])];
     let pendingSignIn;
     let signInFailure;
     const requests = new Map();
@@ -125,14 +166,21 @@ export async function serveMcp(input, output, options = {}) {
         if (!object(args))
             throw new ProtocolError(-32602, "Tool arguments must be an object.");
         const name = params.name;
-        const allowed = name === ANALYZE_TOOL_NAME ? ["path", "proposal", ...(choicesEnabled ? ["scope"] : [])] : name === "get_finding" ? (numbersEnabled ? Object.keys(numberedFindingInputSchema.properties) : ["id"])
+        const allowed = name === "analyze_skipped_files" ? ["path", "action"] : name === ANALYZE_TOOL_NAME ? ["path", "proposal", ...(multipleEnabled ? ["paths"] : []), ...((scopeEnabled || choicesEnabled) ? ["scope"] : [])] : name === "get_finding" ? (numbersEnabled ? Object.keys(numberedFindingInputSchema.properties) : ["id"])
             : name === "claim_fix" ? ["id"]
                 : name === "sign_in_status" ? (emailSignIn ? ["wait", "path"] : ["wait"])
                     : emailSignIn && name === "sign_in" ? ["email"] : emailSignIn && name === "sign_in_with_code" ? ["email", "code"] : [];
         if (!tools.some(tool => tool.name === name) || Object.keys(args).some(key => !allowed.includes(key)))
             throw new ProtocolError(-32602, "Unknown tool or argument.");
-        if (name === ANALYZE_TOOL_NAME && (typeof args.path !== "string" || !args.path.trim()))
+        if (name === ANALYZE_TOOL_NAME && (args.paths === undefined
+            ? typeof args.path !== "string" || !args.path.trim()
+            : args.path !== undefined || !Array.isArray(args.paths) || !args.paths.length || args.paths.some(path => typeof path !== "string" || !path.trim()))) {
+            throw new ProtocolError(-32602, "Provide a path.");
+        }
+        if (name === "analyze_skipped_files" && (typeof args.path !== "string" || !args.path.trim()))
             throw new ProtocolError(-32602, "Provide a path.");
+        if (name === "analyze_skipped_files" && !["files", "plan", "analyze"].includes(args.action))
+            throw new ProtocolError(-32602, "Choose files, plan, or analyze.");
         if (name === "get_finding" && (typeof args.id !== "string" || !args.id.trim()))
             throw new ProtocolError(-32602, "Provide a finding id.");
         if (name === "get_finding" && args.projectId !== undefined && (typeof args.projectId !== "string" || !args.projectId.trim()))
@@ -154,7 +202,12 @@ export async function serveMcp(input, output, options = {}) {
         let scopeChoice;
         let findingIds;
         let findings, projectId;
+        let skippedFilesCount;
+        let topFindingIds;
+        let notActiveCount, analysisId;
+        let nextFinding;
         let loadedFinding;
+        let notActiveHint = "";
         let fixRequests, claimed;
         let waitingCount;
         let url, analysisFolder;
@@ -165,7 +218,7 @@ export async function serveMcp(input, output, options = {}) {
             if (selectionEnabled)
                 analysisStartup ??= readCliSettings(analysisEnv, emailSignIn);
             const analysisSettings = analysisStartup?.settings ?? {};
-            const ctx = commandContext({ ...options, ...(analysisStartup ? { startup: analysisStartup } : {}), env: { ...(analysisEnv ?? options.env ?? process.env), ...analysisSwitches, CF_FINDING_AUDIENCE: audienceChoice },
+            const ctx = commandContext({ ...options, ...(analysisStartup ? { startup: analysisStartup } : {}), env: { ...(analysisEnv ?? options.env ?? process.env), ...analysisSwitches, ...skippedSettings, ...partSettings, CF_FINDING_AUDIENCE: audienceChoice },
                 onCheckFailure: failure => { reason = failure.reason; options.onCheckFailure?.(failure); },
                 emailSignIn, findingSettings, signal, onCheckStart: () => {
                     started = true;
@@ -179,9 +232,30 @@ export async function serveMcp(input, output, options = {}) {
                     options.onScopeChoice?.(choice);
                 }, onAgentChoice: choice => { agentChoice = choice; options.onAgentChoice?.(choice); }, onCheckComplete: result => {
                     findingIds = result.findingIds ?? [];
+                    topFindingIds = result.topFindingIds;
+                    if (skippedEnabled && result.skippedFiles)
+                        skippedFilesCount = sizeSkippedFiles(result.skippedFiles).length;
+                    const groups = groupByActivity(result.findings ?? [], result.notActiveEnabled);
+                    notActiveFindings.set(result.projectId, groups.notActive);
+                    if (groups.notActive.length) {
+                        notActiveCount = groups.notActive.length;
+                        analysisId = result.analysisId;
+                        const ids = groups.notActive.map(finding => numbersEnabled && finding.seq !== undefined ? formatFindingNumber(finding.seq) : finding.id);
+                        notActiveHint = `Not active details: use get_finding for ${ids.join(", ")}.\n`;
+                    }
                     if (numbersEnabled) {
-                        findings = findingDisplayRows(result.findings ?? [], { numbersEnabled,
-                            audienceEnabled: result.audienceEnabled, labels: "reference" }).map(row => row.finding);
+                        const displayed = presentSavedFindings(result, { numbersEnabled, agentReadableResults,
+                            audienceEnabled: result.audienceEnabled, notActiveEnabled: result.notActiveEnabled, projectId: result.projectId, surface: "mcp" });
+                        findings = displayed.findings;
+                        findingIds = displayed.findingIds;
+                        nextFinding = displayed.nextFinding;
+                        if (agentReadableResults && result.analysisId !== undefined) {
+                            analysisFindings.delete(result.analysisId);
+                            analysisFindings.set(result.analysisId, { projectId: result.projectId, findings: displayed.orderedReferences });
+                            // Older details remain available from the console without keeping every chain in memory.
+                            if (analysisFindings.size > MAX_ANALYSIS_FINDING_HISTORY)
+                                analysisFindings.delete(analysisFindings.keys().next().value);
+                        }
                         projectId = result.projectId;
                         references.remember(result.projectId);
                     }
@@ -205,9 +279,23 @@ export async function serveMcp(input, output, options = {}) {
             else if (name === "get_finding") {
                 const project = numbersEnabled ? await references.resolve(args.id, args.projectId, fixesEnabled ? () => waitingFixes(ctx.api, { timeoutMs: FIX_DISCOVERY_TIMEOUT_MS }) : undefined) : undefined;
                 await finding(args.id, ctx, { projectId: project, numbers: numbersEnabled, onLoaded: value => {
-                        if (numbersEnabled)
-                            loadedFinding = { ...value, ...(value.seq !== undefined ? { number: formatFindingNumber(value.seq) } : {}) };
+                        // Older consoles retain the finding and fixes but may not store its activity yet.
+                        const activity = [...notActiveFindings.values()].flat().find(saved => saved.id === value.id)?.activity;
+                        if (activity)
+                            ctx.write(formatFindingActivity(activity));
+                        if (numbersEnabled || activity)
+                            loadedFinding = { ...value, ...(activity ? { activity } : {}),
+                                ...(numbersEnabled && value.seq !== undefined ? { number: formatFindingNumber(value.seq) } : {}) };
+                        if (agentReadableResults && numbersEnabled) {
+                            for (const { projectId, findings } of analysisFindings.values()) {
+                                const index = findings.findIndex(item => item.id === value.id);
+                                if (index >= 0 && findings[index + 1])
+                                    nextFinding = findingDetailReference(findings[index + 1], projectId);
+                            }
+                        }
                     } });
+                if (nextFinding)
+                    text += formatFindingContinuation(nextFinding);
             }
             else if (name === "get_balance")
                 await balance(ctx, { onLoaded: value => { freeAnalysisAvailable = value.freeAnalysisAvailable; } });
@@ -252,7 +340,7 @@ export async function serveMcp(input, output, options = {}) {
                 const failure = signInFailure;
                 signInFailure = undefined;
                 if (failure && !signIn.signedIn) {
-                    const shown = mcpFailure(failure.error, failureReasons);
+                    const shown = mcpFailure(failure.error, failureReasons, fileScopeEnabled(analysisSwitches));
                     text = (failure.error instanceof SignInExpiredError
                         ? emailSignInMessages.mcp_expired : failure.error instanceof SignInDeniedError
                         ? emailSignInMessages.mcp_cancelled : shown.message) + "\n";
@@ -316,19 +404,30 @@ export async function serveMcp(input, output, options = {}) {
                 const launchFolder = await launch;
                 if (guarded && !launchFolder)
                     throw new CliRefusalError("launch_folder_unavailable");
-                const scope = await loadAnalysisScope({ scope: args.scope }, cwd, analysisSettings);
-                const selection = selectionEnabled ? await resolveAnalysisSelection(args.path, launchFolder ?? cwd, analysisSettings, scope) : undefined;
+                const partScope = Array.isArray(args.scope) ? args.scope : undefined;
+                if (partScope && (!scopeEnabled || args.proposal !== undefined))
+                    throw new Error(cliRefusals.invalid_body);
+                const scope = partScope ? undefined : await loadAnalysisScope({ scope: args.scope }, cwd, analysisSettings);
+                const selection = selectionEnabled ? await resolveAnalysisSelection((args.paths ?? args.path), launchFolder ?? cwd, analysisSettings, scope) : undefined;
                 if (guarded && selection?.kind === "folder")
                     await resolveMcpAgentFolder(selection.path, launchFolder, ctx.homeDir);
                 const folder = selection?.path ?? (guarded ? await resolveMcpAgentFolder(args.path, launchFolder, ctx.homeDir) : resolveAgentFolder(args.path, cwd));
-                const key = selection ? JSON.stringify([selection.launchRoot, selection.path]) : folder;
+                const request = selection?.request;
+                const originalEntries = request?.kind === "file" ? request.entries ?? [request.entry] : undefined;
+                const chosen = request?.kind === "file" ? request.scope : undefined;
+                const includedEntries = originalEntries && (request?.kind === "file" && request.entries && chosen && chosen.imports !== "all"
+                    ? originalEntries.filter(entry => entry === chosen.entry || Array.isArray(chosen.imports) && chosen.imports.includes(entry))
+                    : originalEntries);
+                const key = selection ? includedEntries
+                    ? JSON.stringify([selection.launchRoot, [...includedEntries].sort()]) : JSON.stringify([selection.launchRoot, selection.path]) : folder;
                 const last = lastAnalysis.get(key);
-                if (guarded && last !== undefined && ctx.now() - last < 10 * 60 * 1000) {
+                if (name === ANALYZE_TOOL_NAME && guarded && last !== undefined && ctx.now() - last < 10 * 60 * 1000) {
                     throw new CliRefusalError("repeat_too_soon");
                 }
                 analysisFolder = key;
                 try {
-                    exitCode = await analyze(folder, { proposal: args.proposal, scope, selection }, ctx);
+                    exitCode = name === "analyze_skipped_files" ? await skipped(folder, args.action, ctx, analyze, "mcp")
+                        : await analyze(folder, { proposal: args.proposal, scope: partScope ?? scope, selection, surface: "mcp", analyzedFolder: args.path }, ctx);
                 }
                 finally {
                     if (reason === "results_pending")
@@ -339,11 +438,15 @@ export async function serveMcp(input, output, options = {}) {
             }
         }
         catch (error) {
-            const failure = mcpFailure(error, failureReasons);
+            const failure = mcpFailure(error, failureReasons, fileScopeEnabled(analysisSwitches));
             text += failure.message + "\n";
             reason = failure.reason;
             exitCode = errorCode(error);
         }
+        // Choices return before other output today; replace the terminal command list with the names-only MCP list.
+        if (agentChoice?.kind === "choose_scope")
+            text = agentChoiceMessage(agentChoice, "mcp") + "\n";
+        text += notActiveHint;
         if (scopeChoice) {
             const refusal = scopeChoiceRefusal(scopeChoice);
             if (!refusal)
@@ -358,7 +461,10 @@ export async function serveMcp(input, output, options = {}) {
             structuredContent: { text, exitCode, ...agentChoice, ...(findingIds ? { findingIds } : {}), ...(url ? { url } : {}), ...signIn,
                 ...(exitCode !== 0 && failureReasons ? { reason: reason ?? failureReason(undefined) } : {}),
                 ...(freeAnalysisAvailable ? { freeAnalysisAvailable } : {}),
-                ...(findings ? { findings, projectId } : {}), ...(loadedFinding ? { finding: loadedFinding } : {}),
+                ...(skippedFilesCount ? { skippedFilesCount } : {}),
+                ...(topFindingIds ? { topFindingIds } : {}),
+                ...(notActiveCount === undefined ? {} : { notActiveCount }), ...(analysisId === undefined ? {} : { analysisId }),
+                ...(findings ? { findings, projectId } : {}), ...(nextFinding ? { nextFinding } : {}), ...(loadedFinding ? { finding: loadedFinding } : {}),
                 ...(fixRequests ? { fixRequests } : {}), ...claimed, ...(waitingCount !== undefined ? { waitingFixes: waitingCount } : {}) } };
     }
     async function respond(message, id, signal) {

package/dist/cli/relay-check.js

@@ -1,6 +1,11 @@
+import { skippedFilesEnabled } from "../analysis-core/settings.js";
+import { analysisSkippedFiles, sizeSkippedFiles } from "../analysis-core/analysis/code-agents/skipped-files.js";
+import { loadAnalysisResults, loadPublicReport, saveAnalysisContext, settleAnalysisContext } from "../adapters/analysis-results.js";
+import { fingerprintOf } from "../analysis-core/analysis/finding-identity.js";
+import { combineAssessments } from "../adapters/combined-results.js";
 import { randomUUID } from "node:crypto";
 import { disabledSetupPings } from "../setup-pings/client.js";
-import { scopeChoicesEnabled } from "../adapters/settings.js";
+import { fileScopeEnabled, scopeChoicesEnabled } from "../adapters/settings.js";
 import { saveCompletion, discardCompletion, lockCompletion } from "../adapters/completion.js";
 import { saveLocalResults } from "../adapters/results.js";
 import { GITIGNORE_OUTPUT_NOTICE } from "../adapters/gitignore-output.js";
@@ -10,8 +15,8 @@ import { validateClientRelease } from "../adapters/release.js";
 import { selectAnalysisExecution } from "../adapters/models.js";
 import { resolveFolderPath } from "../adapters/folder-path.js";
 import { AgentChoiceError } from "../contract/agent-choice.js";
-import { savedAnalysisUrl } from "../contract/console-url.js";
-import { prepareRelayCheck } from "./relay-preparation.js";
+import { savedAnalysisUrl, savedArchitectureUrl } from "../contract/console-url.js";
+import { prepareRelayCheck, prepareFolderChoice } from "./relay-preparation.js";
 import { cliRefusals, refusalExitCode } from "../contract/cli-refusals.js";
 import { ConsoleClient, ConsoleError } from "../gatekeeper/console.js";
 import { GatekeeperClient } from "../gatekeeper/client.js";
@@ -30,6 +35,7 @@ import { recoverRelayFailure } from "./relay-failure.js";
 import { analysisSaveOptions, resolveRunSelection } from "./analysis-selection.js";
 import { SCOPE_CHOICE_EXIT_CODE, progressLine } from "../contract/scope-choice.js";
 import { ScopeChoiceError, scopeChoiceRefusal, selectionScopeChoices } from "../contract/selection-offer.js";
+import { fileScopeOf } from "../analysis-core/analysis/file-analysis-plan.js";
 const stateLine = (status) => `Reservation ${status.state}; settlement ${status.settlement}; lease ${new Date(status.expiresAt).toLocaleString("en-US", { timeZone: "America/Los_Angeles", timeZoneName: "short" })}.\n`;
 export function runRelayCheck(folder, options) {
     return runRelayLifecycle(folder, options);
@@ -42,13 +48,17 @@ async function runRelayLifecycle(folder, options, existing) {
     const { config, stdout, stderr } = options;
     const retainUnsaved = config.CF_LOCAL_RESULTS_RETRY !== "0";
     let settings = options.settings;
-    const summaryOptions = { audienceEnabled: false };
+    const summaryOptions = { audienceEnabled: false, notActiveEnabled: false, skippedFilesEnabled: skippedFilesEnabled(settings), skippedOffer: !options.addToAnalysisId, analyzedFolder: options.analyzedFolder ?? folder };
+    let skippedFiles = [];
     let client, reservationId, projectId;
     let connection = existing?.connection;
     let completedPayload;
     let displayFindings;
     let completionOrigin, completionRecordPath;
     let completionTiming = {};
+    let combinedFindings;
+    let topFindingIds;
+    let refusedCalls;
     let completed = false, uploaded = false, heartbeat;
     let selection, membership;
     let selectedPaths, completionIdentity;
@@ -84,9 +94,25 @@ async function runRelayLifecycle(folder, options, existing) {
     };
     const showSaved = (result) => {
         const url = savedAnalysisUrl(result.projectId, config.CF_CONSOLE_URL);
-        const findings = savedFindings({ findingIds: result.findingIds ?? [], findings: result.findings }, displayFindings ?? completedPayload?.findings ?? []);
-        options.onSaved?.({ ...result, findings, url, audienceEnabled: summaryOptions.audienceEnabled });
+        const architectureUrl = completedPayload?.architecture ? savedArchitectureUrl(result.projectId, config.CF_CONSOLE_URL) : undefined;
+        const findings = combinedFindings ?? savedFindings({ findingIds: result.findingIds ?? [], findings: result.findings }, displayFindings ?? completedPayload?.findings ?? []);
+        options.onSaved?.({ ...result, ...(combinedFindings ? { findingIds: combinedFindings.map(f => f.id), topFindingIds } : {}), ...(!skippedFilesEnabled(settings) ? {} : { skippedFiles }), findings, url, ...(architectureUrl ? { architectureUrl } : {}), ...summaryOptions });
         stdout(result.analysisId ? `Saved analysis ${result.analysisId}: ${url}\n` : `Full results: ${url}\n`);
+        if (architectureUrl)
+            stdout(`Architecture: ${architectureUrl}\n`);
+    };
+    const settleSaved = async (result) => {
+        const payload = completedPayload;
+        if (!result.analysisId || !skippedFilesEnabled(settings) || !payload?.coverage || !payload.addToAnalysisId && !sizeSkippedFiles(payload.coverage.skippedFiles).length)
+            return;
+        const context = await settleAnalysisContext(folder, { ...result, analysisId: result.analysisId, findingIds: result.findingIds ?? [] }, payload.checkId, payload.addToAnalysisId, outputDir);
+        const { report } = await loadAnalysisResults(folder, outputDir);
+        skippedFiles = report.refusedFiles;
+        if (payload.addToAnalysisId) {
+            topFindingIds = context.topFindingIds;
+            const references = new Map(context.findings?.map(f => [f.fingerprint, f]));
+            combinedFindings = report.findings.flatMap(finding => { const saved = references.get(fingerprintOf(finding)); return saved ? [saved] : []; });
+        }
     };
     try {
         if (!config.CF_CONSOLE_URL || !existing && (!config.CF_RELAY_URL || !config.CF_CONSOLE_TOKEN)) {
@@ -108,9 +134,16 @@ async function runRelayLifecycle(folder, options, existing) {
         const validated = validateClientRelease(options.release, settings);
         const { bundle } = validated;
         settings = validated.settings;
-        summaryOptions.audienceEnabled = readFindingSettings(settings).audienceEnabled;
+        const findingSettings = readFindingSettings(settings);
+        summaryOptions.audienceEnabled = findingSettings.audienceEnabled;
+        summaryOptions.notActiveEnabled = findingSettings.notActiveEnabled;
         selection = await resolveRunSelection(folder, options.cwd ?? process.cwd(), settings, options);
-        folder = selection?.outputAnchor ?? await resolveFolderPath(folder);
+        // Verify the selected folder before output and recovery operations can fail for their own reasons.
+        folder = await resolveFolderPath(selection?.outputAnchor ?? folder).catch(error => {
+            if (error instanceof Error)
+                Object.assign(error, { localOperation: "read" });
+            throw error;
+        });
         outputDir ??= selection?.outputDir;
         if (selection?.kind === "file")
             completionIdentity = {
@@ -138,6 +171,7 @@ async function runRelayLifecycle(folder, options, existing) {
             completionStored = true;
             completionRecordPath = path;
             completedPayload = prior.payload;
+            skippedFiles = prior.payload.coverage?.skippedFiles ?? [];
             completionOrigin = prior.consoleOrigin;
             completionTiming = { completedAt: prior.completedAt, absoluteExpiresAt: prior.absoluteExpiresAt };
             uploaded = prior.uploaded ?? false;
@@ -146,12 +180,24 @@ async function runRelayLifecycle(folder, options, existing) {
             const saved = await submit(prior.payload, retainUnsaved && uploaded);
             uploaded = true;
             await persist(prior.payload, prior.consoleOrigin, true);
+            await settleSaved(saved);
             showSaved(saved);
             return 0;
         }
         signal.throwIfAborted();
         if (options.retryUpload)
             throw new Error("The saved completion record is missing. Keep the local report and check the output directory.");
+        // Negotiate once before paid work: older strict intake schemas cannot accept optional metadata.
+        const capabilities = skippedFilesEnabled(settings) && options.skippedFilesSupported === undefined
+            || settings.CF_LOCAL_ARCHITECTURE === "1" && options.consoleSupportsArchitecture === undefined
+            ? await client.capabilities() : undefined;
+        const consoleSupportsArchitecture = options.consoleSupportsArchitecture ?? capabilities?.architecture ?? false;
+        if (skippedFilesEnabled(settings) && !(options.skippedFilesSupported ?? capabilities?.skippedFiles)) {
+            if (options.addToAnalysisId || fileScopeOf(settings) !== undefined)
+                throw new ConsoleError("unavailable", "start");
+            settings = Object.freeze({ ...settings, CF_SKIPPED_FILES: "0" });
+            summaryOptions.skippedFilesEnabled = false;
+        }
         try {
             await outputPaths(folder, ["findings.json", "summary.md", ...(selection?.kind === "file" ? ["selection.json"] : [])], outputDir);
         }
@@ -159,14 +205,18 @@ async function runRelayLifecycle(folder, options, existing) {
             if (error.code !== "ENOENT")
                 throw error;
         }
-        const prepared = await prepareRelayCheck(selection?.path ?? folder, { ...options, selection, signal, expectedCommit: existing?.expectedCommit, expectedFiles: existing?.expectedFiles }, validated);
+        const prepared = await prepareRelayCheck(selection?.path ?? folder, { ...options, settings, selection, signal, expectedCommit: existing?.expectedCommit, expectedFiles: existing?.expectedFiles }, { ...validated, settings });
         const { source, provenance, plan, start, startMetadata } = prepared;
         membership = prepared.membership;
         const includedPaths = Object.keys(source.files);
         selectedPaths = includedPaths;
+        refusedCalls = plan.calls;
+        skippedFiles = source.skippedFiles;
         let reservation = existing?.reservation;
         if (!reservation) {
-            const started = await client.start(start, startMetadata);
+            const started = await client.start(start, { ...startMetadata, ...(options.addToAnalysisId ? { addToAnalysisId: options.addToAnalysisId } : {}) });
+            if (options.expectedProjectId && started.projectId !== options.expectedProjectId)
+                throw new ConsoleError("check_conflict");
             projectId = started.projectId;
             signal.throwIfAborted();
             const created = await client.create({ ...started, checkId: randomUUID(), plan });
@@ -197,31 +247,53 @@ async function runRelayLifecycle(folder, options, existing) {
         options.onStart?.();
         stderr(progressLine(selection));
         (options.setupPings ?? disabledSetupPings).ping("first_analysis_started");
-        const report = await runAnalysisToEnd(source, execution.model, settings, { execution });
+        const report = await runAnalysisToEnd(source, execution.model, settings, { execution, ...(options.addToAnalysisId ? { findingsOnly: true } : {}) });
+        skippedFiles = !skippedFilesEnabled(settings) ? source.skippedFiles : analysisSkippedFiles(source.skippedFiles, report.skippedFiles);
+        const priorResults = options.addToAnalysisId ? await loadAnalysisResults(folder, outputDir) : undefined;
+        const assessments = combineAssessments(priorResults?.context.assessments ?? [], report.findingCheck.qualityAudit?.assessments ?? []);
         completionTiming = observedCompletionTiming({ completedAt: Date.now() }, { kind: "found", status: reservation }, reservation);
         // The 30-minute lease covers upload retries; renewal failure must not cancel completed results.
         if (retainUnsaved)
             clearInterval(heartbeat);
         else
             signal.throwIfAborted();
+        let saveContext;
         const saveReports = async () => {
-            const paths = await saveLocalResults(folder, report, source.skippedFiles, outputDir, { ...summaryOptions, settings,
-                ...analysisSaveOptions(selection, options.outputDir), selection: membership, includedPaths });
+            const paths = await saveLocalResults(folder, report, skippedFiles, outputDir, { ...summaryOptions, settings,
+                ...analysisSaveOptions(selection, options.outputDir), selection: membership, includedPaths,
+                ...(options.addToAnalysisId ? { append: { readPaths: includedPaths, assessments } } : {}) });
             try {
                 options.onLocalSaved?.(paths);
                 if (paths.ignoreAdded)
                     stderr(GITIGNORE_OUTPUT_NOTICE);
             }
             catch { /* Output failure must not change a server outcome. */ }
+            await saveContext?.();
             return paths;
         };
+        // The retry off path saves the full report even when intake validation refuses it.
         let paths = retainUnsaved ? undefined : await saveReports();
-        const { payload, resultCheck, findingIndexes } = buildIntakePayload({ checkId: reservation.checkId, projectId: projectId, reservationId,
-            bundleVersion: bundle.version, relayVersion: options.release.relayVersion, counterfactLocalVersion: options.release.localVersion }, provenance, report, { settings, files: source.snapshot });
-        displayFindings = findingIndexes.map(index => {
+        const { payload, resultCheck, findingIndexes, findingActivities } = buildIntakePayload({ checkId: reservation.checkId, projectId: projectId, reservationId,
+            bundleVersion: bundle.version, relayVersion: options.release.relayVersion, counterfactLocalVersion: options.release.localVersion }, provenance, report, { settings, files: source.snapshot, consoleSupportsActivity: options.consoleSupportsActivity, consoleSupportsArchitecture,
+            ...(!skippedFilesEnabled(settings) || !options.addToAnalysisId && !sizeSkippedFiles(skippedFiles).length ? {} : { coverage: { skippedFiles: sizeSkippedFiles(skippedFiles), readPaths: includedPaths },
+                addToAnalysisId: options.addToAnalysisId, findingAssessments: report.findingCheck.qualityAudit?.assessments ?? [] }) });
+        displayFindings = findingIndexes.map((index, acceptedIndex) => {
             const finding = report.findings[index];
-            return { title: findingPresentation(finding).displayTitle, audience: finding.audience };
+            const activity = findingActivities[acceptedIndex];
+            return { title: findingPresentation(finding).displayTitle, audience: finding.audience,
+                severity: finding.severity, site: finding.site, fixes: finding.fixes,
+                ...(activity === undefined ? {} : { activity }) };
         });
+        if (skippedFilesEnabled(settings) && (options.addToAnalysisId || sizeSkippedFiles(skippedFiles).length)) {
+            saveContext = async () => {
+                await saveAnalysisContext(folder, { projectId: projectId, analysisId: options.addToAnalysisId ?? reservation.checkId,
+                    settings: priorResults?.context.settings ?? settings, assessments,
+                    ...(priorResults?.context.findings ? { findings: priorResults.context.findings } : {}),
+                    pending: { checkId: reservation.checkId, fingerprints: findingIndexes.map(index => fingerprintOf(report.findings[index])), titles: [...displayFindings] } }, outputDir);
+            };
+            if (paths)
+                await saveContext();
+        }
         if (resultCheck?.droppedFindings) {
             const count = resultCheck.droppedFindings;
             const reason = resultCheck.schemaDroppedFindings || resultCheck.capDroppedFindings
@@ -256,7 +328,8 @@ async function runRelayLifecycle(folder, options, existing) {
             uploaded = true;
             await persist(payload, completionOrigin, true);
         }
-        stdout(formatSummary(report, summaryOptions));
+        await settleSaved(saved);
+        stdout(formatSummary(options.addToAnalysisId ? await loadPublicReport(folder, outputDir) : { ...report, refusedFiles: skippedFiles }, summaryOptions));
         stdout(`\nSaved ${paths.findingsPath}\nSaved ${paths.summaryPath}\n`);
         showSaved(saved);
         return 0;
@@ -297,14 +370,16 @@ async function runRelayLifecycle(folder, options, existing) {
             completionTiming = error.timing ?? completionTiming;
         const failure = await recoverRelayFailure({ error, retryEnabled: retainUnsaved, payload: completedPayload, completed,
             timing: completionTiming, statusLookup, uploadOutcome, savedResult,
-            canWrite: !lostCompletionLock, completionStored, localErrorMessage, fileSelection: selection?.kind === "file" }, {
+            canWrite: !lostCompletionLock, completionStored, localErrorMessage, fileSelection: selection?.kind === "file", fileMode: fileScopeEnabled(settings) }, {
             markUploaded: () => persist(completedPayload, completionOrigin, true),
             keepPending: timing => { completionTiming = timing; return persist(completedPayload, completionOrigin); },
             retire: () => retainUnsaved ? completionRecordPath ? discardCompletion(folder, completionRecordPath, completionIdentity) : Promise.resolve() : persist(completedPayload, completionOrigin, false, true),
         });
         if (failure.saved) {
             try {
-                showSaved(savedResult ?? { projectId: status.projectId, analysisId: status.analysisId, findingIds: status.findingIds, findings: status.findings });
+                const saved = savedResult ?? { projectId: status.projectId, analysisId: status.analysisId, findingIds: status.findingIds, findings: status.findings };
+                await settleSaved(saved);
+                showSaved(saved);
             }
             catch { /* Output failure must not change a server outcome. */ }
             if (!failure.message)
@@ -316,10 +391,19 @@ async function runRelayLifecycle(folder, options, existing) {
             catch { /* Reporting failure cannot undo saved results. */ }
             return 1;
         }
+        let scopeChoice;
+        if (!reservationId && !existing && error instanceof ConsoleError && (error.code === "folder_too_large" || error.code === "plan_over_limit")) {
+            try {
+                const choice = await prepareFolderChoice(folder, { ...options, settings, signal, limit: error.code, refusedCalls });
+                if (choice)
+                    scopeChoice = new AgentChoiceError(choice);
+            }
+            catch { /* A failed local plan preserves the console's authoritative refusal. */ }
+        }
         try {
-            options.onError?.({ code: error instanceof ConsoleError ? error.code : undefined, reason: failure.reason, message: failure.message,
-                ...(error instanceof AgentChoiceError ? { agentChoice: error.agentChoice } : {}) });
-            stderr(`${failure.message}\n`);
+            options.onError?.({ code: error instanceof ConsoleError ? error.code : undefined, reason: failure.reason, message: scopeChoice?.message ?? failure.message,
+                ...(scopeChoice ? { agentChoice: scopeChoice.agentChoice } : error instanceof AgentChoiceError ? { agentChoice: error.agentChoice } : {}) });
+            stderr(`${scopeChoice?.message ?? failure.message}\n`);
             if (status && !(error instanceof ConsoleError && error.code === "low_balance"))
                 stderr(stateLine(status));
         }

package/dist/cli/relay-failure.js

@@ -2,8 +2,8 @@ import { CompletionBusyError } from "../adapters/completion-lock.js";
 import { OutputPathError } from "../adapters/output-paths.js";
 import { AgentChoiceError } from "../contract/agent-choice.js";
 import { INVALID_PROPOSAL_MESSAGE } from "../contract/agent-proposal.js";
-import { cliRefusals, COMMITTED_FILES_MESSAGE, failureReason, FINISH_FAILURE_MESSAGE, RESULTS_TOO_LARGE_MESSAGE } from "../contract/cli-refusals.js";
-import { isSelectionRefusal } from "../contract/scope-choice.js";
+import { cliRefusals, COMMITTED_FILES_MESSAGE, failureReason, FINISH_FAILURE_MESSAGE, localFailure, RESULTS_TOO_LARGE_MESSAGE } from "../contract/cli-refusals.js";
+import { isSelectionRefusal, selectionRefusalMessage } from "../contract/scope-choice.js";
 import { ConsoleError } from "../gatekeeper/console.js";
 import { recoverCompletedResults } from "./completion-delivery.js";
 import { CompletionSettingsMismatchError } from "./prior-completion.js";
@@ -24,9 +24,9 @@ export async function recoverRelayFailure(input, operations) {
         || error instanceof CompletionBusyError || error instanceof CompletionSettingsMismatchError || error instanceof Error
         && ([cliRefusals.release_unavailable, COMMITTED_FILES_MESSAGE, RESULTS_TOO_LARGE_MESSAGE, INVALID_PROPOSAL_MESSAGE].includes(error.message)
             || error.message.startsWith("The saved completion"));
-    const message = recovery?.message ?? input.localErrorMessage ?? (known ? error.message : FINISH_FAILURE_MESSAGE);
+    const message = recovery?.message ?? input.localErrorMessage ?? localFailure(error)?.message ?? (known ? error.message : FINISH_FAILURE_MESSAGE);
     const reason = !retryEnabled ? failureReason(error)
         : recovery?.decision.action === "retry" && input.completionStored ? "results_pending"
             : recovery?.decision.action === "give-up" ? "results_discarded" : failureReason(error);
-    return { saved: false, message, reason };
+    return { saved: false, message: selectionRefusalMessage(message, input.fileMode ?? true), reason };
 }