@mgiles/perk 3.0.0 → 3.2.0

package/extension/doors/submitPrReview.ts

@@ -1,18 +1,22 @@
-// The warm `submit_pr_review` tool — the agent-driven curated-posting surface shared by the two
-// PR-review doors (`/pr-review-terminal`, `/pr-review-browser`).
+// The warm `submit_pr_review` tool — the agent-driven curated-posting surface shared by the
+// PR-review doors (`/pr-review-terminal`, `/pr-review-browser`, `/stack-review-browser`).
 //
 // `submit_pr_review` implements the per-door posting contract (contracts §8.4): nothing perk-
 // driven reaches GitHub before the human triage; ALL perk-side posting flows through this tool
 // on every door (`gh` mutations and direct `perk pr review-submit` calls are forbidden); the
 // verdict lands last, atomically with the comments. On the terminal door this tool is the sole
-// posting path. On the browser door the human platform-posts from the plannotator UI — that
-// native posting IS the GitHub path; perk composes nothing by default and posts only what the
-// human explicitly hands it (typically a request-changes verdict, which the UI cannot post). It
-// delegates to the Python cold door (`perk pr review-submit` — mutations canonical in Python)
-// via `runColdDoor` (the batch rides the run-scratch stdin channel), then appends `last_review`
-// to `perk:workflow-state`. The human gate splits: explicit conversational go-ahead ALWAYS
-// (pinned in the guidelines/skill); formal events (`approve`/`request-changes`) additionally get
-// the structural gate — headless refuses, interactive raises a blocking `ctx.ui.confirm`.
+// posting path. On the single-PR browser door the human platform-posts from the plannotator
+// UI — that native posting IS the GitHub path; perk composes nothing by default and posts only
+// what the human explicitly hands it (typically a request-changes verdict, which the UI cannot
+// post). On the stack door the local-diff session has NO attached PR, so ALL posting is
+// perk-side after triage: one real call per member PR, bottom→top, each under its own dry-run
+// anchor validation. It delegates to the Python cold door (`perk pr review-submit` — mutations
+// canonical in Python) via `runColdDoor` (the batch rides the run-scratch stdin channel), then
+// appends `last_review` AND the accumulating `review_posts` ledger row to `perk:workflow-state`
+// (the stack flow's resume authority — posted PRs are skipped, never replayed). The human gate
+// splits: explicit conversational go-ahead ALWAYS (pinned in the guidelines/skill); formal
+// events (`approve`/`request-changes`) additionally get the structural gate — headless refuses,
+// interactive raises a blocking `ctx.ui.confirm`.
 // `dry_run` is the anchor-repair loop: no gates, no record, nothing posted.
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -34,7 +38,12 @@ import {
   stringParam,
   type ToolParams,
 } from "../substrate/toolParams.ts";
-import { appendWorkflowState, type EntrySink } from "../substrate/workflowState.ts";
+import {
+  appendWorkflowState,
+  branchOf,
+  type EntrySink,
+  rebuildWorkflowState,
+} from "../substrate/workflowState.ts";
 import type { Severity } from "../surfaces/report.ts";
 
 // ------------------------------------------------------------------------ params
@@ -55,6 +64,7 @@ export interface SubmitParams {
   body: string;
   comments?: SubmitComment[];
   dry_run?: boolean;
+  allow_repost?: boolean;
 }
 
 /** Decode the optional `comments` array; null = present-but-malformed (whole-batch refusal). */
@@ -87,7 +97,7 @@ function decodeSubmitComments(p: ToolParams): SubmitComment[] | undefined | null
  * malformed field ⇒ null (whole-batch refusal). `pr` must be an int; `event` exactly one of the
  * three flag spellings; `body` a string (EMPTY ALLOWED — the cold door owns the event-conditioned
  * body rule and reports `bad_batch`); each `comments` row strict on
- * path/line(int)/side(LEFT|RIGHT)/body; `dry_run` a boolean.
+ * path/line(int)/side(LEFT|RIGHT)/body; `dry_run` and `allow_repost` booleans.
  */
 export function decodeSubmitParams(params: unknown): SubmitParams | null {
   const p = paramsOf(params);
@@ -102,9 +112,12 @@ export function decodeSubmitParams(params: unknown): SubmitParams | null {
   if (comments === null) return null;
   const dryRun = booleanParam(p, "dry_run");
   if (dryRun === null) return null;
+  const allowRepost = booleanParam(p, "allow_repost");
+  if (allowRepost === null) return null;
   const result: SubmitParams = { pr, event, body };
   if (comments !== undefined) result.comments = comments;
   if (dryRun !== undefined) result.dry_run = dryRun;
+  if (allowRepost !== undefined) result.allow_repost = allowRepost;
   return result;
 }
 
@@ -167,6 +180,42 @@ function decodeInvalidAnchors(payload: ColdJson): InvalidAnchor[] | null {
   return rows;
 }
 
+// ------------------------------------------------------------------------ the posting ledger
+
+/** One `review_posts` ledger row: a REAL submission that reached GitHub. */
+export interface ReviewPostRow {
+  pr: number;
+  event: string;
+  at: string;
+}
+
+/**
+ * Tolerant re-narrow of the rebuilt `review_posts` list (best-effort tier: a malformed row is
+ * dropped, never a refusal — the ledger only ever grows from this tool's own writes).
+ */
+export function reviewPostsOf(raw: unknown): ReviewPostRow[] {
+  if (!Array.isArray(raw)) return [];
+  const rows: ReviewPostRow[] = [];
+  for (const item of raw) {
+    const row = paramsOf(item);
+    if (row === null) continue;
+    if (typeof row.pr !== "number" || !Number.isInteger(row.pr)) continue;
+    if (typeof row.event !== "string" || typeof row.at !== "string") continue;
+    rows.push({ pr: row.pr, event: row.event, at: row.at });
+  }
+  return rows;
+}
+
+/** Ledger equality for the read-back verification (order-sensitive — posting order matters). */
+function reviewPostsEqual(rebuilt: unknown, expected: unknown): boolean {
+  const a = reviewPostsOf(rebuilt);
+  const b = reviewPostsOf(expected);
+  if (a.length !== b.length) return false;
+  return a.every(
+    (row, i) => row.pr === b[i]?.pr && row.event === b[i]?.event && row.at === b[i]?.at,
+  );
+}
+
 /** Flag spelling → the REST wire spelling shown in the human confirm. */
 const WIRE_EVENT: Record<ReviewEvent, string> = {
   approve: "APPROVE",
@@ -209,6 +258,27 @@ export async function submitPrReview(
   const dryRun = params.dry_run === true;
   const commentCount = params.comments?.length ?? 0;
 
+  // The enforced resume guard (before the confirm AND the cold-door mutation): a PR that
+  // already has a review_posts ledger row in this session is a confirmed success — a repeat
+  // real post is refused unless explicitly deliberate. A ledger row can only be MISSING
+  // spuriously (best-effort tier), never present spuriously — so the guard refuses on
+  // presence and stays silent on absence (a missing row still means: verify posted-vs-pending
+  // against GitHub before re-posting).
+  if (!dryRun && params.allow_repost !== true) {
+    const prior = reviewPostsOf(rebuildWorkflowState(branchOf(ctx)).review_posts).filter(
+      (row) => row.pr === params.pr,
+    );
+    const last = prior.at(-1);
+    if (last !== undefined) {
+      return fail(
+        `a ${last.event} review was already posted to PR #${params.pr} in this session ` +
+          `(review_posts row at ${last.at}) — on a stack resume skip this member; pass ` +
+          "allow_repost: true only for a deliberate second review of the same PR",
+        "already_posted",
+      );
+    }
+  }
+
   if (!dryRun && params.event !== "comment") {
     if (!ctx.hasUI) {
       return fail(
@@ -305,6 +375,21 @@ export async function submitPrReview(
     failure: "last_review read-back failed",
   });
 
+  // The accumulating per-PR ledger (read-rebuild-append): ordered rows, one per real success —
+  // the stack flow's partial-outcome/resume authority. Same best-effort tier as last_review.
+  const posts: ReviewPostRow[] = [
+    ...reviewPostsOf(rebuildWorkflowState(branchOf(ctx)).review_posts),
+    { pr: record.pr, event: params.event, at: record.at },
+  ];
+  appendWorkflowState(pi, ctx, {
+    data: { review_posts: posts },
+    field: "review_posts",
+    expected: posts,
+    scope: "review",
+    failure: "review_posts read-back failed",
+    equals: reviewPostsEqual,
+  });
+
   let text =
     `submitted ${params.event} review to PR #${record.pr} ` +
     `(${data.comment_count ?? commentCount} inline comment(s))`;
@@ -320,10 +405,10 @@ export async function submitPrReview(
 
 const TOOL_GUIDELINES = [
   "Call submit_pr_review only after the human triage has settled the batch AND the human has explicitly approved posting — nothing reaches GitHub before triage.",
-  "Validate first with dry_run: true and repair any reported anchors until validation passes; a dry-run never posts, never gates, and records nothing.",
-  "Make ONE real call: comments + body + event land atomically in a single review — the verdict never lands before the comments.",
+  "Validate first with dry_run: true and repair any reported anchors until validation passes; a dry-run never posts, never gates, and records nothing. A stack review dry-runs ALL per-PR batches before ANY real post.",
+  "Make ONE real call per target PR: comments + body + event land atomically in a single review — the verdict never lands before the comments. A stack review posts one review per member PR, bottom→top; each real success appends a {pr, event, at} row to the review_posts workflow-state ledger. The tool ENFORCES skip-on-resume: a real post to a PR that already has a ledger row is refused (already_posted) unless allow_repost: true — a deliberate second review only. A MISSING row is not proof of no post (the ledger is best-effort): verify posted-vs-pending against GitHub before re-posting.",
   "Formal events (approve / request-changes) additionally raise a blocking in-TUI confirm; headless sessions refuse them (use event: comment or re-run interactively).",
-  "All perk-side GitHub posting flows through this tool on both review doors — never post via gh or bash (direct perk pr review-submit calls are forbidden). On /pr-review-terminal this tool is the sole posting path; on /pr-review-browser the plannotator UI's native platform-posting is the human's own GitHub path, and perk posts only what the human explicitly hands it (typically a request-changes verdict).",
+  "All perk-side GitHub posting flows through this tool on every review door — never post via gh or bash (direct perk pr review-submit calls are forbidden). On /pr-review-terminal this tool is the sole posting path. On /pr-review-browser the plannotator UI's native platform-posting is the human's own GitHub path, and perk posts only what the human explicitly hands it (typically a request-changes verdict). On /stack-review-browser the local-diff session has NO attached PR, so ALL posting is perk-side after triage.",
 ];
 
 // ------------------------------------------------------------------------ registration
@@ -334,9 +419,12 @@ export function registerSubmitPrReview(pi: ExtensionAPI): void {
     name: "submit_pr_review",
     label: "Submit PR review",
     description:
-      "Submit the human-curated review-door outcome to the foreign PR as ONE atomic review " +
-      "(comments + body + event) via the perk cold door. dry_run validates the anchors without " +
-      "posting (the repair loop); a real submission records last_review in workflow-state.",
+      "Submit the human-curated review-door outcome to the target PR as ONE atomic review " +
+      "(comments + body + event) via the perk cold door — the posting surface of the " +
+      "/pr-review-terminal, /pr-review-browser, and /stack-review-browser doors (a stack " +
+      "review makes one real call per member PR). dry_run validates the anchors without " +
+      "posting (the repair loop); a real submission records last_review and appends the " +
+      "review_posts ledger row in workflow-state.",
     promptSnippet: "Submit the curated review batch to the PR",
     promptGuidelines: TOOL_GUIDELINES,
     executionMode: "sequential",
@@ -363,7 +451,9 @@ export function registerSubmitPrReview(pi: ExtensionAPI): void {
           type: "array",
           description:
             "The curated inline comments — human-authored or human-approved only, each anchored " +
-            "to a line in the PR diff (never re-anchor a child's finding).",
+            "to a line in the PR diff. Single-PR mode: never re-anchor a child's finding. Stack " +
+            "mode: the parent re-anchors combined-diff findings into per-PR coordinates under " +
+            "the dry-run loop.",
           items: {
             type: "object",
             additionalProperties: false,
@@ -386,6 +476,13 @@ export function registerSubmitPrReview(pi: ExtensionAPI): void {
             "Validate the batch + anchors without posting (the anchor-repair loop). No gates, " +
             "no last_review record.",
         },
+        allow_repost: {
+          type: "boolean",
+          description:
+            "Deliberately post ANOTHER review to a PR that already has a review_posts ledger " +
+            "row in this session — the enforced resume guard refuses with already_posted " +
+            "otherwise. Never pass it to work around a stack-resume refusal.",
+        },
       },
     },
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {

package/extension/factories/objectiveDraft.ts

@@ -11,8 +11,9 @@
 // `objective_save`/`/objective-save` still persist the objective to GitHub.
 //
 // Format doctrine: JSON is the storage/transport format, NEVER the human review surface. The
-// artifact carries `{schema_version, title?, prose, roadmap}` — the structured roadmap rides
-// verbatim (node-shape validation stays with the Python plane at save time, the
+// artifact carries `{schema_version, title?, prose, roadmap}` (plus, in a perk learn dream
+// session, the tool-written `dream_report` block — contracts §8.63) — the structured roadmap
+// rides verbatim (node-shape validation stays with the Python plane at save time, the
 // `parse_structured_roadmap` path). The review surface reads the draft via
 // `readObjectiveDraft` (over `readSessionArtifact` — digest-validated, fail-open) and renders
 // markdown via `renderObjectiveDraft` (the prose + a roadmap table) — never raw JSON; the
@@ -20,9 +21,10 @@
 // back as structured JSON.
 //
 // Vocabulary ownership: this module owns the shared draft/save param vocabulary
-// (`ObjectiveSaveParams`, `decodeObjectiveSaveParams`, `ROADMAP_PARAM_SCHEMA`) — objectiveDraft is
-// the LEAF (mirroring planDraft←planSave's direction); objectiveSave.ts consumes it, so it may
-// value-import `readObjectiveDraft` cycle-free for the approval→save orchestration.
+// (`ObjectiveSaveParams`, `decodeObjectiveSaveParams`, `ROADMAP_PARAM_SCHEMA`,
+// `DREAM_REPORT_PARAM_SCHEMA`) — objectiveDraft is the LEAF (mirroring planDraft←planSave's
+// direction); objectiveSave.ts consumes it, so it may value-import `readObjectiveDraft`
+// cycle-free for the approval→save orchestration.
 //
 // Imports stay node builtins + sibling seams (sessionData.ts, result.ts) so the module loads
 // under `node --test`; no manual `scratch`/`runs` path segments (cacheGuard.test.ts).
@@ -37,9 +39,15 @@ import {
   type SessionDataCtx,
   writeSessionArtifact,
 } from "../substrate/sessionData.ts";
-import { arrayParam, paramsOf, stringParam } from "../substrate/toolParams.ts";
+import { arrayParam, objectParam, paramsOf, stringParam } from "../substrate/toolParams.ts";
 import type { EntrySink } from "../substrate/workflowState.ts";
 import type { ReportTarget } from "../surfaces/report.ts";
+import { DREAM_REPORT_INPUT_SCHEMA } from "../waves/dreamReport.ts";
+import {
+  decodeDreamReportBlock,
+  type ObjectiveDreamReportBlock,
+  resolveDreamReportGate,
+} from "./objectiveDreamReport.ts";
 
 /** The reviewed objective delivery choice (contracts §8.45). */
 export type DeliveryChoice = "incremental" | "stacked";
@@ -53,6 +61,9 @@ export interface ObjectiveSaveParams {
   base?: string;
   // The reviewed delivery choice; omitted ⇒ incremental (the §8.42 absence rule).
   delivery?: DeliveryChoice;
+  // The dream-report input (perk learn dream only — §8.63); deep validation is the gate
+  // resolver's, so the decode keeps it opaque beyond the plain-object shape.
+  dream_report?: unknown;
 }
 
 /**
@@ -69,6 +80,20 @@ export const DELIVERY_PARAM_SCHEMA = {
     "one atomic PR train — capability-checked at save).",
 } as const;
 
+/**
+ * The `dream_report` property, shared between `objective_save` and `objective_draft` so the
+ * two tools' dream contracts cannot drift: the §8.62 `DREAM_REPORT_INPUT_SCHEMA` embedded by
+ * identifier (the `DELIVERY_PARAM_SCHEMA`/`ROADMAP_PARAM_SCHEMA` shared-schema pattern) plus
+ * the gate description. Structurally reachable only inside a `perk learn dream` session (the
+ * resolver refuses it outside one).
+ */
+export const DREAM_REPORT_PARAM_SCHEMA = {
+  ...DREAM_REPORT_INPUT_SCHEMA,
+  description:
+    "The perk learn dream session's final report input (the parent's decisions only) — " +
+    "required inside a dream session, refused outside one.",
+} as const;
+
 /**
  * The roadmap-node items JSON schema, shared between `objective_save` and `objective_draft`
  * so the two tools' roadmap contracts cannot drift.
@@ -116,12 +141,22 @@ export function decodeObjectiveSaveParams(params: unknown): ObjectiveSaveParams
   const roadmap = arrayParam(p, "roadmap");
   const base = stringParam(p, "base");
   const delivery = stringParam(p, "delivery");
-  if (prose === null || title === null || roadmap === null || base === null || delivery === null) {
+  // `dream_report` must be a plain object when present (absent → undefined); deep validation
+  // stays with the gate resolver (resolveDreamReportGate).
+  const dreamReport = objectParam(p, "dream_report");
+  if (
+    prose === null ||
+    title === null ||
+    roadmap === null ||
+    base === null ||
+    delivery === null ||
+    dreamReport === null
+  ) {
     return null;
   }
   // The delivery enum is strict beyond `string`: an off-enum value is present-but-mistyped.
   if (delivery !== undefined && delivery !== "incremental" && delivery !== "stacked") return null;
-  return { prose: prose ?? "", title, roadmap, base, delivery };
+  return { prose: prose ?? "", title, roadmap, base, delivery, dream_report: dreamReport };
 }
 
 /** The fixed working-objective artifact name (one JSON file: prose + the structured roadmap). */
@@ -144,7 +179,9 @@ export type ObjectiveDraftResult = Result<ObjectiveDraftOk>;
  * structured roadmap, verbatim — the draft never validates node shapes) as one JSON artifact and
  * write it through the accessor seam (file + `session_artifacts` provenance pointer). Soft
  * result, never throws — failure taxonomy: empty prose → `invalid_input`; no session run_id →
- * `no_run_id`; file-or-pointer write failure → `write_failed` (the seam already warned).
+ * `no_run_id`; a `dream_report` gate refusal → `invalid_input`/`bad_state` (the §8.63 matrix —
+ * validated at write time so a report-less dream bundle can never reach review);
+ * file-or-pointer write failure → `write_failed` (the seam already warned).
  */
 export function writeObjectiveDraft(
   sink: EntrySink,
@@ -155,6 +192,7 @@ export function writeObjectiveDraft(
     roadmap?: unknown[];
     base?: string;
     delivery?: DeliveryChoice;
+    dream_report?: unknown;
   },
 ): ObjectiveDraftResult {
   const fail = failFor(ctx, "objective-draft");
@@ -168,6 +206,13 @@ export function writeObjectiveDraft(
     return fail("session has no run_id — cannot write the objective-draft artifact", "no_run_id");
   }
 
+  // The §8.63 gate: validated at draft-write time via buildDreamReport, the ONE stamp stored
+  // with the block; `absent` keeps the payload byte-identical (every non-dream path unchanged).
+  const gate = resolveDreamReportGate(ctx, opts.dream_report, new Date().toISOString());
+  if (gate.kind === "refuse") {
+    return fail(gate.detail, gate.errorType);
+  }
+
   // Deterministic key order via the explicit literal; `title`/`base`/`delivery` are omitted
   // when blank/absent (schema_version stays 1 — an additive optional field, fail-open readers).
   const title = opts.title?.trim();
@@ -179,6 +224,7 @@ export function writeObjectiveDraft(
     ...(title ? { title } : {}),
     ...(base ? { base } : {}),
     ...(delivery ? { delivery } : {}),
+    ...(gate.kind === "block" ? { dream_report: gate.block } : {}),
     prose: opts.prose,
     roadmap,
   };
@@ -216,6 +262,8 @@ export interface ObjectiveDraft {
   base?: string;
   // The reviewed delivery choice; kept only when exactly the enum (junk → absent, like `base`).
   delivery?: DeliveryChoice;
+  // The dream-report block (§8.63); a present-but-malformed block refuses the WHOLE draft.
+  dream_report?: ObjectiveDreamReportBlock;
 }
 
 /**
@@ -223,7 +271,10 @@ export interface ObjectiveDraft {
  * `readSessionArtifact`'s loud tier): no pointer/file/digest → `null` (the seam already spoke);
  * malformed JSON, a non-object payload, an unsupported `schema_version`, or blank prose → a
  * stderr warning + `null`. `roadmap` defaults to `[]` when absent/non-array; `title` is kept
- * only when a non-blank string. Never throws.
+ * only when a non-blank string. A present-but-malformed `dream_report` block refuses the WHOLE
+ * draft (warn + `null`) — deliberately stricter than the lenient junk→absent handling of
+ * `base`/`delivery`, because silently dropping a malformed report is exactly what §8.63
+ * forbids. Never throws.
  */
 export function readObjectiveDraft(ctx: SessionDataCtx): ObjectiveDraft | null {
   const artifact = readSessionArtifact(ctx, OBJECTIVE_DRAFT_ARTIFACT);
@@ -258,10 +309,19 @@ export function readObjectiveDraft(ctx: SessionDataCtx): ObjectiveDraft | null {
     payload.delivery === "incremental" || payload.delivery === "stacked"
       ? payload.delivery
       : undefined;
+  let dreamReport: ObjectiveDreamReportBlock | undefined;
+  if ("dream_report" in payload) {
+    const block = decodeDreamReportBlock(payload.dream_report);
+    if (block === null) {
+      return refuse("carries a malformed dream_report block");
+    }
+    dreamReport = block;
+  }
   return {
     ...(title !== undefined ? { title } : {}),
     ...(base !== undefined ? { base } : {}),
     ...(delivery !== undefined ? { delivery } : {}),
+    ...(dreamReport !== undefined ? { dream_report: dreamReport } : {}),
     prose,
     roadmap,
   };
@@ -294,7 +354,10 @@ function nodeDependsOn(node: unknown): string {
  * a `## Roadmap` section with ONE markdown table. A prominent `**Delivery:**` line renders
  * directly under the title unconditionally (the reviewed choice must be visible either way —
  * contracts §8.45). The `Phase` column appears only when some node carries a non-blank string
- * `phase`. Pure; never throws.
+ * `phase`. When the draft carries a `dream_report` block, the stored CANONICAL parts append as
+ * the final section — the review surface IS the approval bundle: the objective and its report
+ * review (and are approved or denied) together (§8.63); the parts carry their own
+ * `# Dream report — <run_id>` headers. Pure; never throws.
  */
 /** The always-present prominent `**Delivery:**` review line (contracts §8.45). */
 function deliveryLine(draft: ObjectiveDraft): string {
@@ -313,23 +376,27 @@ export function renderObjectiveDraft(draft: ObjectiveDraft): string {
   out += `${deliveryLine(draft)}\n\n`;
   out += draft.prose;
 
-  if (draft.roadmap.length === 0) return out;
+  if (draft.roadmap.length > 0) {
+    const withPhase = draft.roadmap.some((node) => nodeString(node, "phase").trim().length > 0);
+    const header = withPhase
+      ? "| Node | Phase | Description | Depends On | Status |\n| --- | --- | --- | --- | --- |"
+      : "| Node | Description | Depends On | Status |\n| --- | --- | --- | --- |";
+    const rows = draft.roadmap.map((node) => {
+      const cells = [
+        tableCell(nodeString(node, "id")),
+        ...(withPhase ? [tableCell(nodeString(node, "phase"))] : []),
+        tableCell(nodeString(node, "description")),
+        tableCell(nodeDependsOn(node)),
+        tableCell(nodeString(node, "status") || "pending"),
+      ];
+      return `| ${cells.join(" | ")} |`;
+    });
+    out = `${out.trimEnd()}\n\n## Roadmap\n\n${header}\n${rows.join("\n")}\n`;
+  }
 
-  const withPhase = draft.roadmap.some((node) => nodeString(node, "phase").trim().length > 0);
-  const header = withPhase
-    ? "| Node | Phase | Description | Depends On | Status |\n| --- | --- | --- | --- | --- |"
-    : "| Node | Description | Depends On | Status |\n| --- | --- | --- | --- |";
-  const rows = draft.roadmap.map((node) => {
-    const cells = [
-      tableCell(nodeString(node, "id")),
-      ...(withPhase ? [tableCell(nodeString(node, "phase"))] : []),
-      tableCell(nodeString(node, "description")),
-      tableCell(nodeDependsOn(node)),
-      tableCell(nodeString(node, "status") || "pending"),
-    ];
-    return `| ${cells.join(" | ")} |`;
-  });
-  return `${out.trimEnd()}\n\n## Roadmap\n\n${header}\n${rows.join("\n")}\n`;
+  if (draft.dream_report === undefined) return out;
+  // The approval bundle: objective first, then the stored CANONICAL report parts.
+  return `${out.trimEnd()}\n\n${draft.dream_report.parts.join("\n\n")}\n`;
 }
 
 const TOOL_GUIDELINES = [
@@ -371,6 +438,7 @@ export function registerObjectiveDraft(pi: ExtensionAPI): void {
             "Optional target branch for this objective's plans (omit to use the repo default).",
         },
         delivery: DELIVERY_PARAM_SCHEMA,
+        dream_report: DREAM_REPORT_PARAM_SCHEMA,
         roadmap: {
           type: "array",
           description: