codecartographer-pi 0.20.0 → 0.22.0

package/dist/core/completion.js

@@ -110,7 +110,13 @@ async function appendDecisionLog(workspaceDir, phaseId, closeoutFile, decisions)
         const number = String(nextNumber + index).padStart(3, "0");
         return `D${number} | ${decision.trim()} | ${source} | closeouts/${closeoutFile} §Decisions Beyond Prompt (${phaseId})`;
     });
-    content += `${content.endsWith("\n") ? "" : "\n"}${rows.join("\n")}\n`;
+    // A row appended straight after the section's explanatory paragraph is
+    // rendered as part of that paragraph by most Markdown renderers; a blank
+    // line makes the rows their own block (self-audit F4). Rows already
+    // present stay contiguous with the new ones.
+    const trailing = content.replace(/\n+$/, "").split("\n").pop() ?? "";
+    const separator = /^D\d+\s*\|/.test(trailing) || trailing.trim() === "" ? "" : "\n";
+    content += `${content.endsWith("\n") ? "" : "\n"}${separator}${rows.join("\n")}\n`;
     await writeFile(join(workspaceDir, "DECISIONS.md"), content, "utf8");
     return fresh.length;
 }

package/dist/core/library.js

@@ -33,7 +33,7 @@ import { spawn } from "node:child_process";
 import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import { acquireLock } from "./status.js";
-import { atomicWriteFile, canonicalPath, isPlainObject, normalizeForComparison, pathExists, uniqueTempSuffix } from "./utils.js";
+import { atomicWriteFile, canonicalPath, GIT_TIMEOUT_MS, isPlainObject, normalizeForComparison, pathExists, uniqueTempSuffix } from "./utils.js";
 import { parseSimpleYaml, stringifySimpleYaml } from "./yaml.js";
 // ─── Constants ──────────────────────────────────────────────────────────────
 export const LIBRARY_MARKER_FILE = ".codecarto-library";
@@ -830,7 +830,7 @@ async function writeIndexMarkdown(libraryRoot, index, marker) {
     const lines = [];
     lines.push(`# ${escapeMd(marker.name)} — Library Index`);
     lines.push("");
-    lines.push(`_Generated ${index.generated_at}. Do not edit by hand — regenerate with \`codecarto library-reindex\`._`);
+    lines.push(`_Generated ${index.generated_at}. Do not edit by hand — regenerate with the \`codecarto_library_reindex\` MCP tool._`);
     lines.push("");
     // A single-tenant library has no namespaces but is still one namespace's
     // worth of entries; count once so the noun agrees with the number shown.
@@ -1041,7 +1041,9 @@ export async function commitPublish(libraryRoot, message, opts = {}) {
 }
 function runGit(cwd, args) {
     return new Promise((resolvePromise) => {
-        const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        // Bounded like every fetch: a credential helper waiting on a prompt
+        // used to hang publish or source-repo resolution for good (sem 3.12).
+        const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: GIT_TIMEOUT_MS });
         let stdout = "";
         let stderr = "";
         child.stdout.on("data", (b) => {

package/dist/core/pipeline.d.ts

@@ -4,11 +4,47 @@ export declare const DEFAULT_PIPELINE_PATH = "workflow/pipeline-full-with-deep-a
 export declare function getPhaseMap(pipeline: PipelineFile): Map<string, PipelinePhase>;
 export declare function getPipelineLabel(pipelinePath: string): string;
 export declare function getNextEligiblePhase(state: WorkspaceState): PipelinePhase | null;
+/** One phase the pipeline cannot reach, and the dependencies keeping it there. */
+export interface BlockedPhase {
+    phaseId: string;
+    /** Each unmet `depends_on` entry, with why it will not clear on its own. */
+    missing: Array<{
+        dependencyId: string;
+        reason: "not-in-pipeline" | "blocked";
+    }>;
+}
+/**
+ * What the pipeline can do next. `getNextEligiblePhase` returned null both
+ * when every phase was complete and when the remaining phases waited on a
+ * dependency that would never clear, and every consumer read null as
+ * complete: a DAG with an unmet dependency reported 1/2 complete and unlocked
+ * the post-pipeline skills (#228). The third outcome is the difference.
+ */
+export type PipelineOutcome = {
+    kind: "eligible";
+    phase: PipelinePhase;
+} | {
+    kind: "complete";
+} | {
+    kind: "stuck";
+    blocked: BlockedPhase[];
+};
+export declare function resolvePipelineOutcome(state: WorkspaceState): PipelineOutcome;
+/** True when every phase in the active pipeline is complete. */
+export declare function isPipelineComplete(state: WorkspaceState): boolean;
+/**
+ * One sentence both surfaces print for a stuck pipeline, naming each blocked
+ * phase and the dependency keeping it there. The pipeline file is the thing to
+ * fix — or switch away from — so the sentence says so.
+ */
+export declare function describeStuckPipeline(blocked: BlockedPhase[]): string;
 /**
  * Point `current_phase` and `next_actions` at whatever the engine finds
- * eligible now, or at the terminal routing when nothing is. Completion and a
- * pipeline switch both derive the cursor this way (#236), so status.yaml never
- * disagrees with the phase records it sits beside. Returns the eligible phase.
+ * eligible now, at the terminal routing when every phase is complete, or at
+ * the first blocked phase with the stuck sentence when nothing can run.
+ * Completion and a pipeline switch both derive the cursor this way (#236), so
+ * status.yaml never disagrees with the phase records it sits beside. Returns
+ * the eligible phase, or null.
  */
 export declare function recomputeCursor(state: WorkspaceState): PipelinePhase | null;
 /**

package/dist/core/pipeline.js

@@ -40,17 +40,71 @@ export function getNextEligiblePhase(state) {
     }
     return null;
 }
+export function resolvePipelineOutcome(state) {
+    const phase = getNextEligiblePhase(state);
+    if (phase)
+        return { kind: "eligible", phase };
+    const phaseMap = getPhaseMap(state.pipeline);
+    const isComplete = (phaseId) => state.status.phases[phaseId]?.status === "complete";
+    const incomplete = state.pipeline.phase_order.filter((phaseId) => !isComplete(phaseId));
+    if (incomplete.length === 0)
+        return { kind: "complete" };
+    // Nothing is eligible and something is incomplete, so every incomplete
+    // phase has an unmet dependency. Each one is either a phase this pipeline
+    // does not declare, or one of the blocked phases themselves (a cycle, or a
+    // chain back to one).
+    const blocked = incomplete.map((phaseId) => ({
+        phaseId,
+        missing: (phaseMap.get(phaseId)?.depends_on ?? [])
+            .filter((dependencyId) => !isComplete(dependencyId))
+            .map((dependencyId) => ({
+            dependencyId,
+            reason: state.pipeline.phase_order.includes(dependencyId) ? "blocked" : "not-in-pipeline",
+        })),
+    }));
+    return { kind: "stuck", blocked };
+}
+/** True when every phase in the active pipeline is complete. */
+export function isPipelineComplete(state) {
+    return resolvePipelineOutcome(state).kind === "complete";
+}
+/**
+ * One sentence both surfaces print for a stuck pipeline, naming each blocked
+ * phase and the dependency keeping it there. The pipeline file is the thing to
+ * fix — or switch away from — so the sentence says so.
+ */
+export function describeStuckPipeline(blocked) {
+    const parts = blocked.map((entry) => {
+        const deps = entry.missing.map((m) => m.reason === "not-in-pipeline" ? `${m.dependencyId}, which is not in this pipeline` : `${m.dependencyId}, which is itself blocked`);
+        return `${entry.phaseId} depends on ${deps.join(" and ") || "nothing it can reach"}`;
+    });
+    return `Pipeline is stuck: ${parts.join("; ")}. No phase can run until the pipeline file's depends_on is fixed (or switch pipelines with codecarto_switch_pipeline / /codecarto-switch-pipeline).`;
+}
 /**
  * Point `current_phase` and `next_actions` at whatever the engine finds
- * eligible now, or at the terminal routing when nothing is. Completion and a
- * pipeline switch both derive the cursor this way (#236), so status.yaml never
- * disagrees with the phase records it sits beside. Returns the eligible phase.
+ * eligible now, at the terminal routing when every phase is complete, or at
+ * the first blocked phase with the stuck sentence when nothing can run.
+ * Completion and a pipeline switch both derive the cursor this way (#236), so
+ * status.yaml never disagrees with the phase records it sits beside. Returns
+ * the eligible phase, or null.
  */
 export function recomputeCursor(state) {
-    const next = getNextEligiblePhase(state);
-    state.status.current_phase = next?.id ?? "complete";
-    state.status.next_actions = next ? [beginPhaseAction(next)] : buildTerminalNextActions(state.status);
-    return next;
+    const outcome = resolvePipelineOutcome(state);
+    if (outcome.kind === "eligible") {
+        state.status.current_phase = outcome.phase.id;
+        state.status.next_actions = [beginPhaseAction(outcome.phase)];
+        return outcome.phase;
+    }
+    if (outcome.kind === "stuck") {
+        // The cursor stays on the first phase that cannot run; "complete" is
+        // reserved for the state where nothing is left (#228).
+        state.status.current_phase = outcome.blocked[0]?.phaseId ?? "complete";
+        state.status.next_actions = [describeStuckPipeline(outcome.blocked)];
+        return null;
+    }
+    state.status.current_phase = "complete";
+    state.status.next_actions = buildTerminalNextActions(state.status);
+    return null;
 }
 /**
  * Phases status.yaml records as complete whose primary output is not on disk.

package/dist/core/prompts.js

@@ -120,6 +120,13 @@ export async function buildPhasePrompt(state, phase, forced, options = {}) {
     const preflight = options.preflight ?? await runPhasePreflight(state, phase);
     const synthesisWorkflow = state.pipeline.workflow_name === "evidence-backed-project-synthesis";
     const handoffTemplateExists = await pathExists(join(state.workspaceDir, "templates", "phase-handoff.yaml"));
+    // The framework's own three files are the first reads on every phase, and
+    // after the first phase they are the same three files. Say so, so a host
+    // that carries context across phases spends it on the phase's inputs
+    // rather than re-reading the guide (self-audit F5). status.yaml is the
+    // exception: completion rewrote it, and it is the cursor.
+    const laterPhase = Object.values(state.status.phases).some((phaseState) => phaseState.status === "complete");
+    const unchangedNote = laterPhase ? " (framework-owned; unchanged since your last phase unless the scaffold was refreshed — skim rather than re-read if you still hold it)" : "";
     const lines = [
         `Read .codecarto/GUIDE.md and continue the CodeCartographer workflow for the phase \`${phase.id}\`.`,
         synthesisWorkflow
@@ -127,11 +134,11 @@ export async function buildPhasePrompt(state, phase, forced, options = {}) {
             : "Work on this phase only. The analyzed source code is the repository outside .codecarto/.",
         "",
         "Required reads before analysis:",
-        "- .codecarto/GUIDE.md",
-        "- .codecarto/workflow/status.yaml",
+        `- .codecarto/GUIDE.md${unchangedNote}`,
+        `- .codecarto/workflow/status.yaml${laterPhase ? " (rewritten by the last completion; read it)" : ""}`,
     ];
     if (handoffTemplateExists) {
-        lines.push("- .codecarto/templates/phase-handoff.yaml");
+        lines.push(`- .codecarto/templates/phase-handoff.yaml${unchangedNote}`);
     }
     const primaryOutput = phase.primary_output ? `.codecarto/${phase.primary_output}` : undefined;
     if (primaryOutput) {

package/dist/core/status.d.ts

@@ -3,6 +3,14 @@ export declare const LOCK_RETRY_MS = 125;
 export declare const LOCK_TIMEOUT_MS = 5000;
 export declare const STALE_LOCK_MS = 60000;
 export declare function assertSafePhaseId(phaseId: string): void;
+/**
+ * A YAML scalar as text: strings as written, numbers and booleans spelled
+ * back out. Files written before #225 hold owner notes such as `2048` or
+ * `true` bare, which the reader returns as a number or a boolean; dropping
+ * or crashing on those would lose real state, so they are read as the text
+ * they were. Anything else (null, arrays, objects) has no text.
+ */
+export declare function textOf(value: unknown): string | null;
 export declare function ensureArray(value: unknown): string[];
 /**
  * Normalize a handoff's `open_question_closures` (#122, #186). Accepts both

package/dist/core/status.js

@@ -13,8 +13,28 @@ export function assertSafePhaseId(phaseId) {
         throw new Error(`Invalid phase id: ${phaseId}`);
     }
 }
+/**
+ * A YAML scalar as text: strings as written, numbers and booleans spelled
+ * back out. Files written before #225 hold owner notes such as `2048` or
+ * `true` bare, which the reader returns as a number or a boolean; dropping
+ * or crashing on those would lose real state, so they are read as the text
+ * they were. Anything else (null, arrays, objects) has no text.
+ */
+export function textOf(value) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    return null;
+}
+/** Like {@link textOf}, trimmed, and "" for a value that has no text. */
+function trimmedText(value) {
+    return (textOf(value) ?? "").trim();
+}
 export function ensureArray(value) {
-    return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+    if (!Array.isArray(value))
+        return [];
+    return value.map(textOf).filter((entry) => entry !== null);
 }
 function coerceEntry(value, allowTargetPhase) {
     if (typeof value === "string") {
@@ -27,22 +47,22 @@ function coerceEntry(value, allowTargetPhase) {
         return null;
     const raw = value;
     const entry = {};
-    if (typeof raw.id === "string" && raw.id.trim())
-        entry.id = raw.id.trim();
-    if (typeof raw.kind === "string" && raw.kind.trim())
-        entry.kind = raw.kind.trim();
-    if (typeof raw.description === "string" && raw.description.trim())
-        entry.description = raw.description.trim();
-    if (typeof raw.deferred_reason === "string" && raw.deferred_reason.trim())
-        entry.deferred_reason = raw.deferred_reason.trim();
-    if (allowTargetPhase && typeof raw.target_phase === "string" && raw.target_phase.trim())
-        entry.target_phase = raw.target_phase.trim();
+    if (trimmedText(raw.id))
+        entry.id = trimmedText(raw.id);
+    if (trimmedText(raw.kind))
+        entry.kind = trimmedText(raw.kind);
+    if (trimmedText(raw.description))
+        entry.description = trimmedText(raw.description);
+    if (trimmedText(raw.deferred_reason))
+        entry.deferred_reason = trimmedText(raw.deferred_reason);
+    if (allowTargetPhase && trimmedText(raw.target_phase))
+        entry.target_phase = trimmedText(raw.target_phase);
     // derives_from rides the same flag as target_phase: it is a carry-forward
     // concept only — the id of the open question this routed item answers one
     // candidate of (#122, #186). An open_questions entry has nothing to derive
     // from, so the field is dropped there rather than silently carried.
-    if (allowTargetPhase && typeof raw.derives_from === "string" && raw.derives_from.trim())
-        entry.derives_from = raw.derives_from.trim();
+    if (allowTargetPhase && trimmedText(raw.derives_from))
+        entry.derives_from = trimmedText(raw.derives_from);
     return Object.keys(entry).length > 0 ? entry : null;
 }
 /**
@@ -218,11 +238,13 @@ export function normalizeStatus(status, pipeline, pipelinePath, cwd) {
             };
         }
     }
+    // Coerced, not assumed: a status.yaml written before #225 spells a
+    // digit-named project bare, and the reader returns a number for it.
     return {
-        project_name: status.project_name?.trim() || basename(cwd),
-        pipeline: status.pipeline?.trim() || pipelinePath,
-        current_phase: status.current_phase?.trim() || pipeline.phase_order[0] || "complete",
-        last_updated: status.last_updated?.trim() || "",
+        project_name: trimmedText(status.project_name) || basename(cwd),
+        pipeline: trimmedText(status.pipeline) || pipelinePath,
+        current_phase: trimmedText(status.current_phase) || pipeline.phase_order[0] || "complete",
+        last_updated: trimmedText(status.last_updated) || "",
         schema_version: typeof status.schema_version === "number" ? status.schema_version : 1,
         phases,
         next_actions: ensureArray(status.next_actions),

package/dist/core/utils.d.ts

@@ -77,3 +77,10 @@ export declare function formatMillis(ms: number): string;
  * hand-edited markers) so callers can fall back to string equality.
  */
 export declare function compareDottedVersions(a: string, b: string): number | null;
+/**
+ * Every git subprocess gets this. A hung git — a credential helper waiting
+ * on a prompt, a slow filesystem — used to hang a publish or a Broad-Side
+ * submit indefinitely while every fetch carried a 30 s timeout (self-audit
+ * sem 3.12).
+ */
+export declare const GIT_TIMEOUT_MS = 30000;

package/dist/core/utils.js

@@ -206,3 +206,10 @@ export function compareDottedVersions(a, b) {
     }
     return 0;
 }
+/**
+ * Every git subprocess gets this. A hung git — a credential helper waiting
+ * on a prompt, a slow filesystem — used to hang a publish or a Broad-Side
+ * submit indefinitely while every fetch carried a 30 s timeout (self-audit
+ * sem 3.12).
+ */
+export const GIT_TIMEOUT_MS = 30_000;

package/dist/core/workspace.js

@@ -7,7 +7,7 @@ import { appendFile, copyFile, cp, mkdir, readFile, readdir, rename } from "node
 import { basename, dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getPipelineLabel, recomputeCursor } from "./pipeline.js";
-import { acquireLock, applyHandoff, autoAssignIds, createEmptyStatus, normalizeStatus, parseHandoff } from "./status.js";
+import { acquireLock, applyHandoff, autoAssignIds, createEmptyStatus, normalizeStatus, parseHandoff, textOf } from "./status.js";
 import { atomicWriteFile, compareDottedVersions, newlineIfUnterminated, pathExists } from "./utils.js";
 import { loadYamlFile, stringifySimpleYaml } from "./yaml.js";
 // Walk up from the current file to find the package root. Needed because the
@@ -68,7 +68,7 @@ export async function getWorkspaceState(cwd) {
     if (!(await pathExists(statusPath)))
         return null;
     const rawStatus = await loadYamlFile(statusPath);
-    const pipelineRelativePath = rawStatus.pipeline?.trim();
+    const pipelineRelativePath = (textOf(rawStatus.pipeline) ?? "").trim();
     if (!pipelineRelativePath) {
         throw new Error(`Missing pipeline in ${relative(cwd, statusPath) || statusPath}`);
     }

package/dist/core/yaml.js

@@ -497,8 +497,15 @@ export function formatYamlScalar(value) {
     const stringValue = String(value);
     if (stringValue === "")
         return '""';
-    if (/^[A-Za-z0-9_./-]+$/.test(stringValue))
+    // Bare only when the reader would hand the same string back. The charset
+    // keeps out spaces, quotes, `#` and `:`; the round-trip check keeps out the
+    // strings the reader coerces — "2048", "true", "null", "1.5" — which used
+    // to go out bare and come back as a number, a boolean, or nothing, until a
+    // repository named `2048` bricked its workspace on `project_name.trim`
+    // (#225). A lone `-` is a sequence marker inside a list, so it is quoted too.
+    if (/^[A-Za-z0-9_./-]+$/.test(stringValue) && stringValue !== "-" && parseYamlScalar(stringValue) === stringValue) {
         return stringValue;
+    }
     return JSON.stringify(stringValue);
 }
 export function stringifySimpleYaml(value, indent = 0) {

package/dist/extensions/codecarto/auto-runner.d.ts

@@ -45,7 +45,7 @@ export interface AutoCompleteResult {
     warnings: string[];
 }
 export declare function autoCompletePhase(cwd: string, validation: ValidationResult): Promise<AutoCompleteResult>;
-export type AutoOutcome = "complete" | "stopped" | "aborted";
+export type AutoOutcome = "complete" | "stopped" | "aborted" | "stuck";
 export interface AutoRunOptions {
     strict: boolean;
     llmSteerOverride?: boolean;

package/dist/extensions/codecarto/auto-runner.js

@@ -17,7 +17,7 @@ import { clearPhase, finishPhase, getPhaseActivity, startPhase } from "./agent-s
 import { buildSteeringMessage, rewritePhasePrompt } from "./agent-rewriter.js";
 import { buildPhaseSummary } from "./agent-summary.js";
 import { getAgentsWidget } from "./agent-widget.js";
-import { appendUsageRun, buildPhasePrompt, buildValidationSummary, completeValidatedPhase, formatMillis, formatTokenCount, getNextEligiblePhase, getWorkspaceState, describeConfigProblems, loadCodecartoConfig, PACKAGE_VERSION, PhasePreflightError, runPhasePreflight, validatePhaseOutput, writeDashboard, } from "../../core/index.js";
+import { appendUsageRun, buildPhasePrompt, buildValidationSummary, completeValidatedPhase, formatMillis, formatTokenCount, describeStuckPipeline, resolvePipelineOutcome, getWorkspaceState, describeConfigProblems, loadCodecartoConfig, PACKAGE_VERSION, PhasePreflightError, runPhasePreflight, validatePhaseOutput, writeDashboard, } from "../../core/index.js";
 /**
  * Run one phase end to end: optional LLM-steered rewrite, spawn the sub-agent,
  * wait for it, then emit the side effects the historical /codecarto-next chain
@@ -203,13 +203,22 @@ export async function runAuto(ctx, pi, initialState, options) {
                 reason: "User aborted the auto run.",
             });
         }
-        const phase = getNextEligiblePhase(state);
-        if (!phase) {
+        const outcome = resolvePipelineOutcome(state);
+        if (outcome.kind === "stuck") {
+            // Not "complete": the loop ending because nothing can run is the
+            // case that used to read as success (#228).
+            return finish({
+                outcome: "stuck",
+                reason: describeStuckPipeline(outcome.blocked),
+            });
+        }
+        if (outcome.kind === "complete") {
             return finish({
                 outcome: "complete",
                 reason: "Pipeline complete.",
             });
         }
+        const phase = outcome.phase;
         let preflight;
         try {
             preflight = await runPhasePreflight(state, phase);
@@ -308,6 +317,8 @@ export function buildAutoSummary(result, availableSkills = []) {
                 return `**Auto pipeline stopped at \`${result.stoppedAt?.phaseId ?? "?"}\`.**`;
             case "aborted":
                 return `**Auto pipeline aborted${result.stoppedAt?.phaseId ? ` during \`${result.stoppedAt.phaseId}\`` : ""}.**`;
+            case "stuck":
+                return `**Auto pipeline stuck: no phase can run.**`;
         }
     })();
     const statsLine = `_⟳ ${ranOf} · ${tokensStr} tokens · ${wallTime}_`;
@@ -321,6 +332,10 @@ export function buildAutoSummary(result, availableSkills = []) {
         lines.push("", result.reason);
         lines.push("", recoveryHint(result));
     }
+    if (result.outcome === "stuck") {
+        // The reason is the stuck sentence, which already says what to fix.
+        lines.push("", result.reason);
+    }
     if (result.outcome === "complete") {
         lines.push("", "Dashboard: `.codecarto/dashboard.html`");
         if (availableSkills.length > 0) {

package/dist/extensions/codecarto/broadside-flags.d.ts

@@ -16,11 +16,17 @@ export interface BroadsideFlags {
     /** Undefined means "use the repository's config default". */
     maxCost?: number;
     waitSeconds?: number;
+    /** For collect: the run to collect instead of the most recent (#268). */
+    runId?: string;
+    /** For submit: the run's batch model, replacing config.yaml's (#141). */
+    model?: string;
+    /** For submit: per-lens model overrides, layered over config.yaml's (#141). */
+    lensModels?: Partial<Record<BroadsideLensId, string>>;
     benchmarks: boolean;
     unknown: string[];
     /** Set on an invalid combination. The caller surfaces it as an error. */
     error?: string;
 }
 /** Every token the completer offers, in the order it offers them. */
-export declare const KNOWN_BROADSIDE_TOKENS: readonly ["submit", "collect", "status", "models", "architecture", "api", "security", "defect", "conventions", "porting", "--incremental", "--no-incremental", "--max-cost=", "--wait=", "--no-synthesis", "--no-triage", "--no-retry-truncated", "--benchmarks"];
+export declare const KNOWN_BROADSIDE_TOKENS: readonly ["submit", "collect", "status", "models", "architecture", "api", "security", "defect", "conventions", "porting", "--incremental", "--no-incremental", "--max-cost=", "--wait=", "--run=", "--model=", "--lens-model=", "--no-synthesis", "--no-triage", "--no-retry-truncated", "--benchmarks"];
 export declare function parseBroadsideFlags(args: string): BroadsideFlags;

package/dist/extensions/codecarto/broadside-flags.js

@@ -13,6 +13,12 @@
 //   --no-incremental       --no-triage
 //   --max-cost=N           --no-retry-truncated
 //   --wait=SECONDS         --benchmarks (models only)
+//   --run=ID (collect only: an older run, as listed by status)
+//   --model=ID (submit only: the run's batch model, as listed by models)
+//   --lens-model=LENS:ID (submit only, repeatable: one lens on its own model)
+//
+// A model id itself contains a colon (`vendor/name:batch`), so --lens-model
+// splits on the first colon only: `security:deepseek/deepseek-v4-pro:batch`.
 //
 // --incremental has a spelled-out negative because the value is tri-state:
 // absent defers to config.yaml, so a repository that set `incremental: true`
@@ -34,6 +40,9 @@ export const KNOWN_BROADSIDE_TOKENS = [
     "--no-incremental",
     "--max-cost=",
     "--wait=",
+    "--run=",
+    "--model=",
+    "--lens-model=",
     "--no-synthesis",
     "--no-triage",
     "--no-retry-truncated",
@@ -106,6 +115,39 @@ export function parseBroadsideFlags(args) {
             result.waitSeconds = parseNumeric(token, "--wait", result);
             continue;
         }
+        if (token.startsWith("--run=")) {
+            const value = token.slice("--run=".length).trim();
+            if (!value)
+                result.error ??= "--run= needs a run id (see /codecarto-broadside status).";
+            result.runId = value || undefined;
+            continue;
+        }
+        if (token.startsWith("--model=")) {
+            const value = token.slice("--model=".length).trim();
+            // An empty value is a mistyped selection, not "use the default":
+            // the command is about to spend money on whichever model wins.
+            if (!value)
+                result.error ??= "--model= needs an OpenRouter batch model id (see /codecarto-broadside models).";
+            result.model = value || undefined;
+            continue;
+        }
+        if (token.startsWith("--lens-model=")) {
+            const value = token.slice("--lens-model=".length).trim();
+            const colon = value.indexOf(":");
+            const lensId = colon > 0 ? value.slice(0, colon).trim() : "";
+            const modelId = colon > 0 ? value.slice(colon + 1).trim() : "";
+            if (!lensId || !modelId) {
+                result.error ??= `--lens-model needs LENS:MODEL, e.g. --lens-model=security:vendor/name:batch (got "${value}").`;
+            }
+            else if (!BROADSIDE_LENS_IDS.includes(lensId)) {
+                result.error ??= `--lens-model: unknown lens "${lensId}". Lenses: ${BROADSIDE_LENS_IDS.join(", ")}.`;
+            }
+            else {
+                result.lensModels ??= {};
+                result.lensModels[lensId] = modelId;
+            }
+            continue;
+        }
         result.unknown.push(token);
     }
     // Flags that only mean something for one action are refused rather than
@@ -125,5 +167,14 @@ export function parseBroadsideFlags(args) {
     if (result.action === "status" && result.waitSeconds !== undefined) {
         result.error ??= "--wait is only meaningful for submit and collect; status reads recorded state.";
     }
+    if (result.runId !== undefined && result.action !== "collect") {
+        result.error ??= `--run is only meaningful for collect (got action "${result.action}").`;
+    }
+    if (result.model !== undefined && result.action !== "submit") {
+        result.error ??= `--model is only meaningful for submit (got action "${result.action}").`;
+    }
+    if (result.lensModels !== undefined && result.action !== "submit") {
+        result.error ??= `--lens-model is only meaningful for submit (got action "${result.action}").`;
+    }
     return result;
 }