codecartographer-pi 0.11.0 → 0.12.1

package/.codecarto/workflow/pipeline-synthesis.yaml

@@ -0,0 +1,105 @@
+workflow_name: evidence-backed-project-synthesis
+workflow_version: 1
+workflow_goal: Combine a product vision with confirmed library specifications into a provenance-preserving implementation plan.
+source_location: ../
+validation_protocol: workflow/VALIDATE.md
+phase_order:
+  - vision-capture
+  - goal-synthesis-propose
+  - spec-merge
+  - goal-synthesis-finalize
+phases:
+  - id: vision-capture
+    purpose: Turn the user's product intent into a bounded, testable vision without prematurely selecting source specifications.
+    skill_path: findings/vision-capture/SKILL.md
+    output_template: templates/vision.md
+    depends_on: []
+    primary_output: findings/vision-capture/vision.md
+    secondary_outputs: []
+    required_reads:
+      - GUIDE.md
+      - workflow/status.yaml
+    preflight:
+      - requires-vision-input
+    completion_criteria:
+      - The target audience, problem, outcomes, constraints, and non-goals are explicit.
+      - Success measures and acceptance scenarios are testable.
+      - Assumptions and unresolved decisions are separated from confirmed intent.
+      - Coverage and limits name inspected scope, skipped scope, evidence basis, and blind spots.
+    handoff_requirements:
+      - Run validation per workflow/VALIDATE.md. Append validation block to primary output.
+      - Write the canonical phase handoff; do not edit workflow state directly.
+  - id: goal-synthesis-propose
+    purpose: Shortlist library specifications against the vision and pause for explicit human confirmation.
+    skill_path: findings/goal-synthesis-propose/SKILL.md
+    output_template: templates/proposal.md
+    depends_on:
+      - vision-capture
+    primary_output: findings/goal-synthesis/proposal.md
+    secondary_outputs: []
+    required_reads:
+      - GUIDE.md
+      - workflow/status.yaml
+      - findings/vision-capture/vision.md
+    preflight:
+      - requires-library
+    completion_criteria:
+      - Candidate library entries are ranked against explicit vision needs.
+      - Inclusion benefits, likely conflicts, and missing capabilities are stated for every candidate.
+      - At least one entry is presented with an unchecked human-confirmation box.
+      - Coverage and limits name inspected scope, skipped scope, evidence basis, and blind spots.
+    handoff_requirements:
+      - Stop after writing the proposal; the user confirms selections by changing one or more [ ] boxes to [x].
+      - Run validation per workflow/VALIDATE.md. Append validation block to primary output.
+      - Write the canonical phase handoff; do not edit workflow state directly.
+  - id: spec-merge
+    purpose: Merge only the human-confirmed specifications into a normalized, conflict-explicit intermediate.
+    skill_path: findings/spec-merge/SKILL.md
+    output_template: templates/merged-spec.md
+    depends_on:
+      - goal-synthesis-propose
+    primary_output: findings/spec-merge/merged-spec.md
+    secondary_outputs: []
+    required_reads:
+      - GUIDE.md
+      - workflow/status.yaml
+      - findings/vision-capture/vision.md
+      - findings/goal-synthesis/proposal.md
+    preflight:
+      - requires-library
+      - requires-confirmed-proposal
+    completion_criteria:
+      - Only human-confirmed library entries are merged.
+      - Capabilities, invariants, constraints, and acceptance behavior are normalized by concept rather than copied by source structure.
+      - Conflicts, gaps, and chosen dispositions are explicit.
+      - Every load-bearing merged claim has a provenance reference.
+      - Coverage and limits name inspected scope, skipped scope, evidence basis, and blind spots.
+    handoff_requirements:
+      - Run validation per workflow/VALIDATE.md. Append validation block to primary output.
+      - Write the canonical phase handoff; do not edit workflow state directly.
+  - id: goal-synthesis-finalize
+    purpose: Transform the confirmed vision and merged specifications into an implementation-ready project plan with a provenance ledger.
+    skill_path: findings/goal-synthesis-finalize/SKILL.md
+    output_template: templates/project-plan.md
+    depends_on:
+      - spec-merge
+    primary_output: findings/goal-synthesis/project-plan.md
+    secondary_outputs: []
+    required_reads:
+      - GUIDE.md
+      - workflow/status.yaml
+      - findings/vision-capture/vision.md
+      - findings/goal-synthesis/proposal.md
+      - findings/spec-merge/merged-spec.md
+    preflight:
+      - requires-library
+      - requires-confirmed-proposal
+    completion_criteria:
+      - The plan defines coherent product scope, architecture, work packages, dependencies, and acceptance gates.
+      - Each load-bearing plan decision is traceable through the provenance ledger.
+      - Conflicts and unknowns remain visible with explicit dispositions.
+      - The implementation sequence identifies an executable first slice.
+      - Coverage and limits name inspected scope, skipped scope, evidence basis, and blind spots.
+    handoff_requirements:
+      - Run validation per workflow/VALIDATE.md. Append validation block to primary output.
+      - Write the canonical phase handoff; do not edit workflow state directly.

package/.codecarto/workflow/status.yaml

@@ -1,4 +1,5 @@
 project_name: ""
+schema_version: 1
 # source_location is defined in the active pipeline YAML. Do not duplicate it here.
 pipeline: workflow/pipeline-full-with-deep-audit.yaml
 # ^^^ To switch pipelines, change the line above AND adjust the phases below to match:
@@ -62,3 +63,4 @@ phases:
     carry_forward: []
 next_actions:
   - Begin architecture phase by reading the repository and producing findings/architecture/architecture-map.md
+post_pipeline: []

package/README.md

@@ -9,7 +9,7 @@
 [![npm version](https://img.shields.io/npm/v/codecartographer-pi.svg)](https://www.npmjs.com/package/codecartographer-pi)
 [![Node](https://img.shields.io/badge/node-%3E%3D20-brightgreen.svg)](package.json)
 
-> **A structured pipeline for reverse-engineering unfamiliar codebases with an LLM.** Drop it into any repo, point an LLM at the guide, and walk away with a layered analysis: architecture map, behavioral contracts, protocol documentation, defect report, porting bundle, and a language-agnostic reimplementation spec. Every finding is evidence-tagged. Every phase output is validated before the next one starts.
+> **Evidence-backed software cartography for coding agents.** Turn an unfamiliar repository into validated architecture, contracts, defects, and a reimplementation specification—then combine explicitly confirmed specifications with a product vision to produce a provenance-backed implementation plan.
 
 ```text
 ●  CodeCartographer
@@ -32,14 +32,17 @@
 | **HTML dashboard** — single-file aggregate of progress, links, usage, narrative | `.codecarto/dashboard.html` |
 | **Per-phase token tracking** | `/codecarto-usage` |
 | **Opt-in LLM steering** of the next phase's seed prompt | `/codecarto-next --llm-steer` |
+| **Forward synthesis** — vision + confirmed library specs → provenance-backed project plan | `pipeline-synthesis.yaml` |
 
-> **Forward-flow synthesis is underway.** v0.9.0 adds the experimental library foundation and MCP publish/list/reindex tools for accumulating `reimplementation-spec.md` artifacts in a git-trackable library. The Pi publish UX and synthesis pipeline that turns selected library entries plus a vision into `project-plan.md` are still in progress. See [`docs/synthesis-roadmap.md`](docs/synthesis-roadmap.md) for the implementation tracker.
+Publish completed reimplementation specs from Pi or MCP, then run the `synthesis` pipeline to turn a product vision and explicitly confirmed library entries into a conflict-aware `project-plan.md` with a decision-level provenance ledger.
+
+OpenAI Build Week reviewers: see the [new-vs-existing scope and one-command demo](docs/build-week-2026.md).
 
 ---
 
 ## Install
 
-Three surfaces, in recommended order. All three share the same `core/` and produce byte-identical phase prompts — but the user experience differs by surface, and new features (live widget, dashboard, auto-runner, the upcoming library + synthesis workflows) land on Pi first, MCP second, drop-in last.
+Three surfaces, in recommended order. All three share the same `core/` and produce byte-identical phase prompts. Pi provides the richest orchestration UX; Pi and MCP both support the executable library and synthesis workflows; drop-in mode provides the analysis framework without those runtime operations.
 
 1. **Pi extension** — recommended for interactive use. First-class UX.
 2. **MCP server** — for Claude Code, Codex, opencode, Cursor, Claude Desktop, and any other MCP-capable agent.
@@ -83,6 +86,8 @@ Add to your host config (`~/.config/claude-code/config.json`, `claude_desktop_co
 }
 ```
 
+Official MCP Registry server name: `io.github.huginnindustries/codecartographer`.
+
 ### Drop-in template (one-off / evaluation)
 
 Use this to try CodeCartographer in any repo without installing anything, or in environments where neither Pi nor an MCP-capable agent is available. Works with any LLM that can read and write files.
@@ -93,7 +98,47 @@ cp -r /path/to/CodeCartographer/.codecarto /path/to/your-repo/
 
 Then in the LLM session: `Read .codecarto/GUIDE.md and begin the analysis.`
 
-> **Limitation.** Drop-in mode runs the analysis pipeline fully, but library + synthesis workflows require executable code. Publishing and reading library entries are currently available through the MCP server; Pi publish UX and project-plan synthesis are still in progress. See [`docs/synthesis-roadmap.md`](docs/synthesis-roadmap.md) for the planned scope.
+> **Limitation.** Drop-in mode runs the analysis pipeline fully, but library + synthesis workflows require executable code through Pi or MCP.
+
+---
+
+## Forward synthesis quickstart
+
+Analysis turns repositories into reusable specifications. Synthesis runs the other direction: it combines a raw product vision with human-confirmed specifications and produces an implementation-ready plan without losing provenance.
+
+1. Configure the library that contains specs published with `/codecarto-publish` or the MCP `codecarto_publish` tool:
+
+   ```yaml
+   # ~/.codecarto/config.yaml or .codecarto/workflow/config.yaml
+   library:
+     path: /absolute/path/to/codecarto-library
+     namespace: your-namespace # omit for a single-tenant library
+     publish_confirm: true
+   ```
+
+2. Initialize a clean planning workspace and fill in its brief:
+
+   ```text
+   /codecarto-init synthesis
+   ```
+
+   Edit `.codecarto/inputs/vision.md` with the audience, problem, desired outcome, constraints, and non-goals.
+
+3. Run until CodeCartographer creates the candidate proposal:
+
+   ```text
+   /codecarto-next --auto
+   ```
+
+   The run intentionally stops before merging. Review `.codecarto/findings/goal-synthesis/proposal.md` and change one or more candidate boxes from `[ ]` to `[x]`.
+
+4. Resume:
+
+   ```text
+   /codecarto-next --auto
+   ```
+
+The final `.codecarto/findings/goal-synthesis/project-plan.md` contains product scope, architecture, work packages, acceptance gates, an unresolved-conflict register, and a provenance ledger mapping every load-bearing decision back to the vision or a confirmed specification. Runtime preflight checks prevent merging or finalization before explicit human confirmation.
 
 ---
 
@@ -134,7 +179,7 @@ The filesystem, not the conversation, is the durable memory of a run:
 
 - Each phase gets a fresh context window. In the Pi extension it runs as an isolated phase sub-agent; MCP and drop-in hosts should use the same one-session-per-phase pattern.
 - Completed findings live under `.codecarto/findings/`. Later phases re-read the specific upstream artifacts declared by the active pipeline instead of relying on conversational recall.
-- `workflow/status.yaml` records progress, `open_questions`, and `carry_forward` items routed to later phases. `CONVENTIONS.md`, `DECISIONS.md`, closeouts, and `THREAD_LOG.md` preserve cross-session knowledge and handoffs.
+- `workflow/status.yaml` records progress, terminal `open_questions`, in-pipeline `carry_forward`, and a separate `post_pipeline` backlog for optional spikes, amendments, deltas, decisions, and reruns after completion. Phase agents propose changes in `.codecarto/scratch/handoffs/<phase>.yaml`; completion validates and applies them under a lock with host timestamps, one canonical closeout, and an idempotent `THREAD_LOG.md` entry.
 - Pi phase transcripts are file-backed and remain available through `/resume`, `/tree`, and `/export`, even when the active model context has been compacted.
 - For isolated Pi phase sessions, compaction uses a phase-aware continuation summary that explicitly preserves evidence, files inspected, output progress, open questions, and validation gaps. The resulting summary is also checkpointed atomically at `.codecarto/scratch/checkpoints/<phase>.md`.
 - Pi records successful, failed, and aborted compactions plus their trigger (`threshold`, `overflow`, or `manual`) in local usage data and exposes the totals in the widget, `/codecarto-usage`, completion summaries, and dashboard.
@@ -175,6 +220,7 @@ The default is a 7-phase run that splits the defect scan into a mechanical early
 | **Defect scan** | 2 | Maintenance audit to surface latent problems |
 | **Lite** | 3 | You need to understand behavior without porting plans |
 | **Architecture only** | 1 | Quick structural overview |
+| **Synthesis** | 4 | Turn a product vision and confirmed library specifications into a provenance-backed implementation plan |
 
 Set the active pipeline by editing `workflow/status.yaml`'s `pipeline:` field, or pass it as the argument to `/codecarto-init`.
 
@@ -188,6 +234,7 @@ Set the active pipeline by editing `workflow/status.yaml`'s `pipeline:` field, o
 | Defect scan | `workflow/pipeline-defect-scan.yaml` |
 | Lite | `workflow/pipeline-lite.yaml` |
 | Architecture only | `workflow/pipeline-architecture-only.yaml` |
+| Synthesis | `workflow/pipeline-synthesis.yaml` |
 
 ---
 
@@ -232,7 +279,7 @@ Beyond the slash commands, the Pi extension layers on:
 
 **Per-phase usage tracking.** Each phase run is appended to `.codecarto/workflow/.usage.local.yaml`. `/codecarto-usage` reports cumulative + per-phase token, runtime, tool-use, and compaction totals, including threshold/overflow/manual triggers and successful/failed/aborted outcomes.
 
-**Tool interception.** `bash` is blocked outright; `edit` and `write` are confined to `.codecarto/`. Same rules apply to phase sub-agents.
+**Tool interception.** `bash` is blocked outright; `edit` and `write` are confined to `.codecarto/`, plus the configured, marker-validated CodeCartographer library when one is configured. Same rules apply to phase sub-agents.
 
 ### Slash commands
 
@@ -244,8 +291,9 @@ Beyond the slash commands, the Pi extension layers on:
 | `/codecarto-next [--auto [--strict]] [--llm-steer \| --no-llm-steer]` | Spawn the next eligible phase as a sub-agent. `--auto` walks the full pipeline end-to-end (auto-validate + auto-complete + advance); `--strict` flips the `PASS WITH GAPS` rule from "advance" to "pause". |
 | `/codecarto-phase <id>` | Force a specific phase, even out of pipeline order |
 | `/codecarto-validate [phase]` | Validate a phase output against completion criteria |
-| `/codecarto-complete [phase]` | Atomically mark a phase complete (validation must pass) |
+| `/codecarto-complete [phase]` | Validate and atomically apply the phase handoff, canonical status, closeout, and log entry |
 | `/codecarto-skill <name>` | Run a post-pipeline skill once all phases are complete |
+| `/codecarto-publish` | Publish the reimplementation spec to the configured library after reviewing an explicit confirmation preview |
 | `/codecarto-usage` | Cumulative + per-phase token usage |
 | `/codecarto-dashboard [--narrate]` | Regenerate `.codecarto/dashboard.html`; `--narrate` for the LLM executive summary |
 
@@ -427,7 +475,7 @@ If you're testing a new model, start with `pipeline-architecture-only.yaml` on a
     protocols/               # Event streams, state machines, persistence formats.
     porting/                 # Reverse-engineering synthesis bundle.
     reimplementation-spec/   # Language-agnostic build spec.
-  scratch/                   # Disposable analysis notes.
+  scratch/                   # Disposable notes plus checkpoints and structured phase handoffs.
   templates/                 # Output structure templates.
   workflow/                  # Pipeline definitions, status, validation, config.
   closeouts/                 # Per-session closeout files.

package/dist/core/completion.d.ts

@@ -0,0 +1,6 @@
+import type { ValidationResult, WorkspaceState } from "./types.ts";
+export type CompletionResult = {
+    updatedState: WorkspaceState;
+    closeoutNotice?: string;
+};
+export declare function completeValidatedPhase(cwd: string, validation: ValidationResult, sourceLabel: string): Promise<CompletionResult>;

package/dist/core/completion.js

@@ -0,0 +1,127 @@
+import { appendFile, copyFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getNextEligiblePhase, resolvePhase } from "./pipeline.js";
+import { applyHandoff, autoAssignIds, loadHandoffFile, normalizeStatus } from "./status.js";
+import { dateOnly, pathExists, uniqueStrings } from "./utils.js";
+import { getWorkspaceState, updateStatusAtomically } from "./workspace.js";
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function canonicalCloseoutFile(workspaceDir, phaseId, timestamp) {
+    const closeoutsDir = join(workspaceDir, "closeouts");
+    await mkdir(closeoutsDir, { recursive: true });
+    const pattern = new RegExp(`^\\d{4}-\\d{2}-\\d{2}-${escapeRegExp(phaseId)}\\.md$`);
+    const existing = (await readdir(closeoutsDir)).filter((name) => pattern.test(name)).sort();
+    return existing.at(-1) ?? `${dateOnly(timestamp)}-${phaseId}.md`;
+}
+async function writeCompletionArtifacts(workspaceDir, phaseId, validation, timestamp, handoff) {
+    const closeoutFile = await canonicalCloseoutFile(workspaceDir, phaseId, timestamp);
+    const closeoutPath = join(workspaceDir, "closeouts", closeoutFile);
+    const suppliedContent = handoff?.closeout_content?.trim();
+    if (suppliedContent) {
+        const decisions = handoff?.decisions ?? [];
+        const decisionsSection = decisions.length > 0
+            ? `\n\n## Decisions Beyond Prompt\n\n${decisions.map((decision) => `- ${decision}`).join("\n")}`
+            : "";
+        await writeFile(closeoutPath, `${suppliedContent}${decisionsSection}\n`, "utf8");
+    }
+    else if (!(await pathExists(closeoutPath))) {
+        const templatePath = join(workspaceDir, "templates", "closeout-template.md");
+        if (await pathExists(templatePath))
+            await copyFile(templatePath, closeoutPath);
+    }
+    const summary = handoff?.closeout_summary?.trim() || `Validation: ${validation.overall}`;
+    const entry = `- ${dateOnly(timestamp)} — ${phaseId} — ${summary} — [closeout](closeouts/${closeoutFile})`;
+    const threadLogPath = join(workspaceDir, "THREAD_LOG.md");
+    let current = "";
+    try {
+        current = await readFile(threadLogPath, "utf8");
+    }
+    catch {
+        // Created below when absent.
+    }
+    const link = `[closeout](closeouts/${closeoutFile})`;
+    if (!current.split(/\r?\n/).some((line) => line.includes(link))) {
+        await appendFile(threadLogPath, `${entry}\n`, "utf8");
+    }
+    return `.codecarto/closeouts/${closeoutFile}`;
+}
+export async function completeValidatedPhase(cwd, validation, sourceLabel) {
+    const initialState = await getWorkspaceState(cwd);
+    if (!initialState)
+        throw new Error("CodeCartographer workspace not found. Run /codecarto-init first.");
+    const handoff = await loadHandoffFile(validation.phaseId, initialState.workspaceDir);
+    if (handoff && handoff.phase_id !== validation.phaseId) {
+        throw new Error(`Invalid handoff: phase_id ${handoff.phase_id} does not match ${validation.phaseId}`);
+    }
+    if (handoff) {
+        const activePhases = new Set(initialState.pipeline.phase_order);
+        const sourceIndex = initialState.pipeline.phase_order.indexOf(validation.phaseId);
+        for (const entry of handoff.carry_forward) {
+            const targetIndex = entry.target_phase ? initialState.pipeline.phase_order.indexOf(entry.target_phase) : -1;
+            if (!entry.target_phase || !activePhases.has(entry.target_phase) || targetIndex <= sourceIndex) {
+                throw new Error(`Invalid handoff: carry_forward target_phase ${entry.target_phase ?? "(missing)"} is not a downstream active pipeline phase; use post_pipeline for work after the pipeline`);
+            }
+        }
+        for (const entry of handoff.post_pipeline) {
+            if (!entry.id?.trim())
+                throw new Error("Invalid handoff: post_pipeline entries require a canonical id");
+        }
+    }
+    const completionTimestamp = new Date().toISOString();
+    let closeoutPath;
+    const updatedState = await updateStatusAtomically(cwd, async (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",
+        }));
+        autoAssignIds(gapEntries, "oq", validation.phaseId);
+        const mergedOpenQuestions = [...existingPhase.open_questions];
+        for (const candidate of gapEntries) {
+            if (!mergedOpenQuestions.some((entry) => entry.description === candidate.description && entry.deferred_reason === candidate.deferred_reason)) {
+                mergedOpenQuestions.push(candidate);
+            }
+        }
+        nextStatus.phases[validation.phaseId] = {
+            status: "complete",
+            owner_notes: uniqueStrings([
+                ...existingPhase.owner_notes,
+                `Completed via ${sourceLabel}.`,
+                `Primary output: .codecarto/${validation.primaryOutput}`,
+                `Validation: ${validation.overall}`,
+            ]),
+            outputs_present: uniqueStrings([...existingPhase.outputs_present, validation.primaryOutput]),
+            open_questions: mergedOpenQuestions,
+            carry_forward: existingPhase.carry_forward ?? [],
+        };
+        if (handoff)
+            applyHandoff(nextStatus, handoff);
+        nextStatus.last_updated = completionTimestamp;
+        const nextWorkspace = { ...lockedState, status: nextStatus };
+        const nextEligible = getNextEligiblePhase(nextWorkspace);
+        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."];
+        closeoutPath = await writeCompletionArtifacts(lockedState.workspaceDir, validation.phaseId, validation, completionTimestamp, handoff);
+        return { state: { ...nextWorkspace, status: nextStatus } };
+    });
+    return {
+        updatedState,
+        closeoutNotice: closeoutPath ? `Closeout: ${closeoutPath}` : undefined,
+    };
+}

package/dist/core/dashboard.js

@@ -22,6 +22,7 @@ export function renderDashboard(inputs) {
         renderUsagePanel(inputs),
         renderActivityTimeline(inputs.usage.runs),
         renderOpenQuestionsRollup(inputs.status),
+        renderPostPipelineWork(inputs.status),
         renderCloseoutsList(inputs),
         renderFooter(inputs),
         `</div>`,
@@ -74,6 +75,7 @@ function renderSidebar(inputs) {
         `<a class="cc-nav-section" href="#phases">Phases</a>`,
         phaseLinks,
         `<a class="cc-nav-section" href="#usage">Usage</a>`,
+        (inputs.status.post_pipeline?.length ?? 0) > 0 ? `<a class="cc-nav-section" href="#post-pipeline">Post-pipeline</a>` : "",
         `<a class="cc-nav-section" href="#closeouts">Closeouts</a>`,
         `</nav>`,
         `<button type="button" class="cc-export" data-export>Export dashboard JSON</button>`,
@@ -134,6 +136,7 @@ function renderHealthPanel(inputs) {
     const issues = collectDashboardIssues(inputs);
     const openQuestionCount = countOpenQuestions(status);
     const carryForwardCount = countCarryForward(status);
+    const postPipelineCount = (status.post_pipeline ?? []).filter((entry) => entry.status !== "resolved").length;
     const health = issues.some((i) => i.severity === "blocker") ? "attention required" : issues.length ? "review recommended" : completed === total ? "complete" : "on track";
     const healthClass = issues.some((i) => i.severity === "blocker") ? "bad" : issues.length ? "warn" : "ok";
     const tokenText = usageHasTokenAccounting(usage) ? formatTokenCount(totals.tokens.input + totals.tokens.output) : usage.runs.length ? "unavailable" : "0";
@@ -150,6 +153,7 @@ function renderHealthPanel(inputs) {
         renderHealthMetric("Artifacts needing attention", String(issues.length), issues.length ? "bad" : "ok"),
         renderHealthMetric("Open questions", String(openQuestionCount), openQuestionCount ? "warn" : "ok"),
         renderHealthMetric("Carry-forward items", String(carryForwardCount), carryForwardCount ? "warn" : "ok"),
+        renderHealthMetric("Post-pipeline work", String(postPipelineCount), postPipelineCount ? "neutral" : "ok"),
         renderHealthMetric("Tool uses", String(totals.tool_uses), "neutral"),
         renderHealthMetric("Runtime", formatMillis(totals.duration_ms), "neutral"),
         renderHealthMetric("Tokens", tokenText, tokenText === "unavailable" ? "warn" : "neutral"),
@@ -468,7 +472,7 @@ function renderOpenQuestionsRollup(status) {
     for (const [phaseId, phaseState] of Object.entries(status.phases)) {
         const questions = [];
         for (const q of phaseState.open_questions ?? []) {
-            const key = `${q.kind ?? ""}|${q.description ?? ""}|${q.deferred_reason ?? ""}`;
+            const key = q.id ?? `${q.kind ?? ""}|${q.description ?? ""}|${q.deferred_reason ?? ""}`;
             if (seen.has(key))
                 continue;
             seen.add(key);
@@ -486,6 +490,19 @@ function renderOpenQuestionsRollup(status) {
     const kindSummary = [...byKind.entries()].sort((a, b) => b[1] - a[1]).map(([kind, count]) => `<span class="cc-kind-chip"><strong>${count}</strong>${escapeHtml(kind)}</span>`).join("");
     return [`<section class="cc-card cc-rollup" aria-label="Open questions roll-up" data-section data-search-text="open questions">`, `<div class="cc-section-head"><h2>Open questions</h2><span>${total} unique</span></div>`, `<div class="cc-kind-summary">${kindSummary}</div>`, buckets.join("\n"), `</section>`].join("\n");
 }
+function renderPostPipelineWork(status) {
+    const items = status.post_pipeline ?? [];
+    if (items.length === 0)
+        return "";
+    const pending = items.filter((entry) => entry.status !== "resolved").length;
+    const rows = items.map((entry) => {
+        const state = entry.status ?? "pending";
+        const source = entry.source_phase ? `<span class="cc-pill cc-pill-target">from ${escapeHtml(entry.source_phase)}</span>` : "";
+        const kind = entry.kind ? `<span class="cc-kind">${escapeHtml(String(entry.kind))}</span>` : "";
+        return `<li>${kind}<strong>${escapeHtml(entry.id ?? "unidentified")}</strong> ${escapeHtml(entry.description ?? "")}${source}<span class="cc-pill">${escapeHtml(state)}</span></li>`;
+    }).join("");
+    return [`<section class="cc-card cc-rollup" id="post-pipeline" aria-label="Post-pipeline work" data-section data-search-text="post pipeline spikes amendments deltas decisions reruns">`, `<div class="cc-section-head"><h2>Post-pipeline work</h2><span>${pending} pending · ${items.length} total</span></div>`, `<p class="cc-muted">Optional work after the active pipeline; these items do not make pipeline completion partial.</p>`, `<ul class="cc-question-list">${rows}</ul>`, `</section>`].join("\n");
+}
 function renderCloseoutsList(inputs) {
     const closeouts = inputs.closeouts;
     if (closeouts.length === 0)
@@ -535,7 +552,7 @@ function renderExportData(inputs) {
             secondary_outputs: outputs?.secondary ?? [],
         };
     });
-    const data = { project: inputs.status.project_name, generatedAt: inputs.generatedAt, packageVersion: inputs.packageVersion, phases, usage: inputs.usage, closeouts: inputs.closeouts };
+    const data = { project: inputs.status.project_name, generatedAt: inputs.generatedAt, packageVersion: inputs.packageVersion, phases, post_pipeline: inputs.status.post_pipeline, usage: inputs.usage, closeouts: inputs.closeouts };
     return `<script id="cc-dashboard-data" type="application/json">${escapeJsonForScript(data)}</script>`;
 }
 function renderScripts() {

package/dist/core/index.d.ts

@@ -5,7 +5,9 @@ export * from "./status.ts";
 export * from "./pipeline.ts";
 export * from "./prompts.ts";
 export * from "./workspace.ts";
+export * from "./completion.ts";
 export * from "./orchestrator-config.ts";
 export * from "./usage.ts";
 export * from "./dashboard.ts";
 export * from "./library.ts";
+export * from "./synthesis.ts";

package/dist/core/index.js

@@ -8,7 +8,9 @@ export * from "./status.js";
 export * from "./pipeline.js";
 export * from "./prompts.js";
 export * from "./workspace.js";
+export * from "./completion.js";
 export * from "./orchestrator-config.js";
 export * from "./usage.js";
 export * from "./dashboard.js";
 export * from "./library.js";
+export * from "./synthesis.js";

package/dist/core/pipeline.js

@@ -9,6 +9,7 @@ export const PIPELINE_ALIASES = {
     "defect-scan": "workflow/pipeline-defect-scan.yaml",
     lite: "workflow/pipeline-lite.yaml",
     "architecture-only": "workflow/pipeline-architecture-only.yaml",
+    synthesis: "workflow/pipeline-synthesis.yaml",
 };
 export const DEFAULT_PIPELINE_PATH = "workflow/pipeline-full-with-deep-audit.yaml";
 export function getPhaseMap(pipeline) {

package/dist/core/prompts.d.ts

@@ -1,7 +1,15 @@
-import type { CarryForwardEntry, OpenQuestionEntry, PipelinePhase, ValidationResult, WorkspaceState } from "./types.ts";
+import type { CarryForwardEntry, OpenQuestionEntry, PipelinePhase, WorkspaceState } from "./types.ts";
+import { type PhasePreflightResult } from "./synthesis.ts";
 export declare function describeEntry(entry: OpenQuestionEntry | CarryForwardEntry): string;
 export declare function collectRoutedCarryForward(state: WorkspaceState, targetPhaseId: string): CarryForwardEntry[];
 export interface BuildPhasePromptOptions {
+    /**
+     * A result the caller already validated immediately before prompt building.
+     * Pi uses this to preserve its caller-specific preflight error handling
+     * without repeating the same filesystem reads. Callers that omit it (MCP
+     * and direct/forced prompting) remain self-contained and run preflight here.
+     */
+    preflight?: PhasePreflightResult;
     /**
      * Set when the phase is being run inside `/codecarto-next --auto` (or any
      * other non-interactive driver). Suppresses interactive hooks that would
@@ -14,7 +22,5 @@ export interface BuildPhasePromptOptions {
 }
 export declare function buildPhasePrompt(state: WorkspaceState, phase: PipelinePhase, forced: boolean, options?: BuildPhasePromptOptions): Promise<string>;
 export declare function closeoutFileName(date: string, phaseOrModule: string): string;
-export declare function buildThreadLogEntry(phaseOrModule: string, validation: ValidationResult, timestamp: string): string;
-export declare function ensureCloseoutStub(workspaceDir: string, phaseOrModule: string, timestamp: string): Promise<string | null>;
 export declare function listSkillNames(workspaceDir: string): Promise<string[]>;
 export declare function buildSkillPrompt(state: WorkspaceState, skillName: string): Promise<string>;