create-pmos 0.54.0 → 0.55.0

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

@@ -1,206 +1,141 @@
-/* pm/today-goals.js — the goals for today at the top of Today (initiative today-goals, PRD G5 and G6).
+/* pm/today-goals.js — the goals for today inside the day section (initiative today-goals, PRD G5, G6 and G16).
  *
- *   goalsSection({ ws, setState })  → the section node, or null in fixture mode
- *   goalsSig(ws)                    → a string that changes whenever what the section shows changes
+ *   goalRows(ctx)            → the left column's goal rows: number, text, jobs done, a small bar
+ *   goalAdd(ctx)             → the add input under them ("Add a goal and press Enter")
+ *   goalDetail(ctx, goalId)  → the right column's detail of one goal: its meetings, its jobs, the steps found, and the
+ *                              presses done, drop, reopen and remove; on an agent step that names an initiative, Prepare
+ *                              then Queue it (the shipped background prepare: one approval is one prompt hash)
+ *   addGoal(ctx, text, ini)  → POST the add; true when the goal is on the list
+ *   goalsSig()               → a string that changes whenever what this module draws changes on its own
  *
- * 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.
+ * `ctx` is the day section's (today-day.js): { ws, m (the day model), select(type, id), reload(), rerender(), cur(type, id) }.
+ * The server joins the goals to the brief and Today by goal id or initiative (lib/goals.js planDay). Nothing here guesses.
  */
 
 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 { button, field, badge, toast, row, meter } from './primitives.js';
+import { pmPost } from './http.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;
+const D = COPY.day;
 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) {
+async function press(ctx, 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);
+  await ctx.reload();
   return true;
 }
 
-// "Prepare my day", per repository: { state: 'busy' | 'started' | 'failed', at, session, error }. The session runs in the
-// background, so the section says what happened and offers to open it; a toast alone is gone before the PM looks.
-const runs = new Map();
+/** Add a goal. `ini` ties it to an initiative, so the brief's items and meetings of that initiative join it. */
+export function addGoal(ctx, text, ini) {
+  const body = { action: 'add', text: String(text || '').trim().slice(0, 140) };
+  if (ini) body.initiative_id = ini;
+  return press(ctx, body);
+}
 
-async function prepareDay(ws) {
-  const cur = runs.get(ws);
-  if (cur && cur.state === 'busy') return;
-  runs.set(ws, { state: 'busy' });
-  rerender();
-  const r = await pmPost('/api/proactive/goals/plan', { ws });
-  const sid = r && r.result && r.result.sessionId;
-  if (r && r.ok) {
-    const session = sid ? { id: sid, name: 'morning-brief' } : null;
-    runs.set(ws, { state: 'started', at: Date.now(), session });
-    toast({ text: G.started });
-    if (session) openSession(session);
-  } else {
-    const error = (r && r.error) || G.unreached;
-    runs.set(ws, { state: 'failed', at: Date.now(), error });
-    toast({ text: G.runFailed(error), tone: 'destructive' });
-  }
-  rerender();
-  load(ws);
+/** The jobs of a goal: the day model's jobs that name it. */
+const jobsOf = (m, id) => m.jobs.filter((j) => j.goal === id && !j.worth);
+
+export function goalRows(ctx) {
+  const { m } = ctx;
+  if (!m.goals.length) return null;
+  return el('ul', { class: 'td-day__rows', 'data-day-list': 'goals' }, ...m.goals.map((g, i) => {
+    const js = jobsOf(m, g.id);
+    const done = js.filter((j) => j.group === 'done').length;
+    const need = js.filter((j) => j.group === 'needs').length;
+    const closed = g.status !== 'open';
+    const sub = closed ? (G.coverage[g.coverage] || g.status) : js.length ? D.goalJobs(done, js.length) + (need ? ' · ' + D.goalNeed(need) : '') : (G.coverage[g.coverage] || D.goalNone);
+    const cur = ctx.cur('goal', g.id);
+    return el('li', null, row({
+      title: g.text, meta: [sub], done: closed, onOpen: () => ctx.select('goal', g.id),
+      lead: [el('span', { class: 'td-day__lead' }, String(i + 1))],
+      trail: [meter({ done: js.length ? done : g.status === 'done' ? 1 : 0, total: js.length || 1, label: '' })],
+      attrs: { class: 'td-day__r', 'data-day-sel': 'goal:' + g.id, 'data-goal': g.id, 'data-goal-coverage': g.coverage, 'data-cur': cur },
+      openAttrs: { 'aria-current': cur },
+    }));
+  }));
 }
 
-async function openSession(session) {
-  try { const m = await import('./handoff-box.js'); await m.openSessionTab(null, session); } catch (e) { console.error('[pm] could not open the session:', e); }
+export function goalAdd(ctx) {
+  const { m } = ctx;
+  const max = m.maxGoals;
+  if (m.goals.length >= max) return el('p', { class: 'td-day__note' }, G.full(max));
+  const f = field({ label: G.inputLabel, value: '', placeholder: G.inputHint, hideLabel: true, attrs: { 'data-goals': 'input', 'data-day-input': 'goal', maxlength: '140' },
+    onCommit: async (v) => {
+      if (!String(v).trim()) { draft = v; return; }
+      // clear before the press: its reload re-renders the section, and a rebuild must not bring the text back
+      draft = '';
+      if (await addGoal(ctx, v)) { if (f.control.resetCommitted) f.control.resetCommitted(''); f.control.value = ''; ctx.rerender(); }
+      else { draft = v; ctx.rerender(); }
+    } });
+  // a rebuild keeps what is typed. The field is made empty and filled after, so Enter still commits the restored text.
+  f.control.value = draft;
+  f.control.addEventListener('input', () => { draft = f.control.value; });
+  return el('div', { class: 'td-day__goaladd' }, f);
 }
 
-async function prepareStep(ws, st) {
-  const r = await pmPost('/api/proactive/prepare/plan', { ws, initiative_id: st.initiative_id });
+async function prepareStep(ctx, st) {
+  const r = await pmPost('/api/proactive/prepare/plan', { ws: ctx.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();
+  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 || ctx.ws });
+  ctx.rerender();
 }
 
-async function queueStep(ref) {
+async function queueStep(ctx, 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();
+  ctx.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;
+function stepNode(ctx, st) {
   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
+  const acts = !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) });
+      button({ label: G.queue, size: 'sm', attrs: { 'data-goal-queue': st.ref }, onClick: () => queueStep(ctx, st.ref) }))
+      : button({ label: G.prepare, size: 'sm', variant: 'ghost', attrs: { 'data-goal-prepare': st.ref }, onClick: () => prepareStep(ctx, st) });
   return el('li', { class: 'td-goal__step', 'data-goal-step': st.ref },
-    badge({ text: who, tone: st.owner === 'pm' ? 'outline' : 'muted' }),
+    badge({ text: st.owner === 'pm' ? G.you : G.agent, 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) {
+/** The detail of one goal. `row(type, id, label, lead, trail)` draws a selectable row (today-day.js). */
+export function goalDetail(ctx, id, row) {
+  const { m } = ctx;
+  const i = m.goals.findIndex((g) => g.id === id);
+  if (i < 0) return null;
+  const g = m.goals[i];
   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) => {
-          if (!String(v).trim()) { draft = v; return; }
-          // clear before the press: its reload re-renders the section, and a rebuild must not bring the text back
-          draft = '';
-          if (await press(ws, { action: 'add', text: v })) { if (f.control.resetCommitted) f.control.resetCommitted(''); f.control.value = ''; rerender(); }
-          else { draft = v; 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)));
-    const run = runs.get(ws);
-    const busy = !!run && run.state === 'busy';
-    kids.push(el('div', { class: 'td-goals__bar' },
-      button({ label: busy ? G.starting : G.prepareDay, attrs: { 'data-goals': 'prepare-day', title: G.prepareDayHint, 'aria-busy': busy ? 'true' : 'false' },
-        disabled: !openN || busy, onClick: () => prepareDay(ws) }),
-      run && run.state === 'started' && run.session
-        ? button({ label: G.openSession, variant: 'ghost', attrs: { 'data-goals': 'open-session' }, onClick: () => openSession(run.session) }) : null));
-    if (run && run.state !== 'busy') {
-      kids.push(el('p', { class: 'td-goals__run' + (run.state === 'failed' ? ' td-goals__run--failed' : ''), 'data-goals': 'run', 'data-run': run.state,
-        role: run.state === 'failed' ? 'alert' : 'status' }, run.state === 'failed' ? G.runFailed(run.error) : G.runStarted(hhmm(run.at))));
-    }
-    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));
+  const js = jobsOf(m, g.id);
+  const meets = m.events.filter((e) => e.goal === g.id);
+  const ctrls = closed
+    ? [button({ label: G.reopen, size: 'sm', attrs: { 'data-goal-act': 'reopen' }, onClick: () => press(ctx, { action: 'reopen', id: g.id }) })]
+    : [button({ label: G.done, size: 'sm', attrs: { 'data-goal-act': 'done' }, onClick: () => press(ctx, { action: 'done', id: g.id }) }),
+      button({ label: G.drop, size: 'sm', variant: 'ghost', attrs: { 'data-goal-act': 'drop' }, onClick: () => press(ctx, { action: 'drop', id: g.id }) })];
+  ctrls.push(button({ label: G.remove, size: 'sm', variant: 'ghost', attrs: { 'data-goal-act': 'remove' },
+    onClick: async () => { if (await press(ctx, { action: 'remove', id: g.id })) ctx.select(null, null); } }));
+  const steps = (g.steps || []).filter((st) => st.from !== 'brief' || st.prepare);   // brief items show as jobs; Today cards and preparable steps here
+  return [
+    el('div', { class: 'td-day__dhead' }, el('span', { class: 'td-day__kind' }, D.kind.goal(i + 1)), el('h3', null, g.text)),
+    el('div', { class: 'td-day__acts' }, badge({ text: G.coverage[g.coverage] || g.coverage, tone: g.coverage === 'needs-plan' ? 'warning' : 'outline' }),
+      g.initiative_id ? el('span', { class: 'td-day__mono' }, g.initiative_id) : null),
+    js.length ? el('p', null, D.goalJobs(js.filter((j) => j.group === 'done').length, js.length)) : el('p', { class: 'td-day__note' }, G.noStep),
+    meets.length ? el('div', { class: 'td-day__rel' }, el('h4', null, D.meetings), el('ul', { class: 'td-day__rows' }, ...meets.map((e) => row('event', e.id, e.title, e.time)))) : null,
+    js.length ? el('div', { class: 'td-day__rel' }, el('h4', null, D.jobs), el('ul', { class: 'td-day__rows' }, ...js.map((j) => row('job', j.id, j.title, '', j)))) : null,
+    !closed && steps.length ? el('div', { class: 'td-day__rel', 'data-goals': 'steps' }, el('h4', null, D.stepsTitle), el('ul', { class: 'td-goal__steps' }, ...steps.map((st) => stepNode(ctx, st)))) : null,
+    el('div', { class: 'td-day__acts' }, ...ctrls),
+  ];
 }
 
-export function goalsSig(ws) {
-  const c = cache.get(ws) || {};
-  return JSON.stringify([open, draft === '', c.data && c.data.plan, c.error, [...prepared.keys()], runs.get(ws) || null]);
+export function goalsSig() {
+  return JSON.stringify([draft === '', [...prepared.keys()]]);
 }

package/workspace/replaced-tests.json

@@ -40,6 +40,16 @@
         "I6 an unknown brief source is refused with the allowed names"
       ]
     },
+    {
+      "id": "STG-MAX30",
+      "file": "workspace/proactive.test.js",
+      "run": "today-goals",
+      "ref": "planning/prd/today-goals-prd.md G9 (a brief holds at most 30 items)",
+      "reason": "G8 asserted that 13 items are refused with 'at most 12'. today-goals G9 raises the limit to 30, so it now sends 31 items and expects 'at most 30'; the event limit and the field limits are asserted unchanged.",
+      "names": [
+        "G8 too many items, too many events and an over-long field are refused"
+      ]
+    },
     {
       "id": "S6-D86",
       "file": "workspace/d86-seams.test.js",

package/workspace/server.js

@@ -95,6 +95,7 @@ const proactiveLib = require('./lib/proactive');
 const learnLib = require('./lib/learn');
 const briefLib = require('./lib/brief');
 const goalsLib = require('./lib/goals');
+const dayRunLib = require('./lib/day-run');
 const todayLib = require('./lib/today');
 const prepareQueue = require('./lib/prepare-queue');
 const harness = require('./lib/harness-parse');
@@ -2325,7 +2326,7 @@ function checkDueSchedules() {
 // PMOS_TICK_MS exists for the suites (same footing as PMOS_LIVENESS_MS): proactive-prepare.test.js
 // used to wait on two real minutes of this clock. Unset, the interval is the 60 seconds it always was.
 const TICK_MS = Math.max(200, Number(process.env.PMOS_TICK_MS) || 60000);
-try { const _tick = setInterval(() => { checkDueSchedules(); proactiveTick(); try { prepareTick({ manual: false }); } catch { /* the next tick tries again */ } autoSync.tick().catch(() => {}); }, TICK_MS); if (_tick.unref) _tick.unref(); } catch {}
+try { const _tick = setInterval(() => { checkDueSchedules(); proactiveTick(); try { prepareTick({ manual: false }); } catch { /* the next tick tries again */ } try { dayTick(); } catch (e) { warnWriteFail('day run tick', e); } autoSync.tick().catch(() => {}); }, TICK_MS); if (_tick.unref) _tick.unref(); } catch {}
 
 // ── Sessions: real PTYs, owned by the server, with disk-backed scrollback + metadata. ──
 /** @type {Map<string, {id,ws,name,agent,cwd,state,note,created,pty,buf,cols,rows,clients:Set}>} */
@@ -3572,6 +3573,103 @@ function prepareHandoff(body) {
   };
 }
 
+// ── Today day run (G13, G14, G21, G22; initiative today-goals) ───────────────────────────────────────────────────
+// The PM's press of "Prepare my day" records a run in goals/<date>.run.json beside the goals file. These helpers are
+// the only code that writes that file and the only code that starts its sessions: one per task through the `day-task`
+// skill (mode do, revise or send) and one per check through the `day-check` skill, both through spawnSession as
+// fireSchedule starts a scheduled agent skill. Every rule (which task, how many at once, when a check is due) is in
+// lib/day-run.js; this only reads, starts and writes. Nothing here runs for a day the PM did not press.
+const dayRunFile = (date) => path.join(GOALS_DIR(), date + '.run.json');
+function readDayRun(date) {
+  let raw = null;
+  try { raw = JSON.parse(fs.readFileSync(dayRunFile(date), 'utf8')); } catch { /* no run that day */ }
+  const run = dayRunLib.readRun(raw, date);
+  if (run && raw && typeof raw.ws === 'string') run.ws = raw.ws;   // the repository the PM pressed in; the sessions run there
+  return run;
+}
+function writeDayRun(run) {
+  try { fs.mkdirSync(GOALS_DIR(), { recursive: true }); fs.writeFileSync(dayRunFile(run.date), JSON.stringify(run) + '\n'); return true; }
+  catch (e) { warnWriteFail('day run (goals/<date>.run.json)', e); return false; }
+}
+function briefOfDay(date) {
+  try { return JSON.parse(fs.readFileSync(path.join(STATE, 'briefs', date + '.json'), 'utf8')); } catch { return null; }
+}
+const daySessionAlive = (id) => { const s = id && sessions.get(id); return !!s && s.state !== 'exited'; };
+// The skill's own body is the prompt, as fireSchedule hands it over; the line after it names this run's task and mode.
+function daySkillPrompt(run, skillId) {
+  const w = getWs(run.ws);
+  const task = taskById(skillId, w ? w.root : null);
+  if (!task || task.kind !== 'agent' || !task.prompt) return { error: `the ${skillId} skill is not installed for this repository` };
+  return { w, task, prompt: skillStore.retargetFiling(task.prompt, filingContract(w)) };
+}
+/** Start one task session; a start that fails marks the task failed with the reason. Returns the new run. */
+function startDayTask(run, t, now) {
+  const sk = daySkillPrompt(run, 'day-task');
+  let s = null;
+  if (!sk.error) {
+    const prompt = `${sk.prompt}\n\nThis run: /day-task ${t.id} ${t.mode} — read the task first with: pmos proactive day show ${t.id}`;
+    s = spawnSession({ name: `${t.title} · day task`, agent: sk.task.agent || 'claude', ws: sk.w ? sk.w.id : run.ws, origin: 'day-task', initialInput: prompt + '\r',
+      modelAsk: { scheduleTier: null, skillTier: sk.task.tier || null, skill: sk.task.skill } });
+  }
+  const live = s && s.state !== 'exited';
+  const st = dayRunLib.started(run, t.id, live ? s.id : null, now);
+  if (!st.ok) return run;
+  if (live) return st.run;
+  const f = dayRunLib.fail(st.run, t.id, String(sk.error || (s && s.note) || 'the session could not start').slice(0, 240), now);
+  return f.ok ? f.run : st.run;
+}
+/** Start what lib/day-run.js says may start now (at most 5 sessions at once). */
+function startDayTasks(run, now) {
+  for (const t of dayRunLib.toStart(run)) run = startDayTask(run, t, now);
+  return run;
+}
+/** Start one check session. @returns {{ok:true, run, session}|{ok:false, error}} */
+function startDayCheck(run, reason, now) {
+  if (run.checks.session_id && daySessionAlive(run.checks.session_id)) return { ok: false, error: 'a check is already running' };
+  if (run.checks.session_id) run = dayRunLib.sessionEnded(run, run.checks.session_id, now).run;
+  const sk = daySkillPrompt(run, 'day-check');
+  if (sk.error) return { ok: false, error: sk.error };
+  const prompt = `${sk.prompt}\n\nThis run: /day-check ${reason} — the last check was at ${run.checks.last || 'none yet'}; read what changed since ${run.checks.last || run.started_at}.`;
+  const s = spawnSession({ name: 'Daytime check', agent: sk.task.agent || 'claude', ws: sk.w ? sk.w.id : run.ws, origin: 'day-check', initialInput: prompt + '\r',
+    modelAsk: { scheduleTier: null, skillTier: sk.task.tier || null, skill: sk.task.skill } });
+  if (s.state === 'exited') return { ok: false, error: s.note || 'the check session could not start' };
+  const c = dayRunLib.checkStarted(run, s.id, reason, now);
+  return c.ok ? { ok: true, run: c.run, session: s.id } : c;
+}
+/** A brief for a day with a run arrived: its agent priorities become tasks and start. */
+function dayAfterBrief(date, merged) {
+  const now = Date.now();
+  let run = readDayRun(date);
+  if (!run) return null;
+  const brief = briefOfDay(date);
+  if (merged && run.checks.session_id) { const c = dayRunLib.checkDone(run, merged, now); if (c.ok) run = c.run; }
+  const a = dayRunLib.addTasks(run, brief);
+  if (a.ok) run = a.run;
+  run = startDayTasks(run, now);
+  writeDayRun(run);
+  return run;
+}
+/** The tick: mark ended sessions, start what may start, and start a check when one is due. */
+function dayTick() {
+  const now = Date.now();
+  const date = briefLib.localDate(now);
+  let run = readDayRun(date);
+  if (!run) return;
+  const before = JSON.stringify(run);
+  const ids = new Set([...run.tasks.filter((t) => (t.status === 'working' || t.status === 'sending') && t.session_id).map((t) => t.session_id),
+    run.brief_session && !run.brief_session.ended_at ? run.brief_session.id : null, run.checks.session_id].filter(Boolean));
+  for (const id of ids) if (!daySessionAlive(id)) run = dayRunLib.sessionEnded(run, id, now).run;
+  const brief = briefOfDay(date);
+  const a = dayRunLib.addTasks(run, brief);
+  if (a.ok) run = a.run;
+  run = startDayTasks(run, now);
+  const due = dayRunLib.checkDue(run, { settings: proSettings(), now, events: brief ? brief.calendar || [] : [] });
+  if (due.due) { const c = startDayCheck(run, due.reason, now); if (c.ok) run = c.run; }
+  run.checks.next = due.next;
+  if (JSON.stringify(run) !== before) writeDayRun(run);
+}
+// ── end of the today day run helpers ─────────────────────────────────────────────────────────────────────────────
+
 // ── 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
@@ -6998,13 +7096,21 @@ async function handleRequest(req, res) {
     return json(res, { ok: true, day: r.day, goal: r.goal });
   }
   if (p === '/api/proactive/goals/plan' && req.method === 'POST') {
-    // A PM press: make sure the morning brief is scheduled for this repository, then run it now. The session reads the
-    // goals with `pmos proactive goals` and submits a brief whose items name them.
+    // A PM press ("Prepare my day"): record the day run (G13), make sure the morning brief is scheduled for this
+    // repository, then run it now. The session reads the goals with `pmos proactive goals` and submits a brief whose
+    // items name them. No goal is needed: the brief plans the day either way. A second press while the brief session
+    // still runs starts nothing and answers that session.
     let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
     const w = getWs(body.ws);
     if (!w) return json(res, { ok: false, error: 'no workspace' }, 400);
-    const open = readGoalsDay(briefLib.localDate(Date.now())).goals.filter((g) => g.status === 'open');
-    if (!open.length) return json(res, { ok: false, error: 'add a goal for today first: the plan is made for your goals' }, 409);
+    const pnow = Date.now(); const pdate = briefLib.localDate(pnow);
+    const open = readGoalsDay(pdate).goals.filter((g) => g.status === 'open');
+    let run = readDayRun(pdate) || dayRunLib.newRun(pdate, pnow);
+    run.ws = w.id;
+    if (run.brief_session && !run.brief_session.ended_at) {
+      if (daySessionAlive(run.brief_session.id)) { writeDayRun(run); return json(res, { ok: true, running: true, session: run.brief_session.id, run, goals: open.length }); }
+      run = dayRunLib.sessionEnded(run, run.brief_session.id, pnow).run;
+    }
     let sched = readSchedules().find((x) => x.ws === w.id && x.skill === 'morning-brief');
     let seeded = false;
     if (!sched) {
@@ -7016,9 +7122,69 @@ async function handleRequest(req, res) {
       const list = readSchedules(); list.unshift(sched); writeSchedules(list); seeded = true;
     }
     const result = fireSchedule(sched);
-    return json(res, { ok: !!result.ok, seeded, schedule: { id: sched.id, time: sched.time }, result, goals: open.length,
+    if (result.ok && result.sessionId) run.brief_session = { id: result.sessionId, started_at: new Date(pnow).toISOString(), ended_at: null };
+    writeDayRun(run);
+    return json(res, { ok: !!result.ok, started: !!result.ok, session: result.sessionId || null, run, seeded, schedule: { id: sched.id, time: sched.time }, result, goals: open.length,
       ...(result.ok ? {} : { error: result.reason || 'the morning-brief session did not start' }) }, result.ok ? 200 : 500);
   }
+  /* ── today day run (G13, G14, G21, G22): the day view, the task sessions' reports and the PM's decisions. These
+   *    routes write only goals/<date>.run.json (writeDayRun) and start sessions only through the day-run helpers, for
+   *    the run of a day the PM pressed. Deliver, sent and fail are called by the sessions through `pmos proactive day`;
+   *    decide and check are the PM's presses. ── */
+  if (p === '/api/proactive/day' && req.method === 'GET') {
+    const now = Date.now();
+    const date = briefLib.localDate(now);
+    const w = getWs(url.searchParams.get('ws'));
+    const st = proSettings();
+    const run = readDayRun(date);
+    const stored = briefOfDay(date);
+    const brief = stored && stored.date === date ? stored : null;
+    let cards = []; let cardsError = null;
+    if (w) {
+      const memo = goalsCardsMemo.get(w.id);
+      if (memo && now - memo.at < 30000) ({ cards, error: cardsError } = memo);
+      else {
+        let sess = []; try { sess = sessionList(); } catch { /* no session cards */ }
+        const t = todayLib.todayFor(w, { stateDir: stateDirFor(w), sessions: sess, registered: (root) => { const x = workspaces.get(wsId(root)); return !!x && path.resolve(x.root) === path.resolve(root); } });
+        if (t.ok) cards = t.cards; else cardsError = t.error;
+        goalsCardsMemo.set(w.id, { at: now, cards, error: cardsError });
+      }
+    }
+    const plan = goalsLib.planDay({ day: readGoalsDay(date), brief, cards, now });
+    const due = dayRunLib.checkDue(run, { settings: st, now, events: brief ? brief.calendar || [] : [] });
+    const items = brief ? [...(brief.priorities || []), ...(brief.worth_asking || [])] : [];
+    const sources = proactiveLib.BRIEF_SOURCES.map((k) => ({ k, on: st.briefSources[k] === true, state: brief ? brief.sources[k] || null : null, got: items.filter((x) => x.source === k).length }));
+    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,
+      settings: { briefSources: st.briefSources, scopes: st.scopes, dayCheck: st.dayCheck, websites: st.websites }, sources,
+      check: { every: st.dayCheck.every, last: run ? run.checks.last : null, next: due.next, running: !!(run && run.checks.session_id), log: run ? run.checks.log : [] } });
+  }
+  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);
+    let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const now = Date.now();
+    let run = readDayRun(briefLib.localDate(now));
+    if (!run) return json(res, { ok: false, error: 'no day run today — press Prepare my day first' }, 409);
+    if (verb === 'check') {
+      // "Check now": one check at once, whatever the hour. The PM's press; reason 'manual'.
+      if (body.ws && !run.ws) run.ws = getWs(body.ws) ? getWs(body.ws).id : run.ws;
+      const c = startDayCheck(run, 'manual', now);
+      if (!c.ok) return json(res, { ok: false, error: c.error }, 409);
+      writeDayRun(c.run);
+      return json(res, { ok: true, session: c.session, run: c.run });
+    }
+    const id = String(body.task || '');
+    if (!dayRunLib.findTask(run, id)) return json(res, { ok: false, error: `no task ${id || '(none given)'} in today's run` }, 404);
+    const r = verb === 'deliver' ? dayRunLib.deliver(run, id, { summary: body.summary, body: body.body, link: body.link }, now)
+      : verb === 'sent' ? dayRunLib.sent(run, id, { link: body.link }, now)
+        : verb === 'fail' ? dayRunLib.fail(run, id, body.reason, now)
+          : dayRunLib.decide(run, id, { action: body.action, note: body.note }, now);
+    if (!r.ok) return json(res, { ok: false, error: r.error }, 400);
+    // A delivered, sent or failed task frees a place, and a decision may make a task ready: start what may start now.
+    run = startDayTasks(r.run, now);
+    if (!writeDayRun(run)) return json(res, { ok: false, error: 'could not save — nothing changed' }, 500);
+    return json(res, { ok: true, run, task: dayRunLib.findTask(run, id) });
+  }
   /* ── background prepare (D3): plan is read-only; queue records an approval; the runner starts it later ── */
   if (p === '/api/proactive/prepare/plan' && req.method === 'POST') {
     let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
@@ -7095,9 +7261,20 @@ async function handleRequest(req, res) {
       const bday = body && typeof body.date === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(body.date) ? body.date : briefLib.localDate(Date.now());
       const v = briefLib.validateBrief(body, { now: Date.now(), settings: proSettings(), goalIds: readGoalsDay(bday).goals.map((g) => g.id) });
       if (!v.ok) return json(res, { ok: false, error: v.error }, 400);
-      try { fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(path.join(dir, v.brief.date + '.json'), JSON.stringify(v.brief) + '\n'); }
+      // `merge: true` (a daytime check, G22) merges into the stored brief of that day; with none stored it is stored as it is.
+      let out = { ...v.brief, resolved: [] }; let merged = null;
+      if (body.merge === true) {
+        let stored = null; try { stored = JSON.parse(fs.readFileSync(path.join(dir, v.brief.date + '.json'), 'utf8')); } catch { /* none yet */ }
+        const m = briefLib.mergeBrief(stored, v.brief, { now: Date.now() });
+        if (!m.ok) return json(res, { ok: false, error: m.error }, 400);
+        out = m.brief; merged = { found: m.added, resolved: m.removed };
+      }
+      try { fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(path.join(dir, out.date + '.json'), JSON.stringify(out) + '\n'); }
       catch (e) { warnWriteFail('briefs', e); return json(res, { ok: false, error: 'could not save — nothing changed' }, 500); }
-      return json(res, { ok: true, brief: v.brief });
+      // A brief for a day the PM pressed "Prepare my day": its agent priorities become tasks and start (G13), and a merge
+      // closes the check that sent it (G22).
+      try { dayAfterBrief(out.date, merged); } catch (e) { warnWriteFail('day run after the brief', e); }
+      return json(res, { ok: true, brief: out, ...(merged ? { merged } : {}) });
     }
     if (req.method === 'GET') {
       const now = Date.now(); const st = proSettings();
@@ -7113,7 +7290,11 @@ async function handleRequest(req, res) {
     if (req.method === 'POST') {
       let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
       const cur = proSettings();
-      const n = proactiveLib.normalizeSettings({ ...cur, ...body, triggers: { ...cur.triggers, ...(body.triggers || {}) }, briefSources: { ...cur.briefSources, ...(body.briefSources || {}) } });
+      // A patch: triggers, sources, the check and each service's levels merge over what is stored (a level of null clears it).
+      const bs = body.scopes && typeof body.scopes === 'object' && !Array.isArray(body.scopes) ? body.scopes : null;
+      const scopes = bs ? { ...cur.scopes, ...Object.fromEntries(Object.entries(bs).map(([k, v]) => [k, v && typeof v === 'object' && !Array.isArray(v) ? { ...(cur.scopes[k] || {}), ...v } : v])) } : cur.scopes;
+      const dayCheck = body.dayCheck && typeof body.dayCheck === 'object' && !Array.isArray(body.dayCheck) ? { ...cur.dayCheck, ...body.dayCheck } : (body.dayCheck === undefined ? cur.dayCheck : body.dayCheck);
+      const n = proactiveLib.normalizeSettings({ ...cur, ...body, triggers: { ...cur.triggers, ...(body.triggers || {}) }, briefSources: { ...cur.briefSources, ...(body.briefSources || {}) }, scopes, dayCheck });
       if (!n.ok) return json(res, { ok: false, error: n.error }, 400);
       try { fs.mkdirSync(STATE, { recursive: true }); fs.writeFileSync(PRO_SETTINGS(), JSON.stringify(n.settings) + '\n'); }
       catch (e) { warnWriteFail('proactive-settings.json', e); return json(res, { ok: false, error: 'could not save — nothing changed' }, 500); }