@counterfact-labs/cli 0.2.6 → 0.2.9

package/dist/cli/relay-preparation.js

@@ -1,15 +1,20 @@
+import { fileScopeOf } from "../analysis-core/analysis/file-analysis-plan.js";
 import { randomUUID } from "node:crypto";
 import { join, relative, sep } from "node:path";
-import { outsideLoadersEnabled } from "../analysis-core/settings.js";
+import { outsideLoadersEnabled, folderPartsEnabled } from "../analysis-core/settings.js";
+import { localSourcePlan } from "../analysis-core/requests/local-plan.js";
 import { resolveFolderPath } from "../adapters/folder-path.js";
 import { readLocalFolder } from "../adapters/files.js";
 import { snapshotProvenance, sameFileHashes } from "../adapters/snapshot.js";
 import { validateClientRelease } from "../adapters/release.js";
-import { prepareRelayPlan } from "../adapters/relay-plan.js";
+import { prepareRelayPlan } from "../adapters/source-relay-plan.js";
+import { readAnalysisSource } from "../adapters/selection.js";
 import { AgentChoiceError } from "../contract/agent-choice.js";
 import { COMMITTED_FILES_MESSAGE } from "../contract/cli-refusals.js";
 import { INVALID_PROPOSAL_MESSAGE } from "../contract/agent-proposal.js";
+import { selectionStartIdentity } from "../contract/selection-metadata.js";
 import { repositoryFacts } from "./git.js";
+import { proposalWhollyRefused } from "../analysis-core/index.js";
 /** Absolute checkout paths stay local; repository facts own the start's commit. */
 export function buildRelayStartPayload(facts, files) {
     const { remoteUrl, relPath, folderName, branch, commit, dirty } = facts;
@@ -18,39 +23,85 @@ export function buildRelayStartPayload(facts, files) {
 export function committedFilesOnly(settings) {
     return settings.CF_LOCAL_COMMITTED_ONLY === "1";
 }
+/** Every local choice uses the same canonical launch folder and source coordinates. */
+async function launchChoice(choice, folder, sourceBase, cwd) {
+    const launch = await resolveFolderPath(cwd), base = sourceBase ?? await resolveFolderPath(folder);
+    const launchPath = (path) => relative(launch, join(base, path)).split(sep).join("/") || ".";
+    return { ...choice, candidates: choice.candidates.map(candidate => ({ ...candidate,
+            folder: launchPath(candidate.folder), reason: launchPath(candidate.reason),
+        })) };
+}
+/** Every part must run alone; cost refusals also need a smaller normal call plan. */
+export async function prepareFolderChoice(folder, options) {
+    const { settings, signal } = options;
+    if (!folderPartsEnabled(settings) || fileScopeOf(settings) !== undefined)
+        return undefined;
+    if (options.limit === "plan_over_limit" && !options.refusedCalls)
+        return undefined;
+    signal?.throwIfAborted();
+    const read = await readLocalFolder(settings, folder, options.trialAdmission, { planParts: true, captureSnapshot: true });
+    const count = (calls) => calls.reduce((sum, call) => sum + call.calls, 0);
+    const refusedCount = count(options.refusedCalls ?? []);
+    const candidates = [];
+    // Finish each validation before starting another walk, so ten choices bound the extra reads.
+    for (const part of read.analysisParts ?? []) {
+        signal?.throwIfAborted();
+        try {
+            const scopedSettings = { ...settings, CF_PART_FILES: JSON.stringify(part.files) };
+            const source = await readLocalFolder(scopedSettings, folder, options.trialAdmission, { captureSnapshot: true });
+            if (source.agentChoice || part.files.some(path => !Object.hasOwn(source.files, path)))
+                continue;
+            if (options.limit === "plan_over_limit" && count(localSourcePlan(scopedSettings, source).calls) >= refusedCount)
+                continue;
+            candidates.push({ folder: ".", ...part });
+            if (candidates.length === 10)
+                break;
+        }
+        catch {
+            continue;
+        }
+    }
+    signal?.throwIfAborted();
+    return candidates.length ? launchChoice({ kind: "choose_scope", candidates }, folder, read.sourceBase, options.cwd ?? process.cwd()) : undefined;
+}
 /** Recovery can reuse signature validation without reading the folder again. */
 export async function prepareRelayCheck(folder, options, validated = validateClientRelease(options.release, options.settings)) {
-    const { bundle, tools, settings } = validated;
+    const { bundle } = validated;
     options.signal?.throwIfAborted();
     // Discovery must agree with Git before publishing repository-relative captures.
-    const earlyFacts = outsideLoadersEnabled(options.settings) ? await (options.facts ?? repositoryFacts)(folder) : undefined;
-    options.signal?.throwIfAborted();
-    const read = await readLocalFolder(options.settings, folder, options.trialAdmission, { captureSnapshot: true,
-        proposal: options.proposal,
-        ...(earlyFacts ? { expectedRepositoryRoot: earlyFacts.repoRoot ?? null } : {}) });
-    if (read.proposalCounts?.fromProposal === 0 && read.proposalCounts.rejected > 0)
+    const selection = options.selection;
+    const factsFolder = selection?.factsFolder ?? folder;
+    let earlyFacts;
+    const { source: read, membership } = await readAnalysisSource(options.settings, folder, {
+        selection, provider: options.selectionProvider, proposal: options.proposal, admission: options.trialAdmission, signal: options.signal,
+        readFolder: async () => {
+            if (outsideLoadersEnabled(options.settings))
+                earlyFacts = await (options.facts ?? repositoryFacts)(factsFolder);
+            options.signal?.throwIfAborted();
+            return readLocalFolder(options.settings, folder, options.trialAdmission, { captureSnapshot: true, proposal: options.proposal,
+                ...(earlyFacts ? { expectedRepositoryRoot: earlyFacts.repoRoot ?? null } : {}) });
+        },
+    });
+    if (proposalWhollyRefused(read.proposalCounts))
         throw new Error(INVALID_PROPOSAL_MESSAGE);
     if (read.agentChoice) {
-        const cwd = await resolveFolderPath(options.cwd ?? process.cwd());
-        const launchPath = (path) => relative(cwd, join(read.sourceBase ?? folder, path)).split(sep).join("/") || ".";
-        throw new AgentChoiceError({ ...read.agentChoice,
-            candidates: read.agentChoice.candidates.map(candidate => ({
-                folder: launchPath(candidate.folder), reason: launchPath(candidate.reason),
-            })),
-        });
+        throw new AgentChoiceError(await launchChoice(read.agentChoice, folder, read.sourceBase, options.cwd ?? process.cwd()));
     }
     const source = { ...read, files: Object.freeze({ ...read.files }) };
-    const provenance = await snapshotProvenance(source.sourceBase ?? folder, source.snapshot, { selectionFolder: folder, committedOnly: committedFilesOnly(options.settings) });
+    const provenance = await snapshotProvenance(selection?.kind === "file" ? selection.launchRoot : source.sourceBase ?? folder, source.snapshot, { selectionFolder: factsFolder, committedOnly: committedFilesOnly(options.settings) });
     if (options.expectedCommit === null) {
         if (!sameFileHashes(options.expectedFiles ?? [], source.snapshot))
             throw new Error(COMMITTED_FILES_MESSAGE);
     }
     else if (options.expectedCommit !== undefined && provenance.commit !== options.expectedCommit)
         throw new Error(COMMITTED_FILES_MESSAGE);
-    const { plan, files } = prepareRelayPlan({ bundle, tools, settings, relayVersion: options.release.relayVersion, source });
+    const { plan, files } = prepareRelayPlan({ bundle, settings: validated.settings, relayVersion: options.release.relayVersion, source });
     options.signal?.throwIfAborted();
-    const facts = earlyFacts ?? await (options.facts ?? repositoryFacts)(folder);
+    const facts = earlyFacts ?? await (options.facts ?? repositoryFacts)(factsFolder);
     options.signal?.throwIfAborted();
-    const startMetadata = { analysisSize: source.analysisSize, startAttempt: randomUUID() };
-    return { source, provenance, plan, start: buildRelayStartPayload(source.sourceBase ? { ...facts, relPath: "" } : facts, files), startMetadata };
+    const startMetadata = { analysisSize: source.analysisSize, startAttempt: randomUUID(),
+        ...(selection?.kind === "file" && membership
+            ? { selection: selectionStartIdentity(selection.selectionKey, membership.snapshot) } : {}) };
+    return { source, provenance, plan, start: buildRelayStartPayload(source.sourceBase && selection?.kind !== "file" ? { ...facts, relPath: "" } : facts, files), startMetadata,
+        ...(membership ? { membership } : {}) };
 }

package/dist/cli/result-check.js

@@ -1,6 +1,5 @@
-import { publicFinding, resultCheckFinding, RESULT_CHECK_LIMITS } from "../analysis-core/contracts/relay-analysis.js";
+import { publicFinding, intakeFinding, resultCheckFinding, RESULT_CHECK_LIMITS } from "../analysis-core/contracts/intake-finding.js";
 import { findingSitesInOrder } from "../analysis-core/findings/sites.js";
-import { localFindingSchema } from "../contract/console.js";
 function evidenceQuotes(finding, repoKey) {
     const primary = finding.site ? { repo: finding.siteRepo ?? repoKey, ...finding.site, excerpt: finding.excerpt } : null;
     const sites = findingSitesInOrder(primary, finding.otherSites);
@@ -36,27 +35,47 @@ export function checkIntakeFindings(findings, context, onInvalidQuote) {
         return originals.get(path);
     }
     let quotes = 0, droppedQuotes = 0, invalidQuotes = 0, schemaDroppedFindings = 0, capDroppedFindings = 0;
+    function invalidQuote(quote) {
+        const source = quote.repo === context.repoKey && typeof quote.path === "string" && Object.hasOwn(context.files, quote.path)
+            ? original(quote.path) : null;
+        const invalid = !quote.text.length || source === null || !source.includes(quote.text);
+        if (invalid)
+            onInvalidQuote?.({ text: quote.text, source });
+        return invalid;
+    }
     findings.forEach((finding, index) => {
         const parsed = publicFinding.safeParse(finding);
+        let activityQuoteCount = 0;
+        if (parsed.success && parsed.data.activity) {
+            const activityQuotes = parsed.data.activity.evidence.map(site => ({ repo: parsed.data.siteRepo ?? context.repoKey, path: site.path, text: site.excerpt }));
+            // Optional activity cannot weaken the original-byte evidence boundary or cost a substantive finding.
+            activityQuoteCount = activityQuotes.length;
+            quotes += activityQuoteCount;
+            const invalid = activityQuotes.filter(invalidQuote).length;
+            invalidQuotes += invalid;
+            if (invalid)
+                delete parsed.data.activity;
+            if (parsed.data.activity && (!resultCheckFinding.safeParse(parsed.data).success || !intakeFinding.safeParse(parsed.data).success)) {
+                const substantive = { ...parsed.data };
+                delete substantive.activity;
+                if (resultCheckFinding.safeParse(substantive).success && intakeFinding.safeParse(substantive).success)
+                    delete parsed.data.activity;
+            }
+        }
+        if (parsed.success && !parsed.data.activity)
+            droppedQuotes += activityQuoteCount;
         const evidence = parsed.success ? evidenceQuotes(parsed.data, context.repoKey) : [];
         quotes += evidence.length;
-        const invalid = evidence.filter(quote => {
-            const source = quote.repo === context.repoKey && typeof quote.path === "string" && Object.hasOwn(context.files, quote.path)
-                ? original(quote.path) : null;
-            const invalid = !quote.text.length || source === null || !source.includes(quote.text);
-            if (invalid)
-                onInvalidQuote?.({ text: quote.text, source });
-            return invalid;
-        }).length;
+        const invalid = evidence.filter(invalidQuote).length;
         invalidQuotes += invalid;
-        const schemaValid = parsed.success && resultCheckFinding.safeParse(parsed.data).success && localFindingSchema.safeParse(parsed.data).success;
+        const schemaValid = parsed.success && resultCheckFinding.safeParse(parsed.data).success && intakeFinding.safeParse(parsed.data).success;
         if (!schemaValid)
             schemaDroppedFindings++;
         if (index >= RESULT_CHECK_LIMITS.findings)
             capDroppedFindings++;
         if (!schemaValid || !parsed.success || invalid || index >= RESULT_CHECK_LIMITS.findings) {
             // Removing one supporting quote could change the claim or invalidate source-note indices.
-            droppedQuotes += evidence.length;
+            droppedQuotes += evidence.length + (parsed.success && parsed.data.activity ? activityQuoteCount : 0);
         }
         else {
             accepted.push(parsed.data);

package/dist/cli/results-upload.js

@@ -0,0 +1,131 @@
+import { setTimeout as sleep } from "node:timers/promises";
+import { ConsoleError } from "../gatekeeper/console.js";
+import { completionRecoveryDecision, completionRetryDeadline, observedCompletionTiming, matchesCheck } from "./completion-recovery.js";
+export function requireIntakeReservation(status) {
+    if (status.state === "reserved")
+        return;
+    if (status.state === "closing")
+        throw new ConsoleError("reservation_closing");
+    if (status.state === "closed")
+        throw new ConsoleError("reservation_closed");
+    throw new ConsoleError("reservation_expired", "intake");
+}
+/** Carry the owner's answer so cleanup cannot turn a definite refusal into an endless retry. */
+export class ResultsUploadError extends ConsoleError {
+    decision;
+    timing;
+    outcome;
+    constructor(error, decision, timing, httpStatus = error instanceof ConsoleError ? error.httpStatus : undefined) {
+        super(error instanceof ConsoleError ? error.code : "unavailable", "intake", error instanceof ConsoleError ? { localReason: error.localReason, responseCode: error.responseCode, httpStatus: error.httpStatus } : {});
+        this.decision = decision;
+        this.timing = timing;
+        this.outcome = { kind: "decided", decision, ...(httpStatus === undefined ? {} : { httpStatus }) };
+        if (error instanceof Error)
+            this.name = error.name;
+        if (error instanceof ConsoleError)
+            this.message = error.message;
+    }
+}
+export const uploadFailure = (error) => {
+    if (!(error instanceof ConsoleError))
+        return { kind: "refused", code: "unavailable", transportFailure: true };
+    return { kind: "refused", code: error.responseCode ?? error.code, httpStatus: error.httpStatus };
+};
+const committed = (value) => ({ checkId: value.checkId, projectId: value.projectId,
+    analysisId: value.analysisId, findingIds: value.findingIds,
+    ...(value.findings ? { findings: value.findings } : {}), settlement: value.settlement });
+/** Status confirms committed identity; intake owns whether a completed payload can still be saved. */
+export async function submitResults(client, payload, signal, options) {
+    const now = options.now ?? Date.now;
+    const wait = options.wait ?? ((ms, signal) => sleep(ms, undefined, { signal }));
+    let timing = { ...options.timing, completedAt: options.timing?.completedAt ?? now(), retryStartedAt: now() };
+    let lookup = { kind: "skipped" };
+    let outcome = { kind: options.retry && options.alreadySaved ? "saved" : "pending" };
+    const uploadHttpStatus = () => "httpStatus" in outcome ? outcome.httpStatus : undefined;
+    const failure = (error, decision) => new ResultsUploadError(error, decision, timing, uploadHttpStatus());
+    const deadline = () => completionRetryDeadline(timing, lookup, payload, outcome);
+    const receipt = (value) => value && matchesCheck(value, payload) && value.uploadState === "saved"
+        ? committed(value) : { checkId: payload.checkId, projectId: payload.projectId };
+    const decide = () => completionRecoveryDecision({ retryEnabled: options.retry, payload, statusLookup: lookup, uploadOutcome: outcome, timing, now: now() });
+    const status = async () => {
+        try {
+            const value = await client.status(payload.reservationId);
+            lookup = { kind: "found", status: value };
+            timing = observedCompletionTiming(timing, lookup, payload);
+            return value;
+        }
+        catch (error) {
+            lookup = { ...uploadFailure(error), kind: "failed" };
+            throw error;
+        }
+    };
+    try {
+        signal.throwIfAborted();
+        const before = await status().catch(error => {
+            const decision = decide();
+            if (options.retry && decision.action === "saved")
+                return undefined;
+            if (!options.retry)
+                throw error;
+            return undefined;
+        });
+        const initial = decide();
+        if (initial.action === "saved")
+            return receipt(before);
+        if (options.retry && initial.action === "give-up")
+            throw failure(new ConsoleError(initial.code === "check_conflict" ? "check_conflict" : initial.code === "reservation_expired" ? "reservation_expired" : "reservation_closed", "intake"), initial);
+        if (before && !options.retry) {
+            if (!matchesCheck(before, payload))
+                throw new ConsoleError("check_conflict");
+            requireIntakeReservation(before);
+        }
+        if (options.retry && now() >= deadline())
+            throw failure(new ConsoleError(), initial);
+        let delay = 1000;
+        for (;;) {
+            signal.throwIfAborted();
+            try {
+                const saved = await client.intake(payload, { acceptAnySuccess: options.retry });
+                outcome = { kind: "saved" };
+                decide();
+                return saved;
+            }
+            catch (error) {
+                outcome = uploadFailure(error);
+                // A lost response may have committed; confirm it before retrying the same payload.
+                const after = await status().catch(() => undefined);
+                const decision = decide();
+                if (decision.action === "saved")
+                    return receipt(after);
+                if (!options.retry) {
+                    if (after && !matchesCheck(after, payload))
+                        throw new ConsoleError("check_conflict");
+                    if (error instanceof ConsoleError && error.code === "unavailable" && after) {
+                        requireIntakeReservation(after);
+                        signal.throwIfAborted();
+                        return await client.intake(payload, { acceptAnySuccess: options.retry });
+                    }
+                    throw error;
+                }
+                const remaining = deadline() - now();
+                if (decision.action !== "retry" || !decision.automatic || remaining <= 0)
+                    throw failure(error, decision);
+                await wait(Math.min(delay, remaining), signal);
+                signal.throwIfAborted();
+                if (now() >= deadline())
+                    throw failure(error, decide());
+                delay = Math.min(delay * 2, 30_000);
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof ResultsUploadError)
+            throw error;
+        if (signal.aborted && outcome.kind !== "saved")
+            outcome = { kind: "cancelled", httpStatus: uploadHttpStatus() };
+        const decision = decide();
+        if (decision.action === "saved")
+            return receipt();
+        throw failure(error, decision);
+    }
+}

package/dist/cli/saved-results.js

@@ -0,0 +1,10 @@
+import { readFindingSettings } from "./finding-settings.js";
+import { formatSavedFindings } from "./finding-display.js";
+import { skippedResultText } from "./skipped-files.js";
+/** Terminal and grouped follow-ups use the same final result presentation. */
+export function formatSavedResults(result, settings, numbersEnabled, offer = true, options = {}) {
+    return formatSavedFindings(result, { numbersEnabled, audienceEnabled: result.audienceEnabled, notActiveEnabled: result.notActiveEnabled,
+        agentReadableResults: options.agentReadableResults ?? readFindingSettings(settings).agentReadableResults, projectId: result.projectId, surface: options.surface })
+        + skippedResultText(result.skippedFiles ?? [], settings, { offer, surface: options.surface, folder: options.analyzedFolder }) + `Full results: ${result.url}\n`
+        + (result.architectureUrl ? `Architecture: ${result.architectureUrl}\n` : "");
+}

package/dist/cli/scope-choices.js

@@ -0,0 +1,57 @@
+import { readdir, readFile, unlink } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { outputPaths, writeOutputFiles } from "../adapters/output-paths.js";
+import { analysisScopeSchema, chooseScopeResultSchema, INCLUDED_FILES_CAPTION, OMITTED_IMPORTS_CAPTION, OMITTED_FILES_CAPTION, SCOPE_CHOICE_INSTRUCTION, INCOMPLETE_IMPORTS_MESSAGE, IMPORT_DISCOVERY_LIMIT_MESSAGE, INVALID_SCOPE_MESSAGE, SCOPE_RETRY_TEMPLATE } from "../contract/scope-choice.js";
+import { scopeChoiceRefusal } from "../contract/selection-offer.js";
+import { scopeChoicesEnabled } from "../adapters/settings.js";
+export async function loadAnalysisScope(options, cwd, settings) {
+    if (options.scope === undefined && options.scopeFile === undefined)
+        return undefined;
+    if (!scopeChoicesEnabled(settings))
+        throw new Error(INVALID_SCOPE_MESSAGE);
+    try {
+        const value = options.scopeFile === undefined ? options.scope : JSON.parse(await readFile(resolve(cwd, options.scopeFile), "utf8"));
+        return analysisScopeSchema.parse(value);
+    }
+    catch {
+        throw new Error(INVALID_SCOPE_MESSAGE);
+    }
+}
+export function shellQuote(value) { return `'${value.replaceAll("'", `'"'"'`)}'`; }
+/** MCP and terminal output share the same file coverage; only the terminal adds retry commands. */
+export function scopeChoiceText(value, retryPaths = {}) {
+    const result = chooseScopeResultSchema.parse(value);
+    const refusal = scopeChoiceRefusal(result);
+    if (refusal)
+        return refusal + "\n";
+    const lines = [result.text];
+    if (!result.coverageComplete && result.refusedEdges.length > 0)
+        lines.push(INCOMPLETE_IMPORTS_MESSAGE);
+    if (!result.coverageComplete && result.frontierCount > 0)
+        lines.push(IMPORT_DISCOVERY_LIMIT_MESSAGE);
+    result.choices.forEach((choice, index) => {
+        lines.push(`${index + 1}. ${choice.label}`, choice.description, INCLUDED_FILES_CAPTION, ...choice.includes.map(path => `  ${path}`));
+        if (choice.omitted.length > 0)
+            lines.push(choice.scope.entries ? OMITTED_FILES_CAPTION : OMITTED_IMPORTS_CAPTION, ...choice.omitted.map(path => `  ${path}`));
+        if (choice.fits !== false && retryPaths[index]) {
+            const entry = choice.scope.entry.startsWith("-") ? `./${choice.scope.entry}` : choice.scope.entry;
+            lines.push(SCOPE_RETRY_TEMPLATE.replace("{quoted-entry}", () => shellQuote(entry))
+                .replace("{quoted-scope-file}", () => shellQuote(retryPaths[index])));
+        }
+    });
+    lines.push(SCOPE_CHOICE_INSTRUCTION);
+    return lines.join("\n") + "\n";
+}
+export async function renderScopeChoices(value, anchor) {
+    const result = chooseScopeResultSchema.parse(value);
+    // Validate the output directory and old entries before removing only generated scope files.
+    const [probe] = await outputPaths(anchor.outputAnchor, ["scope-1.json"], anchor.outputDir, true);
+    const old = (await readdir(dirname(probe))).filter(name => /^scope-.*\.json$/.test(name));
+    await outputPaths(anchor.outputAnchor, old, anchor.outputDir);
+    for (const name of old)
+        await unlink(join(dirname(probe), name));
+    const runnable = result.choices.flatMap((choice, index) => choice.fits === false ? [] : [{ choice, index }]);
+    const files = Object.fromEntries(runnable.map(({ choice, index }) => [`scope-${index + 1}.json`, JSON.stringify(choice.scope, null, 2) + "\n"]));
+    const paths = await writeOutputFiles(anchor.outputAnchor, files, anchor.outputDir);
+    return scopeChoiceText(result, Object.fromEntries(runnable.map(({ index }, position) => [index, paths[position]])));
+}

package/dist/cli/sign-in.js

@@ -1,4 +1,4 @@
-import { ApiError } from "./api.js";
+import { ApiError, SavedSignInError } from "./api.js";
 import { readCredentials, saveCredentials } from "./credentials.js";
 import { emailSignInMessages } from "../contract/email-sign-in-messages.js";
 import { cliApiMessages } from "../contract/cli-api-messages.js";
@@ -89,7 +89,7 @@ export async function signInStatus(ctx) {
         return { signedIn: true };
     }
     catch (error) {
-        if (error instanceof ApiError && error.status === 401)
+        if (error instanceof SavedSignInError || error instanceof ApiError && error.status === 401)
             return { signedIn: false };
         throw error;
     }

package/dist/cli/skipped-files.js

@@ -0,0 +1,22 @@
+import { skippedFilesEnabled } from "../analysis-core/settings.js";
+import { skippedFilesNotice, ANALYZE_SKIPPED_FILES_OFFER } from "../analysis-core/analysis/code-agents/skipped-files.js";
+import { analyzeCommand } from "../contract/agent-choice.js";
+function terminalOffer(folder) {
+    return `To analyze them separately, run ${analyzeCommand(folder)} --skipped.`;
+}
+export function skippedResultText(files, settings = {}, options = {}) {
+    if (!skippedFilesEnabled(settings))
+        return "";
+    const notice = skippedFilesNotice(files);
+    if (!notice)
+        return "";
+    const offer = options.offer === false ? "" : `${options.surface === "mcp" ? ANALYZE_SKIPPED_FILES_OFFER : terminalOffer(options.folder ?? ".")}\n`;
+    return `${notice}\n${offer}`;
+}
+export function followupPlanText(plan) {
+    const count = plan.groups.length;
+    return [count ? `This will run ${count} ${count === 1 ? "analysis" : "analyses"}.` : "No skipped files remain to analyze.",
+        ...plan.tooLarge.map(path => `${path}: too large to analyze.`),
+        ...plan.unavailable.map(path => `${path}: could not be read.`),
+        ...(plan.missingContext ?? []).map(file => `${file.path}: some imported files could not be included: ${file.imports.join(", ")}.`), ""].join("\n");
+}

package/dist/cli/summary.js

@@ -1,8 +1,13 @@
+import { skippedResultText } from "./skipped-files.js";
 import { findingPresentation } from "../analysis-core/findings/presentation.js";
-import { findingDisplayRows, TEAM_WORKFLOW_HEADING } from "./finding-display.js";
+import { activityAdvice, findingDisplayRows, notActiveCountLine, TEAM_WORKFLOW_HEADING } from "./finding-display.js";
+import { groupByActivity } from "../analysis-core/analysis/schemas.js";
 export function formatSummary(report, options) {
     const lines = ["# Counterfact analysis", "",
         `${report.findings.length} findings; ${report.structures.length} structural proposals.`, ""];
+    const skipped = skippedResultText(report.refusedFiles ?? [], { CF_SKIPPED_FILES: options.skippedFilesEnabled === false ? "0" : "1" }, { offer: options.skippedOffer, folder: options.analyzedFolder });
+    if (skipped)
+        lines.push(skipped.trimEnd(), "");
     if (!report.findings.length)
         lines.push("No findings.", "");
     const findings = report.findings.map(finding => {
@@ -25,6 +30,15 @@ export function formatSummary(report, options) {
         if (finding.fixes.length)
             lines.push(...finding.fixes.map(fix => `- ${fix.title}`), "");
     }
+    const { notActive } = groupByActivity(findings, options.notActiveEnabled === true);
+    if (notActive.length) {
+        lines.push("<details>", `<summary>${notActiveCountLine(notActive.length)}</summary>`, "");
+        for (const finding of notActive) {
+            const activity = finding.activity;
+            lines.push(`### ${finding.title}`, "", `${activity.state === "dead" ? "Dead" : "Switched off"}: ${activity.reason}`, "", activityAdvice(activity), "", finding.cause, "", ...finding.fixes.map(fix => `- ${fix.title}: ${fix.approach}`), "");
+        }
+        lines.push("</details>", "");
+    }
     if (report.structures.length)
         lines.push("## Structural proposals", "", ...report.structures.flatMap(proposal => {
             const presentation = findingPresentation({ ...proposal, title: proposal.body.title });

package/dist/contract/agent-choice.js

@@ -1,14 +1,37 @@
+import { CLI_VERSION } from "./cli-version.js";
 export const CHOOSE_AGENT_MESSAGE = "Counterfact couldn't tell which folder holds your agent. Run it again on that folder, for example";
 export const NO_AGENT_MESSAGE = "Counterfact couldn't find an agent prompt in this folder. Pass a folder containing an agent prompt or a model call with a system prompt.";
+const ANALYZE_COMMAND = `npx -y @counterfact-labs/cli@${CLI_VERSION} analyze`;
+export function analyzeCommand(folder) {
+    return `${ANALYZE_COMMAND} ${shellArgument(folder)}`;
+}
 /** The local importer supplies the choice; transport keeps its data and wording together. */
 export class AgentChoiceError extends Error {
     agentChoice;
     constructor(agentChoice) {
-        const folders = [...new Set(agentChoice.candidates.map(candidate => candidate.folder))];
-        super(agentChoice.kind === "choose_agent" ? [`${CHOOSE_AGENT_MESSAGE} counterfact-labs analyze ${shellArgument(folders[0])}.`, "These folders look like agents:", ...folders].join("\n") : NO_AGENT_MESSAGE);
+        super(agentChoiceMessage(agentChoice));
         this.agentChoice = agentChoice;
     }
 }
+export function agentChoiceMessage(agentChoice, surface = "terminal") {
+    if (agentChoice.kind === "choose_scope")
+        return scopeChoiceMessage(agentChoice, surface);
+    if (agentChoice.kind === "choose_agent")
+        return folderChoiceMessage(agentChoice);
+    return NO_AGENT_MESSAGE;
+}
+function scopeChoiceMessage(agentChoice, surface) {
+    return ["Choose one part to analyze:", ...agentChoice.candidates.map((candidate, index) => {
+            const label = `${index + 1}. ${candidate.label}`;
+            if (surface === "mcp")
+                return label;
+            return `${label}\n   ${analyzeCommand(candidate.folder)} --scope ${shellArgument(JSON.stringify(candidate.files))}`;
+        })].join("\n");
+}
+function folderChoiceMessage(agentChoice) {
+    const folders = [...new Set(agentChoice.candidates.map(candidate => candidate.folder))];
+    return [`${CHOOSE_AGENT_MESSAGE} ${analyzeCommand(folders[0])}.`, "These folders look like agents:", ...folders].join("\n");
+}
 /** Folder names must remain literal when a user pastes the suggested command. */
 function shellArgument(folder) {
     return /^[a-zA-Z0-9_./-]+$/.test(folder) ? folder : `'${folder.replaceAll("'", "'\\''")}'`;

package/dist/contract/cli-api-messages.js

@@ -1,7 +1,10 @@
+import { CLI_VERSION } from "./cli-version.js";
 export const cliApiMessages = Object.freeze({
     unreachable: "Can't reach Counterfact. Try again shortly.",
     invalid_response: "Counterfact returned an invalid response. Try again shortly.",
     request_failed: "The request could not be completed. Try again shortly.",
+    unreadable_sign_in: "Your saved sign-in can't be read. Sign in again.",
+    unreadable_sign_in_terminal: `Your saved sign-in can't be read. Sign in again with npx -y @counterfact-labs/cli@${CLI_VERSION} login.`,
     unauthorized: "Not signed in. Run counterfact-labs login.",
     invalid_console_url: "COUNTERFACT_URL must be an HTTP or HTTPS address without credentials or query fields.",
 });

package/dist/contract/cli-refusals.js

@@ -1,18 +1,27 @@
 import { FOLDER_TOO_LARGE_MESSAGE } from "../analysis-core/errors.js";
 import { cliApiMessages } from "./cli-api-messages.js";
 import { emailSignInMessages } from "./email-sign-in-messages.js";
+import { ANALYSIS_TOO_LARGE_MESSAGE, INVALID_SELECTION_MESSAGE } from "./scope-choice.js";
 export const START_FAILURE_MESSAGE = "This couldn't start. Try again.";
 export const RESERVATION_EXPIRED_MESSAGE = "This reservation expired. Start a new analysis.";
 export const FINISH_FAILURE_MESSAGE = "The analysis couldn't finish. Try again.";
+export const NOT_ALLOWED_MESSAGE = "Your account can't run analyses. Ask Counterfact for access.";
+export const SIGN_IN_EXPIRED_MESSAGE = "Your sign-in has expired. Run counterfact-labs login, then try again.";
+export const FOLDER_BUSY_MESSAGE = "Another analysis is running on this folder. Try again when it finishes.";
+export const CHECK_CONFLICT_MESSAGE = "Saved results from an earlier run don't match this analysis. Start a new analysis.";
+export const UNSAVED_RESULTS_MESSAGE = "The analysis ended before its results were saved. Start a new analysis.";
+export const PENDING_RESULTS_MESSAGE = "Your results are kept on this computer. Run the same command on the same folder again to save them at no extra charge.";
 export const RESULTS_TOO_LARGE_MESSAGE = "The results were too large to save. Try again.";
 export const COMMITTED_FILES_MESSAGE = "Counterfact analyzes the committed version of the agent's files. Commit your changes, then try again.";
 const unsupportedVersion = "This version of Counterfact can't run analyses. Update it: npm install -g @counterfact-labs/cli@latest.";
 // The console separates over-limit costs from version or route mismatches, so each code gets its own recovery guidance.
-const analysisTooLarge = "This analysis is too large to run at once. Choose a smaller folder, such as one agent's folder.";
+const localReadFailure = "Counterfact couldn't read the selected file or folder. Check that it exists and is readable, then try again.";
 export const localRefusals = {
-    outside_project: "Choose a folder inside this project, or start Claude Code or Codex in the folder you want to analyze.",
-    launch_folder_unavailable: START_FAILURE_MESSAGE,
-    folder_unavailable: START_FAILURE_MESSAGE,
+    outside_project: INVALID_SELECTION_MESSAGE,
+    launch_folder_unavailable: "Counterfact couldn't read the launch folder. Check that it exists and is readable, then try again.",
+    folder_unavailable: localReadFailure,
+    local_read_failed: localReadFailure,
+    local_git_failed: "Counterfact couldn't read this folder's Git information. Check that Git works in this folder, then try again.",
     repeat_too_soon: FINISH_FAILURE_MESSAGE,
 };
 /** Both console clients use the same public messages for server refusals. */
@@ -22,7 +31,7 @@ export const cliRefusals = {
     local_checks_paused: "Analyses are paused right now. Try again later.",
     cli_update_required: "Update Counterfact: run npm install -g @counterfact-labs/cli@latest.",
     release_unavailable: unsupportedVersion,
-    plan_over_limit: analysisTooLarge,
+    plan_over_limit: ANALYSIS_TOO_LARGE_MESSAGE,
     invalid_plan: unsupportedVersion,
     invalid_body: "Counterfact couldn't read this request. Update Counterfact, then try again.",
     body_too_large: "This request is too large. The limit is 2 MB.",
@@ -70,14 +79,39 @@ const reasonValues = [
     ...Object.keys(localRefusals),
     ...Object.values(otherReasons), ...Object.values(messageReasons),
     "console_unreachable", "invalid_console_url", "relay_unreachable", "results_not_saved",
+    "results_saved_report_failed", "results_pending", "results_discarded",
+    "folder_busy", "completion_settings_mismatch",
 ];
 const ownedReasons = new Set(reasonValues);
+const readErrorCodes = new Set(["ENOENT", "EACCES", "EPERM", "ENOTDIR", "EISDIR", "ELOOP", "EMFILE", "ENFILE", "EIO", "ESTALE", "EBADF", "EINVAL", "ENOMEM", "EAGAIN", "EBUSY"]);
+/** Classify local failures without copying paths, command output or file contents into public errors. */
+export function localFailure(error) {
+    if (!(error instanceof Error))
+        return undefined;
+    if ("reason" in error && error.reason === "local_git_failed")
+        return { message: localRefusals.local_git_failed, reason: "local_git_failed" };
+    // Only the selection reader knows whether a filesystem operation belongs to the agent.
+    if (!("localOperation" in error) || error.localOperation !== "read")
+        return undefined;
+    const syscall = "syscall" in error ? error.syscall : undefined;
+    const code = "code" in error ? error.code : undefined;
+    if (typeof code === "string" && readErrorCodes.has(code) && typeof syscall === "string"
+        && (/^(?:read|stat|lstat|scandir|opendir|realpath|readlink|access)$/.test(syscall)
+            || syscall === "open")
+        || "code" in error && error.code === "ERR_ACCESS_DENIED" && "permission" in error && error.permission === "FileSystemRead") {
+        return { message: localRefusals.local_read_failed, reason: "local_read_failed" };
+    }
+    return undefined;
+}
 /** Only fixed reasons may cross the MCP boundary; diagnostics can contain customer data. */
 export function failureReason(error) {
     if (!(error instanceof Error))
         return "request_failed";
     if (error instanceof CliRefusalError)
         return error.code;
+    const local = localFailure(error);
+    if (local)
+        return local.reason;
     if ("reason" in error && typeof error.reason === "string" && ownedReasons.has(error.reason))
         return error.reason;
     const code = "code" in error ? error.code : undefined;

package/dist/contract/cli-version.js

@@ -1 +1 @@
-export const CLI_VERSION = "0.2.6";
+export const CLI_VERSION = "0.2.9";

package/dist/contract/console-url.js

@@ -1,6 +1,9 @@
 export function savedAnalysisUrl(projectId, consoleOrigin) {
     return new URL(`/projects/${projectId}/findings`, consoleOrigin).href;
 }
+export function savedArchitectureUrl(projectId, consoleOrigin) {
+    return new URL(`/projects/${projectId}/architecture/overview`, consoleOrigin).href;
+}
 import { isLoopbackHost } from "../gatekeeper/loopback.js";
 /** Bearer credentials may use plain HTTP only on this machine. */
 export function consoleSchemeAllowed(url) {