@counterfact-labs/cli 0.2.7 → 0.2.10

package/dist/cli/relay-preparation.js

@@ -1,6 +1,8 @@
+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";
@@ -12,6 +14,7 @@ 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;
@@ -20,6 +23,47 @@ 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 } = validated;
@@ -38,16 +82,10 @@ export async function prepareRelayCheck(folder, options, validated = validateCli
                 ...(earlyFacts ? { expectedRepositoryRoot: earlyFacts.repoRoot ?? null } : {}) });
         },
     });
-    if (read.proposalCounts?.fromProposal === 0 && read.proposalCounts.rejected > 0)
+    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(selection?.kind === "file" ? selection.launchRoot : source.sourceBase ?? folder, source.snapshot, { selectionFolder: factsFolder, committedOnly: committedFilesOnly(options.settings) });

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/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

@@ -1,7 +1,7 @@
 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, CHOOSE_SCOPE_MESSAGE, INCLUDED_FILES_CAPTION, OMITTED_IMPORTS_CAPTION, SCOPE_CHOICE_INSTRUCTION, INCOMPLETE_IMPORTS_MESSAGE, IMPORT_DISCOVERY_LIMIT_MESSAGE, INVALID_SCOPE_MESSAGE, SCOPE_RETRY_TEMPLATE } from "../contract/scope-choice.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) {
@@ -24,7 +24,7 @@ export function scopeChoiceText(value, retryPaths = {}) {
     const refusal = scopeChoiceRefusal(result);
     if (refusal)
         return refusal + "\n";
-    const lines = [CHOOSE_SCOPE_MESSAGE];
+    const lines = [result.text];
     if (!result.coverageComplete && result.refusedEdges.length > 0)
         lines.push(INCOMPLETE_IMPORTS_MESSAGE);
     if (!result.coverageComplete && result.frontierCount > 0)
@@ -32,7 +32,7 @@ export function scopeChoiceText(value, retryPaths = {}) {
     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(OMITTED_IMPORTS_CAPTION, ...choice.omitted.map(path => `  ${path}`));
+            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))

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,6 +1,7 @@
 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.";
@@ -14,11 +15,13 @@ export const RESULTS_TOO_LARGE_MESSAGE = "The results were too large to save. Tr
 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. */
@@ -28,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.",
@@ -80,12 +83,35 @@ const reasonValues = [
     "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.7";
+export const CLI_VERSION = "0.2.10";

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) {

package/dist/contract/console.js

@@ -1,10 +1,11 @@
 import { z } from "zod";
-import { findingAudienceSchema, fixDeltaSchema, fixFactsSchema } from "../analysis-core/data/finding-types.js";
-import { inspectFixSchema, otherSiteSchema, rawFindingSchema } from "../analysis-core/analysis/schemas.js";
-import { sourceNotesSchema } from "../analysis-core/analysis/source-notes/types.js";
-import { parseAnalysisSize } from "../analysis-core/conventions/analysis-fit.js";
+import { parseAnalysisSize } from "../analysis-core/contracts/analysis-size.js";
 import { canonicalUuidSchema as uuid, matchingFindingNumbers, numberedFindingsSchema } from "./findings.js";
-import { RESULT_CHECK_LIMITS, validIntakeText } from "../analysis-core/contracts/relay-analysis.js";
+import { publicReportSchema } from "../analysis-core/contracts/relay-analysis.js";
+import { PLANNED_INPUT_BYTES } from "../analysis-core/requests/planned-limits.js";
+import { projectArchitectureSchema } from "./project-architecture.js";
+import { intakeFinding as localFindingSchema, nonblankText as text, RESULT_CHECK_LIMITS, validIntakeText } from "../analysis-core/contracts/intake-finding.js";
+export { localFindingSchema };
 import { selectionStartIdentitySchema } from "./selection-metadata.js";
 export const id = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/);
 const money = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
@@ -16,12 +17,14 @@ export const ANALYSIS_SIZE_HEADER = "x-counterfact-analysis-size";
 export const START_ATTEMPT_HEADER = "x-counterfact-start-attempt";
 export const SELECTION_IDENTITY_HEADER = "x-counterfact-selection";
 export const ANALYSIS_SIZE_HEADER_LIMIT = 256;
+export const ADD_TO_ANALYSIS_HEADER = "x-counterfact-add-to-analysis";
 /** Additive headers let older consoles keep accepting the unchanged, strict start body. */
 export function serializeLocalStartMetadata(metadata) {
     const size = JSON.stringify(parseAnalysisSize(metadata.analysisSize));
     if (Buffer.byteLength(size, "utf8") > ANALYSIS_SIZE_HEADER_LIMIT)
         throw new Error("Invalid analysis size header");
     return { [ANALYSIS_SIZE_HEADER]: size, [START_ATTEMPT_HEADER]: uuid.parse(metadata.startAttempt),
+        ...(metadata.addToAnalysisId ? { [ADD_TO_ANALYSIS_HEADER]: uuid.parse(metadata.addToAnalysisId) } : {}),
         ...(metadata.selection === undefined ? {} : { [SELECTION_IDENTITY_HEADER]: JSON.stringify(selectionStartIdentitySchema.parse(metadata.selection)) }) };
 }
 /** Missing measurements preserve old clients; present measurements must be complete. */
@@ -33,6 +36,7 @@ export function parseLocalStartMetadata(headers) {
         throw new Error("Invalid analysis size header");
     const selection = headers.get(SELECTION_IDENTITY_HEADER);
     return { analysisSize: parseAnalysisSize(JSON.parse(raw)), startAttempt: uuid.parse(headers.get(START_ATTEMPT_HEADER)),
+        ...(headers.get(ADD_TO_ANALYSIS_HEADER) === null ? {} : { addToAnalysisId: uuid.parse(headers.get(ADD_TO_ANALYSIS_HEADER)) }),
         ...(selection === null ? {} : { selection: selectionStartIdentitySchema.parse(JSON.parse(z.string().max(256).parse(selection))) }) };
 }
 const localStartPath = z.string().min(1).max(4096).refine(value => !value.includes("\\") && !value.includes("\0") && !value.startsWith("/")
@@ -47,7 +51,7 @@ export const localStartRequestSchema = z.strictObject({
 export const localStartResponseSchema = z.strictObject({ jobId: uuid, projectId: uuid });
 export const relayPlanSchema = z.strictObject({
     bundleVersion: id, bundleHash: z.string().regex(/^[a-f0-9]{64}$/), relayVersion: id,
-    calls: z.array(z.strictObject({ routeId: id, model: id, calls: count(512), maxInputBytes: count(800_000),
+    calls: z.array(z.strictObject({ routeId: id, model: id, calls: count(512), maxInputBytes: count(PLANNED_INPUT_BYTES),
         maxInputTokens: count(200_000), maxOutputTokens: count(64_000) })).min(1).max(64)
         .refine(calls => new Set(calls.map(call => call.routeId)).size === calls.length && calls.reduce((sum, call) => sum + call.calls, 0) <= 512),
 });
@@ -89,44 +93,19 @@ export const consoleIntakeResultSchema = z.strictObject({
 export const LOCAL_FINDINGS_BODY_LIMIT = 2 * 1024 * 1024;
 export const LOCAL_FINDINGS_QUOTE_LIMIT = RESULT_CHECK_LIMITS.quoteBytes;
 export const LOCAL_FINDINGS_TEXT_LIMIT = RESULT_CHECK_LIMITS.textBytes;
-function shortFindingFields(value) {
-    if (typeof value === "string")
-        return Buffer.byteLength(value, "utf8") <= LOCAL_FINDINGS_TEXT_LIMIT;
-    return value === null || typeof value !== "object" || Object.values(value).every(shortFindingFields);
-}
-const quote = z.string().refine(value => Buffer.byteLength(value, "utf8") <= LOCAL_FINDINGS_QUOTE_LIMIT);
-const text = z.string().min(1).refine(value => value.trim().length > 0);
-const delta = fixDeltaSchema.extend({
-    nodes: z.array(fixDeltaSchema.shape.nodes.element.strict()),
-    edges: z.array(fixDeltaSchema.shape.edges.element.strict()),
-}).strict();
-const fix = inspectFixSchema.extend({
-    ...fixFactsSchema.shape,
-    targetFiles: z.array(inspectFixSchema.shape.targetFiles.element.strict()),
-    delta: delta.nullable(),
-}).strict();
-const notes = sourceNotesSchema.extend({
-    sites: z.array(sourceNotesSchema.shape.sites.element.extend({ keyPhrase: quote }).strict()),
-    counterEvidence: z.array(sourceNotesSchema.shape.counterEvidence.element.extend({ excerpt: quote }).strict()),
-}).strict();
-export const localFindingSchema = rawFindingSchema.extend({
-    audience: findingAudienceSchema.optional(),
-    summary: z.string().nullable(),
-    category: rawFindingSchema.shape.category.removeCatch(),
-    question: rawFindingSchema.shape.question.removeCatch().nullable(),
-    siteRepo: text.nullable(),
-    site: rawFindingSchema.shape.site.unwrap().strict().nullable(),
-    excerpt: quote.nullable(),
-    otherSites: z.array(otherSiteSchema.extend({ repo: text, excerpt: otherSiteSchema.shape.excerpt.pipe(quote) }).strict()),
-    fixes: z.array(fix).min(1),
-    sourceNotes: notes.nullable().optional(),
-}).strict().refine(shortFindingFields);
 const payload = z.strictObject({
     checkId: z.uuid(), projectId: z.uuid(), reservationId: uuid.optional(),
+    addToAnalysisId: uuid.optional(),
+    coverage: z.strictObject({ skippedFiles: z.array(z.strictObject({ path: localStartPath,
+            reason: publicReportSchema.shape.refusedFiles.element.shape.reason })),
+        readPaths: z.array(localStartPath) }).optional(),
+    findingAssessments: z.array(z.strictObject({ fingerprint: z.string().max(8192), support: z.enum(["complete", "incomplete"]),
+        confidence: z.enum(["sure", "not sure"]), weak: z.boolean(), reason: z.string().max(4096) })).optional(),
     agent: z.strictObject({
         repository: text.max(4096), commit: z.string().regex(/^(?:[a-f\d]{40}|[a-f\d]{64})$/i).nullable(),
         files: z.array(z.strictObject({ path: text.max(4096), hash: z.string().regex(/^[a-f\d]{64}$/i) })).min(1),
     }),
+    architecture: projectArchitectureSchema.optional(),
     findings: z.array(localFindingSchema), bundleVersion: text.max(128), relayVersion: text.max(128), counterfactLocalVersion: text.max(128),
 }).refine(validIntakeText);
 // Original JSON size is checked before a shared schema can trim text or apply defaults.

package/dist/contract/engine.js

@@ -3,7 +3,7 @@ import { ANALYSIS_PROTOCOL, analysisCapabilities } from "../analysis-core/contra
 import { stableStringify } from "../analysis-core/llm/stable-json.js";
 import { workloadHardware } from "../gatekeeper/trust/schema.js";
 import { kmsKeyName } from "../transport/kms.js";
-export const ENGINE_ABI = 1;
+export const ENGINE_ABI = 2;
 export const ENGINE_SPAWNER_CONTRACT = 1;
 const hash = z.string().regex(/^[0-9a-f]{64}$/);
 const version = z.string().min(1).max(128).regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/);

package/dist/contract/messages.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { analysisRelease } from "./engine.js";
-import { executionRequest } from "../analysis-core/contracts/requests.js";
+import { executionRequest } from "../analysis-core/contracts/execution-request.js";
+import { PLANNED_INPUT_BYTES } from "../analysis-core/requests/planned-limits.js";
 import { compactJwtPattern, hexChallenge } from "./attestation.js";
 export { PRODUCTION_EVIDENCE_VERSION, RELAY_CHANNEL_AUDIENCE, RELAY_PORT, RELAY_URL, RELAY_HEALTH_PATH, RELAY_HEALTH_URL, GOOGLE_ATTESTATION_ISSUER, MAX_ATTESTATION_BYTES, attestationChallenge, productionEvidence, evidenceBinding, googleAttestationClaims, observedAttestationClaims, probeAttestationClaims, attestationClaims } from "./attestation.js";
 /**
@@ -66,14 +67,14 @@ const outputCount = z.number().int().nonnegative().max(64_000);
 /** A reservation lookup establishes the owner without reserving spend or contacting the model provider. */
 export const reservationCheck = z.object({ action: z.literal("check"), ...billingScope }).strict();
 export const reservationIdentity = z.object({ clientId: z.string().min(1).max(128) }).strict();
-export const callCounts = z.object({ inputBytes: z.number().int().positive().max(800_000),
+export const callCounts = z.object({ inputBytes: z.number().int().positive().max(PLANNED_INPUT_BYTES),
     inputTokens: inputCount.positive(), maxOutputTokens: outputCount.positive() }).strict();
 export const authorizationRequest = z.object({ action: z.literal("authorize"), ...billingScope,
     routeId: billingId, templateId: billingId, answerFormatId: billingId, model: billingId, ...callCounts.shape }).strict();
 export const callAuthorization = z.object({ attemptId: z.uuid(), model: billingId, role: z.enum(["required", "optional"]),
     /** Stable opaque owner supplied only by the authenticated authorization service. */
     clientId: reservationIdentity.shape.clientId,
-    deadline: z.iso.datetime(), countLimits: z.object({ maxInputBytes: z.number().int().positive().max(800_000),
+    deadline: z.iso.datetime(), countLimits: z.object({ maxInputBytes: z.number().int().positive().max(PLANNED_INPUT_BYTES),
         maxInputTokens: inputCount.positive(), maxOutputTokens: outputCount.positive() }).strict() }).strict();
 export const providerUsage = z.object({ kind: z.enum(["actual", "estimated", "unpaid"]),
     outcome: z.enum(["success", "unknown", "retryable_failure", "terminal_provider_failure", "schema_refusal", "leak_refusal"]),

package/dist/contract/project-architecture.js

@@ -0,0 +1 @@
+export { PROJECT_ARCHITECTURE_BYTES, projectArchitectureSchema, projectArchitecture } from "../analysis-core/analysis/project-architecture.js";