create-pmos 0.53.0 → 0.53.1

package/workspace/public/pm/components.css

@@ -1977,12 +1977,55 @@
   background: var(--sidebar);
 }
 .fr-dock {
-  width: clamp(360px, 36vw, 640px);
+  width: var(--fr-dock-w, clamp(360px, 36vw, 640px));
+  max-width: calc(100vw - 280px);
   border-left: 1px solid var(--border);
 }
+/* 0.53.1: while the dock is open its rail is a thin grip on the dock's left edge that resizes it (dock.js dockGrip). */
+.fr-dock-grip {
+  display: none;
+}
 .fr-body[data-fr-dock="open"] > .fr-dock-rail {
+  width: 6px;
+  padding: 0;
+  border-left: 0;
+  align-items: stretch;
+  background: transparent;
+}
+.fr-body[data-fr-dock="open"] > .fr-dock-rail > :not(.fr-dock-grip) {
+  display: none;
+}
+.fr-body[data-fr-dock="open"] .fr-dock-grip {
+  display: block;
+  flex: 1;
+  cursor: col-resize;
+  touch-action: none;
+  outline: none;
+}
+/* The grip shows a 1px line without hover (a touch screen has none); a press, a drag or the keyboard focus fills it. */
+.fr-body[data-fr-dock="open"] .fr-dock-grip {
+  border-left: 1px solid var(--border);
+}
+.fr-dock-grip:focus-visible,
+.fr-dock-grip[data-dragging] {
+  background: var(--ring);
+}
+@media (hover: hover) {
+  .fr-dock-grip:hover {
+    background: var(--ring);
+  }
+}
+/* 0.53.1 Focus: the dock has the whole window; the page, the detail and the rail step aside (they stay mounted). */
+.fr-body[data-fr-dock="max"] > .fr-main,
+.fr-body[data-fr-dock="max"] > .fr-detail,
+.fr-body[data-fr-dock="max"] > .fr-dock-rail {
   display: none;
 }
+.fr-body[data-fr-dock="max"] > .fr-dock {
+  width: auto;
+  max-width: none;
+  border-left: 0;
+}
 .fr-body[data-fr-dock="rail"] > .fr-dock {
   display: none !important;
 }
@@ -2054,6 +2097,7 @@
   .fr-detail,
   .fr-dock {
     width: auto;
+    max-width: none;
     border-left: 0;
   }
   .fr-set {
@@ -2104,6 +2148,43 @@
   flex-direction: column;
   gap: 8px;
 }
+/* today-goals (G6): the goals for today, above what is owed */
+.td-goals {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 8px 12px;
+  border: 1px solid var(--border);
+  background: var(--card);
+}
+.td-goals__head { display: flex; align-items: center; }
+.td-goals__list, .td-goal__steps, .td-goal__ctx-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+.td-goals__list { counter-reset: goal; }
+.td-goal { display: flex; flex-direction: column; gap: 4px; }
+.td-goal__head { display: flex; flex-wrap: wrap; align-items: center; gap: 4px 8px; }
+.td-goal__text { color: var(--foreground); font-weight: 500; }
+.td-goal__text::before { counter-increment: goal; content: counter(goal) ". "; color: var(--muted-foreground); }
+.td-goal--closed .td-goal__text { color: var(--muted-foreground); text-decoration: line-through; }
+.td-goal__ctrls { display: inline-flex; gap: 4px; margin-left: auto; }
+.td-goal__body { display: flex; flex-direction: column; gap: 4px; padding-left: 16px; }
+.td-goal__step { display: flex; flex-wrap: wrap; align-items: center; gap: 4px 8px; }
+.td-goal__step-title { color: var(--foreground); }
+.td-goal__meta, .td-goal__ctx, .td-goal__none, .td-goals__note, .td-goal__prep-text {
+  color: var(--muted-foreground);
+  font-size: 12px;
+  line-height: 16px;
+  margin: 0;
+}
+.td-goal__prep { display: inline-flex; align-items: center; gap: 8px; }
+.td-goals__bar { display: flex; gap: 8px; }
+.td-goals__sub { margin: 4px 0 0; font-size: 12px; font-weight: 600; color: var(--muted-foreground); }
 .td-card {
   display: flex;
   flex-direction: column;

package/workspace/public/pm/dest-today.js

@@ -21,6 +21,7 @@ import { wsOf } from './data.js';
 import { state, setState, FIXTURE } from './state.js';
 import { COPY } from './today-copy.js';
 import { todayCard, acceptCard, rankNodes, scopeCtx, ensureFeed, feedOf, feedErrorOf, bannerOf, onFeed } from './today-cards.js';
+import { goalsSection, goalsSig } from './today-goals.js';
 
 const SHOWN = 3;   // cards drawn before "Show more": the first paint holds at most 17 controls (first-paint-today.test.js)
 let expanded = false;
@@ -117,7 +118,10 @@ function build(ctx0) {
     ? button({ label: expanded ? COPY.fewer : COPY.more(nodes.length - SHOWN), variant: 'ghost', attrs: { 'data-today': 'more' }, onClick: () => { expanded = !expanded; setState({}); } })
     : null;
   nodes.forEach((node) => node.setAttribute('role', 'listitem'));
-  return { children: [head, health, list, more], sig: JSON.stringify([sc.all, sc.repo, n, ready, expanded, banner]) + nodes.map((x) => x.outerHTML).join('') };
+  // today-goals (G6): the PM's goals sit above what is owed; they are joined to the cards of the first repository in scope
+  const goalsWs = sc.repos.length ? wsOf(sc.repos[0]) : null;
+  const goals = goalsSection({ ws: goalsWs, setState: ctx0.setState || setState });
+  return { children: [head, goals, health, list, more], sig: JSON.stringify([sc.all, sc.repo, n, ready, expanded, banner]) + goalsSig(goalsWs) + nodes.map((x) => x.outerHTML).join('') };
 }
 
 /** The key of the control that has the focus inside the board, so it can be focused again after a rebuild. */
@@ -128,6 +132,7 @@ function focusKey(root) {
   const attr = ['data-today-act', 'data-today-more', 'data-today-add-note', 'data-today-accept', 'data-today-return'].find((k) => a.hasAttribute(k));
   if (card && attr) return { id: card.getAttribute('data-today-id'), attr };
   if (a.closest('[data-today-note]')) return { id: card && card.getAttribute('data-today-id'), note: true };
+  if (a.getAttribute('data-goals') === 'input') return { goalsInput: true, caret: a.selectionStart };
   if (a.hasAttribute('data-today-scope')) return { scope: a.getAttribute('data-today-scope') };
   if (a.hasAttribute('data-today') && a.getAttribute('data-today') === 'more') return { more: true };
   return null;
@@ -138,9 +143,10 @@ function refocus(root, k) {
   let t = null;
   if (k.note && card) t = card.querySelector('[data-today-note] input, [data-today-note] textarea, input[data-today-note], textarea[data-today-note]');
   else if (k.attr && card) t = card.querySelector('[' + k.attr + ']');
+  else if (k.goalsInput) t = root.querySelector('[data-goals="input"]');
   else if (k.scope) t = root.querySelector('[data-today-scope="' + k.scope + '"]');
   else if (k.more) t = root.querySelector('[data-today="more"]');
-  if (t && !t.hidden) { try { t.focus({ preventScroll: true }); } catch { /* not focusable */ } }
+  if (t && !t.hidden) { try { t.focus({ preventScroll: true }); if (k.goalsInput && typeof k.caret === 'number') t.setSelectionRange(k.caret, k.caret); } catch { /* not focusable */ } }
 }
 
 /** Draw Today into `host`. Safe to call on every render: nothing changes unless what Today shows changed. */

package/workspace/public/pm/dock.js

@@ -6,8 +6,11 @@
  * the dock is a rail waits in the dock until the PM opens it.
  *
  * This module holds the parts of the dock that are new in the frame:
- *   createDockRail({ open, label })      the 44px rail: one control that opens the dock
+ *   createDockRail({ open, resize })     the 44px rail: one control that opens the dock. While the dock is open the rail
+ *                                         is a thin grip on the dock's left edge that resizes it (0.53.1)
  *   foldButton({ fold })                  the control in the open dock's strip that folds it back to the rail
+ *   focusButton({ toggle }) / paintFocus(b, on)
+ *                                         Focus: the dock takes the whole window, and Exit focus gives the page back (0.53.1)
  *   sessionMenuButton({ newSession, withOptions, openSkill, ws })
  *                                         "＋ Session": New session, Session with options, then the skills to start
  *                                         from (R10: Skills start from the dock's ＋session menu; the Skills view goes)
@@ -47,9 +50,76 @@ export function setSessionDefaults(patch) {
 
 /* ── the rail and the fold control ────────────────────────────────────────────────────────────────────────────────── */
 
-export function createDockRail({ open } = {}) {
+export function createDockRail({ open, resize } = {}) {
   const b = iconButton({ icon: 'bot', ariaLabel: COPY.dock.open, onClick: () => open && open(), attrs: { 'data-fr': 'dock-open', 'aria-keyshortcuts': 'Meta+J Control+J' } });
-  return el('div', { class: 'fr-dock-rail', 'data-fr': 'dock-rail' }, b);
+  return el('div', { class: 'fr-dock-rail', 'data-fr': 'dock-rail' }, b, resize ? dockGrip(resize) : null);
+}
+
+/* ── the dock's width (0.53.1: the PM found the terminal too small) ───────────────────────────────────────────────────
+ * The grip sits in the rail's place while the dock is open, so the body keeps its four children and the dock stays the
+ * fourth. `resize` = { get() → px | null, set(px | null) }: null is the default width (the CSS clamp). The grip measures
+ * from the body's right edge, so the dock is as wide as the distance from the pointer to the window's edge. */
+export const DOCK_MIN = 320;
+export const DOCK_STEP = 32;
+/** The widest the dock may be in a body `bodyW` wide: the page keeps 280px beside it. */
+export const dockMax = (bodyW) => Math.max(DOCK_MIN, Math.round(bodyW) - 280);
+export const clampDock = (px, bodyW) => Math.min(dockMax(bodyW), Math.max(DOCK_MIN, Math.round(px)));
+
+function dockGrip(resize) {
+  const g = el('div', {
+    class: 'fr-dock-grip', 'data-fr': 'dock-grip', role: 'separator', 'aria-orientation': 'vertical',
+    'aria-label': COPY.dock.resize, title: COPY.dock.resize, tabindex: '0',
+  });
+  grips.set(g, resize);
+  g.addEventListener('dblclick', () => resize.set(null));
+  g.addEventListener('keydown', (e) => {
+    if (e.key !== 'ArrowLeft' && e.key !== 'ArrowRight') return;
+    e.preventDefault();
+    const b = g.closest('.fr-body');
+    const d = b && b.querySelector(':scope > .fr-dock');
+    const now = resize.get() || (d ? d.getBoundingClientRect().width : 0);
+    resize.set(clampDock(now + (e.key === 'ArrowLeft' ? DOCK_STEP : -DOCK_STEP), b ? b.getBoundingClientRect().width : window.innerWidth));
+  });
+  return g;
+}
+
+/* The drag is read on the document, once: a press on a grip starts it, and the moves and the release are the window's,
+ * so a drag that leaves the grip (it is 6px wide) keeps going. The grip itself is a separator with keys (above). */
+const grips = new WeakMap();   // grip -> resize
+let drag = null;               // { g, resize, right }
+document.addEventListener('pointerdown', (e) => {
+  const g = e.button === 0 && e.target && e.target.closest ? e.target.closest('[data-fr="dock-grip"]') : null;
+  const resize = g && grips.get(g);
+  const b = g && g.closest('.fr-body');
+  if (!resize || !b) return;
+  e.preventDefault();
+  drag = { g, resize, body: b, right: b.getBoundingClientRect().right };
+  g.setAttribute('data-dragging', '');
+});
+window.addEventListener('pointermove', (e) => {
+  if (drag) drag.resize.set(clampDock(drag.right - e.clientX, drag.body.getBoundingClientRect().width));
+});
+const endDrag = () => { if (drag) { drag.g.removeAttribute('data-dragging'); drag = null; } };
+window.addEventListener('pointerup', endDrag);
+window.addEventListener('pointercancel', endDrag);
+
+const focusLabels = new WeakMap();   // the Focus control -> its label node
+export function focusButton({ toggle } = {}) {
+  const label = el('span', null, COPY.dock.focus);
+  const b = button({ label, variant: 'ghost', size: 'sm',
+    attrs: { class: 'fr-dock-focus', 'data-fr': 'dock-focus', 'aria-pressed': 'false', title: COPY.dock.focusTitle, 'aria-keyshortcuts': 'Meta+Shift+J Control+Shift+J' },
+    onClick: () => toggle && toggle() });
+  focusLabels.set(b, label);
+  return b;
+}
+/** Show the Focus control's state: pressed while the dock has the whole window. */
+export function paintFocus(b, on) {
+  if (!b) return;
+  const label = focusLabels.get(b);
+  const text = on ? COPY.dock.unfocus : COPY.dock.focus;
+  if (label && label.textContent !== text) label.textContent = text;
+  b.setAttribute('aria-pressed', on ? 'true' : 'false');
+  b.title = on ? COPY.dock.unfocusTitle : COPY.dock.focusTitle;
 }
 
 export function foldButton({ fold } = {}) {

package/workspace/public/pm/frame-copy.js

@@ -36,6 +36,11 @@ export const COPY = {
   dock: {
     open: 'Open the agent dock (⌘J)',
     fold: 'Fold the agent dock (⌘J)',
+    focus: 'Focus',
+    unfocus: 'Exit focus',
+    focusTitle: 'Give the dock the whole window (⌘⇧J)',
+    unfocusTitle: 'Show the page beside the dock again (⌘⇧J)',
+    resize: 'Resize the agent dock. Drag, or use the left and right arrow keys. Double-click resets the width.',
     session: 'Session',
     sessionMenu: 'Start a session',
     newSession: 'New session',

package/workspace/public/pm/panel-tabs.js

@@ -719,13 +719,11 @@ const bottomBar = el('div', { 'data-tabs': 'bottom', 'data-term-chrome': '', cla
   button({ label: copyLabel, variant: 'outline', size: 'sm', onClick: () => copyActive() }),
 );
 
-/* pm-os-absorb Run 3 (R11): the capture box is gone, so in real mode the bar has no scratchpad toggle and paintBottom
- * lays it out: the session's name and `copy`, or, on a phone, the terminal's compose line. Fixture mode keeps the
- * prototype's bar (the parity lock holds until slice 3D lifts it). */
-const [, bottomTitle, bottomCopy] = bottomBar.children;
-
-/* The drawer had its toggle in the bar and has none now: a stored "open" is dropped once, at load, so no capture box comes back. */
-if (!FIXTURE && state.scratchOpen) setState({ scratchOpen: false });
+/* pm-os-absorb Run 3 (R11) took the scratchpad toggle out of the bar, and with it the only way to the pad on a desktop.
+ * 0.53.1 puts it back: paintBottom lays the bar out as the scratchpad toggle, the session's name and `copy`, or, on a
+ * phone, the terminal's compose line (the same per-session pad). Fixture mode keeps the prototype's bar. */
+const [bottomToggle, bottomTitle, bottomCopy] = bottomBar.children;
+bottomToggle.setAttribute('data-scratch', 'toggle');
 
 /* The compose line: one message field and Send on the SAME per-session pad as the drawer (padKey), so the text is kept
  * on this machine and never crosses sessions. On a desktop ⌘K "Ask <session>" types to a session (pm/palette.js). */
@@ -751,7 +749,7 @@ function sendCompose() {
   onScratchInput('');
 }
 
-/** The bar in real mode: no scratchpad toggle; a phone's terminal gets the compose line in its place. */
+/** The bar in real mode: the scratchpad toggle, the title and copy; a phone's terminal gets the compose line instead. */
 function paintBottom(act) {
   const compose = isMobile() && !!act && act.kind === 'term';
   bottomTitle.textContent = act ? act.title : '';
@@ -761,7 +759,7 @@ function paintBottom(act) {
     if (composeInput.control.value !== text) composeInput.control.value = text;
     composeSend.disabled = !text.trim();
   }
-  setChildren(bottomBar, compose ? [composeLine] : (act ? [bottomTitle, bottomCopy] : [bottomTitle]));
+  setChildren(bottomBar, compose ? [composeLine] : (act ? [bottomToggle, bottomTitle, bottomCopy] : [bottomToggle, bottomTitle]));
 }
 
 /* ── clipboard + scratchpad actions (lines 2098–2118) ───────────────────────────────────────── */
@@ -1101,9 +1099,12 @@ function frameDock() {
         openSkill: (sk) => openTab({ id: 'skill:' + sk.id, kind: 'skill', title: sk.label || sk.skill || sk.id, skillId: sk.id, repo: state.product || null, slug: null, role: 'SKILL' }),
       }),
       fold: dockParts ? dockParts.fold : dockMod.foldButton({ fold: () => window.pmApp.frame.foldDock() }),
+      focus: dockParts ? dockParts.focus : dockMod.focusButton({ toggle: () => window.pmApp.frame.toggleFocus() }),
     };
   }
-  return { session: dockParts.session, fold: isMobile() ? null : dockParts.fold };
+  if (isMobile()) return { session: dockParts.session, fold: null, focus: null };
+  dockMod.paintFocus(dockParts.focus, !!window.pmApp.frame.dockMax);
+  return { session: dockParts.session, fold: dockParts.fold, focus: dockParts.focus };
 }
 
 /**
@@ -1290,6 +1291,7 @@ export function renderTabs(host) {
         newSessionOptsBtn,
         canSplit ? splitBtn : null,
         orientBtn,
+        fr ? fr.focus : null,
         fr ? fr.fold : null),
     ]);
   } else if (ck) {
@@ -1304,7 +1306,7 @@ export function renderTabs(host) {
     ].filter(Boolean);
     extras[0].style.marginLeft = 'auto';
     // The switch sits after `+ session`, so the strip still ends the mockup's way in the fixture, which does not draw it.
-    setChildren(tabBar, [...visTabs.map((t) => cockpitTabNode(t, act, splitTab)), ...extras, fr ? fr.session : newSessionBtn, FIXTURE ? null : orientBtn, fr ? fr.fold : null]);
+    setChildren(tabBar, [...visTabs.map((t) => cockpitTabNode(t, act, splitTab)), ...extras, fr ? fr.session : newSessionBtn, FIXTURE ? null : orientBtn, fr ? fr.focus : null, fr ? fr.fold : null]);
   } else {
     tabBar.setAttribute('style', BAR_STYLE);
     newSessionBtn.setAttribute('style', CHIP_STYLE);
@@ -1363,7 +1365,7 @@ export function renderTabs(host) {
     newSessionBlock(),
     visTabs.length === 0 && !state.startPrompt && !state.newSess ? emptyState : null,
     panesRow,
-    state.scratchOpen ? scratchBlock : null,
+    state.scratchOpen && (FIXTURE || !isMobile()) ? scratchBlock : null,
     bottomBar,
   ]);
 }

package/workspace/public/pm/today-copy.js

@@ -56,6 +56,35 @@ export const COPY = {
   commandShown: (cmd) => `Run this in a terminal: ${cmd}`,
   noInitiative: 'This card names no initiative.',
   sessionGone: 'That session has ended.',
+  /** The goals for today (initiative today-goals, PRD G6). The word for what the session finds is "step", never a plan. */
+  goals: {
+    title: 'Goals for today',
+    toggle: (open, total) => (total ? `Goals for today · ${open} open of ${total}` : 'Set your goals for today'),
+    intro: 'List what you want done today. Prepare my day then finds the meetings, mentions and steps that move each goal.',
+    inputLabel: 'Add a goal',
+    inputHint: 'What do you want done today? Press Enter to add it.',
+    full: (max) => `A day has at most ${max} goals. Drop or remove one to add another.`,
+    prepareDay: 'Prepare my day',
+    prepareDayHint: 'Starts a session that reads your calendar and your Slack, Jira and Confluence mentions, and ties what it finds to your goals.',
+    started: 'The session started. The steps show here when it is done.',
+    coverage: { planned: 'has steps', 'needs-plan': 'no step yet', done: 'done', dropped: 'dropped' },
+    done: 'Done', drop: 'Drop', reopen: 'Reopen', remove: 'Remove',
+    you: 'You', agent: 'Agent', mention: 'mention',
+    noStep: 'No step found yet. Press Prepare my day, or open the initiative.',
+    prepare: 'Prepare',
+    queue: 'Queue it',
+    prepareShows: (key, branch) => `${key} on ${branch || 'a local branch'}. Queue it to approve this exact prompt.`,
+    queued: (key) => `Queued ${key}. It starts when background prepare is on and the budget and quiet hours allow.`,
+    also: 'Also on your plate',
+    worthAsking: 'Worth asking',
+    free: (min, until) => `${Math.floor(min / 60)} h ${min % 60} min free until ${until}.`,
+    comingUp: (title, at) => `Coming up: ${title} at ${at}.`,
+    notRead: (list) => `Not read: ${list}.`,
+    stale: (date) => `What was read is from ${date}. It is out of date, so only what Today found is used.`,
+    noBrief: 'Nothing was read yet today. Press Prepare my day to read your calendar and mentions.',
+    refused: (why) => `Nothing changed. ${why}`,
+    unreached: 'The workspace did not answer.',
+  },
   /** The Acceptance Gate card (D12): the PM's own act on a run. */
   accept: {
     review: 'Review',

package/workspace/public/pm/today-goals.js

@@ -0,0 +1,172 @@
+/* pm/today-goals.js — the goals for today at the top of Today (initiative today-goals, PRD G5 and G6).
+ *
+ *   goalsSection({ ws, setState })  → the section node, or null in fixture mode
+ *   goalsSig(ws)                    → a string that changes whenever what the section shows changes
+ *
+ * The server joins the goals to what the morning-brief session read and to Today's cards (lib/goals.js planDay, GET /api/proactive/goals).
+ * This module draws that answer and sends the PM's presses: add, done, drop, reopen, remove, "Prepare my day" (runs the
+ * morning-brief schedule) and, on an agent step that names an initiative, Prepare then Queue it (the shipped background
+ * prepare: one approval is one prompt hash).
+ *
+ * FIRST PAINT. Folded, the section is one control (its toggle) and a list of the goals as text, so Today keeps inside its
+ * control budget (first-paint-today.test.js). The input and the buttons are drawn only when the PM opens it.
+ */
+
+import { el } from './dom.js';
+import { button, field, badge, toast } from './primitives.js';
+import { pmGet, pmPost } from './http.js';
+import { FIXTURE } from './state.js';
+import { COPY } from './today-copy.js';
+
+const G = COPY.goals;
+const POLL_MS = 30000;
+const cache = new Map();        // ws -> { data, error, at }
+let open = false;
+let draft = '';
+const prepared = new Map();     // step ref -> { key, branch, item_id, prompt_sha, initiative_id, ws } (a plan shown, not yet queued)
+let rerender = () => {};
+let timer = null;
+
+async function load(ws) {
+  const out = await pmGet('/api/proactive/goals' + (ws ? '?ws=' + encodeURIComponent(ws) : ''));
+  const prev = cache.get(ws);
+  const next = out && out.ok ? { data: out, error: null, at: Date.now() } : { data: prev ? prev.data : null, error: (out && out.error) || G.unreached, at: Date.now() };
+  cache.set(ws, next);
+  if (!prev || JSON.stringify(prev.data) !== JSON.stringify(next.data) || prev.error !== next.error) rerender();
+}
+
+function ensure(ws) {
+  if (!cache.has(ws)) { cache.set(ws, { data: null, error: null, at: 0 }); load(ws); }
+  if (!timer && typeof window !== 'undefined') {
+    timer = setInterval(() => { for (const w of cache.keys()) load(w); }, POLL_MS);
+  }
+}
+
+async function press(ws, body) {
+  const r = await pmPost('/api/proactive/goals', body);
+  if (!r || r.ok === false) { toast({ text: G.refused((r && r.error) || G.unreached), tone: 'destructive' }); return false; }
+  await load(ws);
+  return true;
+}
+
+async function prepareDay(ws) {
+  const r = await pmPost('/api/proactive/goals/plan', { ws });
+  toast({ text: r && r.ok ? G.started : G.refused((r && r.error) || G.unreached), tone: r && r.ok ? undefined : 'destructive' });
+  load(ws);
+}
+
+async function prepareStep(ws, st) {
+  const r = await pmPost('/api/proactive/prepare/plan', { ws, initiative_id: st.initiative_id });
+  if (!r || r.ok === false) { toast({ text: G.refused((r && r.error) || G.unreached), tone: 'destructive' }); return; }
+  if (r.refused) { toast({ text: G.refused(r.refused.why) }); return; }
+  prepared.set(st.ref, { key: r.item.key, branch: r.plan && r.plan.branch, item_id: r.item.id, prompt_sha: r.prompt_sha, initiative_id: st.initiative_id, ws: r.ws || ws });
+  rerender();
+}
+
+async function queueStep(ref) {
+  const p = prepared.get(ref);
+  if (!p) return;
+  const r = await pmPost('/api/proactive/prepare/queue', { confirm: true, ws: p.ws, initiative_id: p.initiative_id, item_id: p.item_id, prompt_sha: p.prompt_sha });
+  prepared.delete(ref);
+  toast({ text: r && r.ok ? G.queued(p.key) : G.refused((r && r.error) || G.unreached), tone: r && r.ok ? undefined : 'destructive' });
+  rerender();
+}
+
+const hhmm = (iso) => { const d = new Date(iso); return Number.isNaN(d.getTime()) ? String(iso) : `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`; };
+
+function stepNode(ws, st, opened) {
+  const who = st.owner === 'pm' ? G.you : G.agent;
+  const meta = [st.source, st.mention ? G.mention : null, st.effort].filter(Boolean).join(' · ');
+  const p = prepared.get(st.ref);
+  const acts = !opened || !st.prepare ? null
+    : p ? el('span', { class: 'td-goal__prep' }, el('span', { class: 'td-goal__prep-text' }, G.prepareShows(p.key, p.branch)),
+      button({ label: G.queue, size: 'sm', attrs: { 'data-goal-queue': st.ref }, onClick: () => queueStep(st.ref) }))
+      : button({ label: G.prepare, size: 'sm', variant: 'ghost', attrs: { 'data-goal-prepare': st.ref }, onClick: () => prepareStep(ws, st) });
+  return el('li', { class: 'td-goal__step', 'data-goal-step': st.ref },
+    badge({ text: who, tone: st.owner === 'pm' ? 'outline' : 'muted' }),
+    el('span', { class: 'td-goal__step-title' }, st.title),
+    meta ? el('span', { class: 'td-goal__meta' }, meta) : null,
+    acts);
+}
+
+function goalNode(ws, g, opened) {
+  const closed = g.status !== 'open';
+  const ctrls = opened ? el('span', { class: 'td-goal__ctrls' },
+    ...(closed
+      ? [button({ label: G.reopen, size: 'sm', variant: 'ghost', attrs: { 'data-goal-act': 'reopen' }, onClick: () => press(ws, { action: 'reopen', id: g.id }) })]
+      : [button({ label: G.done, size: 'sm', attrs: { 'data-goal-act': 'done' }, onClick: () => press(ws, { action: 'done', id: g.id }) }),
+        button({ label: G.drop, size: 'sm', variant: 'ghost', attrs: { 'data-goal-act': 'drop' }, onClick: () => press(ws, { action: 'drop', id: g.id }) })]),
+    button({ label: G.remove, size: 'sm', variant: 'ghost', attrs: { 'data-goal-act': 'remove' }, onClick: () => press(ws, { action: 'remove', id: g.id }) })) : null;
+  const ctx = (g.context || []).map((e) => el('li', { class: 'td-goal__ctx' }, `${hhmm(e.start)} ${e.title}${e.with ? ' · ' + e.with : ''}`));
+  const body = opened && !closed ? el('div', { class: 'td-goal__body' },
+    ctx.length ? el('ul', { class: 'td-goal__ctx-list' }, ...ctx) : null,
+    g.steps.length ? el('ul', { class: 'td-goal__steps' }, ...g.steps.map((st) => stepNode(ws, st, opened))) : el('p', { class: 'td-goal__none' }, G.noStep)) : null;
+  return el('li', { class: 'td-goal' + (closed ? ' td-goal--closed' : ''), 'data-goal': g.id, 'data-goal-coverage': g.coverage },
+    el('div', { class: 'td-goal__head' },
+      el('span', { class: 'td-goal__text' }, g.text),
+      badge({ text: G.coverage[g.coverage] || g.coverage, tone: g.coverage === 'needs-plan' ? 'warning' : 'muted' }),
+      g.initiative_id ? el('span', { class: 'td-goal__meta' }, g.initiative_id) : null,
+      ctrls),
+    body);
+}
+
+function stepList(ws, title, steps, attr) {
+  if (!steps.length) return null;
+  return el('div', { class: 'td-goals__also', 'data-goals': attr },
+    el('p', { class: 'td-goals__sub' }, title),
+    el('ul', { class: 'td-goal__steps' }, ...steps.map((st) => stepNode(ws, st, true))));
+}
+
+/** The section. `ws` is the repository whose Today cards the goals are joined to. */
+export function goalsSection({ ws, setState } = {}) {
+  if (FIXTURE) return null;
+  // like Today's own feeds, a read that lands re-renders only while the section is on the page: a hidden Today must not
+  // cause a whole-page render under whatever the PM is doing elsewhere
+  if (setState) rerender = () => { if (document.querySelector('[data-today="goals"]')) setState({}); };
+  ensure(ws);
+  const c = cache.get(ws) || {};
+  const d = c.data;
+  const plan = d && d.plan;
+  const goals = plan ? plan.goals : [];
+  const openN = goals.filter((g) => g.status === 'open').length;
+  const toggle = button({ label: G.toggle(openN, goals.length), variant: 'ghost', iconEnd: open ? 'chevron-down' : 'chevron-right',
+    attrs: { 'data-goals': 'toggle', 'aria-expanded': open ? 'true' : 'false' }, onClick: () => { open = !open; rerender(); } });
+  const list = goals.length ? el('ol', { class: 'td-goals__list', 'data-goals': 'list' }, ...goals.map((g) => goalNode(ws, g, open))) : null;
+  const kids = [el('div', { class: 'td-goals__head' }, toggle), list];
+  if (c.error) kids.push(el('p', { class: 'td-goals__note', role: 'status' }, G.refused(c.error)));
+  if (open) {
+    if (!goals.length) kids.push(el('p', { class: 'td-goals__note' }, G.intro));
+    const max = (d && d.max_goals) || 7;
+    if (goals.length < max) {
+      const f = field({ label: G.inputLabel, value: draft, placeholder: G.inputHint, hideLabel: true, attrs: { 'data-goals': 'input', maxlength: '140' },
+        onCommit: async (v) => {
+          draft = v;
+          if (!String(v).trim()) return;
+          if (await press(ws, { action: 'add', text: v })) { draft = ''; if (f.control.resetCommitted) f.control.resetCommitted(''); rerender(); }
+        } });
+      f.control.addEventListener('input', () => { draft = f.control.value; });   // a rebuild keeps what is typed
+      kids.push(f);
+    } else kids.push(el('p', { class: 'td-goals__note' }, G.full(max)));
+    kids.push(el('div', { class: 'td-goals__bar' },
+      button({ label: G.prepareDay, attrs: { 'data-goals': 'prepare-day', title: G.prepareDayHint }, disabled: !openN, onClick: () => prepareDay(ws) })));
+    if (plan) {
+      const lines = [];
+      if (!plan.brief) lines.push(G.noBrief);
+      else if (!plan.brief.fresh) lines.push(G.stale(plan.brief.date));
+      if (plan.time) {
+        lines.push(G.free(plan.time.free_minutes, plan.time.until));
+        if (plan.time.next) lines.push(G.comingUp(plan.time.next.title, hhmm(plan.time.next.start)));
+      }
+      if (plan.not_read && plan.not_read.length) lines.push(G.notRead(plan.not_read.map((x) => x.source).join(', ')));
+      if (lines.length) kids.push(el('p', { class: 'td-goals__note', 'data-goals': 'context' }, lines.join(' ')));
+      kids.push(stepList(ws, G.also, plan.also || [], 'also'));
+      kids.push(stepList(ws, G.worthAsking, plan.worth_asking || [], 'worth-asking'));
+    }
+  }
+  return el('section', { class: 'td-goals', 'data-today': 'goals', 'aria-label': G.title }, ...kids.filter(Boolean));
+}
+
+export function goalsSig(ws) {
+  const c = cache.get(ws) || {};
+  return JSON.stringify([open, c.data && c.data.plan, c.error, [...prepared.keys()]]);
+}

package/workspace/replaced-tests.json

@@ -24,6 +24,19 @@
       "ref": "contract-run2 done_criteria 14 (the plan-routes.test.js Origin cases)",
       "reason": "R9 asserted the route's own no-Origin text, which named the terminal route. After Run 2 the route runs pm-guard first, so R9 now asserts pm-guard's refusal; the 403 and the nothing-written check stay.",
       "names": ["R9 a POST with no Origin is 403 and names the terminal route; nothing is written"]
+    },
+    {
+      "id": "STG-SLACK",
+      "file": "workspace/proactive.test.js",
+      "run": "today-goals",
+      "ref": "planning/prd/today-goals-prd.md G2 (slack becomes a brief source)",
+      "reason": "These four assertions used slack as the example of an unknown brief source. today-goals G2 makes slack a known source, so each now uses teams as the unknown name; the refusal and its reason are asserted unchanged.",
+      "names": [
+        "G5 a non-object, a bad date and an unknown source are refused with the reason",
+        "G6 a confidence outside 0 to 1, a bad owner, a bad effort, a missing why_now and an unknown item source are each refused",
+        "G14 the new settings are checked: name length, source names, booleans",
+        "I6 an unknown brief source is refused with the allowed names"
+      ]
     }
   ],
   "entries": [