codecartographer-pi 0.22.0 → 0.22.1

package/.codecarto/broadside/SKILL.md

@@ -95,11 +95,14 @@ OpenRouter advertises a `:batch` variant for, and many of those variants do not
 exist — submitting one returns `does not have a :batch endpoint`, with nothing in
 the catalog to distinguish it beforehand. A rejected batch costs nothing, so
 probe a candidate on a single lens first. And reasoning competes with the answer for
-`max_tokens`: Broad-Side caps thinking at a quarter of each lens's output budget
-so three quarters remain for the JSON, which is the split the cost estimate
-already assumes. It caps rather than disables because some endpoints refuse to
-be switched off entirely. Override with `reasoning:` in `config.yaml` only
-alongside a raised output budget.
+`max_tokens`: Broad-Side asks every model for low reasoning effort so the output
+budget stays with the JSON, which is the split the cost estimate already
+assumes. An effort level rather than a token cap, because Gemini 3.x ignores a
+cap (measured: 11,518 thinking tokens under a 5,800 cap) and honours the level;
+a level rather than off, because some endpoints refuse to be switched off. A
+slice that still truncates is retried once with a doubled budget at low effort.
+Override with `reasoning:` in `config.yaml` only alongside a raised output
+budget, and set `effort` or `max_tokens`, never both.
 
 Lenses do not all have to run on the same model. `lens_models` in `config.yaml`
 routes individual lenses to their own batch model — the usual reason being that

package/.codecarto/broadside/config.yaml

@@ -72,29 +72,50 @@
 
 # Reasoning control, sent on every lens request.
 #
-# By default Broad-Side caps thinking at a quarter of the lens's output budget,
-# leaving the other three quarters for the answer — which is exactly the split
-# the cost estimate already assumes.
-#
-# The cap exists because reasoning competes with the answer for `max_tokens`.
-# One measured run spent 5,758 of a 6,000-token budget thinking and left ~230
-# tokens for the JSON, which truncated mid-structure on 11 of 13 slices; those
-# tokens bill at the full output rate, so it paid for ~6,000 output tokens per
-# slice to receive ~230 usable ones. The shipped default model does the same
-# thing less consistently — reasoning from 0 to 5,757 tokens across 13 slices,
-# three of them cut off — so this is not something only exotic models do.
-#
-# It is a cap rather than an off switch on purpose. Some endpoints refuse to be
-# switched off: `google/gemini-3.8-flash:batch` rejects the entire batch with
-# "Reasoning is mandatory for this endpoint and cannot be disabled", which turns
-# a partial result into none at all. Capping works either way.
-#
-# Override only with a raised lens output budget, or the JSON truncates exactly
-# as above.
+# By default Broad-Side asks every model for low reasoning effort
+# (`effort: low`), leaving the output budget for the answer — which is the
+# split the cost estimate already assumes.
+#
+# The control exists because reasoning competes with the answer for
+# `max_tokens`. One measured run spent 5,758 of a 6,000-token budget thinking
+# and left ~230 tokens for the JSON, which truncated mid-structure on 11 of 13
+# slices; those tokens bill at the full output rate, so it paid for ~6,000
+# output tokens per slice to receive ~230 usable ones. The shipped default
+# model does the same thing less consistently — reasoning from 0 to 5,757
+# tokens across 13 slices, three of them cut off — so this is not something
+# only exotic models do.
+#
+# It is an effort level rather than a token cap because a cap is not honoured
+# everywhere. Gemini 3.x models take a thinking *level*, not a budget: under
+# `max_tokens: 5800`, google/gemini-3.8-flash:batch reasoned 5,218 tokens on
+# the first pass and 11,518 on the doubled-budget retry — the cap changed
+# nothing, both results truncated, and the retry cost twice the original for
+# no JSON. The same lens at `effort: low` reasoned 0 tokens, returned valid
+# JSON, and cost a twelfth as much. `effort` is what OpenRouter can translate
+# for every provider; a token cap reaches only the providers that take one.
+#
+# And it is a level rather than an off switch on purpose. Some endpoints refuse
+# to be switched off: `google/gemini-3.8-flash:batch` rejects the entire batch
+# with "Reasoning is mandatory for this endpoint and cannot be disabled", which
+# turns a partial result into none at all. Low effort works either way.
+#
+# A slice that still truncates is re-submitted once with a doubled `max_tokens`
+# and, whatever this block says, low effort — the cutoff is usually thinking.
+#
+# Set `effort` OR `max_tokens`, not both: OpenRouter refuses a request that
+# carries both ("Only one of reasoning.effort and reasoning.max_tokens can be
+# specified") — per request, after the batch is accepted, so every lens fails
+# at $0. Submit refuses a config.yaml that sets both. Raise the effort only
+# together with a raised lens output budget, or the JSON truncates exactly as
+# above.
 #
 # reasoning:
 #   effort: low        # minimal | low | medium | high
-#   max_tokens: 2000   # or set the thinking budget directly
+#
+# reasoning:
+#   max_tokens: 2000   # a thinking budget, where the provider honours one
+#
+# reasoning:
 #   enabled: false     # only where the provider allows it
 
 # Approximate run expense limit in USD. The default is 1.00, and it applies

package/.codecarto/workflow/scaffold-version.yaml

@@ -3,4 +3,4 @@
 # workspace's framework-owned files (GUIDE.md, templates/, workflow/ pipelines
 # and VALIDATE.md) predate the running release. Written at release time and
 # copied verbatim by init — never edit by hand.
-scaffold_version: 0.22.0
+scaffold_version: 0.22.1

package/dist/core/broadside.d.ts

@@ -137,31 +137,43 @@ export type BroadsideReasoning = {
     max_tokens?: number;
 };
 /**
- * The share of a lens's output budget reasoning may spend.
+ * The reasoning control every lens request carries: low effort.
  *
- * `estimateCost` already budgets output at 75% of `maxTokens`; capping thinking
- * at the remaining quarter makes that assumption true by construction and
- * guarantees the answer has room. A floor keeps the cap sane for a small lens.
+ * It used to be a token cap — `max_tokens` at a quarter of the lens's output
+ * budget, so three quarters stayed for the answer. Measured live on
+ * `google/gemini-3.8-flash:batch` (0.22.0 verification, defect lens, cap
+ * 5,800 of a 6,000 budget): the model reasoned 5,218 tokens on the first
+ * pass and **11,518 under the same cap** on the doubled-budget retry —
+ * thinking scaled with `max_tokens` and the cap changed nothing, both
+ * results truncated, and the retry cost twice the original for no JSON.
+ * The same lens with `effort: "low"` reasoned 0 tokens, finished with
+ * `stop`, returned valid JSON, and cost a twelfth as much. Gemini 3.x
+ * models take a thinking *level*, not a budget, and OpenRouter forwards a
+ * `max_tokens` cap to them as nothing at all; `effort` is what it can
+ * translate for every provider (a level where the provider has levels, a
+ * fraction of the budget where it takes a budget). So the default asks for
+ * little thinking in the one vocabulary that reaches everyone.
+ *
+ * Deliberately not `enabled: false`: `google/gemini-3.8-flash:batch` refuses
+ * the whole batch with *"Reasoning is mandatory for this endpoint and cannot
+ * be disabled"*, turning a partial result into none at all. Low effort works
+ * whether or not a provider allows reasoning to be switched off.
  */
-export declare const BROADSIDE_REASONING_BUDGET_FRACTION = 0.25;
-export declare const BROADSIDE_MIN_REASONING_TOKENS = 512;
+export declare const BROADSIDE_DEFAULT_REASONING: Readonly<BroadsideReasoning>;
+/** The reasoning control a lens request carries when config.yaml sets none. */
+export declare function defaultReasoningFor(): BroadsideReasoning;
 /**
- * Cap reasoning for a lens request — deliberately a cap, not an off switch.
- *
- * Disabling outright is not portable: `google/gemini-3.8-flash:batch` refuses
- * the whole batch with *"Reasoning is mandatory for this endpoint and cannot be
- * disabled"*, turning a partial result into none at all. Capping works whether
- * or not a provider allows reasoning to be switched off.
+ * The reasoning control a truncated slice is re-submitted with.
  *
- * The failure this prevents is the budget being spent thinking rather than
- * answering. Measured on one run: 5,758 of a 6,000-token budget went to
- * reasoning, leaving ~230 tokens for JSON that truncated mid-structure — and
- * those tokens bill at the full output rate. The shipped default model does the
- * same thing less consistently (reasoning tokens from 0 to 5,757 across 13
- * slices, three of them cut off at `finish_reason: length`), so this is not a
- * multi-model concern.
+ * A truncation on a reasoning-capable model is usually thinking that ate the
+ * answer's budget, and doubling `max_tokens` doubles the thinking where the
+ * provider ignores a token cap (see {@link BROADSIDE_DEFAULT_REASONING}). The
+ * retry therefore asks for low effort as well, replacing a `max_tokens` cap
+ * (OpenRouter refuses a request carrying both) and lowering a higher effort.
+ * An explicit `enabled: false` and an effort already at or below low are left
+ * as they are.
  */
-export declare function defaultReasoningFor(maxTokens: number): BroadsideReasoning;
+export declare function retryReasoningFor(original: BroadsideReasoning | undefined): BroadsideReasoning;
 export type BatchRequest = {
     custom_id: string;
     body: {
@@ -189,6 +201,8 @@ export type BroadsideBatchEntry = {
     cost?: number;
     resultCount?: number;
     error?: unknown;
+    /** Why a `skipped` lens had nothing to submit: the globs that matched no file. */
+    reason?: string;
     /** Set when this lens used a model other than the run default. */
     model?: string;
     /** The completion ceiling of this lens's model; bounds the truncation retry. */
@@ -704,6 +718,7 @@ export declare function runBroadsideStatus(cwd: string): Promise<{
     state: BroadsideStateFile;
 }>;
 export declare function renderFindingsMarkdown(content: string): string;
+export declare function describeIncrementalFallback(reason: BroadsideIncrementalOutcome["reason"]): string;
 export declare function estimateSubmitText(result: BroadsideSubmitResult, lenses: LensDefinition[]): string;
 export declare function modelsText(entries: CatalogEntry[], opts: {
     benchmarks: CodingBenchmarks | null;
@@ -724,5 +739,12 @@ export declare function modelsText(entries: CatalogEntry[], opts: {
  */
 export declare function explainBatchError(error: unknown): string | null;
 export declare function collectResultText(result: BroadsideCollectResult): string;
+/**
+ * An `onStatus` callback that appends one line to `lines` per *change* of a
+ * lens's polled status. Every poll used to append a line, so a four-minute
+ * wait returned twenty-six identical "in_progress (0/1)" lines per lens
+ * before the result (0.22.0 live run).
+ */
+export declare function statusLineWriter(lines: string[]): (lensId: string, status: string, counts: Record<string, unknown>) => void;
 export declare function statusText(state: BroadsideStateFile): string;
 export {};

package/dist/core/broadside.js

@@ -94,32 +94,51 @@ export const BROADSIDE_DEFAULT_POLL_BUDGET_MS = 25 * 60 * 1000;
  */
 export const BROADSIDE_DEFAULT_MAX_COST = 1;
 /**
- * The share of a lens's output budget reasoning may spend.
+ * The reasoning control every lens request carries: low effort.
  *
- * `estimateCost` already budgets output at 75% of `maxTokens`; capping thinking
- * at the remaining quarter makes that assumption true by construction and
- * guarantees the answer has room. A floor keeps the cap sane for a small lens.
+ * It used to be a token cap — `max_tokens` at a quarter of the lens's output
+ * budget, so three quarters stayed for the answer. Measured live on
+ * `google/gemini-3.8-flash:batch` (0.22.0 verification, defect lens, cap
+ * 5,800 of a 6,000 budget): the model reasoned 5,218 tokens on the first
+ * pass and **11,518 under the same cap** on the doubled-budget retry —
+ * thinking scaled with `max_tokens` and the cap changed nothing, both
+ * results truncated, and the retry cost twice the original for no JSON.
+ * The same lens with `effort: "low"` reasoned 0 tokens, finished with
+ * `stop`, returned valid JSON, and cost a twelfth as much. Gemini 3.x
+ * models take a thinking *level*, not a budget, and OpenRouter forwards a
+ * `max_tokens` cap to them as nothing at all; `effort` is what it can
+ * translate for every provider (a level where the provider has levels, a
+ * fraction of the budget where it takes a budget). So the default asks for
+ * little thinking in the one vocabulary that reaches everyone.
+ *
+ * Deliberately not `enabled: false`: `google/gemini-3.8-flash:batch` refuses
+ * the whole batch with *"Reasoning is mandatory for this endpoint and cannot
+ * be disabled"*, turning a partial result into none at all. Low effort works
+ * whether or not a provider allows reasoning to be switched off.
  */
-export const BROADSIDE_REASONING_BUDGET_FRACTION = 0.25;
-export const BROADSIDE_MIN_REASONING_TOKENS = 512;
+export const BROADSIDE_DEFAULT_REASONING = Object.freeze({ effort: "low" });
+/** The reasoning control a lens request carries when config.yaml sets none. */
+export function defaultReasoningFor() {
+    return { ...BROADSIDE_DEFAULT_REASONING };
+}
 /**
- * Cap reasoning for a lens request — deliberately a cap, not an off switch.
- *
- * Disabling outright is not portable: `google/gemini-3.8-flash:batch` refuses
- * the whole batch with *"Reasoning is mandatory for this endpoint and cannot be
- * disabled"*, turning a partial result into none at all. Capping works whether
- * or not a provider allows reasoning to be switched off.
+ * The reasoning control a truncated slice is re-submitted with.
  *
- * The failure this prevents is the budget being spent thinking rather than
- * answering. Measured on one run: 5,758 of a 6,000-token budget went to
- * reasoning, leaving ~230 tokens for JSON that truncated mid-structure — and
- * those tokens bill at the full output rate. The shipped default model does the
- * same thing less consistently (reasoning tokens from 0 to 5,757 across 13
- * slices, three of them cut off at `finish_reason: length`), so this is not a
- * multi-model concern.
+ * A truncation on a reasoning-capable model is usually thinking that ate the
+ * answer's budget, and doubling `max_tokens` doubles the thinking where the
+ * provider ignores a token cap (see {@link BROADSIDE_DEFAULT_REASONING}). The
+ * retry therefore asks for low effort as well, replacing a `max_tokens` cap
+ * (OpenRouter refuses a request carrying both) and lowering a higher effort.
+ * An explicit `enabled: false` and an effort already at or below low are left
+ * as they are.
  */
-export function defaultReasoningFor(maxTokens) {
-    return { max_tokens: Math.max(BROADSIDE_MIN_REASONING_TOKENS, Math.floor(maxTokens * BROADSIDE_REASONING_BUDGET_FRACTION)) };
+export function retryReasoningFor(original) {
+    if (original?.enabled === false)
+        return { ...original };
+    if (original?.effort === "minimal" || original?.effort === "low")
+        return { ...original };
+    const { max_tokens: _cap, effort: _effort, ...rest } = original ?? {};
+    return { ...rest, effort: "low" };
 }
 /**
  * OpenRouter rejected the API key (HTTP 401/403). Thrown from the catalog
@@ -1348,7 +1367,7 @@ export function buildBatchRequest(lens, info, slice, index, sliceCount, model =
             max_tokens: maxTokensOverride ?? lens.maxTokens,
             // Always sent, never inherited: an absent field means the model's
             // own default, and that default is what truncated the JSON.
-            reasoning: reasoningOverride ?? lens.reasoning ?? defaultReasoningFor(maxTokensOverride ?? lens.maxTokens),
+            reasoning: reasoningOverride ?? lens.reasoning ?? defaultReasoningFor(),
         },
     };
 }
@@ -1549,6 +1568,21 @@ export async function loadBroadsideConfig(broadsideDir) {
                 throw new BroadsideConfigError(configPath, "is not a YAML mapping");
             raw = parsed;
         }
+        // OpenRouter accepts `reasoning.effort` or `reasoning.max_tokens`, not
+        // both: a request carrying both is refused per request *after* the batch
+        // is accepted, so every lens fails at $0 with the reason in each
+        // result's error. Seen live on 0.22.0 with the two keys set together.
+        // Refuse here, where the file can be fixed, rather than submit a run
+        // that cannot produce a result.
+        const reasoning = raw.reasoning;
+        if (reasoning && typeof reasoning === "object" && !Array.isArray(reasoning)) {
+            const value = reasoning;
+            const hasEffort = typeof value.effort === "string";
+            const hasBudget = typeof value.max_tokens === "number" && value.max_tokens > 0;
+            if (hasEffort && hasBudget) {
+                throw new BroadsideConfigError(configPath, 'sets both reasoning.effort and reasoning.max_tokens; OpenRouter accepts one or the other ("Only one of reasoning.effort and reasoning.max_tokens can be specified"), and every lens request would fail after the batch is accepted. Keep one');
+            }
+        }
     }
     return buildBroadsideConfig(raw);
 }
@@ -2132,6 +2166,8 @@ export async function runBroadsideSubmit(cwd, apiKey, opts = {}) {
     }
     // Slice offline first so the estimate covers every request we would send.
     const slicesByLens = new Map();
+    // Why a lens ended up with nothing to submit, for the report (see below).
+    const skipReasons = new Map();
     let estimatedInputTokens = 0;
     let estimatedOutputTokens = 0;
     let estimatedTotalCost = 0;
@@ -2149,12 +2185,21 @@ export async function runBroadsideSubmit(cwd, apiKey, opts = {}) {
             for (const file of slice.redactedFiles ?? [])
                 redactedFiles.add(file);
         }
+        const matchedBeforeIncremental = slices.length;
         if (changed) {
             // Repo-info slices (empty files, e.g. architecture) always run;
             // file-backed slices run only when one of their files changed.
             slices = slices.filter((s) => s.files.length === 0 || s.files.some((f) => changed.has(f)));
         }
         slicesByLens.set(lensId, slices);
+        if (slices.length === 0) {
+            const globs = lens.globsFor(info).filter(Boolean);
+            skipReasons.set(lensId, globs.length === 0
+                ? "the lens has no file patterns for this language"
+                : matchedBeforeIncremental > 0
+                    ? "incremental: none of this lens's files changed since the previous run"
+                    : `no files matched ${globs.join(", ")}${lens.skipTestFiles ? " (test files excluded)" : ""}`);
+        }
         const lensModel = modelForLens(lensId);
         const { pricing: lensPricing, outputCap: lensOutputCap } = resolved.get(lensModel);
         const maxTokens = lensOutputCap ? Math.min(lens.maxTokens, lensOutputCap) : lens.maxTokens;
@@ -2263,7 +2308,15 @@ export async function runBroadsideSubmit(cwd, apiKey, opts = {}) {
         if (requests.length === 0) {
             // No files matched the lens's globs. That is a coverage gap to
             // report, not a batch to submit — the API rejects empty batches.
+            // Name the globs: a JavaScript service whose server lives at
+            // src/server.js gets no security review (that lens reads server/**,
+            // **/auth*, **/middleware/**), and "skipped (0 request(s))" alone
+            // read as an empty repository rather than a lens that looked in
+            // the wrong place.
             entry.status = "skipped";
+            const reason = skipReasons.get(lensId);
+            if (reason)
+                entry.reason = reason;
             continue;
         }
         submissions.push((async () => {
@@ -2284,6 +2337,12 @@ export async function runBroadsideSubmit(cwd, apiKey, opts = {}) {
         })());
     }
     await Promise.allSettled(submissions);
+    // A run with no batch behind it has nothing in flight. Every lens was
+    // skipped or refused, so no poll will ever complete it; leaving it
+    // "in-flight" had status listing a refused run above the completed ones
+    // with synthesis and triage "pending" forever.
+    if (!Object.values(run.batches).some((entry) => entry.batchId))
+        run.status = "failed";
     await persistBroadsideRun(broadsideDir, run);
     // What the provider just said about each model's batch endpoint outlives
     // the run: the `models` action reads it back (#141).
@@ -2625,9 +2684,12 @@ export async function runBroadsideCollect(cwd, apiKey, opts = {}) {
         }
         await persistBroadsideRun(broadsideDir, run);
     }
-    // #133: re-submit truncated slices once with a bumped output cap. Batch
-    // requests are pure, so re-running is always safe; the aim is to recover
-    // coverage the first pass lost to a max_tokens cutoff, not to loop forever.
+    // #133: re-submit truncated slices once with a bumped output cap and low
+    // reasoning effort. Batch requests are pure, so re-running is always safe;
+    // the aim is to recover coverage the first pass lost to a max_tokens
+    // cutoff, not to loop forever. Low effort because the cutoff is usually
+    // thinking, and a doubled budget doubled the thinking where a token cap
+    // was ignored (see retryReasoningFor).
     //
     // All bumped requests for one model go out as ONE batch, and the batches
     // (one per model, since a batch carries a single model) are polled
@@ -2658,7 +2720,10 @@ export async function runBroadsideCollect(cwd, apiKey, opts = {}) {
             if (bumpedMax <= previousMax)
                 continue; // already at the ceiling
             const group = byModel.get(lensModel) ?? { requests: [], slices: new Map() };
-            group.requests.push({ ...original, body: { ...original.body, max_tokens: bumpedMax } });
+            group.requests.push({
+                ...original,
+                body: { ...original.body, max_tokens: bumpedMax, reasoning: retryReasoningFor(original.body.reasoning) },
+            });
             group.slices.set(stored.customId, stored);
             byModel.set(lensModel, group);
         }
@@ -2959,7 +3024,7 @@ function parseSynthesisTopFindings(content) {
     }
 }
 // ---------- formatting helpers for tool output ----------
-function describeIncrementalFallback(reason) {
+export function describeIncrementalFallback(reason) {
     switch (reason) {
         case "dirty-worktree":
             return "the working tree has uncommitted changes, so there is no committed state to diff against";
@@ -2993,8 +3058,13 @@ export function estimateSubmitText(result, lenses) {
         const override = entry.model ? ` on ${entry.model}` : "";
         // A rejected lens says why: the message is the only way to tell a
         // catalog id with no batch endpoint from a full job quota, and both
-        // used to read as a bare "rejected".
-        const reason = !entry.batchId && entry.error ? ` — ${explainBatchError(entry.error)}` : "";
+        // used to read as a bare "rejected". A skipped lens names the globs
+        // that matched nothing.
+        const reason = !entry.batchId && entry.error
+            ? ` — ${explainBatchError(entry.error)}`
+            : !entry.batchId && entry.reason
+                ? ` — ${entry.reason}`
+                : "";
         lines.push(`  ${lens.name}: ${status} (${entry.requests} request(s), ~$${entry.estimatedCost.toFixed(4)})${override}${reason}`);
     }
     if (result.repo) {
@@ -3178,6 +3248,22 @@ export function collectResultText(result) {
     lines.push("", "Disclaimer: Broad-Side findings are unverified scouting signals from a batch model, not validated claims.");
     return lines.join("\n");
 }
+/**
+ * An `onStatus` callback that appends one line to `lines` per *change* of a
+ * lens's polled status. Every poll used to append a line, so a four-minute
+ * wait returned twenty-six identical "in_progress (0/1)" lines per lens
+ * before the result (0.22.0 live run).
+ */
+export function statusLineWriter(lines) {
+    const last = new Map();
+    return (lensId, status, counts) => {
+        const line = `  ${lensId}: ${status} (${counts.completed ?? 0}/${counts.total ?? "?"})`;
+        if (last.get(lensId) === line)
+            return;
+        last.set(lensId, line);
+        lines.push(line);
+    };
+}
 export function statusText(state) {
     if (state.runs.length === 0) {
         return "No Broad-Side runs recorded. Call codecarto_broadside with action 'submit' first.";
@@ -3195,7 +3281,8 @@ export function statusText(state) {
             const entry = run.batches[lensId];
             if (!entry)
                 continue;
-            lines.push(`  ${lensId}: ${entry.status}${entry.batchId ? ` (${entry.batchId})` : ""}${entry.cost !== undefined ? `, $${entry.cost.toFixed(6)}` : ""}`);
+            lines.push(`  ${lensId}: ${entry.status}${entry.batchId ? ` (${entry.batchId})` : ""}${entry.cost !== undefined ? `, $${entry.cost.toFixed(6)}` : ""}` +
+                (entry.status === "skipped" && entry.reason ? ` — ${entry.reason}` : ""));
         }
         lines.push(`  synthesis: ${run.synthesis.status}`);
         lines.push(`  triage: ${run.triage?.status ?? "pending"}`);

package/dist/extensions/codecarto/index.js

@@ -9,7 +9,7 @@ import { parseNextFlags } from "./next-flags.js";
 import { buildPiGuideMessage } from "./guide-framing.js";
 import { isCtxLive, notifyCtx } from "./notify.js";
 import { phaseCompactionExtension } from "./phase-compaction.js";
-import { applyAmendment, buildPhasePrompt, buildSkillPrompt, buildValidationSummary, backupWorkspaceState, canonicalPath, copyPackagedWorkspace, computePerPhaseTotals, computeTotals, ConfidentialityMismatchError, createEmptyStatus, DEFAULT_PIPELINE_PATH, describeScaffoldStaleness, deriveSlug, discoverLibrary, describeDanglingCarryForward, describeMissingCompletedOutputs, describeStuckPipeline, expandTilde, getPipelineLabel, getWorkspaceState, isWithinPath, resolveExistingPrefix, BROADSIDE_LENS_IDS, BROADSIDE_SKILL_NAME, BroadsideConfigError, defaultBroadsideConfig, BroadsideCancelledError, broadsideDirFor, collectResultText, estimateSubmitText, getLens, listAmendmentNames, listBatchModels, listGuideTopics, listScaffoldRefreshFiles, listMissingCompletedOutputs, listSkillNames, resolvePipelineOutcome, resolveSkillName, loadAmendmentFile, loadBroadsideConfig, modelsText, runBroadsideCollect, runBroadsideStatus, runBroadsideSubmit, statusText, describeConfigProblems, loadCodecartoConfig, loadUsage, loadYamlFile, normalizeForComparison, packagedWorkspaceDir, pathExists, PACKAGE_VERSION, readBroadsideSkill, readGuide, refreshScaffold, PhasePreflightError, PIPELINE_ALIASES, publishEntry, resolvePhase, resolvePipelineChoice, resolvePublishSourceRepo, SourceRepoMismatchError, runPhasePreflight, SCAFFOLD_REFRESH_PROTECTED, seedOrchestratorFiles, stringifySimpleYaml, switchPipeline, validatePhaseOutput, writeLibraryConfig, writeDashboard, } from "../../core/index.js";
+import { applyAmendment, buildPhasePrompt, buildSkillPrompt, buildValidationSummary, backupWorkspaceState, canonicalPath, copyPackagedWorkspace, computePerPhaseTotals, computeTotals, ConfidentialityMismatchError, createEmptyStatus, DEFAULT_PIPELINE_PATH, describeScaffoldStaleness, deriveSlug, discoverLibrary, describeDanglingCarryForward, describeMissingCompletedOutputs, describeStuckPipeline, expandTilde, getPipelineLabel, getWorkspaceState, isWithinPath, resolveExistingPrefix, BROADSIDE_LENS_IDS, BROADSIDE_SKILL_NAME, BroadsideConfigError, defaultBroadsideConfig, BroadsideCancelledError, broadsideDirFor, collectResultText, estimateSubmitText, getLens, listAmendmentNames, listBatchModels, listGuideTopics, listScaffoldRefreshFiles, listMissingCompletedOutputs, listSkillNames, resolvePipelineOutcome, resolveSkillName, loadAmendmentFile, loadBroadsideConfig, modelsText, runBroadsideCollect, runBroadsideStatus, runBroadsideSubmit, statusText, describeConfigProblems, describeIncrementalFallback, loadCodecartoConfig, loadUsage, loadYamlFile, normalizeForComparison, packagedWorkspaceDir, pathExists, PACKAGE_VERSION, readBroadsideSkill, readGuide, refreshScaffold, PhasePreflightError, PIPELINE_ALIASES, publishEntry, resolvePhase, resolvePipelineChoice, resolvePublishSourceRepo, SourceRepoMismatchError, runPhasePreflight, SCAFFOLD_REFRESH_PROTECTED, seedOrchestratorFiles, stringifySimpleYaml, switchPipeline, validatePhaseOutput, writeLibraryConfig, writeDashboard, } from "../../core/index.js";
 import { initLibrary } from "../../core/library.js";
 import { resolveUserConfigPath } from "../../core/orchestrator-config.js";
 const STATUS_WIDGET_ID = "codecarto-widget";
@@ -144,11 +144,14 @@ function describeBroadsideEstimate(estimate) {
             ? `This EXCEEDS the configured max_cost of $${estimate.maxCost.toFixed(2)}. Approving here overrides it for this run.`
             : `Within the configured max_cost of $${estimate.maxCost.toFixed(2)}.`);
     }
-    if (estimate.baseHead) {
-        lines.push(`Incremental: only modules changed since ${estimate.baseHead.slice(0, 8)} are included.`);
-    }
-    else if (estimate.sourceDirty) {
-        lines.push("Incremental was requested but the tree is dirty — this is a full scan.");
+    // Only a requested incremental run has anything to say here. The dialog
+    // used to print "Incremental was requested but the tree is dirty" on every
+    // dirty tree, requested or not — a full scan that nobody asked to shrink
+    // read as a fallback.
+    if (estimate.incremental?.requested) {
+        lines.push(estimate.incremental.applied
+            ? `Incremental: only modules changed since ${(estimate.baseHead ?? "").slice(0, 8)} are included.`
+            : `Incremental was requested but NOT applied — ${describeIncrementalFallback(estimate.incremental.reason)}. This is a full scan.`);
     }
     lines.push("", "The estimate is a pre-flight prediction from file sizes; OpenRouter bills actual usage.");
     return lines.join("\n");
@@ -1114,6 +1117,9 @@ export default function codeCartographerExtension(pi) {
                 const lenses = flags.lenses.length > 0 ? flags.lenses : config.defaultLenses;
                 renderProgress("Slicing the repository and pricing the run…");
                 let submit;
+                // Set when a headless run was refused over max_cost, so the cancel
+                // message says so instead of reading as a user's "no".
+                let headlessRefusal = null;
                 try {
                     submit = await runBroadsideSubmit(ctx.cwd, apiKey, {
                         lenses,
@@ -1128,14 +1134,32 @@ export default function codeCartographerExtension(pi) {
                         incremental: flags.incremental ?? config.incremental,
                         // Pi can ask, so it asks instead of refusing over max_cost the
                         // way MCP has to. An approval here IS the force flag.
-                        confirm: (estimate) => ctx.ui.confirm(`Broad-Side will spend about $${estimate.totalCost.toFixed(4)}`, describeBroadsideEstimate(estimate)),
+                        confirm: (estimate) => {
+                            if (ctx.hasUI) {
+                                return ctx.ui.confirm(`Broad-Side will spend about $${estimate.totalCost.toFixed(4)}`, describeBroadsideEstimate(estimate));
+                            }
+                            // No dialog under `pi -p`: the stub answered "no" to every
+                            // estimate, so a headless submit could never fire. Behave as
+                            // the MCP surface does — an estimate within max_cost is
+                            // approved by the cap itself; one over it is refused, since
+                            // nobody is here to say yes — and print the breakdown either
+                            // way, because the dialog was the only place it showed.
+                            notifyCtx(ctx, describeBroadsideEstimate(estimate), "info");
+                            if (estimate.exceedsLimit) {
+                                headlessRefusal =
+                                    `Broad-Side refused: the estimate ~$${estimate.totalCost.toFixed(4)} exceeds max_cost $${estimate.maxCost.toFixed(2)} ` +
+                                        "and there is no dialog to approve it in a headless run. Raise --max-cost (0 for no limit) or run interactively.";
+                                return false;
+                            }
+                            return true;
+                        },
                     });
                 }
                 catch (error) {
                     if (ctx.hasUI)
                         ctx.ui.setWidget(BROADSIDE_WIDGET_ID, undefined);
                     if (error instanceof BroadsideCancelledError) {
-                        notifyCtx(ctx, "Broad-Side cancelled. Nothing was submitted.", "info");
+                        notifyCtx(ctx, headlessRefusal ?? "Broad-Side cancelled. Nothing was submitted.", headlessRefusal ? "error" : "info");
                         return;
                     }
                     notifyCtx(ctx, `Broad-Side submit failed: ${error instanceof Error ? error.message : String(error)}`, "error");

package/dist/mcp-server/server.js

@@ -17,7 +17,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
 import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
 import { basename, isAbsolute, join } from "node:path";
-import { buildPhasePrompt, buildSkillPrompt, buildValidationSummary, BROADSIDE_DIR, broadsideDirFor, BROADSIDE_LENS_IDS, BROADSIDE_SKILL_NAME, BroadsideConfigError, defaultBroadsideConfig, backupWorkspaceState, canonicalPath, copyPackagedWorkspace, collectResultText, completeValidatedPhase, computePerPhaseTotals, computeTotals, createEmptyStatus, DEFAULT_PIPELINE_PATH, deriveSlug, discoverLibrary, describeScaffoldStaleness, detectProvenanceConflicts, estimateSubmitText, getLens, describeDanglingCarryForward, describeMissingCompletedOutputs, describeStuckPipeline, getPipelineLabel, getWorkspaceState, isValidSlug, isWithinPathResolved, listBatchModels, listEntries, listGuideTopics, loadBroadsideConfig, modelsText, readGuide, listMissingCompletedOutputs, listSkillNames, resolvePipelineOutcome, resolveSkillName, loadCodecartoConfig, loadUsage, loadYamlFile, normalizeForComparison, PACKAGE_VERSION, packagedWorkspaceDir, pathExists, PhasePreflightError, previewPublishVersion, publishEntry, reindex as libraryReindex, refreshScaffold, resolvePhase, resolvePipelineChoice, readBroadsideSkill, runBroadsideCollect, runBroadsideStatus, runBroadsideSubmit, seedOrchestratorFiles, statusText, stringifySimpleYaml, switchPipeline, validatePhaseOutput, writeLibraryConfig, writeDashboard, } from "../core/index.js";
+import { buildPhasePrompt, buildSkillPrompt, buildValidationSummary, BROADSIDE_DIR, broadsideDirFor, BROADSIDE_LENS_IDS, BROADSIDE_SKILL_NAME, BroadsideConfigError, defaultBroadsideConfig, backupWorkspaceState, canonicalPath, copyPackagedWorkspace, collectResultText, completeValidatedPhase, computePerPhaseTotals, computeTotals, createEmptyStatus, DEFAULT_PIPELINE_PATH, deriveSlug, discoverLibrary, describeScaffoldStaleness, detectProvenanceConflicts, estimateSubmitText, getLens, describeDanglingCarryForward, describeMissingCompletedOutputs, describeStuckPipeline, getPipelineLabel, getWorkspaceState, isValidSlug, isWithinPathResolved, listBatchModels, listEntries, listGuideTopics, loadBroadsideConfig, modelsText, readGuide, listMissingCompletedOutputs, listSkillNames, resolvePipelineOutcome, resolveSkillName, loadCodecartoConfig, loadUsage, loadYamlFile, normalizeForComparison, PACKAGE_VERSION, packagedWorkspaceDir, pathExists, PhasePreflightError, previewPublishVersion, publishEntry, reindex as libraryReindex, refreshScaffold, resolvePhase, resolvePipelineChoice, readBroadsideSkill, runBroadsideCollect, runBroadsideStatus, runBroadsideSubmit, seedOrchestratorFiles, statusLineWriter, statusText, stringifySimpleYaml, switchPipeline, validatePhaseOutput, writeLibraryConfig, writeDashboard, } from "../core/index.js";
 import { applyAmendment } from "../core/amendment.js";
 import { appendUsageRun } from "../core/usage.js";
 import { initLibrary } from "../core/library.js";
@@ -1151,7 +1151,10 @@ export async function handleBroadside(args) {
                 includeSynthesis,
                 includeTriage,
                 retryTruncated,
-                onStatus: (lensId, status, counts) => lines.push(`  ${lensId}: ${status} (${counts.completed ?? 0}/${counts.total ?? "?"})`),
+                // One line per *change* of a lens's status. Every poll used to
+                // append a line, so a four-minute wait returned twenty-six
+                // "in_progress (0/1)" lines before the result (0.22.0 live run).
+                onStatus: statusLineWriter(lines),
             }).catch((error) => {
                 // The `collect` action normalizes this same call; without it here,
                 // a failure during submit-with-wait reached the client as an

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecartographer-pi",
-  "version": "0.22.0",
+  "version": "0.22.1",
   "mcpName": "io.github.HuginnIndustries/codecartographer",
   "description": "Turn an unfamiliar codebase into a validated reimplementation spec, then synthesize confirmed specs and a product vision into a traceable plan.",
   "type": "module",