codecartographer-pi 0.24.0 → 0.25.0

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

@@ -132,8 +132,9 @@ export async function runSinglePhase(ctx, pi, state, phase, options) {
         return { status: "error", activity, error: message };
     }
     finally {
-        // Linger 30s so /codecarto-status can show that the phase ran.
-        setTimeout(() => clearPhase(phase.id), 30_000);
+        // Linger 30s so /codecarto-status can show that the phase ran. Tied
+        // to this run's entry: a re-run inside the window keeps its own (#343).
+        setTimeout(() => clearPhase(phase.id, activity), 30_000).unref?.();
     }
 }
 /**
@@ -304,6 +305,19 @@ export async function runAuto(ctx, pi, initialState, options) {
 // ----------------------------------------------------------------------------
 // buildAutoSummary — the codecarto-auto-summary message body
 // ----------------------------------------------------------------------------
+/**
+ * The one-line notification for an auto run's end. A run that stopped short
+ * carries its reason: the auto-summary message and the widget carry it too,
+ * but under `pi -p` neither is rendered, and "stopped: 0/1 phases" alone
+ * sent a reader back to the code to find out why (#347).
+ */
+export function describeAutoOutcome(result) {
+    const line = `Auto pipeline ${result.outcome}: ${result.phasesRun.length}/${result.totalPhases} phases.`;
+    if (result.outcome === "complete")
+        return line;
+    const reason = result.reason.trim();
+    return reason ? `${line.replace(/\.$/, "")} — ${reason}` : line;
+}
 export function buildAutoSummary(result, availableSkills = []) {
     const totalTokens = result.totalTokens.input + result.totalTokens.output;
     const wallTime = formatMillis(result.endedAt - result.startedAt);

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

@@ -24,11 +24,13 @@ export interface BroadsideFlags {
     lensModels?: Partial<Record<BroadsideLensId, string>>;
     /** For verify: how many findings to read (#143). */
     top?: number;
+    /** For collect: reset the settled post-passes and run them again (#338). */
+    regeneratePostPasses?: boolean;
     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", "verify", "architecture", "api", "security", "defect", "conventions", "porting", "--incremental", "--no-incremental", "--max-cost=", "--wait=", "--run=", "--model=", "--lens-model=", "--top=", "--no-synthesis", "--no-triage", "--no-retry-truncated", "--benchmarks"];
+export declare const KNOWN_BROADSIDE_TOKENS: readonly ["submit", "collect", "status", "models", "verify", "architecture", "api", "security", "defect", "conventions", "porting", "--incremental", "--no-incremental", "--max-cost=", "--wait=", "--run=", "--model=", "--lens-model=", "--top=", "--regenerate", "--no-synthesis", "--no-triage", "--no-retry-truncated", "--benchmarks"];
 export declare function parseBroadsideFlags(args: string): BroadsideFlags;

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

@@ -7,6 +7,7 @@
 //   /codecarto-broadside status
 //   /codecarto-broadside models --benchmarks
 //   /codecarto-broadside verify --top=10       → read the top findings against the source
+//   /codecarto-broadside collect --regenerate  → rebuild synthesis and triage from the verdicts
 //
 // Flags mirror the codecarto_broadside tool parameters, with the negative
 // forms spelled out because a slash command has no place to pass `false`:
@@ -18,6 +19,7 @@
 //   --model=ID (submit: the run's batch model, as listed by models; verify: the sync model to read with)
 //   --lens-model=LENS:ID (submit only, repeatable: one lens on its own model)
 //   --top=N (verify only: how many findings to read, most severe first)
+//   --regenerate (collect only: reset the settled post-passes and run them again, verdicts included)
 //
 // 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`.
@@ -47,6 +49,7 @@ export const KNOWN_BROADSIDE_TOKENS = [
     "--model=",
     "--lens-model=",
     "--top=",
+    "--regenerate",
     "--no-synthesis",
     "--no-triage",
     "--no-retry-truncated",
@@ -107,6 +110,10 @@ export function parseBroadsideFlags(args) {
             result.retryTruncated = false;
             continue;
         }
+        if (token === "--regenerate") {
+            result.regeneratePostPasses = true;
+            continue;
+        }
         if (token === "--benchmarks") {
             result.benchmarks = true;
             continue;
@@ -188,6 +195,12 @@ export function parseBroadsideFlags(args) {
     if (result.top !== undefined && result.action !== "verify") {
         result.error ??= `--top is only meaningful for verify (got action "${result.action}").`;
     }
+    if (result.regeneratePostPasses && result.action !== "collect") {
+        result.error ??= `--regenerate is only meaningful for collect (got action "${result.action}").`;
+    }
+    if (result.regeneratePostPasses && result.includeSynthesis === false && result.includeTriage === false) {
+        result.error ??= "--regenerate with both --no-synthesis and --no-triage leaves nothing to regenerate.";
+    }
     if (result.action === "verify" && result.waitSeconds !== undefined) {
         result.error ??= "--wait is only meaningful for submit and collect; verify runs to completion.";
     }

package/dist/extensions/codecarto/index.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
-import { autoCompletePhase, buildAutoSummary, isPhaseRunning, runAuto, runSinglePhase } from "./auto-runner.js";
+import { autoCompletePhase, buildAutoSummary, describeAutoOutcome, isPhaseRunning, runAuto, runSinglePhase } from "./auto-runner.js";
 import { disposeAgentsWidget } from "./agent-widget.js";
 import { parseDashboardFlags } from "./dashboard-flags.js";
 import { narrateDashboard } from "./dashboard-narrator.js";
@@ -11,7 +11,7 @@ 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, runBroadsideVerify, verifyResultText, 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 { initLibrary, isValidSlug } from "../../core/library.js";
 import { resolveUserConfigPath } from "../../core/orchestrator-config.js";
 const STATUS_WIDGET_ID = "codecarto-widget";
 // Broad-Side gets its own widget id: a scout run is legal on a repository with
@@ -638,7 +638,7 @@ export default function codeCartographerExtension(pi) {
                 });
                 lastFeedbackLines = [`Auto pipeline ${result.outcome}: ${result.reason}`];
                 await refreshWorkspaceUi(ctx, lastFeedbackLines);
-                notifyCtx(ctx, `Auto pipeline ${result.outcome}: ${result.phasesRun.length}/${result.totalPhases} phases.`, result.outcome === "complete" ? "info" : "warning");
+                notifyCtx(ctx, describeAutoOutcome(result), result.outcome === "complete" ? "info" : "warning");
                 return;
             }
             const outcome = resolvePipelineOutcome(state);
@@ -995,7 +995,7 @@ export default function codeCartographerExtension(pi) {
         },
     });
     pi.registerCommand("codecarto-broadside", {
-        description: "Batch reconnaissance (Broad-Side): /codecarto-broadside [submit|collect|status|models|verify] [lenses…] [--model=ID] [--lens-model=LENS:ID] [--top=N] [flags]",
+        description: "Batch reconnaissance (Broad-Side): /codecarto-broadside [submit|collect|status|models|verify] [lenses…] [--model=ID] [--lens-model=LENS:ID] [--top=N] [--regenerate] [flags]",
         // Completes the token under the cursor, so lens names and flags are
         // offered after the action too, and keeps everything typed before it.
         getArgumentCompletions: (prefix) => completeLastToken(prefix, KNOWN_BROADSIDE_TOKENS.map((value) => ({ value }))),
@@ -1220,6 +1220,7 @@ export default function codeCartographerExtension(pi) {
                     retryTruncated,
                     onStatus,
                     ...(flags.runId && { runId: flags.runId }),
+                    ...(flags.regeneratePostPasses && { regeneratePostPasses: true }),
                 });
                 const lines = collectResultText(collect).split("\n");
                 const done = collect.status === "completed";
@@ -1354,12 +1355,41 @@ export default function codeCartographerExtension(pi) {
     pi.registerCommand("codecarto-library-init", {
         description: "Initialize a CodeCartographer library and configure it: /codecarto-library-init <path> [--namespace <name>]",
         handler: async (args, ctx) => {
-            const parts = args.trim().split(/\s+/);
-            const pathArg = parts[0];
+            const usage = "Usage: /codecarto-library-init <path> [--namespace <name>]";
+            const parts = args.trim() === "" ? [] : args.trim().split(/\s+/);
+            // `--namespace` with nothing after it used to read as "no namespace"
+            // and initialize an unnamespaced library without a word (Broad-Side
+            // verify, 2026-09-13 run): the flag is either complete or refused.
             const namespaceIdx = parts.indexOf("--namespace");
-            const namespace = namespaceIdx >= 0 ? parts[namespaceIdx + 1] : null;
+            let namespace = null;
+            if (namespaceIdx >= 0) {
+                const value = parts[namespaceIdx + 1];
+                if (value === undefined || value.startsWith("--")) {
+                    notifyCtx(ctx, `--namespace needs a name. ${usage}`, "warning");
+                    return;
+                }
+                // The rule publish applies to it later, applied before it is
+                // written into the config: lowercase ASCII, starts with a
+                // letter, at most 64 characters.
+                if (!isValidSlug(value)) {
+                    notifyCtx(ctx, `Invalid namespace "${value}" (lowercase ASCII, starts with a letter, max 64 chars). ${usage}`, "warning");
+                    return;
+                }
+                namespace = value;
+                parts.splice(namespaceIdx, 2);
+            }
+            const stray = parts.find((part) => part.startsWith("--"));
+            if (stray) {
+                notifyCtx(ctx, `Unknown flag ${stray}. ${usage}`, "warning");
+                return;
+            }
+            const [pathArg, ...extra] = parts;
             if (!pathArg) {
-                notifyCtx(ctx, "Usage: /codecarto-library-init <path> [--namespace <name>]", "warning");
+                notifyCtx(ctx, usage, "warning");
+                return;
+            }
+            if (extra.length > 0) {
+                notifyCtx(ctx, `One path, please — got ${parts.length}. ${usage}`, "warning");
                 return;
             }
             // The same expansion the config loader applies, so `~user/x` and a

package/dist/mcp-server/server.d.ts

@@ -248,6 +248,7 @@ export declare function handleBroadside(args: {
     model?: string;
     lens_models?: Record<string, string>;
     top?: number;
+    regenerate_post_passes?: boolean;
 }): Promise<{
     content: {
         type: "text";

package/dist/mcp-server/server.js

@@ -808,6 +808,11 @@ export async function handleLibraryInit(args) {
     }
     const libraryPath = args.library_path;
     const namespaced = !!args.namespace;
+    // The rule codecarto_publish applies to the namespace later, applied
+    // before it is written into the config.
+    if (namespaced && !isValidSlug(args.namespace)) {
+        throw new McpError(ErrorCode.InvalidParams, `Invalid namespace "${args.namespace}" (lowercase ASCII, starts with a letter, max 64 chars).`);
+    }
     const result = await initLibrary(libraryPath, {
         name: args.name,
         namespaced,
@@ -1207,6 +1212,12 @@ export async function handleBroadside(args) {
         });
     }
     // action === "collect"
+    if (args.regenerate_post_passes !== undefined && typeof args.regenerate_post_passes !== "boolean") {
+        throw new McpError(ErrorCode.InvalidParams, "regenerate_post_passes must be a boolean.");
+    }
+    if (args.regenerate_post_passes && !includeSynthesis && !includeTriage) {
+        throw new McpError(ErrorCode.InvalidParams, "regenerate_post_passes needs at least one of include_synthesis and include_triage.");
+    }
     const collect = await runBroadsideCollect(cwd, apiKey, {
         waitMs,
         includeSynthesis,
@@ -1214,6 +1225,7 @@ export async function handleBroadside(args) {
         retryTruncated,
         signal: serverLifetime?.signal,
         ...(runId && { runId }),
+        ...(args.regenerate_post_passes && { regeneratePostPasses: true }),
     }).catch((error) => {
         throw new McpError(ErrorCode.InvalidRequest, error instanceof Error ? error.message : String(error));
     });
@@ -1227,6 +1239,7 @@ export async function handleBroadside(args) {
         lensOutcomes: collect.lensOutcomes,
         synthesis: collect.synthesis,
         triage: collect.triage,
+        ...(collect.regenerated && { regenerated: collect.regenerated }),
         topFindings: collect.topFindings,
         topTriageItems: collect.topTriageItems,
     });
@@ -1535,7 +1548,7 @@ const TOOLS = [
                 action: {
                     type: "string",
                     enum: ["submit", "collect", "status", "models", "verify"],
-                    description: "submit fires all lens batches and returns batch ids; collect polls submitted batches, saves results, and optionally runs the synthesis pass; status shows recorded runs; models lists batch-capable models with pricing and capabilities; verify reads a collected run's top defect and security findings against the repository with read-only tools (one sync-priced call each, about a cent on the default model) and writes verified.md/verified.json beside triage.md with a verdict per finding: confirmed (a reachable failure, with the trigger), not-a-defect, discarded, or unclear.",
+                    description: "submit fires all lens batches and returns batch ids; collect polls submitted batches, saves results, and optionally runs the synthesis and triage passes — built from verified.json when a verify pass has already written it, so run verify first or collect again with regenerate_post_passes afterwards; status shows recorded runs; models lists batch-capable models with pricing and capabilities; verify reads a collected run's top defect and security findings against the repository with read-only tools (one sync-priced call each, about a cent on the default model) and writes verified.md/verified.json beside triage.md with a verdict per finding: confirmed (a reachable failure, with the trigger), not-a-defect, discarded, or unclear.",
                 },
                 lenses: {
                     type: "array",
@@ -1570,6 +1583,10 @@ const TOOLS = [
                     type: "boolean",
                     description: "Re-submit lens results that came back truncated at the output token limit, once, with a doubled output cap. Falls back to retry_truncated in .codecarto/broadside/config.yaml (default true).",
                 },
+                regenerate_post_passes: {
+                    type: "boolean",
+                    description: "collect only: reset the run's settled synthesis and triage passes and run them again, so a verify pass's verdicts (verified.json) are built into the executive report and the work order — confirmed findings first, discarded ones dropped, not-a-defect ones listed apart. Costs another post-pass pair (a few cents); a pass still in flight is left to finish; a run whose lens batches are still running is refused.",
+                },
                 max_cost: {
                     type: "number",
                     description: "Approximate run expense limit in USD. The submit action estimates the run cost from slice sizes and the configured model's per-token pricing (live OpenRouter lookup, cached 24h) and refuses to submit when the estimate exceeds the limit unless force is true. For verify it is a running cap: the pass stops before the next finding once the calls so far have reached it. Falls back to max_cost in .codecarto/broadside/config.yaml, whose default is $1.00; pass 0 for no limit.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecartographer-pi",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "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",