create-pmos 0.73.0 → 0.75.0

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

@@ -25,7 +25,7 @@
  */
 
 import { el } from './dom.js';
-import { button, iconButton, badge, toast, row, tabs, field } from './primitives.js';
+import { button, iconButton, badge, toast, row, tabs, field, menu, meter } from './primitives.js';
 import { pmGet, pmPost } from './http.js';
 import { FIXTURE } from './state.js';
 import { COPY } from './today-copy.js';
@@ -35,6 +35,7 @@ import { agendaPanel, meetingDetail, memoryBlock, refreshAgenda, agendaSig, onAg
 import { notesBlock, onNotes } from './notes-links.js';
 
 const D = COPY.day;
+const A = COPY.act;
 const SLOW_MS = 30000;
 const FAST_MS = 4000;
 const MAX_REVISIONS = 3;
@@ -58,6 +59,8 @@ const ui = {
   open: (() => { const v = store.get(OPEN_KEY); return v === 'true' ? true : v === 'false' ? false : null; })(),
   sel: null, mtab: 'all', openSrc: null, showIgn: {}, showIgnDigests: false,
   revising: new Set(), notes: new Map(), siteDraft: '', placeDraft: {}, busy: new Set(), scroll: false,
+  // today-act-prepare: the folded groups the PM opened, the item whose hold form is open, and its draft
+  groupsOpen: new Set(), holding: null, holdDraft: { who: '', when: 'h2' }, compose: new Map(), verdict: new Map(),
 };
 let rerender = () => {};
 let notesSub = null;         // the redraw when the meeting notes list is read (pm/notes-links.js)
@@ -119,7 +122,8 @@ const isUrl = (s) => typeof s === 'string' && s.length <= 500 && /^https?:\/\/\S
 const srcName = (k) => D.srcName[k] || (k === 'derived' ? 'PMOS' : String(k || ''));
 
 function jobOf(item, task, worth) {
-  const kind = (item && item.kind) || (task && task.kind) || (item && item.owner === 'pm' ? 'you' : 'approve');
+  // a job the PM gave to the agent (Have the agent draft it) has the task's kind: approve
+  const kind = (task && task.kind) || (item && item.kind) || (item && item.owner === 'pm' ? 'you' : 'approve');
   const status = task ? task.status : kind === 'you' ? 'you' : 'notStarted';
   const group = worth ? 'worth' : ['you', 'review', 'failed'].includes(status) ? 'needs' : ['done', 'sent'].includes(status) ? 'done' : 'working';
   return {
@@ -160,10 +164,20 @@ function model(d, view) {
   for (const x of (brief && brief.worth_asking) || []) add(x, true);
   for (const t of tasks) if (!used.has(t.id)) jobs.push(jobOf(null, t, false));   // an item a check took off: its task stays
   const now = d && d.now ? (typeof d.now === 'number' ? d.now : Date.parse(d.now)) : Date.now();
+  const marks = (d && d.marks) || {};
   const events = ((brief && brief.calendar) || []).map((e, i) => {
     const s = Date.parse(e.start);
     const f = e.end ? Date.parse(e.end) : s + 30 * 60000;
-    return { ...e, id: e.id || 'ev-' + i, s, f, time: hhmm(e.start), ended: Number.isFinite(f) && f <= now };
+    const mark = marks[e.id] || null;
+    const checked = new Set((mark && mark.steps) || []);
+    const before = ((e.steps && e.steps.before) || []).map((st) => ({ ...st, done: !!st.done || checked.has(String(st.t || '')) }));
+    const ended = Number.isFinite(f) && f <= now;
+    // a meeting needs prep when the brief gave a prep line or Before steps (the explainer's contradiction: Before steps
+    // with no prep line read "Nothing to prepare" while the Agenda counted them as prep left)
+    const needsPrep = !ended && (!!e.prep || before.length > 0);
+    const st = mark && mark.state;
+    const group = !needsPrep ? null : st === 'done' || st === 'dismissed' ? 'done' : st === 'snoozed' ? 'later' : 'needs';
+    return { ...e, id: e.id || 'ev-' + i, s, f, time: hhmm(e.start), ended, mark, before, needsPrep, group };
   }).sort((a, b) => a.s - b.s);
   const settings = (d && d.settings) || null;
   const scopes = (settings && settings.scopes) || {};
@@ -176,6 +190,13 @@ function model(d, view) {
   const repos = (d && Array.isArray(d.repos)) ? d.repos : [];
   const repoName = (id) => { const r = repos.find((x) => x.id === id); return r ? r.name : id; };
   for (const j of jobs) j.repo = itemRepos[j.id] || null;
+  // the PM's marks (today-act-prepare, PRD M1 to M6): a job the PM owns leaves Needs you when it is done, snoozed, held
+  // or not the PM's; a snooze or hold whose time has passed comes back as open (the server reads it so)
+  for (const j of jobs) {
+    j.mark = marks[j.id] || null;
+    const st = j.mark && j.mark.state;
+    if (j.status === 'you' && st) j.group = { done: 'done', dismissed: 'done', snoozed: 'later', waiting: 'waiting' }[st] || j.group;
+  }
   for (const g of digests) g.repo = placeRepo(g.source, g.name);
   const v = view || {};
   const narrow = !v.all && !!v.here;
@@ -193,8 +214,9 @@ function model(d, view) {
     readFailed: (d && d.read_failed) || null,
     free: plan && plan.time ? plan.time.free_minutes : null,
     maxGoals: (d && d.max_goals) || 7,
-    needs: shownJobs.filter((j) => j.group === 'needs').length,
-    done: shownJobs.filter((j) => j.group === 'done').length,
+    preps: events.filter((e) => e.needsPrep),
+    needs: shownJobs.filter((j) => j.group === 'needs').length + events.filter((e) => e.group === 'needs').length,
+    done: shownJobs.filter((j) => j.group === 'done').length + events.filter((e) => e.group === 'done').length,
   };
 }
 
@@ -226,7 +248,7 @@ function statusPill(j) {
   const map = {
     notStarted: [s.notStarted, ''], waiting: [s.waiting, ''], working: [s.working, 'info'], sending: [s.sending, 'info'],
     review: [j.kind === 'auto' ? s.reviewAuto : s.review, 'purple'], sent: [s.sent, 'ok'], done: [s.done, 'ok'],
-    failed: [s.failed, 'bad'], you: [s.you, 'warn'],
+    failed: [s.failed, 'bad'],
   };
   const [t, tone] = map[j.status] || [j.status, ''];
   return pill(t, tone, { 'data-day-status': j.status });
@@ -306,6 +328,48 @@ async function decide(ws, task, action, note) {
   load(ws);
 }
 
+/* The PM's marks (today-act-prepare, PRD M1 to M6). Every press but a step check says what it did, with Undo: the
+ * answer carries the mark before the press, and Undo puts it back. */
+async function markPress(ws, id, op, said) {
+  const key = 'mark:' + id;
+  if (ui.busy.has(key)) return;
+  ui.busy.add(key); rerender();
+  const r = await pmPost('/api/proactive/day/mark', { id, ...op });
+  ui.busy.delete(key);
+  if (r && r.ok) {
+    if (op.action !== 'step') ui.holding = null;
+    if (said) toast({ text: said, actionLabel: A.undo, onAction: () => undoMark(ws, id, r.prev) });
+  } else toast({ text: (op.action === 'step' ? A.stepFailed : D.refused)((r && r.error) || D.unreached), tone: 'destructive' });
+  rerender();
+  load(ws);
+}
+async function undoMark(ws, id, prev) {
+  const r = await pmPost('/api/proactive/day/mark', { id, action: 'restore', mark: prev === undefined ? null : prev });
+  toast(r && r.ok ? { text: A.undone } : { text: D.refused((r && r.error) || D.unreached), tone: 'destructive' });
+  load(ws);
+}
+/** "Have the agent draft it" (PRD C2): one briefed task for this job; the job then shows the draft to approve. */
+async function sendPress(ws, j, body, to) {
+  const key = 'send:' + j.id;
+  if (ui.busy.has(key)) return;
+  ui.busy.add(key); rerender();
+  const r = await pmPost('/api/proactive/day/send', { item: j.id, ws, ...body });
+  ui.busy.delete(key);
+  if (r && r.ok) { ui.compose.delete(j.id); ui.verdict.delete(j.id); toast({ text: A.sendStarted(to) }); } else toast({ text: D.refused((r && r.error) || D.unreached), tone: 'destructive' });
+  rerender();
+  load(ws);
+}
+async function draftPress(ws, j) {
+  const key = 'draft:' + j.id;
+  if (ui.busy.has(key)) return;
+  ui.busy.add(key); rerender();
+  const r = await pmPost('/api/proactive/day/draft', { item: j.id, ws });
+  ui.busy.delete(key);
+  toast(r && r.ok ? { text: A.draftStarted } : { text: D.refused((r && r.error) || D.unreached), tone: 'destructive' });
+  rerender();
+  load(ws);
+}
+
 async function setSettings(ws, patch) {
   const r = await pmPost('/api/proactive/settings', patch);
   if (!r || r.ok === false) { toast({ text: D.refused((r && r.error) || D.unreached), tone: 'destructive' }); return false; }
@@ -421,7 +485,11 @@ function jobRow(ctx, j) {
   const n = j.goal ? ctx.m.goalNo.get(j.goal) : null;
   const sub = j.status === 'failed' && j.task && j.task.error ? j.task.error
     : [j.item && j.item.where, srcName(j.source)].filter(Boolean).join(' · ');
-  return rowBtn(ctx, 'job', j.id, { lead: n ? D.pill.goal(n) : '·', title: j.title, meta: sub, trail: el('span', { class: 'td-day__chips' }, repoTag(ctx.m, j.repo), statusPill(j)),
+  const mine = j.status === 'you';
+  const due = mine && j.item && j.item.due ? Date.parse(j.item.due) : NaN;
+  const meta = mine && j.mark && j.mark.state === 'waiting' ? `${A.hold.replace('…', '')} ${j.mark.on}` : sub;
+  return rowBtn(ctx, 'job', j.id, { lead: mine ? verbChip(verbOf(j.item)) : n ? D.pill.goal(n) : '·', title: j.title, meta,
+    trail: el('span', { class: 'td-day__chips' }, repoTag(ctx.m, j.repo), mine ? dueChip(ctx.m, j.mark, due, false) : statusPill(j)),
     dot: j.isNew && !seen.has(j.id) ? el('span', { class: 'td-day__newdot', 'data-day': 'new', role: 'img', 'aria-label': D.newItem }) : null });
 }
 
@@ -438,18 +506,38 @@ function owedItems(owed) {
   });
 }
 
+/** A meeting to prepare for, as a row of the jobs (PRD D4): it selects the meeting. */
+function prepRow(ctx, e) {
+  const total = e.before.length; const d = e.before.filter((x) => x.done).length;
+  return rowBtn(ctx, 'event', e.id, { lead: verbChip('prepare'), title: e.title, meta: [total ? A.readiness(d, total) : null, e.with || null].filter(Boolean).join(' · '),
+    trail: dueChip(ctx.m, e.mark, e.s, true) }, { 'data-day-prep': e.id });
+}
+
 function owedRow(ctx, o) {
-  return rowBtn(ctx, 'owed', o.id, { lead: '·', title: o.title, meta: o.meta, trail: pill(D.status2.you, 'warn') });
+  return rowBtn(ctx, 'owed', o.id, { lead: '·', title: o.title, meta: o.meta, trail: pill(A.chip.today, 'warn', { 'data-day-status': 'you' }) });
 }
 
+// Needs you holds only what the PM can do now (PRD D1): snoozed, held and done items fold into groups of their own.
+const JOB_GROUPS = ['needs', 'later', 'waiting', 'working', 'done', 'worth'];
+const FOLDED = new Set(['later', 'waiting', 'done']);
 function jobsPanel(ctx) {
   const { m } = ctx;
   const owed = ctx.owed;
-  if (!m.jobs.length && !owed.length) return panel('jobs', null, note(m.run && m.stage === 'reading' ? D.readingJobs : D.noJobs, { 'data-day': 'no-jobs' }));
-  const groups = ['needs', 'working', 'done', 'worth'].map((g) => [g, m.jobs.filter((j) => j.group === g)]).filter(([g, l]) => l.length || (g === 'needs' && owed.length));
-  return panel('jobs', D.jobsCount(m.needs + owed.length, m.done), ...groups.map(([g, l]) => el('div', { class: 'td-day__group', 'data-day-group': g },
-    el('div', { class: 'td-day__gh' }, D.groups[g], pill(String(l.length + (g === 'needs' ? owed.length : 0)), '')),
-    el('ul', { class: 'td-day__rows', 'data-day-list': 'jobs-' + g }, ...l.map((j) => jobRow(ctx, j)), ...(g === 'needs' ? owed.map((o) => owedRow(ctx, o)) : [])))));
+  if (!m.jobs.length && !owed.length && !m.preps.length) return panel('jobs', null, note(m.run && m.stage === 'reading' ? D.readingJobs : D.noJobs, { 'data-day': 'no-jobs' }));
+  const groups = JOB_GROUPS.map((g) => [g, m.jobs.filter((j) => j.group === g), m.preps.filter((e) => e.group === g)])
+    .filter(([g, l, p]) => l.length || p.length || (g === 'needs' && owed.length));
+  return panel('jobs', D.jobsCount(m.needs + owed.length, m.done), ...groups.map(([g, l, p]) => {
+    const count = l.length + p.length + (g === 'needs' ? owed.length : 0);
+    const label = A.groups[g] && g !== 'done' ? A.groups[g] : g === 'done' ? A.groups.done : D.groups[g];
+    const foldable = FOLDED.has(g);
+    const shut = foldable && !ui.groupsOpen.has(g);
+    const head = foldable
+      ? button({ label: `${label} · ${count}`, variant: 'ghost', size: 'sm', iconEnd: shut ? 'chevron-right' : 'chevron-down', attrs: { class: 'td-day__fold-head', 'aria-expanded': shut ? 'false' : 'true', 'data-day-fold': g },
+        onClick: () => { if (shut) ui.groupsOpen.add(g); else ui.groupsOpen.delete(g); rerender(); } })
+      : el('div', { class: 'td-day__gh' }, label, pill(String(count), ''));
+    return el('div', { class: 'td-day__group', 'data-day-group': g }, head,
+      shut ? null : el('ul', { class: 'td-day__rows', 'data-day-list': 'jobs-' + g }, ...p.map((e) => prepRow(ctx, e)), ...l.map((j) => jobRow(ctx, j)), ...(g === 'needs' ? owed.map((o) => owedRow(ctx, o)) : [])));
+  }));
 }
 
 /* The coordinator's view of the run: what every agent job came back with, in one place. The server runs the jobs as one
@@ -489,7 +577,8 @@ function goalsPanel(ctx) {
 
 function mentionStatus(j) {
   if (j.group === 'done') return pill(D.status2.handled, 'ok');
-  if (j.status === 'you') return j.item && j.item.reply_needed ? pill(D.status2.replyNeeded, 'warn') : pill(D.status2.you, 'warn');
+  if (j.status === 'you' && j.mark && j.mark.state) return dueChip({ now: Date.now() }, j.mark, NaN, false);
+  if (j.status === 'you') return j.item && j.item.reply_needed ? pill(D.status2.replyNeeded, 'warn', { 'data-day-status': 'you' }) : verbChip(verbOf(j.item));
   return statusPill(j);
 }
 
@@ -523,6 +612,243 @@ function mentionsPanel(ctx) {
   return panel('mentions', m.mentions.length ? D.mentionsCount(m.mentions.length, need) : null, mtabs, rows, dig);
 }
 
+/* ── act and prepare (initiative today-act-prepare) ─────────────────────────────────────────────────────────────── */
+
+const MIN_MS = 60000;
+const clockAt = (ms, hh, mm) => { const d = new Date(ms); return new Date(d.getFullYear(), d.getMonth(), d.getDate(), hh, mm).getTime(); };
+const sameDay = (a, b) => new Date(a).toDateString() === new Date(b).toDateString();
+const verbOf = (it) => (it && A.verb[it.verb] ? it.verb : it && it.reply_needed ? 'reply' : 'do');
+function verbChip(verb) {
+  return el('span', { class: 'td-day__verb', 'data-verb': verb, 'data-day': 'verb' }, A.verb[verb] || A.verb.do);
+}
+/** The chip at the end of a row the PM acts on: where its mark left it, else its due time, coloured by time left. */
+function dueChip(m, mark, due, prep) {
+  const st = mark && mark.state;
+  const at = (v) => hhmm(v);
+  if (st === 'snoozed') return pill(A.back(at(mark.until)), '', { 'data-day-status': 'snoozed' });
+  if (st === 'waiting') return pill(A.check(at(mark.until)), '', { 'data-day-status': 'waiting' });
+  if (st === 'done') return pill(prep ? A.chip.ready : A.chip.done, 'ok', { 'data-day-status': 'marked-done' });
+  if (st === 'dismissed') return pill(prep ? A.chip.skipped : A.chip.dismissed, '', { 'data-day-status': 'dismissed' });
+  const status = prep ? 'prepare' : 'you';
+  if (!Number.isFinite(due)) return pill(A.chip.today, 'warn', { 'data-day-status': status });
+  const left = Math.round((due - m.now) / MIN_MS);
+  return pill(prep ? A.at(at(due)) : A.by(at(due)), left < 60 ? 'bad' : left < 180 ? 'warn' : '', { 'data-day-status': status, title: A.left(left) });
+}
+/** The times a snooze can take, later today: [label, ms]. */
+function snoozeTimes(m, { due, start }) {
+  const out = [];
+  const add = (label, t) => { if (Number.isFinite(t) && t > m.now + 5 * MIN_MS && sameDay(t, m.now) && !out.some((x) => x[1] === t)) out.push([label, t]); };
+  if (Number.isFinite(start)) { add(A.snoozeTo.m30, start - 30 * MIN_MS); add(A.snoozeTo.m15, start - 15 * MIN_MS); return out; }
+  add(A.snoozeTo.hour, m.now + 60 * MIN_MS);
+  if (Number.isFinite(due)) add(A.snoozeTo.due, due - 30 * MIN_MS);
+  add(A.snoozeTo.later, clockAt(m.now, 16, 0));
+  add(A.snoozeTo.end, clockAt(m.now, 17, 30));
+  return out;
+}
+/** The banner of a marked item: what the mark is, and the press that undoes it. */
+function markBanner(ctx, id, mark, prep) {
+  if (!mark) return null;
+  if (mark.back) return note(A.state.back, { 'data-day': 'mark-back' });
+  const st = mark.state;
+  if (!st) return null;
+  const text = st === 'snoozed' ? A.state.snoozed(hhmm(mark.until)) : st === 'waiting' ? A.state.waiting(mark.on, hhmm(mark.until))
+    : st === 'done' ? (prep ? A.state.ready : A.state.done)(hhmm(mark.at)) : A.state.dismissed(A.why[mark.why] || mark.why);
+  return el('div', { class: 'td-day__mark', 'data-day': 'mark', 'data-day-mark-state': st }, el('span', null, text),
+    button({ label: st === 'done' ? A.reopen : A.bringBack, size: 'sm', attrs: { 'data-day-mark': 'reopen' }, onClick: () => markPress(ctx.ws, id, { action: 'reopen' }, A.did.reopen) }));
+}
+/** The steps the PM checks off. A step the brief already marked done stays done. A step that reads a source shows what
+ *  the source says under it (PRD X2), and a note step holds the PM's own note (PRD F3), so no other file needs opening. */
+function stepChecks(ctx, id, steps, { refs = [], mark = null } = {}) {
+  if (!steps.length) return null;
+  return el('ul', { class: 'td-day__steps2', 'data-day': 'steps' }, ...steps.map((st) => {
+    const f = field({ kind: 'check', label: st.t, value: !!st.done, attrs: { 'data-day-step': st.t, disabled: st.fixed ? true : null },
+      onCommit: (v) => markPress(ctx.ws, id, { action: 'step', step: st.t, done: !!v }) });
+    const r = Number.isInteger(st.ref) ? refs[st.ref] : null;
+    return el('li', { class: 'td-day__step2', 'data-done': st.done ? 'true' : 'false' },
+      el('div', { class: 'td-day__steprow' }, f, st.who ? el('span', { class: 'td-day__who' }, D.who[st.who] || st.who) : null),
+      r ? refBlock(r, { open: !st.done, step: true }) : null,
+      st.note ? noteBox(ctx, id, mark) : null);
+  }));
+}
+/** One source in a few lines, in the card: what it says, and a small link to the source for when the PM wants more. */
+function refBlock(r, { open, step } = {}) {
+  return el('details', { class: 'td-day__ref', 'data-day': 'ref', open: open ? true : null },
+    el('summary', null, el('span', null, (step ? A.refRead : '') + r.label), r.source ? el('span', { class: 'td-day__src' }, srcName(r.source)) : null),
+    el('ul', { class: 'td-day__reflines' }, ...(r.lines || []).map((l) => el('li', null, l))),
+    isUrl(r.link) ? extLink(A.refOpen, r.link, { 'data-day-link': 'ref' }) : null);
+}
+/** The sources no step names, under one heading. */
+function refsBlock(refs, steps) {
+  const named = new Set(steps.map((st) => st.ref).filter(Number.isInteger));
+  const rest = refs.filter((_, i) => !named.has(i));
+  return rest.length ? el('div', { class: 'td-day__phase', 'data-day': 'refs' }, el('h4', null, A.refsTitle), ...rest.map((r) => refBlock(r, { open: false }))) : null;
+}
+/** The conversation, as the brief read it: at most 4 messages, the last one first in weight. */
+function threadBlock(thread) {
+  if (!Array.isArray(thread) || !thread.length) return null;
+  return el('div', { class: 'td-day__phase td-day__thread', 'data-day': 'thread' }, el('h4', null, A.threadTitle),
+    ...thread.map((x, i) => el('div', { class: 'td-day__msg' + (i === thread.length - 1 ? ' td-day__msg--last' : '') },
+      el('div', { class: 'td-day__src' }, [x.who, x.at].filter(Boolean).join(' · ')), el('p', null, x.text))));
+}
+/** The PM's own note on a meeting, saved with its marks when the box loses focus. Nothing is sent. */
+function noteBox(ctx, id, mark) {
+  const f = field({ label: A.noteTitle, kind: 'textarea', value: (mark && mark.note) || '', placeholder: A.noteHint, attrs: { maxlength: '1000', 'data-day-input': 'note' },
+    onCommit: (v) => markPress(ctx.ws, id, { action: 'note', text: v }, A.noteSaved) });
+  return el('div', { class: 'td-day__notebox', 'data-day': 'note' }, f, el('span', { class: 'td-day__dim' }, A.noteStays));
+}
+/** Where the PM's own answer goes, and the box to write it in (PRD F1, F2). The press is the approval: the agent posts
+ *  exactly this text, as the PM, to the place the item names. */
+function composer(ctx, j, verb) {
+  const it = j.item || {};
+  const sd = it.send || {};
+  const to = sd.to || it.where || srcName(j.source);
+  const review = !!sd.review;
+  const busy = ui.busy.has('send:' + j.id);
+  const f = field({ label: A.compose[verb] || A.compose.reply, kind: 'textarea', value: ui.compose.get(j.id) || '', placeholder: A.composeHint,
+    attrs: { maxlength: '4000', rows: '4', 'data-day-input': 'compose' } });
+  const ta = f.control;
+  ta.addEventListener('input', () => { ui.compose.set(j.id, ta.value); });
+  const chips = (sd.suggest || []).length ? el('div', { class: 'td-day__chipsrow', 'data-day': 'suggest' }, el('span', { class: 'td-day__dim' }, A.startFrom),
+    ...sd.suggest.map((t, i) => button({ label: t.length > 60 ? t.slice(0, 57) + '…' : t, size: 'sm', variant: 'ghost', attrs: { 'data-day-suggest': String(i), title: t },
+      onClick: () => { ta.value = t; ui.compose.set(j.id, t); ta.focus(); } }))) : null;
+  const verdict = ui.verdict.get(j.id) || null;
+  const toggle = review ? tabs({ variant: 'segmented', role: 'radiogroup', ariaLabel: A.verdictLabel, value: verdict, attrs: { 'data-day': 'verdict' },
+    items: [{ id: 'approve', label: A.verdict.approve }, { id: 'changes', label: A.verdict.changes }], onChange: (k) => { ui.verdict.set(j.id, k); rerender(); } }) : null;
+  const go = () => {
+    const text = (ui.compose.get(j.id) || ta.value || '').trim();
+    if (!text) { toast({ text: A.sendNeed, tone: 'destructive' }); return; }
+    if (review && !verdict) { toast({ text: A.verdictNeed, tone: 'destructive' }); return; }
+    sendPress(ctx.ws, j, { text, verdict: review ? verdict : undefined }, to);
+  };
+  return el('div', { class: 'td-day__compose', 'data-day': 'compose' }, f, chips, toggle,
+    el('div', { class: 'td-day__acts' }, button({ label: review ? A.postReview(to) : A.sendTo(to), variant: 'primary', size: 'sm', iconEnd: 'arrow-right', disabled: busy, attrs: { 'data-day-act': 'send' }, onClick: go })),
+    el('span', { class: 'td-day__dim' }, A.sendNote));
+}
+/** The four presses of a job (Mark done, Snooze, Waiting on…, Not mine) or the three of a meeting (Mark ready, Remind
+ *  me, Skip prep). `strong` makes the first one the primary button: every step is checked. */
+function marksBar(ctx, { id, title, kind, due, start, strong }) {
+  const { m, ws } = ctx;
+  const prep = kind === 'event';
+  const busy = ui.busy.has('mark:' + id);
+  const st = (m.d && m.d.marks && m.d.marks[id] && m.d.marks[id].state) || null;
+  const times = snoozeTimes(m, { due, start });
+  const kids = [];
+  if (st !== 'done') kids.push(button({ label: prep ? A.ready : A.done, variant: strong ? 'primary' : 'outline', size: 'sm', icon: 'check', disabled: busy, attrs: { 'data-day-mark': 'done' },
+    onClick: () => markPress(ws, id, { action: 'done' }, (prep ? A.did.ready : A.did.done)(title)) }));
+  if (times.length) {
+    const b = button({ label: prep ? A.remind : A.snooze, size: 'sm', iconEnd: 'chevron-down', disabled: busy, attrs: { 'data-day-mark': 'snooze', 'aria-haspopup': 'menu' },
+      onClick: () => menu({ anchor: b, ariaLabel: prep ? A.remind : A.snooze, items: times.map(([l, t]) => ({ label: `${l} · ${hhmm(t)}`, attrs: { 'data-day-snooze': hhmm(t) },
+        onSelect: () => markPress(ws, id, { action: 'snooze', until: new Date(t).toISOString() }, A.did.snooze(hhmm(t))) })) }) });
+    kids.push(b);
+  }
+  if (!prep) kids.push(button({ label: A.hold, size: 'sm', disabled: busy, attrs: { 'data-day-mark': 'hold', 'aria-expanded': ui.holding === id ? 'true' : 'false' },
+    onClick: () => { ui.holding = ui.holding === id ? null : id; ui.holdDraft = { who: '', when: 'h2' }; rerender(); } }));
+  const reasons = prep ? ['nothing', 'elsewhere'] : ['no-action', 'someone-else', 'done-elsewhere'];
+  if (st !== 'dismissed') {
+    const nb = button({ label: prep ? A.skip : A.notMine, size: 'sm', variant: 'ghost', iconEnd: 'chevron-down', disabled: busy, attrs: { 'data-day-mark': 'dismiss', 'aria-haspopup': 'menu' },
+      onClick: () => menu({ anchor: nb, ariaLabel: prep ? A.skip : A.notMine, items: reasons.map((w) => ({ label: A.why[w], attrs: { 'data-day-why': w },
+        onSelect: () => markPress(ws, id, { action: 'dismiss', why: w }, A.did.dismiss(A.why[w])) })) }) });
+    kids.push(el('span', { class: 'td-day__grow', 'aria-hidden': 'true' }), nb);
+  }
+  return [el('div', { class: 'td-day__marks', 'data-day': 'marks', role: 'group', 'aria-label': title }, ...kids), ui.holding === id && !prep ? holdForm(ctx, id) : null];
+}
+function holdForm(ctx, id) {
+  const { m } = ctx;
+  const h2 = m.now + 120 * MIN_MS; const end = clockAt(m.now, 17, 30);
+  const opts = [['h2', A.holdWhenOpts.h2, h2], ['end', A.holdWhenOpts.end, end]].filter(([, , t]) => t > m.now && sameDay(t, m.now));
+  if (!opts.some((o) => o[0] === ui.holdDraft.when) && opts.length) ui.holdDraft.when = opts[0][0];
+  const who = field({ label: A.holdWho, value: ui.holdDraft.who, placeholder: A.holdHint, attrs: { maxlength: '80', 'data-day-input': 'hold-who' } });
+  who.control.addEventListener('input', () => { ui.holdDraft.who = who.control.value; });
+  const go = () => {
+    const v = (ui.holdDraft.who || '').trim();
+    const o = opts.find((x) => x[0] === ui.holdDraft.when);
+    if (!v || v.length > 80) { toast({ text: A.holdNeed, tone: 'destructive' }); return; }
+    if (!o) return;
+    markPress(ctx.ws, id, { action: 'hold', on: v, until: new Date(o[2]).toISOString() }, A.did.hold(v, hhmm(o[2])));
+  };
+  return el('div', { class: 'td-day__revise', 'data-day': 'hold' }, who,
+    opts.length ? el('div', { class: 'td-day__ch' }, el('span', null, A.holdWhen), tabs({ variant: 'segmented', role: 'radiogroup', ariaLabel: A.holdWhen, value: ui.holdDraft.when,
+      attrs: { 'data-day': 'hold-when' }, items: opts.map(([k, l, t]) => ({ id: k, label: `${l} (${hhmm(t)})` })), onChange: (k) => { ui.holdDraft.when = k; rerender(); } })) : null,
+    el('div', { class: 'td-day__acts' }, button({ label: A.holdGo, variant: 'primary', size: 'sm', disabled: !opts.length, attrs: { 'data-day-act': 'hold-go' }, onClick: go }),
+      button({ label: D.cancel, size: 'sm', variant: 'ghost', onClick: () => { ui.holding = null; rerender(); } })));
+}
+const open0 = (mark) => !mark || !mark.state;
+/** A link drawn as the primary button of a card. */
+function primaryLink(label, href, attrs) {
+  return extLink(label, href, { class: 'td-day__a td-day__a--primary', ...(attrs || {}) });
+}
+
+/** The card of a job only the PM can do (PRD A1, C1, C2, M1, D3): the verb and one sentence, From and Why now, the
+ *  steps, the button that fits, the marks, and the rest of the context folded. */
+function actCard(ctx, j) {
+  const { m } = ctx;
+  const it = j.item || {};
+  const mark = j.mark || null;
+  const verb = verbOf(it);
+  const todo = it.todo || it.how || it.ask || null;
+  const checked = new Set((mark && mark.steps) || []);
+  const steps = (Array.isArray(it.steps) ? it.steps : []).map((x) => (typeof x === 'string' ? { t: x } : x)).map((x) => ({ ...x, done: checked.has(x.t) }));
+  const refs = Array.isArray(it.refs) ? it.refs : [];
+  const canSend = open0(mark) && it.owner === 'pm' && isUrl(j.link) && (!!it.send || ['reply', 'review', 'decide', 'sign-off'].includes(verb));
+  const due = it.due ? Date.parse(it.due) : NaN;
+  const n = j.goal ? m.goalNo.get(j.goal) : null;
+  const open = !mark || !mark.state;
+  const allDone = steps.length > 0 && steps.every((x) => x.done);
+  const reply = typeof it.reply_needed === 'boolean' ? (it.reply_needed ? D.yes : D.no) : null;
+  const more = dl([[D.about, it.about || null], [D.ask, it.ask || null], [D.reply, reply], [D.how, todo === it.how ? null : it.how || null]]);
+  return el('article', { class: 'td-day__job td-day__job--act', 'data-day-job': j.id, 'data-day-act-card': verb },
+    el('div', { class: 'td-day__jobtop' }, el('span', { class: 'td-day__chips' }, verbChip(verb), el('span', { class: 'td-day__src' }, [srcName(j.source), n ? D.pill.goal(n) : null].filter(Boolean).join(' · '))),
+      dueChip(m, mark, due, false)),
+    el('h3', { class: 'td-day__acth' }, j.title),
+    todo ? el('p', { class: 'td-day__todo', 'data-day': 'todo' }, todo) : null,
+    markBanner(ctx, j.id, mark, false),
+    dl([[D.where, A.from(it.who, it.where)], [D.why, it.why_now || null]]),
+    threadBlock(it.thread),
+    steps.length ? el('div', { class: 'td-day__phase' }, el('h4', null, A.howTitle(steps.filter((x) => x.done).length, steps.length)), stepChecks(ctx, j.id, steps, { refs })) : null,
+    refsBlock(refs, steps),
+    canSend ? composer(ctx, j, verb) : null,
+    open ? el('div', { class: 'td-day__acts', 'data-day': 'cta' },
+      (canSend ? extLink : primaryLink)(A.open[j.source] || A.openLink, j.link, { 'data-day-link': 'conversation' }),
+      j.item && j.item.owner === 'pm' ? button({ label: A.draft, size: 'sm', disabled: ui.busy.has('draft:' + j.id), attrs: { 'data-day-act': 'draft' }, onClick: () => draftPress(ctx.ws, j) }) : null) : null,
+    marksBar(ctx, { id: j.id, title: j.title, kind: 'item', due, strong: allDone }),
+    more ? el('details', { class: 'td-day__fold', 'data-day': 'more' }, el('summary', null, A.more), more, note(A.readOnly)) : null);
+}
+
+/** Free minutes from now to the meeting's start, less the other meetings in between. */
+function freeBefore(m, e) {
+  if (!Number.isFinite(e.s) || e.s <= m.now) return 0;
+  let busy = 0;
+  for (const o of m.events) {
+    if (o.id === e.id) continue;
+    const a = Math.max(o.s, m.now); const b = Math.min(o.f, e.s);
+    if (b > a) busy += b - a;
+  }
+  return Math.max(0, Math.round((e.s - m.now - busy) / MIN_MS));
+}
+
+/** A meeting's prep (PRD A1, C1, M1, M6, D2): the verb and the prep line, how ready the PM is, the Before steps to
+ *  check off, the button that fits, and the marks. */
+function prepBlock(ctx, e) {
+  const { m } = ctx;
+  const steps = e.before.map((st) => ({ t: String(st.t || ''), who: st.who, done: st.done, ref: st.ref, note: !!st.note, fixed: !!(e.steps && e.steps.before && e.steps.before.find((x) => x.t === st.t && x.done)) }));
+  const refs = Array.isArray(e.refs) ? e.refs : [];
+  const d = steps.filter((x) => x.done).length; const total = steps.length;
+  const left = total - d;
+  const free = freeBefore(m, e);
+  const fit = !total ? null : !left ? A.fit.ok : free >= left * 15 ? A.fit.time(left, free) : A.fit.short(left, free);
+  const open = !e.mark || !e.mark.state;
+  const link = Array.isArray(e.links) ? e.links.find((l) => isUrl(l.url)) : null;
+  return el('div', { class: 'td-day__prep', 'data-day': 'prep' },
+    el('div', { class: 'td-day__jobtop' }, verbChip('prepare'), dueChip(m, e.mark, e.s, true)),
+    e.prep ? el('p', { class: 'td-day__todo', 'data-day': 'todo' }, e.prep) : null,
+    markBanner(ctx, e.id, e.mark, true),
+    total ? el('div', { class: 'td-day__ready', 'data-day': 'readiness' }, meter({ done: d, total, label: A.readiness(d, total) }), fit ? el('span', { class: 'td-day__dim' }, fit) : null) : null,
+    total ? el('div', { class: 'td-day__phase' }, el('h4', null, A.beforeTitle(e.time)), stepChecks(ctx, e.id, steps, { refs, mark: e.mark })) : null,
+    refsBlock(refs, steps),
+    open && link && left ? el('div', { class: 'td-day__acts', 'data-day': 'cta' }, primaryLink((link.label || link.url) + ' ↗', link.url, { 'data-day-link': 'prep' })) : null,
+    marksBar(ctx, { id: e.id, title: e.title, kind: 'event', start: e.s, strong: total > 0 && !left }));
+}
+
 /* ── the right column ─────────────────────────────────────────────────────────────────────────────────────────── */
 
 function dhead(kind, title) {
@@ -563,27 +889,31 @@ function eventDetail(ctx, e) {
     el('p', { class: 'td-day__dim td-day__mono' }, `${e.time}${e.end ? '–' + hhmm(e.end) : ''}${e.with ? ' · ' + e.with : ''}${e.ended ? ' · ' + D.ended : ''}`),
     e.with ? peopleLinks(ctx.ws, e.with, { 'data-day': 'people' }) : null,
     e.purpose ? el('p', null, el('b', null, D.purpose + ': '), e.purpose) : null,
-    e.prep ? el('p', null, el('b', null, D.prep + ': '), e.prep) : null,
+    e.needsPrep ? prepBlock(ctx, e) : null,
     ini ? el('div', { class: 'td-day__ini', 'data-day': 'initiative' }, el('span', null, D.initiative + ': ', el('b', { class: 'td-day__mono' }, ini.id), ini.why ? el('span', { class: 'td-day__dim' }, ' (' + D.suggested(ini.why) + ')') : null),
       ctx.openIni ? button({ label: D.openInitiative, size: 'sm', variant: 'ghost', attrs: { 'data-day-act': 'open-initiative' }, onClick: () => ctx.openIni(ini.id) }) : null) : null,
     tie,
     memoryBlock(e.id),
-    !e.ended ? el('div', { class: 'td-day__acts' }, e.prep ? pill(D.needPrep, 'warn') : steps.before && steps.before.length ? pill(D.nothingToPrep, 'ok') : null) : null,
     after,
     notesBlock(e, { ws: ctx.ws, initiative: ini }),
-    !e.ended ? [list(D.phases.before, (steps.before || []).map(stepItem)), list(D.phases.during, (steps.during || []).map(stepItem)), list(D.phases.after, (steps.after || []).map(stepItem)), mailBlock] : null,
+    // with prep, the Before steps are the checklist above; During, After and the mail fold away (PRD D2)
+    !e.ended && e.needsPrep && ((steps.during || []).length || (steps.after || []).length || mailBlock)
+      ? el('details', { class: 'td-day__fold', 'data-day': 'more' }, el('summary', null, A.moreMeeting((steps.during || []).length, (steps.after || []).length)),
+        list(D.phases.during, (steps.during || []).map(stepItem)), list(D.phases.after, (steps.after || []).map(stepItem)), mailBlock) : null,
+    !e.ended && !e.needsPrep ? [list(D.phases.during, (steps.during || []).map(stepItem)), list(D.phases.after, (steps.after || []).map(stepItem)), mailBlock] : null,
     Array.isArray(e.links) && e.links.length ? el('div', { class: 'td-day__acts', 'data-day': 'links' }, ...e.links.map((l) => extLink((l.label || l.url) + ' ↗', l.url))) : null,
   ];
 }
 
 function jobCard(ctx, j) {
+  if (j.status === 'you') return actCard(ctx, j);
   const { m, ws } = ctx;
   const t = j.task;
   const it = j.item || {};
   const n = j.goal ? m.goalNo.get(j.goal) : null;
   const busy = t && ui.busy.has(t.id);
   const revs = t && Array.isArray(t.revisions) ? t.revisions.length : 0;
-  const statusNote = { notStarted: D.notTask, waiting: D.waitingNote, working: D.workingNote, sending: D.sendingNote, you: D.youNote }[j.status]
+  const statusNote = { notStarted: D.notTask, waiting: D.waitingNote, working: D.workingNote, sending: D.sendingNote }[j.status]
     || (j.status === 'done' && j.kind === 'auto' ? D.autoNote : null);
   const draft = t && t.draft ? el('div', { class: 'td-day__draftbox', 'data-day': 'draft' }, el('h4', null, D.draft),
     t.draft.summary ? el('p', null, t.draft.summary) : null,
@@ -902,6 +1232,6 @@ export function daySection({ ws, setState, openIni, owed, here, all } = {}) {
 
 export function daySig(ws) {
   const c = cache.get(ws) || {};
-  return JSON.stringify([forced, ui.open, ui.sel, ui.mtab, ui.openSrc, ui.showIgn, ui.showIgnDigests, [...ui.revising], [...ui.busy], c.error, runs.get(ws) || null, [...seen].length])
+  return JSON.stringify([forced, ui.open, ui.sel, ui.mtab, ui.openSrc, ui.showIgn, ui.showIgnDigests, [...ui.revising], [...ui.busy], [...ui.groupsOpen], ui.holding, ui.holdDraft.when, [...ui.verdict], c.error, runs.get(ws) || null, [...seen].length])
     + dataSig(c.data) + goalsSig() + agendaSig();
 }

package/workspace/server.js

@@ -98,6 +98,7 @@ const briefLib = require('./lib/brief');
 const calMemLib = require('./lib/calendar-memory');
 const goalsLib = require('./lib/goals');
 const dayRunLib = require('./lib/day-run');
+const dayMarksLib = require('./lib/day-marks');
 const todayLib = require('./lib/today');
 const prepareQueue = require('./lib/prepare-queue');
 const harness = require('./lib/harness-parse');
@@ -3842,7 +3843,7 @@ function startDayTask(run, t, now) {
 }
 /** My work's Run agent (initiative my-work, PRD R5): add the briefed task to today's run and start what may start. A day
  *  with no run gets one, marked opened by My work, in the repository the PM pressed from. Returns { ok, run } or why not. */
-function myWorkBrief(spec, wsId) {
+function myWorkBrief(spec, wsId, add) {
   const now = Date.now(); const date = briefLib.localDate(now);
   let run = readDayRun(date);
   if (!run) {
@@ -3850,7 +3851,8 @@ function myWorkBrief(spec, wsId) {
     if (!w) return { ok: false, status: 400, error: 'no workspace to run the agent in' };
     run = { ...dayRunLib.newRun(date, now), ws: w.id, opened_by: 'my-work' };
   }
-  const a = dayRunLib.addBriefed(run, spec);
+  // `add` is how the task joins the run: briefed by default; Send from a Your day card adds the PM's own text (addSend)
+  const a = add ? add(run, spec, now) : dayRunLib.addBriefed(run, spec);
   if (!a.ok) return { ok: false, status: 409, error: a.error };
   const next = startDayTasks(a.run, now);
   if (!writeDayRun(next)) return { ok: false, status: 500, error: 'could not save — nothing changed' };
@@ -3940,6 +3942,30 @@ function writeCalMemory(m) {
   fs.mkdirSync(STATE, { recursive: true }); fs.writeFileSync(tmp, JSON.stringify(m) + '\n'); fs.renameSync(tmp, f);
 }
 
+/* The PM's marks on today's items and meetings (initiative today-act-prepare, PRD M5): done or ready, snoozed, waiting on
+ * someone, not mine, and the steps checked. goals/<date>.marks.json, written only by POST /api/proactive/day/mark. Kept outside the
+ * proactive, prepare and day-run blocks, whose boundary tests list the only files they write. */
+const dayMarksFile = (date) => path.join(GOALS_DIR(), date + '.marks.json');
+function readDayMarks(date) {
+  let raw = null;
+  try { raw = JSON.parse(fs.readFileSync(dayMarksFile(date), 'utf8')); } catch { /* none yet */ }
+  return dayMarksLib.readMarks(raw, date);
+}
+function writeDayMarks(rec) {
+  try {
+    fs.mkdirSync(GOALS_DIR(), { recursive: true });
+    const f = dayMarksFile(rec.date); const tmp = `${f}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(rec) + '\n'); fs.renameSync(tmp, f); return true;
+  } catch (e) { warnWriteFail('day marks', e); return false; }
+}
+/** The ids a mark may name: today's brief items ('item') and calendar events ('event'). */
+function dayMarkIds(brief) {
+  const known = new Map();
+  if (!brief) return known;
+  for (const x of [...(brief.priorities || []), ...(brief.worth_asking || [])]) known.set(x.id, 'item');
+  for (const e of brief.calendar || []) known.set(e.id, 'event');
+  return known;
+}
 // ── Background prepare, slice D3 (initiative proactive-engine) ──────────────────────────────────────────────────
 // The PM approves ONE plan hash from Today. The 60-second tick later starts that session through the SAME path a next-step
 // `go` uses (startWork with origin next-step and the prompt that was shown), only while background prepare is on, outside quiet
@@ -7774,7 +7800,7 @@ async function handleRequest(req, res) {
       : !bs ? { session: null, why: 'the morning-brief session did not start.' }
       : (!!bs.ended_at || !bsess || bsess.state === 'exited') ? { session: bs.id, why: (bsess && bsess.note) || 'the session ended without submitting a brief.' }
       : briefSessionDone(run, date, now) === 'idle' ? { session: bs.id, idle: true, why: 'the session has printed nothing for two minutes and has not submitted a brief.' } : null;
-    return json(res, { ok: true, ws: w ? w.id : null, today: date, now: new Date(now).toISOString(), run, stage: dayRunLib.stage(run, brief), brief, plan, cards_error: cardsError, read_failed: readFailed,
+    return json(res, { ok: true, ws: w ? w.id : null, today: date, now: new Date(now).toISOString(), run, stage: dayRunLib.stage(run, brief), brief, plan, marks: dayMarksLib.effective(readDayMarks(date), now), cards_error: cardsError, read_failed: readFailed,
       settings: { briefSources: st.briefSources, scopes: st.scopes, placeRepos: st.placeRepos, dayCheck: st.dayCheck, websites: st.websites }, sources,
       // one day for every repository: the repositories it can be narrowed to, and the repository of each tagged item
       repos: [...workspaces.values()].map((x) => ({ id: x.id, name: x.name || path.basename(x.root) })),
@@ -7797,6 +7823,58 @@ async function handleRequest(req, res) {
     if (!writeCalMarks(r.marks)) return json(res, { ok: false, error: 'could not save — nothing changed' }, 500);
     return json(res, { ok: true });
   }
+  /* The PM's mark on an item or a meeting of today's brief (initiative today-act-prepare, PRD M1 to M6). It needs no day
+   * run: a mark is about the brief, and only this press writes goals/<date>.marks.json. The answer carries `prev`, the
+   * mark before the press, so the page's Undo can put it back with { action: 'restore', mark: prev }. */
+  if (p === '/api/proactive/day/mark' && req.method === 'POST') {
+    let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const now = Date.now(); const date = briefLib.localDate(now);
+    const stored = briefOfDay(date);
+    const brief = stored && stored.date === date ? stored : null;
+    if (!brief) return json(res, { ok: false, error: 'no brief today — press Prepare my day first' }, 409);
+    const r = dayMarksLib.edit(readDayMarks(date), body, { now, known: dayMarkIds(brief) });
+    if (!r.ok) return json(res, { ok: false, error: r.error }, /no item or meeting with that id/.test(r.error) ? 404 : 400);
+    if (!writeDayMarks(r.rec)) return json(res, { ok: false, error: 'could not save — nothing changed' }, 500);
+    return json(res, { ok: true, mark: r.mark, prev: r.prev, marks: dayMarksLib.effective(r.rec, now) });
+  }
+  /* "Have the agent draft it" on a job the PM owns (PRD C2): one briefed task, kind approve, tied to the item, through the
+   * My work path. The day-task session drafts and sends nothing; the PM approves or revises the draft as for any job. */
+  if (p === '/api/proactive/day/draft' && req.method === 'POST') {
+    let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const now = Date.now(); const date = briefLib.localDate(now);
+    const stored = briefOfDay(date);
+    const brief = stored && stored.date === date ? stored : null;
+    const x = brief ? [...(brief.priorities || []), ...(brief.worth_asking || [])].find((y) => y.id === String(body.item || '')) : null;
+    if (!x) return json(res, { ok: false, error: 'no item with that id in today\'s brief' }, 404);
+    if (x.owner !== 'pm') return json(res, { ok: false, error: 'the agent already does this job: approve or revise its draft' }, 409);
+    const verb = { reply: 'reply', review: 'review notes', decide: 'answer', 'sign-off': 'sign-off comment', read: 'summary', do: 'draft' }[x.verb] || (x.reply_needed ? 'reply' : 'draft');
+    const spec = { id: 't-' + x.id, item_id: x.id, title: x.title, source: x.source, link: x.link || null,
+      instruction: `Draft the PM's ${verb} for this item: ${x.todo || x.how || x.ask || x.title}. Draft only. Send nothing: the PM approves it first.`,
+      context: { from: x.who || null, where: x.where || null, about: x.about || null, ask: x.ask || null, how: x.how || null, why_now: x.why_now || null } };
+    const r = myWorkBrief(spec, body.ws);
+    if (!r.ok) return json(res, { ok: false, error: r.error }, r.status || 400);
+    return json(res, { ok: true, task: r.task });
+  }
+  /* Send from the card (PRD F1 to F3): the PM wrote the reply or the review in the card and pressed Send. The press is the
+   * approval, so the task goes straight to sending with the PM's text, and one send session posts it as written to the
+   * place the item names. Nothing is sent without this press (D65 propose-only). */
+  if (p === '/api/proactive/day/send' && req.method === 'POST') {
+    let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const now = Date.now(); const date = briefLib.localDate(now);
+    const stored = briefOfDay(date);
+    const brief = stored && stored.date === date ? stored : null;
+    const x = brief ? [...(brief.priorities || []), ...(brief.worth_asking || [])].find((y) => y.id === String(body.item || '')) : null;
+    if (!x) return json(res, { ok: false, error: 'no item with that id in today\'s brief' }, 404);
+    if (x.owner !== 'pm') return json(res, { ok: false, error: 'the agent already does this job: approve or revise its draft' }, 409);
+    if (!x.link) return json(res, { ok: false, error: 'this item has no link, so there is no place to send to — open it and answer there' }, 409);
+    const review = !!(x.send && x.send.review);
+    if (review && !['approve', 'changes'].includes(body.verdict)) return json(res, { ok: false, error: 'a review needs a verdict: approve or changes' }, 400);
+    const spec = { id: 't-' + x.id, item_id: x.id, title: x.title, source: x.source, link: x.link, to: (x.send && x.send.to) || x.where || null,
+      text: body.text, verdict: review ? body.verdict : null };
+    const r = myWorkBrief(spec, body.ws, dayRunLib.addSend);
+    if (!r.ok) return json(res, { ok: false, error: r.error }, r.status || 400);
+    return json(res, { ok: true, task: r.task });
+  }
   if (p.startsWith('/api/proactive/day/') && req.method === 'POST') {
     const verb = p.slice('/api/proactive/day/'.length);
     if (!['deliver', 'sent', 'fail', 'decide', 'check'].includes(verb)) return json(res, { ok: false, error: 'unknown day-run action' }, 404);