create-pmos 0.54.1 → 0.55.1

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",