@mgiles/perk 2.3.0 → 3.1.0

package/extension/doors/submit.ts

@@ -22,7 +22,7 @@ import {
   stringField,
 } from "../substrate/coldDoor.ts";
 import { registerPerkCommand } from "../substrate/command.ts";
-import { loadPerkConfig } from "../substrate/config.ts";
+import { subagentModel } from "../substrate/config.ts";
 import { render } from "../substrate/prompts.ts";
 import { failFor, type OkDetails, ok, type Result } from "../substrate/result.ts";
 import { captureSessionPointer } from "../substrate/sessionPointers.ts";
@@ -44,6 +44,18 @@ export interface SubmitOk {
   mergeable?: boolean | null;
   /** The conflicted paths when `mergeable === false`; `[]` otherwise (advisory). */
   conflicts?: string[];
+  /** `"stacked"` when the submit routed through the delivery publish operation (§8.47). */
+  delivery?: string;
+  /** The native-stack facts of a stacked submit (absent for the bottom layer). */
+  stack?: { number: number; size: number; position: number };
+  /** Lenient summary of an automatic suffix synchronization. */
+  operation?: {
+    kind: string;
+    operation_id: string | null;
+    no_op: boolean;
+    affected_count: number;
+    notes: string[];
+  };
 }
 
 export type SubmitResult = Result<SubmitOk>;
@@ -67,6 +79,51 @@ function conflictsField(payload: ColdJson): string[] {
   return [];
 }
 
+/**
+ * A lenient read of the advisory stacked `stack` facts: all three numbers or nothing — a
+ * malformed value must NOT sink a successful submit decode (it just drops the suffix).
+ */
+function stackField(payload: ColdJson): SubmitOk["stack"] {
+  const value = objectField(payload, "stack");
+  if (value === undefined) return undefined;
+  const number = numberField(value, "number");
+  const size = numberField(value, "size");
+  const position = numberField(value, "position");
+  if (number === undefined || size === undefined || position === undefined) return undefined;
+  return { number, size, position };
+}
+
+/**
+ * Lenient all-or-nothing decode of the cascade operation block. The full affected rows remain a
+ * Python/CLI detail; the warm door needs only their count plus the recovery notes.
+ */
+function operationField(payload: ColdJson): SubmitOk["operation"] {
+  const value = objectField(payload, "operation");
+  if (value === undefined) return undefined;
+  const kind = stringField(value, "kind");
+  const operationId = value.operation_id;
+  const noOp = booleanField(value, "no_op");
+  const affected = value.affected;
+  const notes = value.notes;
+  if (
+    kind === undefined ||
+    (typeof operationId !== "string" && operationId !== null) ||
+    noOp === undefined ||
+    !Array.isArray(affected) ||
+    !Array.isArray(notes) ||
+    !notes.every((note) => typeof note === "string")
+  ) {
+    return undefined;
+  }
+  return {
+    kind,
+    operation_id: operationId,
+    no_op: noOp,
+    affected_count: affected.length,
+    notes: notes as string[],
+  };
+}
+
 /**
  * Narrow the `perk pr submit --json` success payload; strict on `pr`, lenient on the rest. The
  * `base`/`mergeable`/`conflicts` mergeability fields are advisory (mirror land.ts's lenient
@@ -90,12 +147,15 @@ function decodeSubmit(payload: ColdJson): SubmitOk | null {
     base: stringField(payload, "base"),
     mergeable: mergeableField(payload),
     conflicts: conflictsField(payload),
+    delivery: stringField(payload, "delivery"),
+    stack: stackField(payload),
+    operation: operationField(payload),
   };
 }
 
-/** A definitively-unmergeable submit: the gate fires only on a *definitive* `false` + conflicts. */
+/** A definitively-unmergeable submit; parsed conflict paths are advisory only. */
 function isUnmergeable(details: SubmitDetails): details is OkDetails<SubmitOk> {
-  return details.ok && details.mergeable === false && (details.conflicts?.length ?? 0) > 0;
+  return details.ok && details.mergeable === false;
 }
 
 /**
@@ -140,15 +200,30 @@ export async function submitPr(pi: ExtensionAPI, ctx: ExtensionContext): Promise
   }
 
   const verb = r.data.pr.existed ? "Found existing" : "Opened draft";
-  const conflicted = r.data.mergeable === false && (r.data.conflicts?.length ?? 0) > 0;
+  const conflicted = r.data.mergeable === false;
   // Reset the counter on every clean (or undetermined) submit — idempotent; keeps a later
   // independent conflict bounded fresh.
   if (r.data.mergeable !== false) resetConflictAttempts(pi, ctx);
+  // Automatic-cascade facts supersede the generic stacked suffix. A malformed operation block was
+  // dropped by the lenient decoder, so it falls back to the pre-existing stack wording.
+  const deliverySuffix =
+    r.data.operation?.kind === "sync"
+      ? r.data.operation.no_op
+        ? " (suffix already in sync)"
+        : ` (cascaded ${r.data.operation.affected_count} layer(s))`
+      : r.data.stack
+        ? ` (stack #${r.data.stack.number}, layer ${r.data.stack.position}/${r.data.stack.size})`
+        : r.data.delivery === "stacked"
+          ? " (stacked layer)"
+          : "";
+  for (const note of r.data.operation?.notes ?? []) {
+    report(ctx, "submit", "warning", note);
+  }
   const message = conflicted
-    ? `${verb} PR #${r.data.pr.number} → ${r.data.pr.url} — merge conflicts detected; resolving`
+    ? `${verb} PR #${r.data.pr.number} → ${r.data.pr.url} — merge conflicts detected; resolving${deliverySuffix}`
     : `${verb} PR #${r.data.pr.number} → ${r.data.pr.url} (${
         r.data.plan_embedded ? "plan embedded" : "no plan embed"
-      })`;
+      })${deliverySuffix}`;
   return ok(message, r.data, { terminate: true });
 }
 
@@ -221,7 +296,7 @@ export function driveConflictResolution(
     scope: "submit",
     failure: `conflict_resolution_attempts read-back failed (expected ${next})`,
   });
-  const model = loadPerkConfig(ctx.cwd).subagents["conflict-resolver"];
+  const model = subagentModel(ctx.cwd, "conflict-resolver");
   const message =
     conflictResolutionGuidance(base, next, CONFLICT_RESOLUTION_ATTEMPT_CAP, model) +
     bindingSuffix(ctx.cwd, "command:submit");

package/extension/factories/gistAuthor.ts

@@ -28,10 +28,10 @@ export const GIST_AUTHOR_CONTEXT_TYPE = "perk:gist-author-context";
 const GIST_AUTHOR_MARKER = "[GIST AUTHORING]";
 
 /**
- * The cooperative gather-then-author contract for gists. Prompting, NOT enforcement (the tool
- * gate is the enforcement). Mirrors skills/perk-gist-author/SKILL.md: clarify the intent,
- * explore lightly, keep the draft current with `gist_draft`, review via `plan_review`, approval
- * auto-saves — no implementation strategy in the artifact.
+ * The gist-authoring session context: live state + pointers only (contracts.md §8.57 — the flow
+ * is stated by the launch statement, the detail by the `perk-gist-author` skill). It names the
+ * working-draft artifact (`gist_draft`), the review tool (`plan_review`), and the bound skill;
+ * it never restates the flow. Prompting, NOT enforcement (the tool gate is the enforcement).
  */
 export const GIST_AUTHORING_CONTEXT = render("contexts/gist-authoring.md", {
   marker: GIST_AUTHOR_MARKER,

package/extension/factories/gistDraft.ts

@@ -232,7 +232,7 @@ export function registerGistDraft(pi: ExtensionAPI): void {
           type: "string",
           description:
             "The gist prose (the problem-space intent: what we want, why it matters, what " +
-            "bounds it — no implementation steps).",
+            "bounds it, and any high-level solution leanings — no implementation steps).",
         },
         title: {
           type: "string",

package/extension/factories/gistSave.ts

@@ -155,7 +155,7 @@ export async function gistApprovalSave(
 
 const TOOL_GUIDELINES = [
   "Use gist_save only after the gist says what it means; it creates the tracked gist in the issue backend and ends the turn.",
-  "Pass gist_save the statement-of-intent PROSE in `prose` — problem-space only, no implementation steps or roadmap.",
+  "Pass gist_save the statement-of-intent PROSE in `prose` — problem-focused, with at most high-level solution leanings; no implementation steps or roadmap.",
   "Pass gist_save's `scope` only once the consumption tier is settled (plan or objective); omit it to keep the pre-seeded/default scope.",
 ];
 
@@ -190,7 +190,7 @@ export function registerGistSave(pi: ExtensionAPI, gating: ToolGating): void {
           type: "string",
           description:
             "The gist prose (the problem-space intent: what we want, why it matters, what " +
-            "bounds it — no implementation steps).",
+            "bounds it, and any high-level solution leanings — no implementation steps).",
         },
         title: {
           type: "string",

package/extension/factories/objective.ts

@@ -7,8 +7,8 @@
 // the "fire only when…" tools live elsewhere. This module ships three pieces, all inert when no
 // objective is active:
 //   1. `/objective [<id>|clear]` — set/clear `active_objective` (LWW field) + seed a dedicated
-//      `perk:objective-budget` activation marker (high-churn budget data kept OFF the shared record,
-//      mirroring checkpoints' dedicated entry).
+//      `perk:objective-budget` activation marker (high-churn budget data kept OFF the shared
+//      record).
 //   2. Budget accounting — stateless rebuild (the goal.ts pattern): sum assistant-message tokens
 //      AFTER the latest activation marker; surface via ctx.ui guarded by ctx.hasUI; rebuilt on
 //      session_start AND session_tree AND agent_settled (survives reload/branch/compaction for
@@ -19,7 +19,7 @@
 //      objective is active, compact when context usage crosses a configurable threshold.
 //
 // Headless-fail-safe: every UI call is ctx.hasUI-guarded; budget accounting + compaction are
-// best-effort and never throw (logged-not-thrown, like checkpoints).
+// best-effort and never throw (logged-not-thrown).
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { registerPerkCommand } from "../substrate/command.ts";
@@ -131,8 +131,8 @@ function activeObjective(ctx: ExtensionContext): string | null {
 }
 
 /**
- * Surface the budget as the objective segment of the composed `perk` status (the `perk-objective`
- * widget is retired; the segment carries id + tokens + elapsed). Headless-safe:
+ * Surface the budget as the single-value `perk` status (the `perk-objective`
+ * widget is retired; the value carries id + tokens + elapsed). Headless-safe:
  * the handle no-ops without UI.
  */
 function renderStatus(ctx: ExtensionContext, status: PerkStatusHandle): void {
@@ -140,11 +140,11 @@ function renderStatus(ctx: ExtensionContext, status: PerkStatusHandle): void {
   try {
     const active = activeObjective(ctx);
     if (active === null) {
-      status.set(ctx, "objective", undefined);
+      status.set(ctx, undefined);
       return;
     }
     const budget = rebuildBudget(scanBranchOf(ctx), Date.now());
-    status.set(ctx, "objective", `${MARK_OBJECTIVE} ${active} · ${formatBudgetLine(budget)}`);
+    status.set(ctx, `${MARK_OBJECTIVE} ${active} · ${formatBudgetLine(budget)}`);
   } catch (error) {
     console.error(`perk: objective status render failed — ${error}`);
   }

package/extension/factories/objectiveAuthor.ts

@@ -29,10 +29,11 @@ export const OBJECTIVE_AUTHOR_CONTEXT_TYPE = "perk:objective-author-context";
 const OBJECTIVE_AUTHOR_MARKER = "[OBJECTIVE AUTHORING]";
 
 /**
- * The cooperative gather-then-author contract for objectives. Prompting, NOT enforcement (the tool
- * gate is the enforcement). Mirrors skills/perk-objective-author/SKILL.md: clarify the goal, explore
- * read-only, structure a roadmap, keep the draft current with `objective_draft`, review via
- * `plan_review`, approval auto-saves — never hand-write roadmap YAML.
+ * The objective-authoring session context: live state + pointers only (contracts.md §8.57 — the
+ * flow is stated by the launch statement, the detail by the `perk-objective-author` skill). It
+ * names the working-draft artifact (`objective_draft`), the review tool (`plan_review`), and
+ * the bound skill; it never restates the flow. Prompting, NOT enforcement (the tool gate is the
+ * enforcement).
  */
 export const OBJECTIVE_AUTHORING_CONTEXT = render("contexts/objective-authoring.md", {
   marker: OBJECTIVE_AUTHOR_MARKER,

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,18 @@ 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";
 
 /** The decoded `objective_save` tool params (shared with `objective_draft`). */
 export interface ObjectiveSaveParams {
@@ -48,8 +59,41 @@ export interface ObjectiveSaveParams {
   roadmap?: unknown[];
   // The objective's target branch; omitted to use the repo default.
   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;
 }
 
+/**
+ * The `delivery` enum property, shared between `objective_save` and `objective_draft` so the
+ * two tools' delivery contracts cannot drift. The description bakes in the explicit-human-choice
+ * discipline: the agent must ASK, with incremental recommended.
+ */
+export const DELIVERY_PARAM_SCHEMA = {
+  type: "string",
+  enum: ["incremental", "stacked"],
+  description:
+    "The reviewed delivery choice — ask the human explicitly (incremental is the recommended " +
+    "default: each plan lands independently; stacked lands ALL non-skipped roadmap nodes as " +
+    "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.
@@ -96,8 +140,23 @@ export function decodeObjectiveSaveParams(params: unknown): ObjectiveSaveParams
   const title = stringParam(p, "title");
   const roadmap = arrayParam(p, "roadmap");
   const base = stringParam(p, "base");
-  if (prose === null || title === null || roadmap === null || base === null) return null;
-  return { prose: prose ?? "", title, roadmap, base };
+  const delivery = stringParam(p, "delivery");
+  // `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, dream_report: dreamReport };
 }
 
 /** The fixed working-objective artifact name (one JSON file: prose + the structured roadmap). */
@@ -120,12 +179,21 @@ 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,
   ctx: SessionDataCtx & ReportTarget,
-  opts: { prose: string; title?: string; roadmap?: unknown[]; base?: string },
+  opts: {
+    prose: string;
+    title?: string;
+    roadmap?: unknown[];
+    base?: string;
+    delivery?: DeliveryChoice;
+    dream_report?: unknown;
+  },
 ): ObjectiveDraftResult {
   const fail = failFor(ctx, "objective-draft");
 
@@ -138,14 +206,25 @@ export function writeObjectiveDraft(
     return fail("session has no run_id — cannot write the objective-draft artifact", "no_run_id");
   }
 
-  // Deterministic key order via the explicit literal; `title`/`base` are omitted when blank.
+  // 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();
   const base = opts.base?.trim();
+  const delivery = opts.delivery;
   const roadmap = opts.roadmap ?? [];
   const payload = {
     schema_version: 1,
     ...(title ? { title } : {}),
     ...(base ? { base } : {}),
+    ...(delivery ? { delivery } : {}),
+    ...(gate.kind === "block" ? { dream_report: gate.block } : {}),
     prose: opts.prose,
     roadmap,
   };
@@ -181,6 +260,10 @@ export interface ObjectiveDraft {
   roadmap: unknown[];
   // The objective's target branch; kept only when a non-blank string in the artifact.
   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;
 }
 
 /**
@@ -188,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);
@@ -219,9 +305,23 @@ export function readObjectiveDraft(ctx: SessionDataCtx): ObjectiveDraft | null {
   const title =
     typeof payload.title === "string" && payload.title.trim() ? payload.title : undefined;
   const base = typeof payload.base === "string" && payload.base.trim() ? payload.base : undefined;
+  const delivery =
+    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,
   };
@@ -251,31 +351,52 @@ function nodeDependsOn(node: unknown): string {
 /**
  * Render the draft as the markdown review surface (JSON is storage/transport only — contracts
  * §8.1): the optional `# title` heading, the prose verbatim, and (when the roadmap is non-empty)
- * a `## Roadmap` section with ONE markdown table. The `Phase` column appears only when some node
- * carries a non-blank string `phase`. Pure; never throws.
+ * 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`. 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 {
+  if (draft.delivery === "stacked") {
+    return (
+      "**Delivery: STACKED** — all non-skipped roadmap nodes land as ONE atomic pull-request " +
+      "train (capability-checked at save)"
+    );
+  }
+  return "**Delivery: incremental** (the default — each plan lands independently)";
+}
+
 export function renderObjectiveDraft(draft: ObjectiveDraft): string {
   let out = "";
   if (draft.title) out += `# ${draft.title}\n\n`;
+  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 = [
@@ -316,6 +437,8 @@ export function registerObjectiveDraft(pi: ExtensionAPI): void {
           description:
             "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: