codecartographer-pi 0.6.1 → 0.9.0

package/dist/extensions/codecarto/dashboard-writer.js

@@ -0,0 +1,148 @@
+// I/O wrapper that gathers all dashboard inputs and writes the rendered
+// HTML to `.codecarto/dashboard.html`. Best-effort — failures are swallowed
+// and never escalate to a phase error the user sees, mirroring the
+// recordUsage discipline at extensions/codecarto/index.ts.
+import { readdir, readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { DASHBOARD_RELATIVE_PATH, getWorkspaceState, loadUsage, NARRATION_CACHE_RELATIVE_PATH, parseSimpleYaml, pathExists, renderDashboard, } from "../../core/index.js";
+const CLOSEOUT_FILENAME_RE = /^(\d{4}-\d{2}-\d{2})-(.+)\.md$/;
+export async function writeDashboard(cwd, packageVersion) {
+    try {
+        const state = await getWorkspaceState(cwd);
+        if (!state)
+            return;
+        const workspaceDir = state.workspaceDir;
+        const [usage, closeouts, outputsPresent, narration] = await Promise.all([
+            loadUsage(workspaceDir),
+            listCloseouts(workspaceDir),
+            buildOutputsPresent(state.workspaceDir, state.pipeline),
+            loadNarration(workspaceDir),
+        ]);
+        const inputs = {
+            status: state.status,
+            pipeline: state.pipeline,
+            usage,
+            closeouts,
+            outputsPresent,
+            packageVersion,
+            generatedAt: new Date().toISOString(),
+            narration,
+        };
+        const html = renderDashboard(inputs);
+        const path = join(workspaceDir, DASHBOARD_RELATIVE_PATH);
+        const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+        await writeFile(tempPath, html, "utf8");
+        await rename(tempPath, path);
+    }
+    catch {
+        // Best-effort: a failed dashboard write must not surface as a phase
+        // error. The user's pipeline state is unaffected; the next state
+        // change will trigger another render attempt.
+    }
+}
+async function listCloseouts(workspaceDir) {
+    const dir = join(workspaceDir, "closeouts");
+    if (!(await pathExists(dir)))
+        return [];
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of entries) {
+        const m = CLOSEOUT_FILENAME_RE.exec(name);
+        if (!m)
+            continue;
+        out.push({ date: m[1], phaseOrModule: m[2], fileName: name, summary: await readCloseoutSummary(join(dir, name)) });
+    }
+    return out;
+}
+async function readCloseoutSummary(path) {
+    try {
+        const raw = await readFile(path, "utf8");
+        const lines = raw.split(/\r?\n/);
+        const summaryStart = lines.findIndex((line) => /^##\s+Summary\s*$/i.test(line.trim()));
+        if (summaryStart === -1)
+            return undefined;
+        const body = [];
+        for (const line of lines.slice(summaryStart + 1)) {
+            if (/^##\s+/.test(line.trim()))
+                break;
+            const trimmed = line.trim();
+            if (!trimmed || trimmed === "-")
+                continue;
+            body.push(trimmed.replace(/^[-*]\s+/, ""));
+            if (body.join(" ").length > 280)
+                break;
+        }
+        const summary = body.join(" ").trim();
+        return summary ? `${summary.slice(0, 280)}${summary.length > 280 ? "…" : ""}` : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function buildOutputsPresent(workspaceDir, pipeline) {
+    const out = new Map();
+    for (const phaseId of pipeline.phase_order) {
+        const phaseDef = pipeline.phases.find((p) => p.id === phaseId);
+        if (!phaseDef)
+            continue;
+        const entry = { secondary: [] };
+        if (phaseDef.primary_output) {
+            entry.primary = {
+                path: phaseDef.primary_output,
+                exists: await pathExists(join(workspaceDir, phaseDef.primary_output)),
+            };
+        }
+        for (const sec of phaseDef.secondary_outputs ?? []) {
+            entry.secondary.push({
+                path: sec.path,
+                exists: await pathExists(join(workspaceDir, sec.path)),
+            });
+        }
+        out.set(phaseId, entry);
+    }
+    return out;
+}
+async function loadNarration(workspaceDir) {
+    const path = join(workspaceDir, NARRATION_CACHE_RELATIVE_PATH);
+    if (!(await pathExists(path)))
+        return undefined;
+    try {
+        const raw = await readFile(path, "utf8");
+        const { frontmatter, body } = splitFrontmatter(raw);
+        if (!frontmatter)
+            return undefined;
+        const generatedAt = typeof frontmatter.generatedAt === "string" ? frontmatter.generatedAt : "";
+        const phaseCountAtGeneration = typeof frontmatter.phaseCountAtGeneration === "number" ? frontmatter.phaseCountAtGeneration : 0;
+        if (!generatedAt)
+            return undefined;
+        return { content: body.trim(), generatedAt, phaseCountAtGeneration };
+    }
+    catch {
+        return undefined;
+    }
+}
+function splitFrontmatter(raw) {
+    if (!raw.startsWith("---\n"))
+        return { frontmatter: null, body: raw };
+    const end = raw.indexOf("\n---\n", 4);
+    if (end === -1)
+        return { frontmatter: null, body: raw };
+    const yamlText = raw.slice(4, end);
+    const body = raw.slice(end + 5);
+    try {
+        const parsed = parseSimpleYaml(yamlText);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return { frontmatter: parsed, body };
+        }
+    }
+    catch {
+        // fall through
+    }
+    return { frontmatter: null, body };
+}

package/dist/extensions/codecarto/index.js

@@ -1,36 +1,15 @@
 import { cp, mkdir, rm, writeFile } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
-import { runPhase } from "./agent-runner.js";
-import { buildSteeringMessage, rewritePhasePrompt } from "./agent-rewriter.js";
-import { clearPhase, finishPhase, getPhaseActivity, startPhase } from "./agent-state.js";
-import { buildPhaseSummary } from "./agent-summary.js";
-import { disposeAgentsWidget, getAgentsWidget } from "./agent-widget.js";
+import { autoCompletePhase, buildAutoSummary, 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";
+import { writeDashboard } from "./dashboard-writer.js";
 import { parseNextFlags } from "./next-flags.js";
-import { appendUsageRun, buildPhasePrompt, buildSkillPrompt, buildThreadLogEntry, buildValidationSummary, canonicalPath, closeoutFileName, computePerPhaseTotals, computeTotals, createEmptyStatus, dateOnly, DEFAULT_PIPELINE_PATH, ensureCloseoutStub, getNextEligiblePhase, getPipelineLabel, getWorkspaceState, isWithinPath, listSkillNames, loadCodecartoConfig, loadUsage, loadYamlFile, normalizeForComparison, normalizeStatus, packagedWorkspaceDir, pathExists, PIPELINE_ALIASES, resolvePhase, resolvePipelineChoice, stringifySimpleYaml, uniqueStrings, updateStatusAtomically, validatePhaseOutput, } from "../../core/index.js";
+import { buildPhasePrompt, buildSkillPrompt, buildValidationSummary, canonicalPath, computePerPhaseTotals, computeTotals, createEmptyStatus, DEFAULT_PIPELINE_PATH, getNextEligiblePhase, getPipelineLabel, getWorkspaceState, isWithinPath, listSkillNames, loadCodecartoConfig, loadUsage, loadYamlFile, normalizeForComparison, packagedWorkspaceDir, pathExists, PACKAGE_VERSION, PIPELINE_ALIASES, resolvePhase, resolvePipelineChoice, stringifySimpleYaml, validatePhaseOutput, } from "../../core/index.js";
 const STATUS_WIDGET_ID = "codecarto-widget";
 const STATUS_LINE_ID = "codecarto-status";
 const SAFE_TOOL_NAMES = ["read", "grep", "find", "ls", "edit", "write"];
-async function recordUsage(workspaceDir, phaseId, status, activity) {
-    try {
-        await appendUsageRun(workspaceDir, {
-            timestamp: new Date().toISOString(),
-            phase: phaseId,
-            status,
-            turn_count: activity.turnCount,
-            tool_uses: activity.toolUses,
-            duration_ms: (activity.completedAt ?? Date.now()) - activity.startedAt,
-            tokens: {
-                input: activity.lifetimeUsage.input,
-                output: activity.lifetimeUsage.output,
-                cache_write: activity.lifetimeUsage.cacheWrite,
-            },
-        });
-    }
-    catch {
-        // Local usage logging is best-effort. A full disk or permission
-        // failure shouldn't surface as a phase error to the user.
-    }
-}
 function formatUsageTokens(count) {
     if (count >= 1_000_000)
         return `${(count / 1_000_000).toFixed(2)}M`;
@@ -203,6 +182,9 @@ export default function codeCartographerExtension(pi) {
             lastFeedbackLines = [`Initialized workspace with pipeline: ${getPipelineLabel(selectedPipelinePath)}`];
             ctx.ui.notify(`Initialized CodeCartographer (${getPipelineLabel(selectedPipelinePath)})`, "info");
             await ctx.reload();
+            // Render the initial dashboard (empty usage, all phases pending) so
+            // the user sees the file exist immediately after /codecarto-init.
+            void writeDashboard(ctx.cwd, PACKAGE_VERSION);
             return;
         },
     });
@@ -219,15 +201,19 @@ export default function codeCartographerExtension(pi) {
         },
     });
     pi.registerCommand("codecarto-next", {
-        description: "Run the next eligible CodeCartographer phase as a sub-agent. Flags: --llm-steer / --no-llm-steer",
+        description: "Run the next eligible CodeCartographer phase as a sub-agent. Flags: --llm-steer / --no-llm-steer / --auto [--strict]",
         getArgumentCompletions: (prefix) => {
-            const items = ["--llm-steer", "--no-llm-steer"]
+            const items = ["--llm-steer", "--no-llm-steer", "--auto", "--strict"]
                 .filter((value) => value.startsWith(prefix))
                 .map((value) => ({ value, label: value }));
             return items.length > 0 ? items : null;
         },
         handler: async (args, ctx) => {
             const flags = parseNextFlags(args);
+            if (flags.error) {
+                ctx.ui.notify(flags.error, "error");
+                return;
+            }
             if (flags.unknown.length > 0) {
                 ctx.ui.notify(`Unknown /codecarto-next flag: ${flags.unknown.join(" ")}`, "error");
                 return;
@@ -235,6 +221,33 @@ export default function codeCartographerExtension(pi) {
             const state = await ensureWorkspaceState(ctx);
             if (!state)
                 return;
+            if (flags.auto) {
+                ctx.ui.notify(`Auto pipeline${flags.strict ? " (strict)" : ""} running…`, "info");
+                const result = await runAuto(ctx, pi, state, {
+                    strict: flags.strict,
+                    llmSteerOverride: flags.llmSteerOverride,
+                    signal: ctx.signal,
+                    onPhaseAdvanced: (advancedState) => {
+                        // Refresh the status widget + session name between phases so
+                        // the readout tracks progress live instead of staying frozen
+                        // at the initial phase until the whole auto run finishes.
+                        setUiState(ctx, advancedState, [`Auto pipeline${flags.strict ? " (strict)" : ""} running…`]);
+                        const phaseId = getNextEligiblePhase(advancedState)?.id ?? advancedState.status.current_phase;
+                        if (phaseId)
+                            pi.setSessionName(`CodeCartographer: ${phaseId}`);
+                    },
+                });
+                const availableSkills = await listSkillNames(state.workspaceDir).catch(() => []);
+                pi.sendMessage({
+                    customType: "codecarto-auto-summary",
+                    content: buildAutoSummary(result, availableSkills),
+                    display: true,
+                });
+                lastFeedbackLines = [`Auto pipeline ${result.outcome}: ${result.reason}`];
+                await refreshWorkspaceUi(ctx, lastFeedbackLines);
+                ctx.ui.notify(`Auto pipeline ${result.outcome}: ${result.phasesRun.length}/${result.totalPhases} phases.`, result.outcome === "complete" ? "info" : "warning");
+                return;
+            }
             const phase = getNextEligiblePhase(state);
             if (!phase) {
                 lastFeedbackLines = ["All phases complete."];
@@ -244,122 +257,23 @@ export default function codeCartographerExtension(pi) {
             }
             // Reject re-entry: don't spawn a duplicate runner for a phase that's
             // already in flight from a previous /codecarto-next invocation.
-            const existing = getPhaseActivity(phase.id);
-            if (existing && existing.status === "running") {
+            if (isPhaseRunning(phase.id)) {
                 ctx.ui.notify(`Phase ${phase.id} is already running.`, "warning");
                 return;
             }
             const config = await loadCodecartoConfig(state.workspaceDir);
             const llmSteerEnabled = flags.llmSteerOverride ?? config.orchestrator.llm_steer_next_phase;
-            let prompt = await buildPhasePrompt(state, phase, false);
-            if (llmSteerEnabled) {
-                ctx.ui.notify(`Customizing ${phase.id} prompt via LLM rewriter…`, "info");
-                const rewrite = await rewritePhasePrompt({ ctx, state, originalPrompt: prompt, nextPhaseId: phase.id });
-                if (rewrite.used) {
-                    prompt = rewrite.prompt;
-                    ctx.ui.notify(`LLM rewriter customized ${phase.id} seed prompt.`, "info");
-                    // Inject the full rewritten prompt into the orchestrator's session
-                    // so the user can audit what the rewriter chose to emphasize before
-                    // the phase sub-agent starts. Same pattern as the phase-completion
-                    // summary: display:true renders in the TUI; no triggerTurn so the
-                    // orchestrator doesn't auto-respond.
-                    pi.sendMessage({
-                        customType: "codecarto-steering",
-                        content: buildSteeringMessage({
-                            nextPhaseId: phase.id,
-                            prevPhaseId: rewrite.prevPhaseId,
-                            rewrittenPrompt: rewrite.prompt,
-                        }),
-                        display: true,
-                    });
-                }
-                else {
-                    ctx.ui.notify(`LLM rewriter skipped (${rewrite.skipReason}); using stock prompt.`, "warning");
-                }
-            }
-            const activity = startPhase(phase.id);
             lastFeedbackLines = [`Running ${phase.id} phase as sub-agent`];
             setUiState(ctx, state, lastFeedbackLines);
-            ctx.ui.notify(`CodeCartographer phase: ${phase.id} (sub-agent running)`, "info");
-            // Attach the persistent "Agents" widget so the user can watch the
-            // phase's tool/turn/token counts live above the editor while the
-            // orchestrator's TUI stays responsive.
-            getAgentsWidget().attach(ctx.ui);
-            // Fire-and-forget: spawn the phase runner asynchronously so the
-            // orchestrator's TUI stays responsive. The runner mutates the shared
-            // agent-state map from event callbacks; M2 will read that map from a
-            // persistent widget. For M1 we just notify on completion.
-            void runPhase(ctx, prompt, {
-                onSessionCreated: (session) => { activity.session = session; },
-                onToolStart: (id, name) => { activity.activeTools.set(id, name); activity.toolUses++; },
-                onToolEnd: (id) => { activity.activeTools.delete(id); },
-                onTextDelta: (_delta, fullText) => { activity.responseText = fullText; },
-                onTurnEnd: (turnCount) => { activity.turnCount = turnCount; },
-                onMessageEnd: (usage) => {
-                    activity.lifetimeUsage.input += usage.input;
-                    activity.lifetimeUsage.output += usage.output;
-                    activity.lifetimeUsage.cacheWrite += usage.cacheWrite;
-                },
-            }, { sessionName: `CodeCartographer phase: ${phase.id}` })
-                .then((result) => {
-                const status = result.aborted ? "aborted" : "completed";
-                finishPhase(phase.id, { status });
-                if (ctx.hasUI) {
-                    ctx.ui.notify(result.aborted
-                        ? `Phase ${phase.id} aborted.`
-                        : `Phase ${phase.id} sub-agent finished (${result.toolUses} tool uses, ${result.turnCount} turns).`, result.aborted ? "warning" : "info");
-                }
-                // Inject a CustomMessageEntry into the orchestrator's session so
-                // the user sees a closeout summary in the TUI scrollback and the
-                // orchestrator's LLM picks up the phase result as context on the
-                // next turn. display:true renders in the TUI; no triggerTurn so
-                // the LLM doesn't auto-respond — the user remains in control.
-                pi.sendMessage({
-                    customType: "codecarto-phase-summary",
-                    content: buildPhaseSummary({
-                        phaseId: phase.id,
-                        status: result.aborted ? "aborted" : "completed",
-                        turnCount: activity.turnCount,
-                        toolUses: activity.toolUses,
-                        tokens: activity.lifetimeUsage,
-                        durationMs: (activity.completedAt ?? Date.now()) - activity.startedAt,
-                        responseText: result.responseText,
-                    }),
-                    display: true,
-                });
-                void recordUsage(state.workspaceDir, phase.id, status, activity);
-            })
-                .catch((err) => {
-                const message = err instanceof Error ? err.message : String(err);
-                finishPhase(phase.id, { status: "error", error: message });
-                if (ctx.hasUI) {
-                    ctx.ui.notify(`Phase ${phase.id} sub-agent failed: ${message}`, "error");
-                }
-                pi.sendMessage({
-                    customType: "codecarto-phase-summary",
-                    content: buildPhaseSummary({
-                        phaseId: phase.id,
-                        status: "error",
-                        turnCount: activity.turnCount,
-                        toolUses: activity.toolUses,
-                        tokens: activity.lifetimeUsage,
-                        durationMs: (activity.completedAt ?? Date.now()) - activity.startedAt,
-                        responseText: "",
-                        error: message,
-                    }),
-                    display: true,
-                });
-                void recordUsage(state.workspaceDir, phase.id, "error", activity);
-            })
+            // Fire-and-forget: keep the TUI responsive while the sub-agent works.
+            // runSinglePhase handles all side effects (steering message, notify,
+            // phase summary, recordUsage, dashboard regen, clearPhase linger).
+            void runSinglePhase(ctx, pi, state, phase, { llmSteerEnabled, signal: ctx.signal })
                 .finally(() => {
-                // Sub-agent may have written findings, owner_notes, or carry-forward
-                // items into status.yaml. Refresh the main status widget so the
-                // "Open questions / Carry-forward / Next" lines reflect the new
-                // state without waiting for the user to run /codecarto-status.
+                // Refresh the status widget after the phase resolves so the
+                // "Open questions / Carry-forward / Next" lines reflect any
+                // owner_notes the sub-agent wrote to status.yaml.
                 void refreshWorkspaceUi(ctx);
-                // Linger 30s in M1 so /codecarto-status can show that the phase ran;
-                // M2's widget owns the proper "linger N turns" lifecycle.
-                setTimeout(() => clearPhase(phase.id), 30_000);
             });
         },
     });
@@ -397,7 +311,13 @@ export default function codeCartographerExtension(pi) {
             const state = await ensureWorkspaceState(ctx);
             if (!state)
                 return;
-            const validation = await validatePhaseOutput(state, args.trim() || undefined);
+            const validation = await validatePhaseOutput(state, args.trim() || undefined).catch((error) => error instanceof Error ? error : new Error(String(error)));
+            if (validation instanceof Error) {
+                lastFeedbackLines = [validation.message];
+                setUiState(ctx, state, lastFeedbackLines);
+                ctx.ui.notify(validation.message, "error");
+                return;
+            }
             lastFeedbackLines = buildValidationSummary(validation);
             setUiState(ctx, state, lastFeedbackLines);
             const level = validation.overall === "FAIL" || validation.overall === "MISSING" ? "error" : validation.overall === "PASS WITH GAPS" ? "warning" : "info";
@@ -410,83 +330,20 @@ export default function codeCartographerExtension(pi) {
             const currentState = await ensureWorkspaceState(ctx);
             if (!currentState)
                 return;
-            const validation = await validatePhaseOutput(currentState, args.trim() || undefined);
+            const validation = await validatePhaseOutput(currentState, args.trim() || undefined).catch((error) => error instanceof Error ? error : new Error(String(error)));
+            if (validation instanceof Error) {
+                lastFeedbackLines = [validation.message];
+                setUiState(ctx, currentState, lastFeedbackLines);
+                ctx.ui.notify(validation.message, "error");
+                return;
+            }
             if (validation.overall === "FAIL" || validation.overall === "MISSING") {
                 lastFeedbackLines = buildValidationSummary(validation);
                 setUiState(ctx, currentState, lastFeedbackLines);
                 ctx.ui.notify(`Cannot complete ${validation.phaseId}: ${validation.overall}`, "error");
                 return;
             }
-            const completionTimestamp = new Date().toISOString();
-            const updatedState = await updateStatusAtomically(ctx.cwd, (lockedState) => {
-                const phase = resolvePhase(lockedState, validation.phaseId);
-                if (!phase?.primary_output) {
-                    throw new Error(`Phase ${validation.phaseId} is missing primary_output.`);
-                }
-                const nextStatus = normalizeStatus(lockedState.status, lockedState.pipeline, lockedState.status.pipeline, lockedState.cwd);
-                const existingPhase = nextStatus.phases[validation.phaseId] ?? {
-                    status: "pending",
-                    owner_notes: [],
-                    outputs_present: [],
-                    open_questions: [],
-                    carry_forward: [],
-                };
-                const gapEntries = validation.rows
-                    .filter((row) => row.result.toUpperCase().includes("PARTIAL"))
-                    .map((row) => ({
-                    kind: "needs-maintainer-decision",
-                    description: row.criterion || "Partial validation gap",
-                    deferred_reason: row.evidence || "Marked PARTIAL by validation",
-                }));
-                const mergedOpenQuestions = [...existingPhase.open_questions];
-                for (const candidate of gapEntries) {
-                    const dupe = mergedOpenQuestions.some((entry) => entry.description === candidate.description && entry.deferred_reason === candidate.deferred_reason);
-                    if (!dupe)
-                        mergedOpenQuestions.push(candidate);
-                }
-                nextStatus.phases[validation.phaseId] = {
-                    status: "complete",
-                    owner_notes: uniqueStrings([
-                        ...existingPhase.owner_notes,
-                        `Completed via /codecarto-complete on ${completionTimestamp}.`,
-                        `Primary output: .codecarto/${validation.primaryOutput}`,
-                        `Validation: ${validation.overall}`,
-                    ]).slice(-3),
-                    outputs_present: uniqueStrings([...existingPhase.outputs_present, validation.primaryOutput]),
-                    open_questions: mergedOpenQuestions,
-                    carry_forward: existingPhase.carry_forward ?? [],
-                };
-                nextStatus.last_updated = completionTimestamp;
-                const updatedWorkspaceState = {
-                    ...lockedState,
-                    status: nextStatus,
-                };
-                const nextEligible = getNextEligiblePhase(updatedWorkspaceState);
-                nextStatus.current_phase = nextEligible?.id ?? "complete";
-                nextStatus.next_actions = nextEligible
-                    ? [
-                        `Begin ${nextEligible.id} phase by producing ${nextEligible.primary_output ?? `findings/${nextEligible.id}/`}`,
-                    ]
-                    : ["All phases complete. Review findings, open questions, and downstream implementation notes."];
-                return {
-                    state: {
-                        ...updatedWorkspaceState,
-                        status: nextStatus,
-                    },
-                    threadLogEntry: buildThreadLogEntry(validation.phaseId, validation, completionTimestamp),
-                };
-            });
-            let closeoutNotice;
-            try {
-                const created = await ensureCloseoutStub(updatedState.workspaceDir, validation.phaseId, completionTimestamp);
-                if (created) {
-                    closeoutNotice = `Closeout stub: .codecarto/closeouts/${closeoutFileName(dateOnly(completionTimestamp), validation.phaseId)} (fill it in)`;
-                }
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                closeoutNotice = `Closeout stub not created: ${message}`;
-            }
+            const { updatedState, closeoutNotice } = await autoCompletePhase(ctx, validation);
             lastFeedbackLines = [
                 `Completed phase: ${validation.phaseId}`,
                 `Validation: ${validation.overall}`,
@@ -567,4 +424,37 @@ export default function codeCartographerExtension(pi) {
             ctx.ui.notify(`CodeCartographer usage: ${totals.runs} run${totals.runs === 1 ? "" : "s"}, ${formatUsageTokens(totals.tokens.input + totals.tokens.output)} tokens total`, "info");
         },
     });
+    pi.registerCommand("codecarto-dashboard", {
+        description: "Regenerate .codecarto/dashboard.html (use --narrate for an LLM executive summary)",
+        getArgumentCompletions: (prefix) => {
+            const items = ["--narrate"]
+                .filter((value) => value.startsWith(prefix))
+                .map((value) => ({ value, label: value }));
+            return items.length > 0 ? items : null;
+        },
+        handler: async (args, ctx) => {
+            const flags = parseDashboardFlags(args);
+            if (flags.unknown.length > 0) {
+                ctx.ui.notify(`Unknown /codecarto-dashboard flag: ${flags.unknown.join(" ")}`, "error");
+                return;
+            }
+            const state = await ensureWorkspaceState(ctx);
+            if (!state)
+                return;
+            if (flags.narrate) {
+                ctx.ui.notify(`Narrating dashboard via LLM…`, "info");
+                const result = await narrateDashboard(ctx, state);
+                if (result.used) {
+                    ctx.ui.notify("Narration written to .codecarto/.dashboard-narration.local.md", "info");
+                }
+                else {
+                    ctx.ui.notify(`LLM narration skipped (${result.skipReason}); rendering deterministic dashboard.`, "warning");
+                }
+            }
+            await writeDashboard(ctx.cwd, PACKAGE_VERSION);
+            lastFeedbackLines = ["Dashboard regenerated: .codecarto/dashboard.html"];
+            setUiState(ctx, state, lastFeedbackLines);
+            ctx.ui.notify("Dashboard regenerated: .codecarto/dashboard.html", "info");
+        },
+    });
 }

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

@@ -1,6 +1,10 @@
 export interface NextFlags {
     llmSteerOverride?: boolean;
+    auto: boolean;
+    strict: boolean;
     unknown: string[];
+    /** Set when --strict is passed without --auto. Caller surfaces as an error. */
+    error?: string;
 }
 export declare function parseNextFlags(args: string): NextFlags;
 export declare const KNOWN_NEXT_FLAGS: readonly string[];

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

@@ -1,19 +1,32 @@
-// Flag parser for /codecarto-next. The user invokes the slash command with
-// an optional "--llm-steer" or "--no-llm-steer" override. We parse and
-// validate; index.ts decides how to merge the override with workspace
-// config to compute the effective "should we run the LLM rewriter?" bit.
-const KNOWN = new Set(["--llm-steer", "--no-llm-steer"]);
+// Flag parser for /codecarto-next. Recognized flags:
+//   --llm-steer / --no-llm-steer  — override the workspace config's
+//                                    llm_steer_next_phase per invocation.
+//   --auto                          — run the entire pipeline end-to-end.
+//   --strict                        — only with --auto; stop on PASS WITH GAPS
+//                                    instead of auto-advancing.
+//
+// The parser returns a populated NextFlags shape and never throws. index.ts
+// decides how to surface errors (unknown flags + invalid combinations) and
+// how to compose --llm-steer with workspace config.
+const KNOWN = new Set(["--llm-steer", "--no-llm-steer", "--auto", "--strict"]);
 export function parseNextFlags(args) {
     const tokens = args.trim().split(/\s+/).filter((t) => t.length > 0);
-    const result = { unknown: [] };
+    const result = { auto: false, strict: false, unknown: [] };
     for (const t of tokens) {
         if (t === "--llm-steer")
             result.llmSteerOverride = true;
         else if (t === "--no-llm-steer")
             result.llmSteerOverride = false;
+        else if (t === "--auto")
+            result.auto = true;
+        else if (t === "--strict")
+            result.strict = true;
         else
             result.unknown.push(t);
     }
+    if (result.strict && !result.auto) {
+        result.error = "Flag --strict requires --auto.";
+    }
     return result;
 }
 export const KNOWN_NEXT_FLAGS = [...KNOWN];

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

@@ -68,6 +68,27 @@ export declare function handleSkill(args: {
     }>;
     structuredContent?: Record<string, unknown>;
 }>;
+export declare function handlePublish(args: Record<string, unknown>): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent?: Record<string, unknown>;
+}>;
+export declare function handleLibraryList(args: Record<string, unknown>): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent?: Record<string, unknown>;
+}>;
+export declare function handleLibraryReindex(args: Record<string, unknown>): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent?: Record<string, unknown>;
+}>;
 export declare function buildServer(): Server<{
     method: string;
     params?: {