@counterfact-labs/cli 0.2.7 → 0.2.10

package/dist/cli/analysis-selection.js

@@ -1,11 +1,13 @@
+import { fileScopeOf } from "../analysis-core/analysis/file-analysis-plan.js";
 import { createHash } from "node:crypto";
 import { realpath, stat } from "node:fs/promises";
 import { dirname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
-import { analysisScopeSchema, analysisSelectionRequestSchema } from "../analysis-core/contracts/analysis-selection.js";
-import { fileScopeEnabled, fileScopeRequested, selectionModeEnabled } from "../adapters/settings.js";
+import { ANALYSIS_SELECTION_LIMITS, analysisScopeSchema, analysisSelectionRequestSchema } from "../analysis-core/contracts/analysis-selection.js";
+import { fileScopeEnabled, fileScopeRequested, multiEntryEnabled, selectionModeEnabled } from "../adapters/settings.js";
 import { resolveFolderPath } from "../adapters/folder-path.js";
 import { INVALID_SCOPE_MESSAGE, INVALID_SELECTION_MESSAGE } from "../contract/scope-choice.js";
 import { cliRefusals } from "../contract/cli-refusals.js";
+import { mapLimit } from "../analysis-core/map-limit.js";
 function within(root, path) {
     const rel = relative(root, path);
     return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
@@ -13,6 +15,10 @@ function within(root, path) {
 function localPath(root, path) {
     return relative(root, path).split(sep).join("/");
 }
+function canonicalScope(scope) {
+    const imports = scope.imports;
+    return { ...scope, imports: Array.isArray(imports) ? imports.length ? [...imports].sort() : "none" : imports };
+}
 function folderSelection(path, launchRoot) {
     const parsed = analysisSelectionRequestSchema.safeParse({ kind: "folder", launchRoot,
         folder: localPath(launchRoot, path) || "." });
@@ -21,6 +27,38 @@ function folderSelection(path, launchRoot) {
 }
 /** Selection coordinates are shared by reading, Git facts, outputs, and recovery. Membership stays in core. */
 export async function resolveAnalysisSelection(path, cwd, settings, scope) {
+    const paths = typeof path === "string" ? [path] : path;
+    if (!paths.length || paths.length > ANALYSIS_SELECTION_LIMITS.files
+        || paths.some(path => typeof path !== "string" || !path.trim()))
+        throw new Error(INVALID_SELECTION_MESSAGE);
+    if (paths.length > 1 || scope?.entries) {
+        if (!multiEntryEnabled(settings))
+            throw new Error(paths.length > 1 ? INVALID_SELECTION_MESSAGE : INVALID_SCOPE_MESSAGE);
+        const requested = await mapLimit(paths, 4, path => resolveAnalysisSelection(path, cwd, settings));
+        if (requested.some(selection => selection.kind !== "file"))
+            throw new Error(INVALID_SELECTION_MESSAGE);
+        const originals = scope?.entries ? await mapLimit(scope.entries, 4, path => resolveAnalysisSelection(path, cwd, settings)) : requested;
+        if (originals.some(selection => selection.kind !== "file")
+            || requested.some(selection => !originals.some(original => original.entryPath === selection.entryPath)))
+            throw new Error(INVALID_SCOPE_MESSAGE);
+        const unique = [...new Map(originals.map(selection => [selection.entryPath, selection])).values()].sort((a, b) => a.entryPath.localeCompare(b.entryPath));
+        if (unique.length === 1) {
+            if (scope?.entries)
+                throw new Error(INVALID_SCOPE_MESSAGE);
+            return resolveAnalysisSelection(unique[0].path, cwd, settings, scope);
+        }
+        const first = unique[0], entries = unique.map(selection => selection.entryPath);
+        const chosen = scope ? canonicalScope(scope) : undefined;
+        const request = analysisSelectionRequestSchema.safeParse({ kind: "file", launchRoot: first.launchRoot, entry: entries[0], entries,
+            ...(chosen ? { scope: chosen } : {}) });
+        if (!request.success)
+            throw new Error(INVALID_SCOPE_MESSAGE);
+        const identity = JSON.stringify([first.launchRoot, entries, chosen ? [chosen.snapshot, chosen.entry, chosen.imports] : null]);
+        const hash = createHash("sha256").update(JSON.stringify(entries)).digest("hex");
+        return { ...first, outputAnchor: first.launchRoot, outputDir: join(first.launchRoot, ".counterfact/files", hash),
+            selectionKey: `files:${createHash("sha256").update(identity).digest("hex")}`, request: request.data };
+    }
+    path = paths[0];
     if (fileScopeRequested(settings) && !fileScopeEnabled(settings))
         throw new Error(cliRefusals.release_unavailable);
     if (!fileScopeEnabled(settings)) {
@@ -62,8 +100,7 @@ export async function resolveAnalysisSelection(path, cwd, settings, scope) {
         const parsed = analysisScopeSchema.safeParse(scope);
         if (!parsed.success || parsed.data.entry !== entryPath)
             throw new Error(INVALID_SCOPE_MESSAGE);
-        const imports = parsed.data.imports;
-        chosen = { ...parsed.data, imports: Array.isArray(imports) ? imports.length ? [...imports].sort() : "none" : imports };
+        chosen = canonicalScope(parsed.data);
     }
     const request = analysisSelectionRequestSchema.safeParse({ kind: "file", launchRoot, entry: entryPath,
         ...(chosen === undefined ? {} : { scope: chosen }) });
@@ -78,12 +115,17 @@ export async function resolveAnalysisSelection(path, cwd, settings, scope) {
 }
 /** Entry points resolve coordinates once; downstream stages reuse the same captured description. */
 export async function resolveRunSelection(path, cwd, settings, options = {}) {
+    if (options.paths && !multiEntryEnabled(settings))
+        throw new Error(INVALID_SELECTION_MESSAGE);
     if (!selectionModeEnabled(settings)) {
         if (options.scope !== undefined)
             throw new Error(INVALID_SCOPE_MESSAGE);
         return undefined;
     }
-    return options.selection ?? resolveAnalysisSelection(path, cwd, settings, options.scope);
+    const selection = options.selection ?? await resolveAnalysisSelection(options.paths ?? path, cwd, settings, options.scope);
+    if (selection.kind === "file" && fileScopeOf(settings) !== undefined)
+        throw new Error(INVALID_SCOPE_MESSAGE);
+    return selection;
 }
 export function analysisSaveOptions(selection, outputDir) {
     return { defaultFileOutput: selection?.kind === "file" && outputDir === undefined,

package/dist/cli/api.js

@@ -1 +1 @@
-export { ApiClient, ApiError, DEFAULT_URL, errorCode, errorText } from "../gatekeeper/cli-api.js";
+export { ApiClient, ApiError, SavedSignInError, DEFAULT_URL, errorCode, errorText } from "../gatekeeper/cli-api.js";

package/dist/cli/commands/analyze.js

@@ -1,3 +1,5 @@
+import { formatSavedResults } from "../saved-results.js";
+import { skipped } from "./skipped.js";
 import { loadDevelopmentRelay } from "../development-relay.js";
 import { loadInstalledRelease } from "../../adapters/release.js";
 import { cliRefusals, START_FAILURE_MESSAGE } from "../../contract/cli-refusals.js";
@@ -10,8 +12,9 @@ import { GITIGNORE_OUTPUT_NOTICE } from "../../adapters/gitignore-output.js";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { loadAgentProposal } from "../../contract/agent-proposal.js";
-import { formatSavedFindings } from "../finding-display.js";
-import { scopeChoicesEnabled } from "../../adapters/settings.js";
+import { fileScopeOf } from "../../analysis-core/analysis/file-analysis-plan.js";
+import { folderPartsEnabled } from "../../analysis-core/settings.js";
+import { captureArchitectureSettings, scopeChoicesEnabled } from "../../adapters/settings.js";
 import { resolveRunSelection } from "../analysis-selection.js";
 import { renderScopeChoices } from "../scope-choices.js";
 import { progressLine } from "../../contract/scope-choice.js";
@@ -34,36 +37,70 @@ function requireLocal(value) {
     // A local-capable client never falls back to sending source files to the hosted upload API.
     if (value.mode !== "local")
         throw new ApiError(503, "unavailable", unavailable);
+    return "skippedFiles" in value && value.skippedFiles === true;
 }
-export function parseAnalyzeOptions(args, choices = false) {
+export function parseAnalyzeOptions(args, choices = false, multiple = false) {
     let path, proposalFile, scopeFile;
+    let skipped;
+    let scope;
+    const paths = [];
     for (let index = 0; index < args.length; index++) {
         const arg = args[index];
-        if (arg === "--proposal" && proposalFile === undefined) {
+        if (["--skipped", "--skipped-plan", "--show-skipped"].includes(arg) && skipped === undefined) {
+            skipped = arg === "--skipped" ? "analyze" : arg === "--skipped-plan" ? "plan" : "files";
+        }
+        else if (arg === "--proposal" && proposalFile === undefined) {
             const value = args[++index];
             if (!value || value.startsWith("-"))
                 throw new Error();
             proposalFile = value;
         }
-        else if (choices && arg === "--scope" && scopeFile === undefined) {
+        else if ((choices || args[index + 1]?.startsWith("[")) && arg === "--scope" && scope === undefined && scopeFile === undefined) {
             const value = args[++index];
             if (!value || value.startsWith("-"))
                 throw new Error();
-            scopeFile = value;
+            if (value.startsWith("["))
+                scope = JSON.parse(value);
+            else
+                scopeFile = value;
+        }
+        else if (!arg.startsWith("-") && (path === undefined || multiple)) {
+            path ??= arg;
+            paths.push(arg);
         }
-        else if (!arg.startsWith("-") && path === undefined)
-            path = arg;
         else
             throw new Error();
     }
-    return { path: path ?? ".", options: { ...(proposalFile === undefined ? {} : { proposalFile }), ...(scopeFile === undefined ? {} : { scopeFile }) } };
+    if (skipped && (paths.length > 1 || proposalFile || scope !== undefined || scopeFile !== undefined))
+        throw new Error();
+    return { path: path ?? ".", options: { ...(paths.length > 1 ? { paths } : {}), ...(scope === undefined ? {} : { scope }), ...(proposalFile === undefined ? {} : { proposalFile }), ...(scopeFile === undefined ? {} : { scopeFile }), ...(skipped ? { skipped } : {}) } };
 }
 export async function analyze(path, options, ctx) {
+    if (Array.isArray(options.scope) && (options.proposal !== undefined || options.proposalFile !== undefined)) {
+        throw new ApiError(400, "invalid_body", cliRefusals.invalid_body);
+    }
+    if (options.skipped)
+        return skipped(path, options.skipped, ctx, analyze, options.surface);
     const startup = ctx.startup;
-    const scope = options.scope;
+    let settings = startup.settings;
+    if (Array.isArray(options.scope)) {
+        try {
+            if (!folderPartsEnabled(settings))
+                throw new Error();
+            const scope = fileScopeOf({ ...settings, CF_PART_FILES: JSON.stringify(options.scope) });
+            if (!scope?.length)
+                throw new Error();
+            settings = Object.freeze({ ...settings, CF_PART_FILES: JSON.stringify(scope) });
+        }
+        catch {
+            throw new ApiError(400, "invalid_body", cliRefusals.invalid_body);
+        }
+    }
+    const scope = Array.isArray(options.scope) ? undefined : options.scope;
     const proposal = await loadAgentProposal(async () => options.proposalFile === undefined ? options.proposal
         : JSON.parse(await readFile(resolve(ctx.cwd ?? process.cwd(), options.proposalFile), "utf8")), startup.settings);
-    requireLocal(await ctx.api.request("checks/mode"));
+    const mode = await (ctx.consoleMode?.() ?? ctx.api.request("checks/mode"));
+    const skippedFilesSupported = requireLocal(mode);
     const development = startup.transport.CF_RELAY_DEV === "1" ? await loadDevelopmentRelay(startup.transport) : undefined;
     const release = development?.release ?? ctx.relayRuntime?.release ?? await loadInstalledRelease();
     if (release.projectContext !== "checks")
@@ -71,7 +108,7 @@ export async function analyze(path, options, ctx) {
     const token = await ctx.token?.();
     if (!token)
         throw new ApiError(401, "unauthorized", cliApiMessages.unauthorized);
-    const selection = await resolveRunSelection(path, ctx.cwd ?? process.cwd(), startup.settings, options);
+    const selection = await resolveRunSelection(path, ctx.cwd ?? process.cwd(), settings, { ...options, scope });
     const folder = selection?.path ?? resolveAgentFolder(path, ctx.cwd);
     const config = Object.freeze({ ...startup.transport, CF_RELAY_URL: startup.transport.CF_RELAY_URL ?? release.relayUrl,
         CF_LOCAL_RELAY: "1", CF_CONSOLE_URL: ctx.api.baseUrl, CF_CONSOLE_TOKEN: token });
@@ -87,10 +124,13 @@ export async function analyze(path, options, ctx) {
     let choice;
     try {
         const code = await (ctx.relayRuntime?.run ?? runRelayCheck)(folder, {
-            settings: startup.settings, config, release, cwd: ctx.cwd, connect: development?.connect ?? ctx.relayRuntime?.connect,
+            analyzedFolder: options.analyzedFolder ?? path,
+            settings: captureArchitectureSettings(settings, config), config, release, skippedFilesSupported, consoleSupportsActivity: !!mode && typeof mode === "object" && "findingActivity" in mode && mode.findingActivity === true, cwd: ctx.cwd, connect: development?.connect ?? ctx.relayRuntime?.connect,
             ...(ctx.relayRuntime?.selectionProvider ? { selectionProvider: ctx.relayRuntime.selectionProvider } : {}),
             ...(proposal ? { proposal } : {}),
             ...(selection ? { selection } : {}), ...(scope ? { scope } : {}),
+            ...(options.addToAnalysisId ? { addToAnalysisId: options.addToAnalysisId, expectedProjectId: options.expectedProjectId } : {}),
+            ...(options.retryUpload ? { retryUpload: true } : {}),
             signal: ctx.signal ? AbortSignal.any([controller.signal, ctx.signal]) : controller.signal,
             stdout() { }, stderr() { },
             onStart: () => { ctx.onCheckStart?.(); ctx.write(`\r\u001b[2K${progressLine(selection, "terminal")}`); progressShown = true; },
@@ -117,8 +157,8 @@ export async function analyze(path, options, ctx) {
             onSaved: result => {
                 clearProgress();
                 ctx.onCheckComplete?.(result);
-                ctx.write(formatSavedFindings(result, { numbersEnabled: ctx.findingNumbers, audienceEnabled: result.audienceEnabled }));
-                ctx.write(`Full results: ${result.url}\n`);
+                if (!options.deferResults)
+                    ctx.write(formatSavedResults(result, settings, ctx.findingNumbers, !options.addToAnalysisId, { agentReadableResults: ctx.findingSettings.agentReadableResults, surface: options.surface, analyzedFolder: options.analyzedFolder ?? path }));
             },
         });
         if (choice && !ctx.onScopeChoice && selection)

package/dist/cli/commands/skipped.js

@@ -0,0 +1,65 @@
+import { followupSettings, skippedFilesEnabled } from "../../analysis-core/settings.js";
+import { loadAnalysisResults } from "../../adapters/analysis-results.js";
+import { readLocalFolder } from "../../adapters/files.js";
+import { loadCompletion } from "../../adapters/completion.js";
+import { sizeSkippedFiles } from "../../analysis-core/analysis/code-agents/skipped-files.js";
+import { followupPlanText } from "../skipped-files.js";
+import { resolveAgentFolder } from "../agent-folder.js";
+import { formatSavedResults } from "../saved-results.js";
+export async function skipped(path, action, ctx, run, surface) {
+    if (!skippedFilesEnabled(ctx.startup.settings))
+        throw new Error("Skipped-file analyses are not enabled.");
+    const folder = resolveAgentFolder(path, ctx.cwd);
+    let latest;
+    let mode;
+    const deferred = { ...ctx, consoleMode: ctx.consoleMode ?? (() => mode ??= ctx.api.request("checks/mode")),
+        onCheckComplete: (result) => { latest = result; } };
+    const publish = () => {
+        if (!latest)
+            return;
+        ctx.onCheckComplete?.(latest);
+        ctx.write(formatSavedResults(latest, ctx.startup.settings, ctx.findingNumbers, false, { agentReadableResults: ctx.findingSettings.agentReadableResults, surface }));
+    };
+    // Finish an already completed upload before planning; its reading must not be purchased again.
+    const pending = await loadCompletion(folder);
+    const unsettled = pending?.uploaded ? await loadAnalysisResults(folder).then(saved => saved.context.pending?.checkId === pending.payload.checkId).catch(() => false) : false;
+    if (pending && !pending.finished && (!pending.uploaded || unsettled)) {
+        const recovered = await run(folder, { retryUpload: true, deferResults: true, surface }, deferred);
+        if (recovered !== 0) {
+            if (action === "analyze")
+                publish();
+            return recovered;
+        }
+    }
+    let saved;
+    try {
+        saved = await loadAnalysisResults(folder);
+    }
+    catch {
+        throw new Error("The saved analysis is missing or unreadable. Run an analysis of this folder first.");
+    }
+    const paths = sizeSkippedFiles(saved.report.refusedFiles).map(file => file.path);
+    if (action === "files") {
+        ctx.write(paths.length ? `${paths.join("\n")}\n` : "No skipped files remain to analyze.\n");
+        return 0;
+    }
+    const settings = followupSettings(ctx.startup.settings, saved.context.settings);
+    const source = await readLocalFolder(settings, folder, undefined, { planSkipped: paths });
+    const plan = source.filePlan;
+    ctx.write(followupPlanText(plan));
+    if (action === "plan")
+        return 0;
+    // Groups share the same local result files; save one completely before starting the next.
+    for (const group of plan.groups) {
+        ctx.signal?.throwIfAborted();
+        const scoped = { ...deferred,
+            startup: { ...ctx.startup, settings: Object.freeze({ ...settings, CF_PART_FILES: JSON.stringify(group.files) }) } };
+        const code = await run(folder, { deferResults: true, surface, addToAnalysisId: saved.context.analysisId, expectedProjectId: saved.context.projectId }, scoped);
+        if (code !== 0) {
+            publish();
+            return code;
+        }
+    }
+    publish();
+    return 0;
+}

package/dist/cli/context.js

@@ -11,11 +11,12 @@ export function commandContext(options = {}) {
     const startup = options.startup ?? readCliSettings(options.env, options.emailSignIn);
     const homeDir = options.homeDir ?? homedir();
     const baseUrl = (options.baseUrl ?? startup.baseUrl ?? DEFAULT_URL).replace(/\/+$/, "");
-    const api = new ApiClient(baseUrl, () => readCredentials(homeDir, api.baseUrl), undefined, options.signal);
+    const api = new ApiClient(baseUrl, () => readCredentials(homeDir, api.baseUrl), undefined, options.signal, startup.transport.CF_CLI_TRANSPORT_ERRORS !== "0");
     const write = options.write ?? (text => { process.stdout.write(text); });
     const findingSettings = options.findingSettings ?? readFindingSettings(options.env);
     return {
         findingNumbers: findingSettings.numbersEnabled,
+        findingSettings,
         signInRetry: (options.env ?? process.env).CF_SIGN_IN_RETRY !== "0",
         startup, signal: options.signal, relayRuntime: options.relayRuntime, cwd: options.cwd ?? process.cwd(),
         token: () => readCredentials(homeDir, api.baseUrl), onCheckComplete: options.onCheckComplete, onCheckStart: options.onCheckStart, onAgentChoice: options.onAgentChoice,

package/dist/cli/finding-display.js

@@ -1,5 +1,9 @@
-import { groupByAudience } from "../analysis-core/analysis/schemas.js";
+import { stripVTControlCharacters } from "node:util";
+import { groupByActivity, groupByAudience } from "../analysis-core/analysis/schemas.js";
 export const TEAM_WORKFLOW_HEADING = "Team workflow";
+export const notActiveCountLine = (count) => `${count} more ${count === 1 ? "finding is" : "findings are"} about code that doesn't run today (not active)`;
+export const activityAdvice = (activity) => activity.state === "dead" ? "Remove it (cleanup)."
+    : `Fix this before turning on ${activity.gate}, or remove it if you don't plan to use it.`;
 export const formatFindingNumber = (seq) => `F-${seq}`;
 /** Intake returns one id per payload finding in order; the optional number mapping is joined by id. */
 export function savedFindings(result, report) {
@@ -7,28 +11,119 @@ export function savedFindings(result, report) {
     return result.findingIds.map((id, index) => {
         const numbered = numbers.get(id), local = report[index];
         return { id, ...(numbered ? { seq: numbered.seq, number: formatFindingNumber(numbered.seq) } : {}),
-            title: local?.title ?? "", ...(local?.audience === undefined ? {} : { audience: local.audience }) };
+            title: local?.title ?? "", ...(local?.audience === undefined ? {} : { audience: local.audience }),
+            ...(local?.activity === undefined ? {} : { activity: local.activity }),
+            ...(local?.activity === undefined || local.fixes === undefined ? {} : { fixes: local.fixes.map(({ title, approach }) => ({ title: title ?? "", approach: approach ?? "" })) }),
+            ...(local?.severity === undefined ? {} : { severity: local.severity }),
+            ...(local?.site === undefined ? {} : { site: local.site }),
+            ...(local?.fixes === undefined ? {} : { shortFix: shortFix(local.fixes[0]) }) };
     });
 }
+function findingLabel(value, enabled, index, labels) {
+    return labels === "position" ? `${index + 1}.` : enabled && value.seq !== undefined ? formatFindingNumber(value.seq) : value.id ?? `${index + 1}.`;
+}
 function findingLine(value, enabled, index, labels, audienceEnabled) {
     // The off switch preserves the original Markdown summary, including whitespace.
     if (labels === "position" && !audienceEnabled)
         return `${index + 1}. ${value.title}`;
     const title = value.title.replace(/[\r\n\u2028\u2029]+/g, " ");
-    const label = labels === "position" ? `${index + 1}.` : enabled && value.seq !== undefined ? formatFindingNumber(value.seq) : value.id ?? `${index + 1}.`;
+    const label = findingLabel(value, enabled, index, labels);
     return `${label}${title ? ` ${title}` : ""}`;
 }
-export function findingDisplayRows(findings, { numbersEnabled = true, audienceEnabled, labels }) {
-    const groups = audienceEnabled ? groupByAudience(findings) : { users: findings, team: [] };
+export function findingDisplayRows(findings, { numbersEnabled = true, audienceEnabled, notActiveEnabled = false, labels }) {
+    const { active } = groupByActivity(findings, notActiveEnabled);
+    const groups = audienceEnabled ? groupByAudience(active) : { users: active, team: [] };
     return [...groups.users, ...groups.team].map((finding, index) => ({ finding,
         label: findingLine(finding, numbersEnabled, index, labels, audienceEnabled), startsTeamGroup: groups.team.length > 0 && index === groups.users.length }));
 }
-export function formatSavedFindings(result, options) {
+function legacyFindingList(result, options) {
+    const groups = groupByActivity(result.findings ?? [], options.notActiveEnabled === true);
+    const collapsed = groups.notActive.length ? notActiveCountLine(groups.notActive.length) + "\n" : "";
     if (options.numbersEnabled !== false && result.findings?.some(value => value.seq !== undefined)) {
-        return "Findings:\n" + findingDisplayRows(result.findings, { ...options, labels: "reference" }).map(row => `${row.startsTeamGroup ? `${TEAM_WORKFLOW_HEADING}:\n` : ""}${row.label}\n`).join("");
+        return "Findings:\n" + findingDisplayRows(result.findings, { ...options, labels: "reference" }).map(row => `${row.startsTeamGroup ? `${TEAM_WORKFLOW_HEADING}:\n` : ""}${row.label}\n`).join("") + collapsed;
     }
+    if (collapsed)
+        return (groups.active.length ? `Finding ids: ${groups.active.map(f => f.id).join(", ")}\n` : "") + collapsed;
     return result.findingIds?.length ? `Finding ids: ${result.findingIds.join(", ")}\n` : "";
 }
+export function formatFindingActivity(activity) {
+    return `${activity.state === "dead" ? "Dead" : "Switched off"}: ${activity.reason}\n${activityAdvice(activity)}\n`;
+}
+// This is a presentation budget, separate from the size of the saved report.
+export const AGENT_FINDING_LIST_BUDGET = 12_000;
+function shortFix(fix) {
+    return [fix?.summary, fix?.title, fix?.approach].find(text => text?.trim()) ?? "";
+}
+function compactText(value, limit) {
+    const text = stripVTControlCharacters(value).replace(/[\p{Cc}\s]+/gu, " ").replace(/\s*\u2014\s*/g, ", ").trim();
+    if (text.length <= limit)
+        return text;
+    // Avoid ending on half of a supplementary Unicode character.
+    return Array.from(text.slice(0, limit - 3)).filter(char => !/^[\ud800-\udbff]$/.test(char)).join("") + "...";
+}
+function sentence(text) { return /[.!?]$/.test(text) ? text : `${text}.`; }
+function compactFinding(value) {
+    const compact = legacyFinding(value);
+    // Full fixes remain in saved detail; compact lists use only the existing short fix.
+    delete compact.fixes;
+    return { ...compact, title: compactText(value.title, 160) || "Untitled finding",
+        severity: compactText(value.severity ?? "", 24) || "severity unavailable",
+        ...(value.site ? { site: { path: compactText(value.site.path, 240), line: value.site.line } } : {}),
+        shortFix: compactText(value.shortFix ?? "", 240) || "No suggested fix available." };
+}
+function legacyFinding(value) {
+    const original = { ...value };
+    delete original.severity;
+    delete original.site;
+    delete original.shortFix;
+    return original;
+}
+export function findingDetailReference(value, projectId) {
+    return { id: value.seq !== undefined ? formatFindingNumber(value.seq) : value.id, ...(projectId ? { projectId } : {}) };
+}
+export function formatFindingContinuation(next) {
+    return `Next finding: get_finding(${JSON.stringify(next)})\n`;
+}
+export function presentSavedFindings(result, options) {
+    const rows = findingDisplayRows(result.findings ?? [], { ...options, labels: "reference" });
+    const orderedReferences = rows.flatMap(({ finding }) => finding.id ? [{ id: finding.id, seq: finding.seq }] : []);
+    if (options.agentReadableResults === false || options.numbersEnabled === false || !rows.length) {
+        return { text: legacyFindingList(result, options), findings: rows.map(row => legacyFinding(row.finding)),
+            findingIds: result.findingIds ?? [], nextFinding: undefined, orderedReferences };
+    }
+    const { notActive } = groupByActivity(result.findings ?? [], options.notActiveEnabled === true);
+    const collapsed = notActive.length ? notActiveCountLine(notActive.length) + "\n" : "";
+    let text = "Findings:\n";
+    const findings = [];
+    let nextFinding;
+    for (const [index, row] of rows.entries()) {
+        const value = compactFinding(row.finding);
+        const label = findingLabel(value, true, index, "reference");
+        const site = value.site ? `${value.site.path}:${value.site.line ?? "?"}` : "File unavailable";
+        const line = `${row.startsTeamGroup ? `${TEAM_WORKFLOW_HEADING}:\n` : ""}${label} (${value.severity}) ${sentence(value.title)} ${site}. Fix: ${value.shortFix}\n`;
+        const next = rows[index + 1]?.finding;
+        const footer = next ? overflowLine(rows.length - index - 1, next, options) : "";
+        const candidate = { text: text + line + footer + collapsed, findings: [...findings, value],
+            findingIds: [...findings, value].flatMap(finding => finding.id ? [finding.id] : []),
+            ...(next ? { nextFinding: findingDetailReference(next, options.projectId) } : {}) };
+        if (JSON.stringify(candidate).length > AGENT_FINDING_LIST_BUDGET) {
+            nextFinding = findingDetailReference(row.finding, options.projectId);
+            text += overflowLine(rows.length - index, row.finding, options);
+            break;
+        }
+        text += line;
+        findings.push(value);
+    }
+    return { text: text + collapsed, findings, findingIds: findings.flatMap(value => value.id ? [value.id] : []), nextFinding, orderedReferences };
+}
+function overflowLine(count, next, options) {
+    const guidance = options.surface === "mcp" ? `Next: get_finding(${JSON.stringify(findingDetailReference(next, options.projectId))}); follow nextFinding for the rest.`
+        : `Run counterfact-labs finding ${next.id} for the next one, or open Full results below.`;
+    return `${count} more ${count === 1 ? "finding" : "findings"}. ${guidance}\n`;
+}
+export function formatSavedFindings(result, options) {
+    return presentSavedFindings(result, options).text;
+}
 export function formatWaitingFixes(items, enabled, needsProject) {
     if (!items.length)
         return "No waiting fixes.";

package/dist/cli/finding-settings.js

@@ -1,5 +1,7 @@
 import { findingAudienceEnabled } from "../analysis-core/analysis/finding-audience-switch.js";
+import { notActiveEnabled } from "../analysis-core/analysis/finding-activity-switch.js";
 export function readFindingSettings(env = process.env, bundle) {
     return { numbersEnabled: env.CF_FINDING_NUMBERS !== "0", fixesEnabled: env.CF_WAITING_FIXES !== "0",
-        audienceEnabled: findingAudienceEnabled(env, bundle) };
+        audienceEnabled: findingAudienceEnabled(env, bundle), notActiveEnabled: notActiveEnabled(env),
+        agentReadableResults: env.CF_AGENT_READABLE_RESULTS !== "0" };
 }

package/dist/cli/intake-payload.js

@@ -1,8 +1,11 @@
+import { skippedFilesEnabled } from "../analysis-core/settings.js";
+import { fingerprintOf } from "../analysis-core/analysis/finding-identity.js";
 import { resultSafetyCheckEnabled } from "../analysis-core/settings.js";
 import { localFindingsPayloadSchema } from "../contract/console.js";
 import { projectPublicFinding } from "../contract/public-report.js";
 import { checkIntakeFindings } from "./result-check.js";
 import { RESULTS_TOO_LARGE_MESSAGE } from "../contract/cli-refusals.js";
+import { projectArchitecture } from "../contract/project-architecture.js";
 export function buildIntakePayload(identity, agent, report, options = {}) {
     const repo = (key) => key === null || key === report.repoKey ? agent.repository : key;
     let findings = report.findings.map(finding => projectPublicFinding(finding, repo));
@@ -19,8 +22,28 @@ export function buildIntakePayload(identity, agent, report, options = {}) {
         resultCheck = counts;
         findingIndexes = acceptedIndexes;
     }
-    const result = localFindingsPayloadSchema.safeParse({ ...identity, agent, findings });
+    const metadata = !skippedFilesEnabled(options.settings ?? {}) ? {} : {
+        ...(options.coverage ? { coverage: options.coverage } : {}),
+        ...(options.addToAnalysisId ? { addToAnalysisId: options.addToAnalysisId } : {}),
+        ...(options.findingAssessments ? { findingAssessments: findingIndexes.flatMap((index, at) => {
+                const assessment = options.findingAssessments.find(row => row.fingerprint === fingerprintOf(report.findings[index]));
+                return assessment ? [{ ...assessment, fingerprint: fingerprintOf(findings[at]) }] : [];
+            }) } : {}),
+    };
+    const findingActivities = findings.map(finding => finding.activity);
+    // Older consoles use a strict schema. Local grouping survives without sending an unsupported field.
+    if (options.consoleSupportsActivity !== true)
+        findings = findings.map(finding => {
+            const legacy = { ...finding };
+            delete legacy.activity;
+            return legacy;
+        });
+    const architecture = options.settings?.CF_LOCAL_ARCHITECTURE === "1" ? projectArchitecture(report.graph) : undefined;
+    let result = localFindingsPayloadSchema.safeParse({ ...identity, agent, findings, ...metadata, ...(architecture ? { architecture } : {}) });
+    // Optional map metadata must not crowd otherwise valid findings out of the total upload allowance.
+    if (!result.success && architecture)
+        result = localFindingsPayloadSchema.safeParse({ ...identity, agent, findings, ...metadata });
     if (!result.success)
         throw new Error(RESULTS_TOO_LARGE_MESSAGE);
-    return { payload: result.data, resultCheck, findingIndexes };
+    return { payload: result.data, resultCheck, findingIndexes, findingActivities };
 }

package/dist/cli/main.js

@@ -2,7 +2,7 @@
 import { pathToFileURL } from "node:url";
 import { realpath } from "node:fs/promises";
 import { errorCode, errorText } from "./api.js";
-import { readEmailSignIn, readSelectionSettings, scopeChoicesEnabled } from "../adapters/settings.js";
+import { fileScopeEnabled, readEmailSignIn, readSelectionSettings, scopeChoicesEnabled, multiEntryEnabled } from "../adapters/settings.js";
 import { commandContext } from "./context.js";
 import { analyze, parseAnalyzeOptions } from "./commands/analyze.js";
 import { finding } from "./commands/finding.js";
@@ -10,23 +10,35 @@ import { balance } from "./commands/balance.js";
 import { login, parseLoginOptions } from "./commands/login.js";
 import { logout } from "./commands/logout.js";
 import { serveMcp } from "./mcp.js";
+import { folderPartsEnabled, skippedFilesEnabled } from "../analysis-core/settings.js";
 import { loadAnalysisScope } from "./scope-choices.js";
 import { FILE_SCOPE_PUBLIC_USAGE } from "../contract/scope-choice.js";
-const usage = "Usage: counterfact-labs analyze [path] [--proposal <json-file>]\n       counterfact-labs finding <id>\n       counterfact-labs balance | login | logout | mcp\n";
 export async function run(args, options = {}) {
+    const skippedUsage = skippedFilesEnabled(options.startup?.settings ?? options.env ?? process.env)
+        ? "       counterfact-labs analyze [path] [--show-skipped | --skipped-plan | --skipped]\n" : "";
+    const usage = `Usage: counterfact-labs analyze [path] [--proposal <json-file>]\n${skippedUsage}       counterfact-labs finding <id>\n       counterfact-labs balance | login | logout | mcp\n`;
     const write = options.write ?? (text => { process.stdout.write(text); });
     const emailSignIn = options.emailSignIn ?? readEmailSignIn(options.env);
+    let fileMode = false;
     try {
         const [command, ...rest] = args;
         const env = options.startup?.settings ?? options.env ?? process.env;
         // Help follows the CLI defaults without validating unrelated commands' analysis switches.
         const selectionSettings = readSelectionSettings(env, { validate: command === "analyze" || command === "mcp" });
+        fileMode = fileScopeEnabled(selectionSettings);
         const commandOptions = { ...options, emailSignIn, env: { ...(options.env ?? process.env), ...selectionSettings,
                 ...(command === "analyze" || command === "mcp" ? {} : {
-                    CF_FILE_SCOPE: undefined, CF_SCOPE_CHOICES: undefined, CF_LOCAL_IMPORT_RESOLUTION: undefined,
+                    CF_FILE_SCOPE: undefined, CF_SCOPE_CHOICES: undefined, CF_LOCAL_IMPORT_RESOLUTION: undefined, CF_MULTI_ENTRY: undefined,
                 }) } };
         const choices = scopeChoicesEnabled(selectionSettings);
-        const commandUsage = choices ? FILE_SCOPE_PUBLIC_USAGE : usage;
+        const scopeUsage = choices ? FILE_SCOPE_PUBLIC_USAGE : usage;
+        // Insert the skipped-files usage line after the first usage line.
+        const firstLineEnd = scopeUsage.indexOf("\n") + 1;
+        let commandUsage = choices && firstLineEnd > 0
+            ? `${scopeUsage.slice(0, firstLineEnd)}${skippedUsage}${scopeUsage.slice(firstLineEnd)}`
+            : scopeUsage;
+        if (folderPartsEnabled(env))
+            commandUsage = commandUsage.replace(choices ? "[--scope <json-file>]" : "[--proposal <json-file>]", choices ? "[--scope <json-file | json-list>]" : "[--proposal <json-file>] [--scope <json-list>]");
         if (["--help", "-h", "help"].includes(command) || !command) {
             write(commandUsage);
             return 0;
@@ -34,13 +46,15 @@ export async function run(args, options = {}) {
         if (command === "analyze") {
             let parsed;
             try {
-                parsed = parseAnalyzeOptions(rest, choices);
+                parsed = parseAnalyzeOptions(rest, choices, multiEntryEnabled(selectionSettings));
             }
             catch {
                 throw new Error(commandUsage.trimEnd());
             }
             const ctx = commandContext(commandOptions);
-            const scope = await loadAnalysisScope(parsed.options, ctx.cwd ?? process.cwd(), ctx.startup.settings);
+            if (Array.isArray(parsed.options.scope) && !folderPartsEnabled(ctx.startup.settings))
+                throw new Error(commandUsage.trimEnd());
+            const scope = Array.isArray(parsed.options.scope) ? parsed.options.scope : await loadAnalysisScope(parsed.options, ctx.cwd ?? process.cwd(), ctx.startup.settings);
             return await analyze(parsed.path, { ...parsed.options, scope }, ctx);
         }
         if (command === "finding" && rest.length === 1 && !rest[0].startsWith("-"))
@@ -70,7 +84,7 @@ export async function run(args, options = {}) {
         throw new Error(commandUsage.trimEnd());
     }
     catch (error) {
-        write(errorText(error) + "\n");
+        write(errorText(error, fileMode) + "\n");
         return errorCode(error);
     }
 }

package/dist/cli/mcp-failure.js

@@ -1,8 +1,9 @@
 import { CliRefusalError, failureReason, START_FAILURE_MESSAGE } from "../contract/cli-refusals.js";
-import { errorText } from "./api.js";
-export function mcpFailure(error, enabled) {
-    // Only outside_project changed its sentence; the other local refusals already use the old sentences.
-    const message = !enabled && error instanceof CliRefusalError && error.code === "outside_project" ? START_FAILURE_MESSAGE
-        : errorText(error);
+import { cliApiMessages } from "../contract/cli-api-messages.js";
+import { errorText, SavedSignInError } from "./api.js";
+export function mcpFailure(error, enabled, fileMode = true) {
+    const message = error instanceof SavedSignInError ? cliApiMessages.unreadable_sign_in
+        : !enabled && !fileMode && error instanceof CliRefusalError && error.code === "outside_project"
+            ? START_FAILURE_MESSAGE : errorText(error, fileMode);
     return { message, ...(enabled ? { reason: failureReason(error) } : {}) };
 }