diff --git a/CONTEXT.md b/CONTEXT.md
index fd3d849..66ac3f7 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -142,21 +142,21 @@ A short written answer to "where is this request, and what comes next?". An agen
 _Avoid_: Summary, status, digest
 
 **Release announcement**:
-The note that customers would read after the problem is solved. The team writes it as a draft when it captures the problem, long before anything ships. The draft says in the customer's words what changes for them, never how it was built. The request page marks it as a draft until the request is **released**. It is free text on the request, written in the request dialog or through `map_upsert_request`.
+The note that customers would read after the problem is solved. A request can hold a draft of it, in the customer's words, long before anything ships. When a **Pitch** is created from the request, the pitch copies the draft into its **Release summary**. After a pitch ships, the request page shows the release summary of that pitch. Until then it shows the request's own draft, marked as a draft.
 _Avoid_: Changelog, release note (that is the Notion record of a shipped release), press release
 
 **Sharp**:
-A request with a problem, an **Appetite** and at least one **Outcome**. A request that has fewer is **rough**. Sharpness is derived, never a stored flag, in the same way **Cycle phase** is date-derived ([ADR 0015](docs/adr/0015-cycle-lifecycle-is-date-derived.md)). **Only a sharp request can be bet on**, so nobody bets on a request that never says what would change.
+A request with a problem, an **Appetite** and at least one **Outcome**. A request that has fewer is **rough**. Sharpness is derived, never a stored flag, in the same way **Cycle phase** is date-derived ([ADR 0015](docs/adr/0015-cycle-lifecycle-is-date-derived.md)). **Only a sharp request can be pitched**, so no pitch starts from a request that never says what would change.
 _Avoid_: Framed, ready, validated, approved
 
 **Request state**:
 A request’s position in its life, derived from what it points at and never stored:
-`rough` (no appetite) → `candidate` (sharp, no **Pitch** yet) → `in_flight` (a pitch that is not `done`) → `released` (its pitch reached `done`) → `monitoring` (released and not resolved) → `resolved` (a person resolved it).
-Monitoring has no end condition. A released request that nobody wakes goes **Dormant** like any other.
+`rough` (no appetite or no outcome) → `candidate` (sharp, no **Pitch** yet) → `pitched` (a pitch waits in an upcoming cycle) → `in_flight` (a pitch in a cycle that has started, not `done`) → `released` (its pitch reached `done`) → `monitoring` (released and not resolved) → `resolved` (a person resolved it).
+A request with more than one pitch shows the furthest one, except that a pitch still in flight always wins. If the betting table deletes its only pitch, the request goes back to `candidate`. Monitoring has no end condition. A released request that nobody wakes goes **Dormant** like any other.
 _Avoid_: Status, stage (reserved for a **Pitch**), workflow state
 
 **Candidate**:
-A sharp request with no **Pitch** yet. A candidate is what the betting table bets on.
+A sharp request with no **Pitch** yet. A candidate is ready to be pitched.
 _Avoid_: Backlog item, proposal, ready
 
 **Candidate statement**:
@@ -230,7 +230,7 @@ The shaped bet, and the thing a cycle contains. Has a stage, a timebox, scopes,
 _Avoid_: Shape (that is one part of a pitch), package (that is what a request does with its **Pointers**), project, epic, initiative, ticket
 
 **Frame**:
-The framing part of a **Pitch**: the full problem, reworked with research, and the outcome the pitch must reach. A **Request** holds a short summary. The frame says it with depth. "Frame Go" means the frame is complete.
+The framing part of a **Pitch**: the full problem, reworked with research (`frame_problem`), the outcomes the pitch must reach (`frame_outcomes`), and its appetite (`frame_appetite`). A **Request** holds a short summary. The frame says it with depth. A new pitch copies its frame from its requests: every outcome, the largest appetite, and the problem summaries. After that the pitch owns its frame, and a change to a request does not change it. "Frame Go" is the move from `framing` to `shaping` ([ADR 0032](docs/adr/0032-the-map-holds-requests-and-framing-returns-to-the-pitch.md)).
 _Avoid_: Frame for the record on the Product Map (that is a **Request**)
 
 **Shape**:
@@ -238,13 +238,17 @@ The solution part of a **Pitch**, at a high level: its **Scopes**, and visuals o
 _Avoid_: Shape for the whole bet (that is a **Pitch**), spec, design
 
 **Stage**:
-A **Pitch**'s current lifecycle phase: `shaping`, `building`, `done`. Can move forward or backward. Cooldown pitches start at `building`. A pitch **auto-advances to `done`** when an update sets the **Needle** to 100% — posting a 100% update is the act of shipping. There is no `framing` stage: framing happens before a pitch exists (see [ADR 0023](docs/adr/0023-framing-leaves-the-shape.md)). `shaping` stays, because shaping work really does happen inside the cycle.
-_Avoid_: Status (ambiguous — see Flagged ambiguities), framing (not a stage)
+A **Pitch**'s current lifecycle phase: `framing`, `shaping`, `building`, `done`. Can move forward or backward. A new pitch starts at `framing`, in the upcoming cycle, where it waits for the betting table. A cooldown pitch starts at `building`. "Frame Go" is `framing` → `shaping`, and "Shape Go" is `shaping` → `building`. A pitch **auto-advances to `done`** when an update sets the **Needle** to 100% — posting a 100% update is the act of shipping (see [ADR 0032](docs/adr/0032-the-map-holds-requests-and-framing-returns-to-the-pitch.md)).
+_Avoid_: Status (ambiguous — see Flagged ambiguities)
 
 **Frame as bet**:
-The problem text of a **Pitch**'s **Frame**, stored as `frame_problem`, with its outcome stored as free text in `frame_outcome`. The problem is copied from the **Request** when the bet is made. The request on the map keeps changing. This copy does not, so a past cycle always shows what the team committed to (see [ADR 0022](docs/adr/0022-the-frame-is-the-captured-unit.md)). A pitch points home through `request_id`.
+The **Frame** of a **Pitch** as it stood when the bet was made. The pitch copies it from its requests when it is created, and the requests on the map keep changing. The copy does not, so a past cycle always shows what the team committed to (see [ADR 0022](docs/adr/0022-the-frame-is-the-captured-unit.md)). A pitch points home through `request_ids`.
 _Avoid_: Request (that is the living record on the map), requirements, spec, PRD
 
+**Release summary**:
+Two or three sentences on a **Pitch**, in the customer's words, that say what changes for them. The full release note lives in Notion, and the pitch links to it through `release_note_url`.
+_Avoid_: Changelog, release note (that is the Notion page)
+
 **Timebox**:
 The fixed time boundary of a pitch. Has start and end dates — but is **optional**: a pitch may have no timebox, in which case its tape is hidden (never "Invalid Date") and it draws no bar on the **Pitch timeline**. Visualized as a tape-measure strip with day ticks and a "today" marker. For the cycle's own span, use **Cycle window** — not "timebox" (see ADR 0010). All of its math — days left, elapsed fill, "Week X of Y" — counts **business days**, not calendar days (see ADR 0013).
 _Avoid_: Deadline, due date, sprint length
@@ -459,7 +463,7 @@ _Avoid_: Scope modal, scope detail dialog, side panel
 - A **Request** has one **Kind**, one **Type**, zero or one **Request owner**, zero or more **Reports**, and zero or more **Pointers**
 - A **Request**'s **Type** selects one **Playbook**; the playbook's expected **Pointers** minus the request's own give its **Gap list**
 - A **Request** has zero or one **Origin request** — the request whose **monitoring** surfaced it
-- A **Pitch** points at zero or one **Request**, and keeps a **Frame as bet** taken when the bet was made
+- A **Pitch** carries zero or more **Requests**, and keeps a **Frame as bet** taken when it was created
 - A **Request** can carry several **Pitches** over its life, each in its own **Cycle**
 - **Mission Control** renders its pitches as a **Pitch timeline** — per-pitch **Timebox** bars grouped by squad on the **Cycle window**'s shared scale; derived, never stored
 
diff --git a/e2e/scope-map.spec.ts b/e2e/scope-map.spec.ts
index 245cfff..4dc9e71 100644
--- a/e2e/scope-map.spec.ts
+++ b/e2e/scope-map.spec.ts
@@ -20,7 +20,7 @@ test.describe('Scope Map view assembly', () => {
 
     // Frame columns
     await expect(page.getByText('Problem')).toBeVisible()
-    await expect(page.getByText('Outcome')).toBeVisible()
+    await expect(page.getByText('Outcomes')).toBeVisible()
 
     // Scopes section
     await expect(page.getByRole('heading', { name: 'Scopes' })).toBeVisible()
diff --git a/scripts/migrate-frames-to-requests.ts b/scripts/migrate-frames-to-requests.ts
index c4ba0ce..ae43175 100644
--- a/scripts/migrate-frames-to-requests.ts
+++ b/scripts/migrate-frames-to-requests.ts
@@ -10,6 +10,7 @@ import { mkdirSync, writeFileSync } from 'node:fs'
 import { Liveblocks, LiveList, LiveObject } from '@liveblocks/node'
 import {
   migrateCycleDocument,
+  migratePitch,
   migrateProductMapDocument,
 } from '../src/lib/migrations/frames-to-requests'
 
@@ -56,10 +57,12 @@ async function main() {
       // @liveblocks/node's LiveList has no toArray(); map() is the way to read it.
       const pitches: any[] = root.get('pitches')?.map((pitch: any) => pitch) ?? []
       for (const pitch of pitches) {
-        const requestId = pitch.get('frame_id')
-        if (requestId === undefined) continue
-        pitch.set('request_id', requestId)
-        pitch.delete('frame_id')
+        const before = pitch.toImmutable() as Record<string, unknown>
+        const after = migratePitch(before)
+        for (const key of Object.keys(before)) if (!(key in after)) pitch.delete(key)
+        for (const [key, value] of Object.entries(after)) {
+          if (JSON.stringify(before[key]) !== JSON.stringify(value)) pitch.set(key, value)
+        }
       }
     })
   }
diff --git a/src/app/[slug]/cycles/[cycleSlug]/mission-control.tsx b/src/app/[slug]/cycles/[cycleSlug]/mission-control.tsx
index 4c89a5e..e6a9e65 100644
--- a/src/app/[slug]/cycles/[cycleSlug]/mission-control.tsx
+++ b/src/app/[slug]/cycles/[cycleSlug]/mission-control.tsx
@@ -1,5 +1,6 @@
 'use client'
 import { newShapeStage, readStage } from '@/lib/stage-engine'
+import { isUpcomingCycle } from '@/lib/product-map-engine'
 
 import { ClientSideSuspense } from '@liveblocks/react'
 import { MissionControlSkeleton } from '@/components/mission-control'
@@ -96,10 +97,9 @@ function MissionControlWired({
         new LiveObject({
           id: nanoid(),
           title,
-          stage: newShapeStage(cycle.type),
+          stage: newShapeStage(cycle.type, isUpcomingCycle(cycle, getTeamToday(new Date()))),
           needle: null,
           frame_problem: '',
-          frame_outcome: '',
           timebox_start: cycle.start_date,
           timebox_end: cycle.end_date,
           emoji: '',
diff --git a/src/app/[slug]/product/actions.ts b/src/app/[slug]/product/actions.ts
index 16f6e87..64de79a 100644
--- a/src/app/[slug]/product/actions.ts
+++ b/src/app/[slug]/product/actions.ts
@@ -2,26 +2,27 @@
 
 import { auth } from '@clerk/nextjs/server'
 import { revalidatePath } from 'next/cache'
-import { getProductMapStorage } from '@/lib/mcp/liveblocks-reader'
+import { getProductMapStorage, listCycleRooms } from '@/lib/mcp/liveblocks-reader'
 import { upsertPitch } from '@/lib/mcp/liveblocks-writer'
-import { isSharp } from '@/lib/product-map-engine'
+import { isSharp, isUpcomingCycle, seedPitchFrame } from '@/lib/product-map-engine'
+import { getTeamToday } from '@/lib/team-time'
 
 /**
- * Bet on a request: create a **Shape** in a cycle that points home to it.
+ * Pitch a request: create a **Pitch** at `framing` in an upcoming cycle that
+ * carries it (ADR 0032). The betting table later keeps the pitch or deletes it.
  *
- * The request is re-read here rather than trusted from the client, because this is
- * the one rule that has to hold — only a SHARP request can be bet on, and nobody
- * bets on half a request.
+ * The request is re-read here rather than trusted from the client, because this
+ * is the rule that has to hold: only a SHARP request can be pitched.
  *
- * The shape's problem is a COPY taken now: the **Frame as bet**. The request on
- * the Product Map keeps changing and this copy never does, so a past cycle always shows
- * what the team committed to (ADR 0022). Nothing here writes back to the Product Map.
+ * The pitch copies its frame from the request now. After that the pitch owns
+ * it, so a past cycle always shows what the team committed to. Nothing here
+ * writes back to the Product Map.
  */
-export async function betOnRequest(input: {
+export async function pitchRequest(input: {
   requestId: string
   cycleSlug: string
   title: string
-}): Promise<{ shapeId: string }> {
+}): Promise<{ pitchId: string }> {
   const { userId, orgId, orgSlug } = await auth()
   if (!userId) throw new Error('Not authenticated')
   if (!/^[a-zA-Z0-9_-]+$/.test(input.cycleSlug)) throw new Error('Invalid cycle')
@@ -32,19 +33,24 @@ export async function betOnRequest(input: {
   if (!request) throw new Error(`Request not found: "${input.requestId}"`)
   if (!isSharp(request)) {
     throw new Error(
-      'A rough request cannot become a shape. Give it a problem and an appetite first.'
+      'A rough request cannot be pitched. Give it a problem, an appetite and an outcome first.'
     )
   }
 
-  // A new shape starts at `shaping`: framing already happened, on the Product Map
-  // (ADR 0023).
+  // listCycleRooms, not readCycleWindows: a Liveblocks failure must surface as
+  // itself, not as "there is no upcoming cycle".
+  const cycle = (await listCycleRooms(orgPrefix)).find((c) => c.slug === input.cycleSlug)
+  if (!cycle || !isUpcomingCycle(cycle, getTeamToday(new Date()))) {
+    throw new Error('Pitch into an upcoming cycle. Create the next cycle first if there is none.')
+  }
+
   const result = await upsertPitch(`${orgPrefix}:cycle:${input.cycleSlug}`, {
     title: input.title.trim() || request.problem,
-    stage: 'shaping',
-    frame_problem: request.problem,
-    request_id: request.id,
+    stage: 'framing',
+    ...seedPitchFrame([request]),
+    request_ids: [request.id],
   })
 
   revalidatePath(`/${orgSlug ?? 'me'}/product`)
-  return { shapeId: result.id }
+  return { pitchId: result.id }
 }
diff --git a/src/app/[slug]/product/page.test.ts b/src/app/[slug]/product/page.test.ts
index 963dca7..0f3c9fa 100644
--- a/src/app/[slug]/product/page.test.ts
+++ b/src/app/[slug]/product/page.test.ts
@@ -87,7 +87,7 @@ describe('ProductMapPage', () => {
     ])
     vi.mocked(getCycleStorage).mockResolvedValueOnce({
       pitches: [
-        { id: 'p1', title: 'Fix imports', stage: 'building', request_id: 'f1' },
+        { id: 'p1', title: 'Fix imports', stage: 'building', request_ids: ['f1'] },
         { id: 'p2', title: 'No request here', stage: 'building' },
       ],
     } as never)
diff --git a/src/app/[slug]/product/product-map.tsx b/src/app/[slug]/product/product-map.tsx
index 1b99048..92396e6 100644
--- a/src/app/[slug]/product/product-map.tsx
+++ b/src/app/[slug]/product/product-map.tsx
@@ -36,6 +36,7 @@ import {
   storeRelated,
   isMemberId,
   renderProductMap,
+  isUpcomingCycle,
   type CycleWindow,
   type RequestState,
   type LinkedShape,
@@ -47,7 +48,7 @@ import {
 } from '@/lib/product-map-engine'
 import { getTeamToday } from '@/lib/team-time'
 import type { OrganizationUser } from '@/lib/users'
-import { betOnRequest } from './actions'
+import { pitchRequest } from './actions'
 import { KIND_LABELS, STATE_LABELS, TYPE_LABELS } from '@/components/product-map/labels'
 import { KIND_ICONS, TYPE_ICONS } from '@/components/product-map/request-icons'
 import { ExternalLink, Pencil, Plus, Trash2, X, type LucideIcon } from 'lucide-react'
@@ -924,13 +925,15 @@ function Resolve({ pin, onClose }: { pin: RenderedPin; onClose: () => void }) {
 }
 
 /**
- * Every shape that attacked this request, with its cycle, plus the way to bet on
+ * Every pitch that carried this request, with its cycle, plus the way to pitch
  * it. A request outlives the work done against it, so the same problem can be
- * attacked again years later and both bets stay visible. The list is read from
- * the cycle rooms and never stored on the request (ADR 0022).
+ * attacked again years later and both pitches stay visible. The list is read
+ * from the cycle rooms and never stored on the request (ADR 0022).
  */
 function Shapes({ pin }: { pin: RenderedPin }) {
-  const cycles = useContext(CyclesContext)
+  // A new pitch waits for the betting table in a cycle that has not started.
+  const today = getTeamToday(new Date())
+  const cycles = useContext(CyclesContext).filter((cycle) => isUpcomingCycle(cycle, today))
   const [cycleSlug, setCycleSlug] = useState('')
   const [error, setError] = useState('')
   const [betting, setBetting] = useState(false)
@@ -939,7 +942,7 @@ function Shapes({ pin }: { pin: RenderedPin }) {
     setBetting(true)
     setError('')
     try {
-      await betOnRequest({ requestId: pin.requestId, cycleSlug, title: pin.problem })
+      await pitchRequest({ requestId: pin.requestId, cycleSlug, title: pin.problem })
     } catch (err) {
       setError((err as Error).message)
     } finally {
@@ -949,7 +952,7 @@ function Shapes({ pin }: { pin: RenderedPin }) {
 
   return (
     <div className="flex flex-col gap-2">
-      <Label>Bets on this request ({pin.shapes.length})</Label>
+      <Label>Pitches for this request ({pin.shapes.length})</Label>
       <ul className="flex flex-col gap-1">
         {pin.shapes.map((shape) => (
           <li key={shape.shapeId} className="text-sm">
@@ -960,14 +963,14 @@ function Shapes({ pin }: { pin: RenderedPin }) {
           </li>
         ))}
       </ul>
-      {/* Only a sharp request can be bet on, so a rough one is offered no bet at
-          all. The action re-checks server-side: this is the courtesy, not the
-          rule. */}
+      {/* Only a sharp request can be pitched, so a rough one is offered no pitch
+          at all. The action re-checks server-side: this is the courtesy, not
+          the rule. */}
       {pin.sharp && cycles.length > 0 && (
         <div className="flex items-center gap-2">
           <Select value={cycleSlug} onValueChange={setCycleSlug}>
-            <SelectTrigger className="h-8 flex-1" aria-label="Bet into cycle">
-              <SelectValue placeholder="Bet into a cycle…" />
+            <SelectTrigger className="h-8 flex-1" aria-label="Pitch into cycle">
+              <SelectValue placeholder="Pitch into an upcoming cycle…" />
             </SelectTrigger>
             <SelectContent>
               {cycles.map((cycle) => (
@@ -984,14 +987,19 @@ function Shapes({ pin }: { pin: RenderedPin }) {
             disabled={!cycleSlug || betting}
             onClick={bet}
           >
-            Bet
+            Pitch
           </Button>
         </div>
       )}
+      {pin.sharp && cycles.length === 0 && (
+        <p className="text-xs text-muted-foreground">
+          No upcoming cycle yet. Create the next cycle, then pitch this request into it.
+        </p>
+      )}
       {!pin.sharp && (
         <p className="text-xs text-muted-foreground">
-          Give this request an appetite before betting on it. Nobody bets on half a
-          request.
+          Give this request an appetite and an outcome before you pitch it. Nobody
+          pitches half a request.
         </p>
       )}
       {error && <p className="text-xs text-destructive">{error}</p>}
diff --git a/src/app/[slug]/product/requests/[requestId]/request-page.tsx b/src/app/[slug]/product/requests/[requestId]/request-page.tsx
index 91acb54..86a92ff 100644
--- a/src/app/[slug]/product/requests/[requestId]/request-page.tsx
+++ b/src/app/[slug]/product/requests/[requestId]/request-page.tsx
@@ -260,7 +260,7 @@ function Track({ pin }: { pin: RenderedPin }) {
   const at = REQUEST_STATES.indexOf(pin.state)
   const current = pin.shapes.find((s) => s.stage !== 'done')
   return (
-    <ol className="grid grid-cols-6 gap-1" aria-label="Request state">
+    <ol className="grid grid-cols-7 gap-1" aria-label="Request state">
       {REQUEST_STATES.map((state, i) => (
         <li
           key={state}
@@ -275,7 +275,7 @@ function Track({ pin }: { pin: RenderedPin }) {
           >
             {i < at && <Check className="h-3 w-3" />}
             {STATE_LABELS[state]}
-            {i === at && state === 'in_flight' && current && ` · ${current.cycleTitle}`}
+            {i === at && (state === 'in_flight' || state === 'pitched') && current && ` · ${current.cycleTitle}`}
           </span>
         </li>
       ))}
@@ -366,7 +366,11 @@ const SHIPPED: RequestState[] = ['released', 'monitoring', 'resolved']
  * means before anybody builds anything.
  */
 function Announcement({ pin, onWrite }: { pin: RenderedPin; onWrite?: () => void }) {
-  if (!pin.announcement) {
+  // Once a pitch ships, its release summary is what went out. Until then the
+  // request's own draft is all there is (ADR 0032).
+  const shipped = pin.shapes.find((s) => s.stage === 'done' && s.releaseSummary)?.releaseSummary
+  const text = shipped ?? pin.announcement
+  if (!text) {
     return (
       <div className="flex flex-wrap items-center gap-3 rounded-xl border border-dashed p-4 text-sm text-muted-foreground">
         <Megaphone className="h-5 w-5 shrink-0" />
@@ -398,7 +402,7 @@ function Announcement({ pin, onWrite }: { pin: RenderedPin; onWrite?: () => void
         )}
       </div>
       <Markdown breaks className="max-w-3xl text-base leading-relaxed">
-        {pin.announcement}
+        {text}
       </Markdown>
     </section>
   )
diff --git a/src/app/e2e/product-map/fixture.ts b/src/app/e2e/product-map/fixture.ts
index a43e7ed..9082d25 100644
--- a/src/app/e2e/product-map/fixture.ts
+++ b/src/app/e2e/product-map/fixture.ts
@@ -191,6 +191,7 @@ export const SHAPES: LinkedShape[] = [
     cycleSlug: 'c3',
     cycleTitle: 'Cycle 3',
     currentCycle: true,
+    upcomingCycle: false,
   },
   {
     requestId: 'f9',
@@ -200,6 +201,7 @@ export const SHAPES: LinkedShape[] = [
     cycleSlug: 'c3',
     cycleTitle: 'Cycle 3',
     currentCycle: false,
+    upcomingCycle: false,
   },
 ]
 
diff --git a/src/app/e2e/scope-map/fixture.ts b/src/app/e2e/scope-map/fixture.ts
index f5c451a..9102040 100644
--- a/src/app/e2e/scope-map/fixture.ts
+++ b/src/app/e2e/scope-map/fixture.ts
@@ -37,8 +37,12 @@ export const FIXTURE: Omit<
     needle: { progress: 0.65, zone: 'on_track' },
     frame_problem:
       'Teams lack visibility into cycle progress. Weekly check-ins are meetings, not artifacts. No shared surface for tracking how pitches are going.',
-    frame_outcome:
-      'A self-updating dashboard where leadership and ICs see every pitch needle, hill chart, and scope status at a glance — no meetings needed.',
+    frame_outcomes: [
+      {
+        id: 'o1',
+        text: 'A self-updating dashboard where leadership and ICs see every pitch needle, hill chart, and scope status at a glance — no meetings needed.',
+      },
+    ],
     timebox_start: '2026-05-26',
     timebox_end: '2026-07-03',
     emoji: '🚀',
diff --git a/src/components/command-palette/command-palette.tsx b/src/components/command-palette/command-palette.tsx
index 778cdfb..eaa2e47 100644
--- a/src/components/command-palette/command-palette.tsx
+++ b/src/components/command-palette/command-palette.tsx
@@ -17,6 +17,7 @@ import { useCommandPalette } from './command-palette-context'
 import type { PaletteCycleItem } from './types'
 
 const STAGE_BADGE_STYLES: Record<Stage, string> = {
+  framing: 'bg-muted text-muted-foreground',
   shaping:
     'bg-yellow-100 text-yellow-800 dark:bg-yellow-900/30 dark:text-yellow-300',
   building:
diff --git a/src/components/mission-control/pitch-timeline.tsx b/src/components/mission-control/pitch-timeline.tsx
index beedd2c..a39f736 100644
--- a/src/components/mission-control/pitch-timeline.tsx
+++ b/src/components/mission-control/pitch-timeline.tsx
@@ -14,6 +14,7 @@ import type { Stage } from '@/cycle-liveblocks.config'
 export const TIMELINE_GRID = 'flex flex-col gap-2'
 
 const STAGE_DOT: Record<Stage, string> = {
+  framing: 'bg-muted-foreground',
   shaping: 'bg-blue-400',
   building: 'bg-amber-400',
   done: 'bg-emerald-500',
diff --git a/src/components/product-map/labels.ts b/src/components/product-map/labels.ts
index ad18439..a7aa614 100644
--- a/src/components/product-map/labels.ts
+++ b/src/components/product-map/labels.ts
@@ -22,6 +22,7 @@ export const TYPE_LABELS: Record<RequestType, string> = {
 export const STATE_LABELS: Record<RequestState, string> = {
   rough: 'Rough',
   candidate: 'Candidate',
+  pitched: 'Pitched',
   in_flight: 'In flight',
   released: 'Released',
   monitoring: 'Monitoring',
diff --git a/src/components/scope-map/scope-map-view.tsx b/src/components/scope-map/scope-map-view.tsx
index 0c17ad1..7f5f269 100644
--- a/src/components/scope-map/scope-map-view.tsx
+++ b/src/components/scope-map/scope-map-view.tsx
@@ -73,7 +73,9 @@ export type ScopeMapViewProps = {
     stage: Stage
     needle: Needle | null
     frame_problem: string
-    frame_outcome: string
+    frame_outcomes?: { id: string; text: string }[]
+    release_summary?: string
+    release_note_url?: string
     timebox_start: string
     timebox_end: string
     emoji: string
@@ -673,7 +675,9 @@ function HeroCard({
     title: string
     stage: Stage
     frame_problem: string
-    frame_outcome: string
+    frame_outcomes?: { id: string; text: string }[]
+    release_summary?: string
+    release_note_url?: string
     timebox_start: string
     timebox_end: string
     emoji: string
@@ -716,7 +720,7 @@ function HeroCard({
       ro.disconnect()
       cancelAnimationFrame(raf)
     }
-  }, [pitch.title, pitch.frame_problem, pitch.frame_outcome])
+  }, [pitch.title, pitch.frame_problem, pitch.frame_outcomes, pitch.release_summary])
 
   const collapsed = overflowing && !expanded
 
@@ -781,11 +785,30 @@ function HeroCard({
           </div>
           <div>
             <h3 className="text-xs font-medium uppercase tracking-wide text-muted-foreground mb-2">
-              Outcome
+              Outcomes
             </h3>
-            <FramingList text={pitch.frame_outcome} />
+            <FramingList text={(pitch.frame_outcomes ?? []).map((o) => o.text).join('\n')} />
           </div>
         </div>
+
+        {(pitch.release_summary || pitch.release_note_url) && (
+          <div>
+            <h3 className="text-xs font-medium uppercase tracking-wide text-muted-foreground mb-2">
+              Release
+            </h3>
+            {pitch.release_summary && <p className="text-sm">{pitch.release_summary}</p>}
+            {pitch.release_note_url && (
+              <a
+                href={pitch.release_note_url}
+                target="_blank"
+                rel="noopener noreferrer"
+                className="text-sm text-muted-foreground underline underline-offset-2 hover:text-foreground"
+              >
+                Full release note
+              </a>
+            )}
+          </div>
+        )}
       </div>
 
       {/* Fade + toggle when the framing exceeds the fixed height */}
diff --git a/src/components/scope-map/stage-badge.test.tsx b/src/components/scope-map/stage-badge.test.tsx
index 9e8f548..906abdd 100644
--- a/src/components/scope-map/stage-badge.test.tsx
+++ b/src/components/scope-map/stage-badge.test.tsx
@@ -29,8 +29,8 @@ describe('StageBadge', () => {
     expect(screen.queryByLabelText(/Advance to/)).toBeNull()
   })
 
-  it('offers no back arrow while still shaping', () => {
-    render(<StageBadge stage="shaping" onChange={vi.fn()} />)
+  it('offers no back arrow while still framing', () => {
+    render(<StageBadge stage="framing" onChange={vi.fn()} />)
     expect(screen.queryByLabelText(/Move back to/)).toBeNull()
   })
 })
diff --git a/src/cycle-liveblocks.config.ts b/src/cycle-liveblocks.config.ts
index 2927b68..b72ca2b 100644
--- a/src/cycle-liveblocks.config.ts
+++ b/src/cycle-liveblocks.config.ts
@@ -2,7 +2,7 @@ import { LiveList, LiveObject } from '@liveblocks/client'
 
 export type Zone = 'on_track' | 'some_risk' | 'concerned'
 
-export type Stage = 'shaping' | 'building' | 'done'
+export type Stage = 'framing' | 'shaping' | 'building' | 'done'
 
 export type Tier = 'must' | 'should' | 'could'
 
@@ -48,13 +48,23 @@ export type CyclePitch = {
    * a past cycle always shows what the team actually committed to (ADR 0022).
    */
   frame_problem: string
-  frame_outcome: string
   /**
-   * The Request on the Product Map this shape attacks (ADR 0022). Undefined on a
-   * shape created with no request, and on every shape written before the Product
-   * Map existed. Editing this shape never writes back to the map.
+   * What the pitch must make true, one item each. Copied from its requests when
+   * the pitch is created, then owned by the pitch (ADR 0032). Absent on a pitch
+   * written before outcomes moved here.
    */
-  request_id?: string
+  frame_outcomes?: { id: string; text: string }[]
+  /** The time the business will spend, copied from the largest request appetite. */
+  frame_appetite?: string
+  /** Two or three sentences, in the customer's words: what changes for them. */
+  release_summary?: string
+  /** The full release note, in Notion. */
+  release_note_url?: string
+  /**
+   * The Requests on the Product Map this pitch carries (ADR 0032). Absent on a
+   * pitch created with no request. Editing the pitch never writes back to the map.
+   */
+  request_ids?: string[]
   timebox_start: string
   timebox_end: string
   /** Identity emoji (single grapheme), or '' when unset. */
diff --git a/src/lib/mcp/liveblocks-reader.test.ts b/src/lib/mcp/liveblocks-reader.test.ts
index 9d78f8d..cfecb7d 100644
--- a/src/lib/mcp/liveblocks-reader.test.ts
+++ b/src/lib/mcp/liveblocks-reader.test.ts
@@ -93,8 +93,8 @@ describe('resolvePitch', () => {
   const storage = {
     cycle: { name: 'Q2', type: 'build' as const, start_date: '', end_date: '' },
     pitches: [
-      { id: 'p1', title: 'Mission Control', stage: 'building' as const, needle: null, frame_problem: '', frame_outcome: '', timebox_start: '', timebox_end: '', emoji: '', notion_url: '' },
-      { id: 'p2', title: 'Agentic Skills', stage: 'shaping' as const, needle: null, frame_problem: '', frame_outcome: '', timebox_start: '', timebox_end: '', emoji: '', notion_url: '' },
+      { id: 'p1', title: 'Mission Control', stage: 'building' as const, needle: null, frame_problem: '', timebox_start: '', timebox_end: '', emoji: '', notion_url: '' },
+      { id: 'p2', title: 'Agentic Skills', stage: 'shaping' as const, needle: null, frame_problem: '', timebox_start: '', timebox_end: '', emoji: '', notion_url: '' },
     ],
     scopes: [],
     tasks: [],
@@ -114,14 +114,21 @@ describe('resolvePitch', () => {
     expect(resolvePitch(storage, 'no-such-pitch')).toBeUndefined()
   })
 
-  // ADR 0023: rooms written before the stage change still hold `framing`.
-  // Nothing rewrites them, so the read surface normalizes on the way out.
-  it('reads a stored framing stage as shaping', () => {
-    const legacy = {
+  // ADR 0032: framing returned to the pitch, so a stored `framing` stage reads as is.
+  it('reads a stored framing stage as framing', () => {
+    const framing = {
       ...storage,
       pitches: [{ ...storage.pitches[0], stage: 'framing' }],
     } as unknown as typeof storage
-    expect(resolvePitch(legacy, 'p1')?.stage).toBe('shaping')
+    expect(resolvePitch(framing, 'p1')?.stage).toBe('framing')
+  })
+
+  it('reads an unknown stored stage as shaping', () => {
+    const unknown = {
+      ...storage,
+      pitches: [{ ...storage.pitches[0], stage: 'pondering' }],
+    } as unknown as typeof storage
+    expect(resolvePitch(unknown, 'p1')?.stage).toBe('shaping')
   })
 
   it('resolves a title with special characters via its cleaned slug', () => {
@@ -129,7 +136,7 @@ describe('resolvePitch', () => {
       ...storage,
       pitches: [
         ...storage.pitches,
-        { id: 'p3', title: 'Agentic Capabilities (Skills & Tools)', stage: 'building' as const, needle: null, frame_problem: '', frame_outcome: '', timebox_start: '', timebox_end: '', emoji: '', notion_url: '' },
+        { id: 'p3', title: 'Agentic Capabilities (Skills & Tools)', stage: 'building' as const, needle: null, frame_problem: '', timebox_start: '', timebox_end: '', emoji: '', notion_url: '' },
       ],
     }
     expect(
diff --git a/src/lib/mcp/liveblocks-writer.test.ts b/src/lib/mcp/liveblocks-writer.test.ts
index 6ac176a..042f1f5 100644
--- a/src/lib/mcp/liveblocks-writer.test.ts
+++ b/src/lib/mcp/liveblocks-writer.test.ts
@@ -365,7 +365,7 @@ describe('upsertPitch', () => {
       title: 'Mission Control',
       stage: 'shaping',
       frame_problem: 'No visibility',
-      frame_outcome: 'Dashboard',
+      frame_outcomes: [{ id: 'o1', text: 'Dashboard' }],
       timebox_start: '2026-04-06',
       timebox_end: '2026-05-15',
       emoji: '',
@@ -389,7 +389,7 @@ describe('upsertPitch', () => {
       title: 'New Title',
       stage: 'building',
       frame_problem: 'Updated',
-      frame_outcome: 'Updated',
+      frame_outcomes: [{ id: 'o1', text: 'Updated' }],
       timebox_start: '2026-04-06',
       timebox_end: '2026-05-15',
       emoji: '',
@@ -410,7 +410,7 @@ describe('upsertPitch', () => {
       title: 'Mission Control',
       stage: 'building',
       frame_problem: 'No visibility',
-      frame_outcome: 'Dashboard',
+      frame_outcomes: [{ id: 'o1', text: 'Dashboard' }],
       timebox_start: '2026-04-06',
       timebox_end: '2026-05-15',
       emoji: '🚀',
@@ -424,7 +424,7 @@ describe('upsertPitch', () => {
     expect(existing.get('timebox_start')).toBe('2026-04-06')
     expect(existing.get('timebox_end')).toBe('2026-05-15')
     expect(existing.get('frame_problem')).toBe('No visibility')
-    expect(existing.get('frame_outcome')).toBe('Dashboard')
+    expect(existing.get('frame_outcomes')).toEqual([{ id: 'o1', text: 'Dashboard' }])
     expect(existing.get('emoji')).toBe('🚀')
     expect(existing.get('notion_url')).toBe('https://notion.so/x')
   })
@@ -438,7 +438,7 @@ describe('upsertPitch', () => {
         title: 'X',
         stage: 'shaping',
         frame_problem: '',
-        frame_outcome: '',
+       
         timebox_start: '',
         timebox_end: '',
         emoji: '',
@@ -1360,7 +1360,7 @@ describe('upsertPitch squad assignment', () => {
     title: 'Mission Control',
     stage: 'shaping' as const,
     frame_problem: '',
-    frame_outcome: '',
+   
     timebox_start: '',
     timebox_end: '',
     emoji: '',
@@ -2466,53 +2466,97 @@ describe('writeBrief', () => {
   })
 })
 
-describe('upsertPitch request pointer', () => {
+describe('upsertPitch requests and frame', () => {
   beforeEach(() => vi.clearAllMocks())
 
   const ROOM = 'org_1:cycle:2026-q3'
+  const OUTCOMES = [{ id: 'o1', text: 'A year of data exports' }]
 
-  it('stores the request the shape attacks', async () => {
+  it('stores the requests the pitch carries and its frame', async () => {
     const storage = setupStorage()
 
     await upsertPitch(ROOM, {
-      title: 'Fix silent imports',
-      stage: 'shaping',
-      frame_problem: 'Imports fail silently',
-      request_id: 'f1',
+      title: 'Fast exports',
+      stage: 'framing',
+      frame_problem: 'Exports time out',
+      frame_outcomes: OUTCOMES,
+      frame_appetite: '6 weeks',
+      release_summary: 'Exports now finish, whatever their size.',
+      release_note_url: 'https://www.notion.so/release',
+      request_ids: ['f1', 'f2'],
     })
 
     const pitch = storage.pitches.find(() => true)!
-    expect(pitch.get('request_id')).toBe('f1')
-    // The Frame as bet: a copy taken now, which the Product Map can never rewrite.
-    expect(pitch.get('frame_problem')).toBe('Imports fail silently')
+    expect(pitch.get('request_ids')).toEqual(['f1', 'f2'])
+    expect(pitch.get('stage')).toBe('framing')
+    expect(pitch.get('frame_problem')).toBe('Exports time out')
+    expect(pitch.get('frame_outcomes')).toEqual(OUTCOMES)
+    expect(pitch.get('frame_appetite')).toBe('6 weeks')
+    expect(pitch.get('release_summary')).toBe('Exports now finish, whatever their size.')
+    expect(pitch.get('release_note_url')).toBe('https://www.notion.so/release')
   })
 
-  it('leaves a shape created with no request without one', async () => {
+  it('leaves a pitch created with no request without one', async () => {
     const storage = setupStorage()
 
     await upsertPitch(ROOM, { title: 'Cooldown chores', stage: 'building' })
 
-    expect(storage.pitches.find(() => true)!.get('request_id')).toBeUndefined()
+    expect(storage.pitches.find(() => true)!.get('request_ids')).toBeUndefined()
   })
 
-  it('leaves the request pointer alone when the caller omits it (ADR 0011)', async () => {
+  it('leaves the requests and the frame alone when the caller omits them (ADR 0011)', async () => {
     const storage = setupStorage({
-      pitches: [makeMockItem({ id: 'p1', title: 'Old', stage: 'building', request_id: 'f1' })],
+      pitches: [
+        makeMockItem({
+          id: 'p1',
+          title: 'Old',
+          stage: 'framing',
+          request_ids: ['f1'],
+          frame_outcomes: OUTCOMES,
+          frame_appetite: '6 weeks',
+          release_summary: 'Summary',
+          release_note_url: 'https://www.notion.so/release',
+        }),
+      ],
     })
 
-    await upsertPitch(ROOM, { id: 'p1', title: 'Renamed', stage: 'building' })
+    await upsertPitch(ROOM, { id: 'p1', title: 'Renamed', stage: 'shaping' })
 
-    expect(storage.pitches.find(() => true)!.get('request_id')).toBe('f1')
+    const pitch = storage.pitches.find(() => true)!
+    expect(pitch.get('request_ids')).toEqual(['f1'])
+    expect(pitch.get('frame_outcomes')).toEqual(OUTCOMES)
+    expect(pitch.get('frame_appetite')).toBe('6 weeks')
+    expect(pitch.get('release_summary')).toBe('Summary')
+    expect(pitch.get('release_note_url')).toBe('https://www.notion.so/release')
   })
 
-  it('clears the request pointer on an empty string', async () => {
+  it('clears the requests on an empty list, and the text fields on an empty string', async () => {
     const storage = setupStorage({
-      pitches: [makeMockItem({ id: 'p1', title: 'Old', stage: 'building', request_id: 'f1' })],
+      pitches: [
+        makeMockItem({
+          id: 'p1',
+          title: 'Old',
+          stage: 'framing',
+          request_ids: ['f1'],
+          frame_appetite: '6 weeks',
+          release_note_url: 'https://www.notion.so/release',
+        }),
+      ],
     })
 
-    await upsertPitch(ROOM, { id: 'p1', title: 'Old', stage: 'building', request_id: '' })
+    await upsertPitch(ROOM, {
+      id: 'p1',
+      title: 'Old',
+      stage: 'framing',
+      request_ids: [],
+      frame_appetite: '',
+      release_note_url: '',
+    })
 
-    expect(storage.pitches.find(() => true)!.get('request_id')).toBeUndefined()
+    const pitch = storage.pitches.find(() => true)!
+    expect(pitch.get('request_ids')).toBeUndefined()
+    expect(pitch.get('frame_appetite')).toBe('')
+    expect(pitch.get('release_note_url')).toBe('')
   })
 })
 
diff --git a/src/lib/mcp/liveblocks-writer.ts b/src/lib/mcp/liveblocks-writer.ts
index e40c4d1..4a8721b 100644
--- a/src/lib/mcp/liveblocks-writer.ts
+++ b/src/lib/mcp/liveblocks-writer.ts
@@ -242,7 +242,10 @@ export async function upsertPitch(
     // to '' (on create). NEVER coerce an omitted field to '' before this point —
     // doing so silently wipes it on update (the timebox-nullification incident).
     frame_problem?: string
-    frame_outcome?: string
+    frame_outcomes?: { id: string; text: string }[]
+    frame_appetite?: string
+    release_summary?: string
+    release_note_url?: string
     timebox_start?: string
     timebox_end?: string
     emoji?: string
@@ -252,10 +255,10 @@ export async function upsertPitch(
     squad?: string
     // Pitch view (see ADR 0018). undefined = leave unchanged / default on create.
     view?: 'scope_map' | 'kanban'
-    // The Request on the Product Map this shape attacks (ADR 0022). '' clears it.
-    // Writing it never touches the request: the shape points at the request, not
-    // the reverse.
-    request_id?: string
+    // The Requests on the Product Map this pitch carries (ADR 0032). [] clears
+    // them. Writing them never touches a request: the pitch points at its
+    // requests, not the reverse.
+    request_ids?: string[]
   },
   injectedRoot?: any
 ): Promise<UpsertResult> {
@@ -283,14 +286,17 @@ export async function upsertPitch(
         stage: params.stage as CyclePitch['stage'],
         needle: null,
         frame_problem: params.frame_problem ?? '',
-        frame_outcome: params.frame_outcome ?? '',
+        ...(params.frame_outcomes ? { frame_outcomes: params.frame_outcomes } : {}),
+        ...(params.frame_appetite ? { frame_appetite: params.frame_appetite } : {}),
+        ...(params.release_summary ? { release_summary: params.release_summary } : {}),
+        ...(params.release_note_url ? { release_note_url: params.release_note_url } : {}),
         timebox_start: params.timebox_start ?? '',
         timebox_end: params.timebox_end ?? '',
         emoji: params.emoji ?? '',
         notion_url: params.notion_url ?? '',
         ...(squadId ? { squadId } : {}),
         ...(params.view ? { view: params.view } : {}),
-        ...(params.request_id ? { request_id: params.request_id } : {}),
+        ...(params.request_ids?.length ? { request_ids: params.request_ids } : {}),
       }
       pitches.push(new LiveObject(pitch))
     } else {
@@ -305,13 +311,19 @@ export async function upsertPitch(
       // Liveblocks treating set(undefined) as a no-op) makes the contract explicit
       // and matches the squad handling below.
       if (params.frame_problem !== undefined) existing.set('frame_problem', params.frame_problem)
-      if (params.frame_outcome !== undefined) existing.set('frame_outcome', params.frame_outcome)
+      if (params.frame_outcomes !== undefined) existing.set('frame_outcomes', params.frame_outcomes)
+      if (params.frame_appetite !== undefined) existing.set('frame_appetite', params.frame_appetite)
+      if (params.release_summary !== undefined) existing.set('release_summary', params.release_summary)
+      if (params.release_note_url !== undefined) existing.set('release_note_url', params.release_note_url)
       if (params.timebox_start !== undefined) existing.set('timebox_start', params.timebox_start)
       if (params.timebox_end !== undefined) existing.set('timebox_end', params.timebox_end)
       if (params.emoji !== undefined) existing.set('emoji', params.emoji)
       if (params.notion_url !== undefined) existing.set('notion_url', params.notion_url)
       if (params.view !== undefined) existing.set('view', params.view)
-      setOrClear(existing, 'request_id', params.request_id)
+      if (params.request_ids !== undefined) {
+        if (params.request_ids.length) existing.set('request_ids', params.request_ids)
+        else existing.delete('request_ids')
+      }
       // squadId: null = clear (remove key), string = assign, undefined = leave.
       if (squadId === null) existing.delete('squadId')
       else if (squadId !== undefined) existing.set('squadId', squadId)
@@ -1753,7 +1765,7 @@ export async function resolveRequest(
  * Product Map: that is resolveRequest, which keeps the record (ADR 0026).
  *
  * Any request that named this one as its origin loses that pointer. Only this
- * room is cleaned: a Shape's `request_id` lives in a cycle room and can be left
+ * room is cleaned: a pitch's `request_ids` live in a cycle room and can be left
  * pointing at a request that is gone (ADR 0026, open question 2).
  */
 export async function deleteRequest(roomId: string, id: string): Promise<void> {
diff --git a/src/lib/mcp/tools.test.ts b/src/lib/mcp/tools.test.ts
index 9eab4dd..fdd779a 100644
--- a/src/lib/mcp/tools.test.ts
+++ b/src/lib/mcp/tools.test.ts
@@ -86,8 +86,8 @@ const ORG_ID = 'org_test'
 const FIXTURE_STORAGE: StorageJson = {
   cycle: { name: 'Q2 Build', type: 'build', start_date: '2026-04-06', end_date: '2026-05-15' },
   pitches: [
-    { id: 'p1', title: 'Mission Control', stage: 'building', needle: { progress: 0.6, zone: 'on_track' }, frame_problem: 'No visibility', frame_outcome: 'Dashboard', timebox_start: '2026-04-06', timebox_end: '2026-05-15', emoji: '', notion_url: '', squadId: 'sq1' },
-    { id: 'p2', title: 'MCP Server', stage: 'shaping', needle: null, frame_problem: '', frame_outcome: '', timebox_start: '2026-04-06', timebox_end: '2026-05-15', emoji: '', notion_url: '' },
+    { id: 'p1', title: 'Mission Control', stage: 'building', needle: { progress: 0.6, zone: 'on_track' }, frame_problem: 'No visibility', frame_outcomes: [{ id: 'o1', text: 'Dashboard' }], timebox_start: '2026-04-06', timebox_end: '2026-05-15', emoji: '', notion_url: '', squadId: 'sq1' },
+    { id: 'p2', title: 'MCP Server', stage: 'shaping', needle: null, frame_problem: '', timebox_start: '2026-04-06', timebox_end: '2026-05-15', emoji: '', notion_url: '' },
   ],
   squads: [{ id: 'sq1', name: 'Platform', color: '#3e63dd' }],
   scopes: [
@@ -532,7 +532,7 @@ describe('handleBatch', () => {
           title: 'New Pitch',
           stage: 'shaping',
           frame_problem: '',
-          frame_outcome: '',
+         
           timebox_start: '2026-04-06',
           timebox_end: '2026-05-15',
         },
@@ -632,7 +632,7 @@ describe('handleBatch', () => {
           title: 'Good Pitch',
           stage: 'shaping',
           frame_problem: '',
-          frame_outcome: '',
+         
           timebox_start: '',
           timebox_end: '',
         },
@@ -722,15 +722,20 @@ describe('handleBatch', () => {
     expect(mockUpsertTask).toHaveBeenCalledTimes(1)
   })
 
-  it('normalizes a legacy framing stage in a batched upsert_pitch', async () => {
-    // The batch path skips the tool's zod enum, so without this a caller could
-    // still write the stage ADR 0023 removed.
+  it('keeps the framing stage in a batched upsert_pitch, and normalizes an unknown one', async () => {
+    // The batch path skips the tool's zod enum, so the writer normalizes it.
     mockUpsertPitch.mockResolvedValue({ created: false, id: 'p1' })
 
     await handleBatch(ORG_ID, 'q2-build', [
       { tool: 'upsert_pitch', params: { id: 'p1', title: 'P', stage: 'framing' } },
+      { tool: 'upsert_pitch', params: { id: 'p1', title: 'P', stage: 'pondering' } },
     ])
 
+    expect(mockUpsertPitch).toHaveBeenCalledWith(
+      'org_test:cycle:q2-build',
+      expect.objectContaining({ stage: 'framing' }),
+      expect.anything()
+    )
     expect(mockUpsertPitch).toHaveBeenCalledWith(
       'org_test:cycle:q2-build',
       expect.objectContaining({ stage: 'shaping' }),
@@ -1901,13 +1906,18 @@ describe('upsert_pitch request pointer', () => {
     return captured
   }
 
-  it('takes an optional request_id, so a shape with no request stays valid', () => {
+  it('takes optional request_ids and frame fields, so a pitch with no request stays valid', () => {
     const schema = z.object(schemaFor('upsert_pitch'))
 
-    const base = { cycle_slug: '2026-q3', title: 'x', stage: 'shaping' as const }
+    const base = { cycle_slug: '2026-q3', title: 'x', stage: 'framing' as const }
 
-    expect(schema.parse(base).request_id).toBeUndefined()
-    expect(schema.parse({ ...base, request_id: 'f1' }).request_id).toBe('f1')
+    const bare = schema.parse(base)
+    expect(bare.request_ids).toBeUndefined()
+    expect(bare.frame_outcomes).toBeUndefined()
+    expect(bare.frame_appetite).toBeUndefined()
+    expect(bare.release_summary).toBeUndefined()
+    expect(bare.release_note_url).toBeUndefined()
+    expect(schema.parse({ ...base, request_ids: ['f1', 'f2'] }).request_ids).toEqual(['f1', 'f2'])
   })
 })
 
@@ -1981,3 +1991,147 @@ describe('map_update_report and map_delete_report', () => {
     expect(JSON.parse(result.content[0].text)).toEqual({ deleted: true, requestId: 'f1', reportCount: 3 })
   })
 })
+
+describe('upsert_pitch frames a new pitch from its requests', () => {
+  function handlerFor(toolName: string) {
+    let handler: ((args: any, extra: any) => Promise<{ content: { text: string }[]; isError?: true }>) | undefined
+    registerCyclesTools({
+      tool(name: string, _d: string, _s: unknown, _a: unknown, fn: any) {
+        if (name === toolName) handler = fn
+      },
+    })
+    return handler!
+  }
+
+  const EXTRA = { authInfo: { extra: { memberships: [{ id: 'org_test', slug: 'vasco' }] } } }
+  const mockGetMap = vi.mocked(getProductMapStorage)
+  const mockUpsert = mockUpsertPitch
+  const request = (id: string, overrides: Record<string, unknown> = {}) => ({
+    id,
+    kind: 'pain_point' as const,
+    type: 'ask' as const,
+    problem: `Problem ${id}`,
+    appetite: '2 weeks',
+    business_case: '',
+    reports: [],
+    pointers: [],
+    outcomes: [{ id: `o-${id}`, text: `Outcome ${id}` }],
+    last_woken: '2026-09-01',
+    resolved: false,
+    ...overrides,
+  })
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockUpsert.mockResolvedValue({ created: true, id: 'p1' })
+  })
+
+  it('copies the problems, outcomes, largest appetite and release draft of its requests', async () => {
+    mockGetMap.mockResolvedValue({
+      areas: [],
+      requests: [
+        request('f1', { announcement: 'Exports finish.' }),
+        request('f2', { appetite: '6 weeks' }),
+      ],
+    })
+
+    const res = await handlerFor('upsert_pitch')(
+      { cycle_slug: 'q4-build', title: 'Fast exports', stage: 'framing', request_ids: ['f1', 'f2'] },
+      EXTRA
+    )
+
+    expect(res.isError).toBeUndefined()
+    expect(mockUpsert).toHaveBeenCalledWith(
+      'org_test:cycle:q4-build',
+      expect.objectContaining({
+        request_ids: ['f1', 'f2'],
+        frame_problem: 'Problem f1\nProblem f2',
+        frame_outcomes: [
+          { id: 'o-f1', text: 'Outcome f1' },
+          { id: 'o-f2', text: 'Outcome f2' },
+        ],
+        frame_appetite: '6 weeks',
+        release_summary: 'Exports finish.',
+      })
+    )
+  })
+
+  it('keeps what the caller wrote over the seed', async () => {
+    mockGetMap.mockResolvedValue({ areas: [], requests: [request('f1')] })
+
+    await handlerFor('upsert_pitch')(
+      { cycle_slug: 'q4-build', title: 'T', stage: 'framing', request_ids: ['f1'], frame_problem: 'Reworked' },
+      EXTRA
+    )
+
+    expect(mockUpsert).toHaveBeenCalledWith(
+      'org_test:cycle:q4-build',
+      expect.objectContaining({ frame_problem: 'Reworked', frame_appetite: '2 weeks' })
+    )
+  })
+
+  it('refuses to pitch a rough request, and writes nothing', async () => {
+    mockGetMap.mockResolvedValue({ areas: [], requests: [request('f1', { appetite: '' })] })
+
+    const res = await handlerFor('upsert_pitch')(
+      { cycle_slug: 'q4-build', title: 'T', stage: 'framing', request_ids: ['f1'] },
+      EXTRA
+    )
+
+    expect(res.isError).toBe(true)
+    expect(res.content[0].text).toContain('rough')
+    expect(mockUpsert).not.toHaveBeenCalled()
+  })
+
+  it('refuses a request that is not on the Product Map', async () => {
+    mockGetMap.mockResolvedValue({ areas: [], requests: [] })
+
+    const res = await handlerFor('upsert_pitch')(
+      { cycle_slug: 'q4-build', title: 'T', stage: 'framing', request_ids: ['nope'] },
+      EXTRA
+    )
+
+    expect(res.isError).toBe(true)
+    expect(res.content[0].text).toContain('Request not found: "nope"')
+  })
+
+  it('applies the same check and seed to a pitch created in a batch', async () => {
+    mockGetMap.mockResolvedValue({ areas: [], requests: [request('f1'), request('f2', { appetite: '' })] })
+
+    const result = await handleBatch('org_test', 'q4-build', [
+      { tool: 'upsert_pitch', params: { title: 'Sharp', stage: 'framing', request_ids: ['f1'] } },
+      { tool: 'upsert_pitch', params: { title: 'Rough', stage: 'framing', request_ids: ['f2'] } },
+    ])
+
+    const data = JSON.parse(result.content[0].text) as { results: { ok?: boolean; error?: string }[] }
+    expect(data.results[0].ok).toBe(true)
+    expect(data.results[1].error).toContain('rough')
+    expect(mockUpsert).toHaveBeenCalledTimes(1)
+    expect(mockUpsert.mock.calls[0][1]).toMatchObject({ frame_appetite: '2 weeks', frame_problem: 'Problem f1' })
+  })
+
+  it('refuses an unknown request on an update too', async () => {
+    mockGetMap.mockResolvedValue({ areas: [], requests: [request('f1')] })
+
+    const res = await handlerFor('upsert_pitch')(
+      { cycle_slug: 'q4-build', id: 'p1', title: 'T', stage: 'shaping', request_ids: ['f1', 'typo'] },
+      EXTRA
+    )
+
+    expect(res.isError).toBe(true)
+    expect(res.content[0].text).toContain('Request not found: "typo"')
+    expect(mockUpsert).not.toHaveBeenCalled()
+  })
+
+  it('seeds nothing on an update, because the pitch owns its frame', async () => {
+    mockUpsert.mockResolvedValue({ created: false, id: 'p1' })
+    mockGetMap.mockResolvedValue({ areas: [], requests: [request('f1'), request('f3')] })
+
+    await handlerFor('upsert_pitch')(
+      { cycle_slug: 'q4-build', id: 'p1', title: 'T', stage: 'shaping', request_ids: ['f1', 'f3'] },
+      EXTRA
+    )
+
+    expect(mockUpsert.mock.calls[0][1]).not.toHaveProperty('frame_outcomes')
+  })
+})
diff --git a/src/lib/mcp/tools.ts b/src/lib/mcp/tools.ts
index 5e0e6fe..32f5def 100644
--- a/src/lib/mcp/tools.ts
+++ b/src/lib/mcp/tools.ts
@@ -21,13 +21,15 @@ import { deliverSlackUpdate, isSlackConfigured } from '@/lib/slack-delivery'
 import { getSlackWebhookUrl } from '@/lib/calendar/org-integrations'
 import { diffHillTrail, noChangeStreaks, summarizeMovement } from '@/lib/hill-trail-engine'
 import { resolveOrigin } from './origin'
-import { productMapRoomId } from '@/product-map-liveblocks.config'
+import { productMapRoomId, type ProductRequest } from '@/product-map-liveblocks.config'
 import { getTeamToday } from '@/lib/team-time'
 import {
   REQUEST_KINDS,
   REQUEST_TYPES,
   POINTER_KINDS,
   isDormant,
+  isSharp,
+  seedPitchFrame,
   withReportIds,
 } from '@/lib/product-map-engine'
 import type { Zone, Needle, CardStatus, Stage } from '@/cycle-liveblocks.config'
@@ -538,8 +540,8 @@ function preparePitchParams(params: WriteParams): WriteParams {
   // Only normalize a field that was actually supplied, so an omitted field is
   // never coerced to '' (ADR 0011).
   if (params.emoji !== undefined) prepared.emoji = normalizeEmoji(params.emoji)
-  // The batch path skips this tool's zod enum, so normalize here too: a caller
-  // passing the stage ADR 0023 removed gets `shaping`, never a stored `framing`.
+  // The batch path skips this tool's zod enum, so normalize here too: an
+  // unknown stage reads as `shaping`.
   if (params.stage !== undefined) prepared.stage = readStage(params.stage as string)
   if (params.notion_url !== undefined) {
     const notion = validateNotionUrl(params.notion_url)
@@ -548,12 +550,53 @@ function preparePitchParams(params: WriteParams): WriteParams {
   return prepared
 }
 
+type PitchFrameParams = {
+  id?: string
+  request_ids?: string[]
+  frame_problem?: string
+  frame_outcomes?: { id: string; text: string }[]
+  frame_appetite?: string
+  release_summary?: string
+}
+
+type MapReader = () => Promise<{ requests: ProductRequest[] }>
+
+/**
+ * A pitch carries sharp requests only, on create and on update (ADR 0032). A
+ * NEW pitch also copies its frame from them, and fields the caller wrote win
+ * over that seed. An update seeds nothing, because the pitch owns its frame.
+ */
+async function framePitchFromRequests<T extends PitchFrameParams>(readMap: MapReader, params: T): Promise<T> {
+  if (!params.request_ids?.length) return params
+  const { requests } = await readMap()
+  const carried = params.request_ids.map((id) => {
+    const request = requests.find((r) => r.id === id)
+    if (!request) throw new Error(`Request not found: "${id}"`)
+    if (!isSharp(request)) {
+      throw new Error(
+        `Request "${id}" is rough. A pitch carries sharp requests only: give it a problem, an appetite and an outcome first.`
+      )
+    }
+    return request
+  })
+  if (params.id) return params
+  const seed = seedPitchFrame(carried)
+  return {
+    ...params,
+    frame_problem: params.frame_problem ?? seed.frame_problem,
+    frame_outcomes: params.frame_outcomes ?? seed.frame_outcomes,
+    frame_appetite: params.frame_appetite ?? seed.frame_appetite,
+    release_summary: params.release_summary ?? seed.release_summary,
+  }
+}
+
 async function prepareWriteParams(
   tool: string,
   params: WriteParams,
-  users: UsersProvider
+  users: UsersProvider,
+  readMap: MapReader
 ): Promise<WriteParams> {
-  if (tool === 'upsert_pitch') return preparePitchParams(params)
+  if (tool === 'upsert_pitch') return preparePitchParams(await framePitchFromRequests(readMap, params))
   if (tool === 'upsert_task' && params.assignee !== undefined) {
     const { assignee, ...rest } = params
     return { ...rest, assigneeId: await resolveAssigneeId(assignee, users) }
@@ -625,10 +668,13 @@ export async function handleBatch(
   // so caching only the result would let every op fire its own fetch first.
   let orgUsers: Promise<OrganizationUser[]> | null = null
   const users: UsersProvider = () => (orgUsers ??= getOrganizationUsers(orgId))
+  // Same memo for the Product Map, which every pitch op that carries requests reads.
+  let map: ReturnType<MapReader> | null = null
+  const readMap: MapReader = () => (map ??= getProductMapStorage(orgId))
   const prepared = await Promise.all(
     operations.map(async (op) => {
       try {
-        return { ok: true as const, params: await prepareWriteParams(op.tool, op.params, users) }
+        return { ok: true as const, params: await prepareWriteParams(op.tool, op.params, users, readMap) }
       } catch (err) {
         return { ok: false as const, error: (err as Error).message }
       }
@@ -1351,14 +1397,13 @@ export function registerCyclesTools(server: any): void {
   defineTool(
     server,
     'upsert_pitch',
-    'Create or update a pitch. IMPORTANT: before creating, call get_cycle to check for an existing pitch with the same name — if one exists, pass its id to update it instead of creating a duplicate. Omit id to create (returns generated id). Provide id to update. Updates are PARTIAL: any field you omit (frame_problem, frame_outcome, timebox_start, timebox_end, emoji, notion_url, squad, request_id) is left unchanged — only fields you pass are overwritten. A pitch is a SHAPE: the work. The problem it attacks is a Request on the Product Map — pass "request_id" so the bet points at the problem, and copy the request\'s problem text into "frame_problem".',
+    'Create or update a pitch. IMPORTANT: before creating, call get_cycle to check for an existing pitch with the same name — if one exists, pass its id to update it instead of creating a duplicate. Omit id to create (returns generated id). Provide id to update. Updates are PARTIAL: any field you omit (frame_problem, frame_outcomes, frame_appetite, release_summary, release_note_url, timebox_start, timebox_end, emoji, notion_url, squad, request_ids) is left unchanged — only fields you pass are overwritten. A pitch is the shaped bet. Its FRAME is the problem, reworked, and the outcomes it must reach. Its SHAPE is the scopes. The problems it attacks are Requests on the Product Map: pass "request_ids" when you create a pitch, and the pitch copies their problems, outcomes, largest appetite and release draft into its frame (fields you pass win). Only sharp requests can be pitched. A new pitch belongs in the upcoming cycle at the "framing" stage.',
     {
       ...orgArg,
       ...cycleSlugArg,
       id: z.string().optional().describe('Pitch id. Omit to create.'),
       title: z.string(),
-      // Derived from STAGES so the tool surface cannot drift from the engine
-      // (ADR 0023 removed `framing`, which this now rejects).
+      // Derived from STAGES so the tool surface cannot drift from the engine.
       stage: z.enum(STAGES as [Stage, ...Stage[]]),
       // On update, these are PARTIAL: omit to leave a field unchanged. They must
       // stay optional (not .default('')) — a default would coerce an omitted
@@ -1368,14 +1413,31 @@ export function registerCyclesTools(server: any): void {
         .string()
         .optional()
         .describe(
-          'The Frame as bet: a copy of the request\'s problem text taken when the bet was made. The request on the Product Map keeps changing; this copy never does, so a past cycle always shows what was committed to.'
+          'The full problem of the pitch\'s frame, reworked from its requests with research. Copied from the request summaries on create when omitted. Editing it never writes back to the Product Map.'
         ),
-      frame_outcome: z.string().optional(),
-      request_id: z
+      frame_outcomes: z
+        .array(z.object({ id: z.string(), text: z.string() }))
+        .optional()
+        .describe(
+          'What the pitch must make true, one observable change per item. Passing this REPLACES the list. Copied from the requests on create when omitted.'
+        ),
+      frame_appetite: z
+        .string()
+        .optional()
+        .describe('The time the business will spend, for example "6 weeks". Copied from the largest request appetite on create when omitted.'),
+      release_summary: z
+        .string()
+        .optional()
+        .describe('Two or three sentences in the customer\'s words: what changes for them. Pass "" to clear.'),
+      release_note_url: z
         .string()
         .optional()
+        .describe('Link to the full release note in Notion. Pass "" to clear.'),
+      request_ids: z
+        .array(z.string())
+        .optional()
         .describe(
-          'The Request on the Product Map this shape attacks (map_list_requests names them). Only a SHARP request — one with both a problem and an appetite — should be bet on. Editing this shape never writes back to the Product Map. Pass "" to clear.'
+          'The Requests on the Product Map this pitch carries (map_list_requests names them). Every one must be SHARP. Passing this REPLACES the list; pass [] to clear. Editing the pitch never writes back to the Product Map.'
         ),
       timebox_start: z.string().optional(),
       timebox_end: z.string().optional(),
@@ -1410,7 +1472,7 @@ export function registerCyclesTools(server: any): void {
       openWorldHint: false,
     },
     async (
-      { org, cycle_slug, ...params }: { org?: string; cycle_slug: string; id?: string; title: string; stage: string; frame_problem?: string; frame_outcome?: string; request_id?: string; timebox_start?: string; timebox_end?: string; emoji?: string; notion_url?: string; squad?: string; view?: 'scope_map' | 'kanban' },
+      { org, cycle_slug, ...params }: { org?: string; cycle_slug: string; id?: string; title: string; stage: string; frame_problem?: string; frame_outcomes?: { id: string; text: string }[]; frame_appetite?: string; release_summary?: string; release_note_url?: string; request_ids?: string[]; timebox_start?: string; timebox_end?: string; emoji?: string; notion_url?: string; squad?: string; view?: 'scope_map' | 'kanban' },
       extra: ToolExtra
     ) => {
       const memberships = getMemberships(extra)
@@ -1420,7 +1482,8 @@ export function registerCyclesTools(server: any): void {
       try {
         // Same normalization the batch path applies — one implementation, so the
         // two entry points can't drift.
-        const result = await upsertPitch(roomId, preparePitchParams(params) as typeof params)
+        const seeded = await framePitchFromRequests(() => getProductMapStorage(resolved.org.id), params)
+        const result = await upsertPitch(roomId, preparePitchParams(seeded) as typeof params)
         return jsonResult(result)
       } catch (err) {
         return errorResult((err as Error).message)
@@ -2492,7 +2555,7 @@ export function registerCyclesTools(server: any): void {
   defineTool(
     server,
     'map_delete_request',
-    'Delete a request for good, because it should never have been on the Product Map — a duplicate, a test, a mistake. This is NOT how a solved problem leaves the Product Map: a problem somebody fixed gets map_resolve_request, which keeps the request and its record (ADR 0026). Deleting erases the problem, its reports and its pointers, and no tool puts it back. Any request that named this one as its origin loses that pointer. A Shape that was bet on this request keeps a request_id pointing at nothing, so check the cycle before you delete a request that was ever bet on.',
+    'Delete a request for good, because it should never have been on the Product Map — a duplicate, a test, a mistake. This is NOT how a solved problem leaves the Product Map: a problem somebody fixed gets map_resolve_request, which keeps the request and its record (ADR 0026). Deleting erases the problem, its reports and its pointers, and no tool puts it back. Any request that named this one as its origin loses that pointer. A pitch that carried this request keeps its id in request_ids, pointing at nothing, so check the cycle before you delete a request that was ever pitched.',
     {
       ...orgArg,
       request_id: z.string().describe('Request to delete. map_list_requests names them.'),
diff --git a/src/lib/migrations/frames-to-requests.test.ts b/src/lib/migrations/frames-to-requests.test.ts
index 237c0d8..9204fe2 100644
--- a/src/lib/migrations/frames-to-requests.test.ts
+++ b/src/lib/migrations/frames-to-requests.test.ts
@@ -90,18 +90,26 @@ describe('migrating a cycle room from frames to requests', () => {
   const oldCycle = {
     cycle: { name: 'Cycle 12' },
     pitches: [
-      { id: 'p1', title: 'Fast exports', frame_problem: 'Exports time out', frame_outcome: '', frame_id: 'f1' },
+      { id: 'p1', title: 'Fast exports', frame_problem: 'Exports time out', frame_outcome: 'A year exports', frame_id: 'f1' },
       { id: 'p2', title: 'No frame', frame_problem: '', frame_outcome: '' },
+      { id: 'p3', title: 'Renamed once', frame_problem: '', frame_outcome: '', request_id: 'f3' },
     ],
     scopes: [{ id: 's1', pitchId: 'p1' }],
   }
 
-  it('points each pitch home to its request and keeps the frame it bet on', () => {
+  it('points each pitch at its list of requests and turns its outcome into a list', () => {
     const migrated = migrateCycleDocument(oldCycle)
 
     expect(migrated.pitches).toEqual([
-      { id: 'p1', title: 'Fast exports', frame_problem: 'Exports time out', frame_outcome: '', request_id: 'f1' },
-      { id: 'p2', title: 'No frame', frame_problem: '', frame_outcome: '' },
+      {
+        id: 'p1',
+        title: 'Fast exports',
+        frame_problem: 'Exports time out',
+        frame_outcomes: [{ id: 'p1-outcome', text: 'A year exports' }],
+        request_ids: ['f1'],
+      },
+      { id: 'p2', title: 'No frame', frame_problem: '', frame_outcomes: [] },
+      { id: 'p3', title: 'Renamed once', frame_problem: '', frame_outcomes: [], request_ids: ['f3'] },
     ])
     expect(migrated.cycle).toEqual(oldCycle.cycle)
     expect(migrated.scopes).toEqual(oldCycle.scopes)
diff --git a/src/lib/migrations/frames-to-requests.ts b/src/lib/migrations/frames-to-requests.ts
index f7dbb3e..966959c 100644
--- a/src/lib/migrations/frames-to-requests.ts
+++ b/src/lib/migrations/frames-to-requests.ts
@@ -26,7 +26,19 @@ export function migrateProductMapDocument<T extends Doc>(doc: T): Doc {
 }
 
 export function migratePitch(pitch: Doc): Doc {
-  return renameKey(pitch, 'frame_id', 'request_id')
+  const { frame_id, request_id, frame_outcome, ...rest } = pitch
+  const next: Doc = { ...rest }
+  // A pitch carries many requests (ADR 0032). Rooms hold either the name from
+  // before the rename (frame_id) or the one from the rename itself (request_id).
+  const single = frame_id ?? request_id
+  if (typeof single === 'string' && single) next.request_ids = [single]
+  // The free-text outcome becomes a list. A fixed id keeps a rerun a no-op.
+  if (typeof frame_outcome === 'string') {
+    next.frame_outcomes = frame_outcome.trim()
+      ? [{ id: `${pitch.id}-outcome`, text: frame_outcome.trim() }]
+      : []
+  }
+  return next
 }
 
 export function migrateCycleDocument<T extends Doc>(doc: T): Doc {
diff --git a/src/lib/mission-control-helpers.test.ts b/src/lib/mission-control-helpers.test.ts
index 6891576..ec33bf9 100644
--- a/src/lib/mission-control-helpers.test.ts
+++ b/src/lib/mission-control-helpers.test.ts
@@ -24,7 +24,7 @@ const pitches: CyclePitch[] = [
     stage: 'building',
     needle: { progress: 0.6, zone: 'on_track' },
     frame_problem: '',
-    frame_outcome: '',
+   
     timebox_start: '2025-01-06',
     timebox_end: '2025-02-14',
     emoji: '',
@@ -37,7 +37,7 @@ const pitches: CyclePitch[] = [
     stage: 'done',
     needle: { progress: 0.9, zone: 'on_track' },
     frame_problem: '',
-    frame_outcome: '',
+   
     timebox_start: '2025-01-06',
     timebox_end: '2025-02-14',
     emoji: '',
diff --git a/src/lib/mission-control-helpers.ts b/src/lib/mission-control-helpers.ts
index 8af2e97..a857644 100644
--- a/src/lib/mission-control-helpers.ts
+++ b/src/lib/mission-control-helpers.ts
@@ -85,11 +85,12 @@ export function partitionByStage(cards: PitchCard[]): {
 const STAGE_ORDER: Record<Stage, number> = {
   building: 0,
   shaping: 1,
-  done: 2,
+  framing: 2,
+  done: 3,
 }
 
 /**
- * Order pitches by stage progression: building → shaping → done.
+ * Order pitches by stage progression: building → shaping → framing → done.
  * Stable within a stage (preserves input order) and non-mutating.
  */
 export function sortByStageProgression(cards: PitchCard[]): PitchCard[] {
diff --git a/src/lib/pitch-move-engine.test.ts b/src/lib/pitch-move-engine.test.ts
index 811fc6a..b449dd3 100644
--- a/src/lib/pitch-move-engine.test.ts
+++ b/src/lib/pitch-move-engine.test.ts
@@ -9,7 +9,7 @@ function pitch(id: string, title: string, extra: Partial<CyclePitch> = {}): Cycl
     stage: 'building',
     needle: null,
     frame_problem: '',
-    frame_outcome: '',
+   
     timebox_start: '',
     timebox_end: '',
     emoji: '',
diff --git a/src/lib/product-map-engine.test.ts b/src/lib/product-map-engine.test.ts
index edc85d1..3da7708 100644
--- a/src/lib/product-map-engine.test.ts
+++ b/src/lib/product-map-engine.test.ts
@@ -18,6 +18,7 @@ import {
   candidateStatement,
   clusterForViewport,
   requestState,
+  seedPitchFrame,
   cyclesSinceWoken,
   gapList,
   inCooldown,
@@ -89,6 +90,7 @@ function makeShape(overrides: Partial<LinkedShape> = {}): LinkedShape {
     cycleSlug: '2026-q3',
     cycleTitle: 'Q3',
     currentCycle: true,
+    upcomingCycle: false,
     ...overrides,
   }
 }
@@ -479,6 +481,12 @@ describe('request state', () => {
     expect(requestState(request, shapes)).toBe('in_flight')
   })
 
+  it('reads pitched while its only pitch waits in an upcoming cycle', () => {
+    const request = makeRequest({ appetite: '2 weeks', outcomes: OUTCOMES })
+    const pitch = makeShape({ stage: 'framing', currentCycle: false, upcomingCycle: true })
+    expect(requestState(request, [pitch])).toBe('pitched')
+  })
+
   it('reads resolved whatever the shapes say, because a person decided', () => {
     const request = makeRequest({ appetite: '2 weeks', resolved: true })
     expect(requestState(request, [makeShape({ stage: 'building' })])).toBe('resolved')
@@ -875,6 +883,7 @@ describe('the engagement ring', () => {
 
   it('draws dashed while a linked shape is being shaped', () => {
     expect(pinOutline([makeShape({ stage: 'shaping', currentCycle: false })])).toBe('dashed')
+    expect(pinOutline([makeShape({ stage: 'framing', currentCycle: false, upcomingCycle: true })])).toBe('dashed')
   })
 
   it('draws solid while a linked shape runs in the cycle happening now', () => {
@@ -901,13 +910,41 @@ describe('the engagement ring', () => {
 describe('reading the shapes out of the cycle rooms', () => {
   const cycle = CYCLES[1]
 
+  it('carries the release summary, so the request shows what shipped for it', () => {
+    const [shipped, silent] = linkedShapesFrom(
+      [
+        {
+          cycle,
+          shapes: [
+            { id: 's1', title: 'a', stage: 'done', request_ids: ['f1'], release_summary: 'Exports finish.' },
+            { id: 's2', title: 'b', stage: 'done', request_ids: ['f1'] },
+          ],
+        },
+      ],
+      '2026-03-01'
+    )
+    expect(shipped.releaseSummary).toBe('Exports finish.')
+    expect(silent.releaseSummary).toBeUndefined()
+  })
+
+  it('links a pitch to every request it carries', () => {
+    const shapes = linkedShapesFrom(
+      [{ cycle, shapes: [{ id: 's1', title: 'Fast exports', stage: 'framing', request_ids: ['f1', 'f2'] }] }],
+      '2026-03-01'
+    )
+    expect(shapes.map((s) => [s.shapeId, s.requestId])).toEqual([
+      ['s1', 'f1'],
+      ['s1', 'f2'],
+    ])
+  })
+
   it('keeps only the shapes that point at a request', () => {
     const shapes = linkedShapesFrom(
       [
         {
           cycle,
           shapes: [
-            { id: 's1', title: 'Fix imports', stage: 'building', request_id: 'f1' },
+            { id: 's1', title: 'Fix imports', stage: 'building', request_ids: ['f1'] },
             { id: 's2', title: 'Something else', stage: 'building' },
           ],
         },
@@ -927,8 +964,8 @@ describe('reading the shapes out of the cycle rooms', () => {
           cycle,
           squads: [{ id: 'q1', name: 'Capture', color: '#8e4ec6' }],
           shapes: [
-            { id: 's1', title: 'a', stage: 'building', request_id: 'f1', squadId: 'q1', notion_url: 'https://notion.so/p' },
-            { id: 's2', title: 'b', stage: 'building', request_id: 'f1', squadId: 'gone', notion_url: '' },
+            { id: 's1', title: 'a', stage: 'building', request_ids: ['f1'], squadId: 'q1', notion_url: 'https://notion.so/p' },
+            { id: 's2', title: 'b', stage: 'building', request_ids: ['f1'], squadId: 'gone', notion_url: '' },
           ],
         },
       ],
@@ -942,30 +979,44 @@ describe('reading the shapes out of the cycle rooms', () => {
 
   it('names the cycle, so the request detail reads a title and not a slug', () => {
     const [shape] = linkedShapesFrom(
-      [{ cycle, shapes: [{ id: 's1', title: 'x', stage: 'done', request_id: 'f1' }] }],
+      [{ cycle, shapes: [{ id: 's1', title: 'x', stage: 'done', request_ids: ['f1'] }] }],
       '2026-03-01'
     )
     expect(shape.cycleTitle).toBe('Two')
   })
 
+  it('marks a pitch in a cycle that has not started as upcoming, and keeps it framing', () => {
+    const [waiting] = linkedShapesFrom(
+      [{ cycle, shapes: [{ id: 's1', title: 'x', stage: 'framing', request_ids: ['f1'] }] }],
+      '2026-02-01'
+    )
+    const [running] = linkedShapesFrom(
+      [{ cycle, shapes: [{ id: 's1', title: 'x', stage: 'framing', request_ids: ['f1'] }] }],
+      '2026-03-01'
+    )
+    expect(waiting.upcomingCycle).toBe(true)
+    expect(waiting.stage).toBe('framing')
+    expect(running.upcomingCycle).toBe(false)
+  })
+
   it('marks a shape in the cycle running today as current', () => {
     const [inside] = linkedShapesFrom(
-      [{ cycle, shapes: [{ id: 's1', title: 'x', stage: 'building', request_id: 'f1' }] }],
+      [{ cycle, shapes: [{ id: 's1', title: 'x', stage: 'building', request_ids: ['f1'] }] }],
       '2026-03-01'
     )
     const [outside] = linkedShapesFrom(
-      [{ cycle, shapes: [{ id: 's1', title: 'x', stage: 'building', request_id: 'f1' }] }],
+      [{ cycle, shapes: [{ id: 's1', title: 'x', stage: 'building', request_ids: ['f1'] }] }],
       '2026-09-02'
     )
     expect(inside.currentCycle).toBe(true)
     expect(outside.currentCycle).toBe(false)
   })
 
-  // Stored data outlives the code that wrote it: a room written before ADR 0023
-  // still holds `framing`, and losing the shape over it would be worse.
-  it('reads a stored framing stage as shaping', () => {
+  // Stored data outlives the code that wrote it, and losing the pitch over an
+  // unreadable stage would be worse.
+  it('reads an unknown stage as shaping', () => {
     const [shape] = linkedShapesFrom(
-      [{ cycle, shapes: [{ id: 's1', title: 'x', stage: 'framing', request_id: 'f1' }] }],
+      [{ cycle, shapes: [{ id: 's1', title: 'x', stage: 'pondering', request_ids: ['f1'] }] }],
       '2026-03-01'
     )
     expect(shape.stage).toBe('shaping')
@@ -1425,6 +1476,7 @@ describe('the zoom ladder', () => {
           cycleSlug: 'c1',
           cycleTitle: 'Cycle 1',
           currentCycle: true,
+          upcomingCycle: false,
         },
       ],
       today: '2026-09-03',
@@ -1626,3 +1678,45 @@ describe('related requests', () => {
     expect(Object.fromEntries(changes)).toEqual({ a: ['c'], b: [], c: ['a'] })
   })
 })
+
+describe('seeding a pitch from its requests', () => {
+  it('copies the outcomes of every request and takes the largest appetite', () => {
+    const seed = seedPitchFrame([
+      makeRequest({
+        problem: 'Exports time out',
+        appetite: '2 weeks',
+        outcomes: [{ id: 'o1', text: 'A year of data exports' }],
+      }),
+      makeRequest({
+        problem: 'Exports miss custom fields',
+        appetite: '6 weeks',
+        outcomes: [{ id: 'o2', text: 'Custom fields appear in the export' }],
+      }),
+      makeRequest({ problem: 'Export is slow', appetite: '3 days', outcomes: [] }),
+    ])
+    expect(seed.frame_outcomes).toEqual([
+      { id: 'o1', text: 'A year of data exports' },
+      { id: 'o2', text: 'Custom fields appear in the export' },
+    ])
+    expect(seed.frame_appetite).toBe('6 weeks')
+    expect(seed.frame_problem).toBe(
+      'Exports time out\nExports miss custom fields\nExport is slow'
+    )
+  })
+
+  it('carries the release draft of a request into the release summary', () => {
+    const seed = seedPitchFrame([
+      makeRequest({ announcement: '' }),
+      makeRequest({ announcement: 'Exports now finish, whatever their size.' }),
+    ])
+    expect(seed.release_summary).toBe('Exports now finish, whatever their size.')
+  })
+
+  it('keeps the first appetite when none can be compared', () => {
+    const seed = seedPitchFrame([
+      makeRequest({ appetite: 'a small batch' }),
+      makeRequest({ appetite: 'a big batch' }),
+    ])
+    expect(seed.frame_appetite).toBe('a small batch')
+  })
+})
diff --git a/src/lib/product-map-engine.ts b/src/lib/product-map-engine.ts
index afb0791..f850447 100644
--- a/src/lib/product-map-engine.ts
+++ b/src/lib/product-map-engine.ts
@@ -3,6 +3,7 @@
 // returns the rendered map model. No React, no Liveblocks, no clock of its own,
 // the same shape as the cycle list engine.
 
+import { STAGES } from '@/lib/stage-engine'
 import type {
   Area,
   ProductRequest,
@@ -57,14 +58,15 @@ export function isRequestType(value: unknown): value is RequestType {
  * A request's position in its life. Derived from what the request points at and
  * never stored, so it can never drift from the truth (ADR 0025):
  *
- * `rough` (no appetite) → `candidate` (sharp, no Shape yet) → `in_flight` (a
- * Shape that is not done) → `released` (its Shape reached done this cycle) →
+ * `rough` (no appetite) → `candidate` (sharp, no pitch yet) → `pitched` (a
+ * pitch waits in an upcoming cycle) → `in_flight` (a pitch that is not done) → `released` (its Shape reached done this cycle) →
  * `monitoring` (released, and nobody has resolved it) → `resolved` (a person
  * decided the problem is gone).
  */
 export type RequestState =
   | 'rough'
   | 'candidate'
+  | 'pitched'
   | 'in_flight'
   | 'released'
   | 'monitoring'
@@ -74,6 +76,7 @@ export type RequestState =
 export const REQUEST_STATES: readonly RequestState[] = [
   'rough',
   'candidate',
+  'pitched',
   'in_flight',
   'released',
   'monitoring',
@@ -81,7 +84,7 @@ export const REQUEST_STATES: readonly RequestState[] = [
 ]
 
 /** A Shape's lifecycle phase. Mirrors the cycle model's Stage (ADR 0023). */
-export type ShapeStage = 'shaping' | 'building' | 'done'
+export type ShapeStage = 'framing' | 'shaping' | 'building' | 'done'
 
 /**
  * A Shape that points home to a request. Passed in, because a request never stores
@@ -97,10 +100,14 @@ export type LinkedShape = {
   cycleTitle: string
   /** True when this shape sits in the cycle that is current today. */
   currentCycle: boolean
+  /** True when this shape sits in a cycle that has not started yet. */
+  upcomingCycle: boolean
   /** The squad on it this cycle. Absent when unassigned, or the squad is gone. */
   squad?: { name: string; color: string }
   /** The pitch's Notion doc. Absent when nobody linked one. */
   notionUrl?: string
+  /** What changes for the customer, in their words. Absent when unwritten. */
+  releaseSummary?: string
 }
 
 /** One link in a request's origin chain: the request whose monitoring surfaced it. */
@@ -223,7 +230,7 @@ export function pinOutline(shapes: LinkedShape[]): PinOutline {
   // including one that already shipped. The request reads `released` at that
   // point, and a release this cycle is current investment, not "no work".
   if (shapes.some((s) => s.currentCycle)) return 'solid'
-  if (shapes.some((s) => s.stage === 'shaping')) return 'dashed'
+  if (shapes.some((s) => s.stage === 'framing' || s.stage === 'shaping')) return 'dashed'
   return 'none'
 }
 
@@ -239,9 +246,10 @@ export function linkedShapesFrom(
       id: string
       title: string
       stage: string
-      request_id?: string
+      request_ids?: string[]
       squadId?: string
       notion_url?: string
+      release_summary?: string
     }[]
     squads?: SquadSummary[]
   }[],
@@ -253,24 +261,32 @@ export function linkedShapesFrom(
       !!cycle.end_date &&
       today >= cycle.start_date &&
       today <= cycle.end_date
-    return shapes
-      .filter((shape) => !!shape.request_id)
-      .map((shape) => ({
-        requestId: shape.request_id as string,
+    const upcomingCycle = isUpcomingCycle(cycle, today)
+    // A pitch carries many requests, so it counts once for each of them.
+    return shapes.flatMap((shape) =>
+      (shape.request_ids ?? []).map((requestId) => ({
+        requestId,
         shapeId: shape.id,
         title: shape.title,
-        // A room written before ADR 0023 can still hold a `framing` stage, and
-        // an unreadable stage is not a reason to lose the shape.
+        // An unreadable stage is not a reason to lose the shape.
         stage: isShapeStage(shape.stage) ? shape.stage : 'shaping',
         cycleSlug: cycle.slug,
         cycleTitle: cycle.title || cycle.slug,
         currentCycle,
+        upcomingCycle,
         ...squadOf(squads, shape.squadId),
         ...(shape.notion_url ? { notionUrl: shape.notion_url } : {}),
+        ...(shape.release_summary ? { releaseSummary: shape.release_summary } : {}),
       }))
+    )
   })
 }
 
+/** A cycle that has not started yet: where a new pitch waits for the betting table. */
+export function isUpcomingCycle(cycle: Pick<CycleWindow, 'start_date'>, today: string): boolean {
+  return !!cycle.start_date && today < cycle.start_date
+}
+
 /** What the Product Map needs of a squad from a cycle room. */
 type SquadSummary = { id: string; name: string; color: string }
 
@@ -280,7 +296,7 @@ function squadOf(squads: SquadSummary[], id?: string) {
 }
 
 function isShapeStage(value: unknown): value is ShapeStage {
-  return value === 'shaping' || value === 'building' || value === 'done'
+  return (STAGES as unknown[]).includes(value)
 }
 
 /**
@@ -304,6 +320,45 @@ export function statedOutcomes(request: Pick<ProductRequest, 'outcomes'>): Reque
   return (request.outcomes ?? []).filter((outcome) => text(outcome?.text) !== '')
 }
 
+/** What a new pitch copies from its requests (ADR 0032). After that, the pitch owns it. */
+export type PitchFrameSeed = {
+  frame_problem: string
+  frame_outcomes: RequestOutcome[]
+  frame_appetite: string
+  release_summary: string
+}
+
+const DAYS_PER_UNIT: Record<string, number> = { day: 1, week: 5, month: 20 }
+
+/** "2 weeks" → 10 business days. Null when the free text names no length. */
+function appetiteDays(appetite: string): number | null {
+  const match = /(\d+(?:\.\d+)?)\s*(day|week|month)/i.exec(appetite)
+  return match ? Number(match[1]) * DAYS_PER_UNIT[match[2].toLowerCase()] : null
+}
+
+/**
+ * Seed the frame of a new pitch from the requests it carries: every outcome,
+ * the largest appetite, and the first release draft. The problem joins the
+ * request summaries, one per line, for the framer to rework.
+ */
+export function seedPitchFrame(
+  requests: Pick<ProductRequest, 'problem' | 'appetite' | 'outcomes' | 'announcement'>[]
+): PitchFrameSeed {
+  const appetites = requests.map((r) => text(r.appetite)).filter(Boolean)
+  // ponytail: reads "N days|weeks|months" only; anything else keeps the first appetite.
+  const largest = appetites.reduce<string | undefined>((best, next) => {
+    const a = best === undefined ? null : appetiteDays(best)
+    const b = appetiteDays(next)
+    return best === undefined || (b !== null && (a === null || b > a)) ? next : best
+  }, undefined)
+  return {
+    frame_problem: requests.map((r) => text(r.problem)).filter(Boolean).join('\n'),
+    frame_outcomes: requests.flatMap(statedOutcomes),
+    frame_appetite: largest ?? '',
+    release_summary: requests.map((r) => text(r.announcement)).find(Boolean) ?? '',
+  }
+}
+
 /**
  * The sentence the Product Map shows under a sharp request. The app builds it from the
  * problem and the appetite, so nobody types it. null for a rough request: there
@@ -329,7 +384,10 @@ export function requestState(
   if (shapes.length > 0) {
     // One shape still moving means work is in flight, even beside an older
     // release: a request can be attacked again years later (ADR 0022).
-    if (shapes.some((s) => s.stage !== 'done')) return 'in_flight'
+    const moving = shapes.filter((s) => s.stage !== 'done')
+    if (moving.some((s) => !s.upcomingCycle)) return 'in_flight'
+    // Every live pitch waits for the betting table, even beside an old release.
+    if (moving.length > 0) return 'pitched'
     // Every shape is done. `released` while the release is this cycle's news;
     // `monitoring` once it is not. Monitoring has no end condition, so only a
     // person moves a request on from here (ADR 0025).
diff --git a/src/lib/stage-engine.test.ts b/src/lib/stage-engine.test.ts
index 3b8f11d..4ad61f7 100644
--- a/src/lib/stage-engine.test.ts
+++ b/src/lib/stage-engine.test.ts
@@ -9,31 +9,29 @@ import {
 } from './stage-engine'
 
 describe('STAGES', () => {
-  it('runs shaping → building → done', () => {
-    expect(STAGES).toEqual(['shaping', 'building', 'done'])
-  })
-
-  it('has no framing stage — framing happens on the Product Map', () => {
-    expect(STAGES).not.toContain('framing')
+  it('runs framing → shaping → building → done', () => {
+    expect(STAGES).toEqual(['framing', 'shaping', 'building', 'done'])
   })
 })
 
 describe('newShapeStage', () => {
-  it('starts a new shape in a build cycle at shaping', () => {
-    expect(newShapeStage('build')).toBe('shaping')
+  it('starts a new pitch in an upcoming build cycle at framing', () => {
+    expect(newShapeStage('build', true)).toBe('framing')
+  })
+
+  // A pitch added to a cycle that already started was bet on already.
+  it('starts a new pitch in a running build cycle at shaping', () => {
+    expect(newShapeStage('build', false)).toBe('shaping')
   })
 
   it('starts a cooldown shape at building', () => {
-    expect(newShapeStage('cooldown')).toBe('building')
+    expect(newShapeStage('cooldown', true)).toBe('building')
   })
 })
 
 describe('readStage', () => {
-  it('reads a stored framing value as shaping', () => {
-    expect(readStage('framing')).toBe('shaping')
-  })
-
   it('passes every current stage through unchanged', () => {
+    expect(readStage('framing')).toBe('framing')
     expect(readStage('shaping')).toBe('shaping')
     expect(readStage('building')).toBe('building')
     expect(readStage('done')).toBe('done')
@@ -48,6 +46,7 @@ describe('readStage', () => {
 
 describe('nextStage', () => {
   it('advances one step forward', () => {
+    expect(nextStage('framing')).toBe('shaping')
     expect(nextStage('shaping')).toBe('building')
     expect(nextStage('building')).toBe('done')
   })
@@ -61,10 +60,11 @@ describe('prevStage', () => {
   it('steps one stage backward', () => {
     expect(prevStage('done')).toBe('building')
     expect(prevStage('building')).toBe('shaping')
+    expect(prevStage('shaping')).toBe('framing')
   })
 
   it('returns null when already at the first stage', () => {
-    expect(prevStage('shaping')).toBeNull()
+    expect(prevStage('framing')).toBeNull()
   })
 })
 
diff --git a/src/lib/stage-engine.ts b/src/lib/stage-engine.ts
index 34def6b..3e2fdca 100644
--- a/src/lib/stage-engine.ts
+++ b/src/lib/stage-engine.ts
@@ -1,26 +1,24 @@
 import type { Stage } from '@/cycle-liveblocks.config'
 
-// The shape lifecycle, in order. A shape moves forward (or back) through these.
-// There is no `framing` stage: framing happens on the Product Map, before a
-// shape exists (see ADR 0023). `shaping` stays, because shaping work really
-// does happen inside the cycle.
-export const STAGES: Stage[] = ['shaping', 'building', 'done']
+// The pitch lifecycle, in order. A pitch moves forward (or back) through these.
+// Framing happens on the pitch, before the betting table (ADR 0032). "Frame Go"
+// is framing → shaping, and "Shape Go" is shaping → building.
+export const STAGES: Stage[] = ['framing', 'shaping', 'building', 'done']
 
-// Where a newly created shape starts. A build cycle's shape starts at
-// `shaping`. A cooldown shape starts at `building`, because cooldown work is
-// picked up already shaped.
-export function newShapeStage(cycleType: 'build' | 'cooldown'): Stage {
-  return cycleType === 'cooldown' ? 'building' : 'shaping'
+// Where a newly created pitch starts. In an upcoming build cycle it starts at
+// `framing`, because it still waits for the betting table. In a build cycle
+// that already started it was bet on, so it starts at `shaping`. A cooldown
+// pitch starts at `building`, because cooldown work is picked up already shaped.
+export function newShapeStage(cycleType: 'build' | 'cooldown', upcoming: boolean): Stage {
+  if (cycleType === 'cooldown') return 'building'
+  return upcoming ? 'framing' : 'shaping'
 }
 
-// Normalize a stage read out of storage. Rooms written before ADR 0023 hold
-// `framing`, which now reads as `shaping` — stored data outlives the code that
-// wrote it, and nothing rewrites those rooms. Anything unrecognized falls back
-// to the first stage rather than breaking a lookup keyed by Stage.
+// Normalize a stage read out of storage. Anything unrecognized reads as
+// `shaping`, the stage every pitch had before framing returned, rather than
+// breaking a lookup keyed by Stage.
 export function readStage(stored: string | undefined): Stage {
-  return (STAGES as string[]).includes(stored ?? '')
-    ? (stored as Stage)
-    : STAGES[0]
+  return (STAGES as string[]).includes(stored ?? '') ? (stored as Stage) : 'shaping'
 }
 
 // The next stage forward, or null if already at the last stage (`done`).
@@ -29,7 +27,7 @@ export function nextStage(stage: Stage): Stage | null {
   return i >= 0 && i < STAGES.length - 1 ? STAGES[i + 1] : null
 }
 
-// The previous stage, or null if already at the first stage (`shaping`).
+// The previous stage, or null if already at the first stage (`framing`).
 export function prevStage(stage: Stage): Stage | null {
   const i = STAGES.indexOf(stage)
   return i > 0 ? STAGES[i - 1] : null