create-pmos 0.59.2 → 0.60.0

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

@@ -9,7 +9,7 @@
  */
 
 export const COPY = {
-  title: 'Today',
+  title: 'Agenda',
   /** "3 need you", "1 needs you". */
   count: (n) => `${n} ${n === 1 ? 'needs' : 'need'} you`,
   countIn: (n, repo) => `${n} ${n === 1 ? 'needs' : 'need'} you in ${repo || 'this repository'}`,
@@ -128,7 +128,7 @@ export const COPY = {
     unreached: 'The workspace did not answer.',
     refused: (why) => `Nothing changed. ${why}`,
     oldServer: 'This workspace server has no day run yet. Only your goals show.',
-    panels: { summary: 'Agent results', calendar: 'Calendar', jobs: 'Jobs', goals: 'Goals for today', mentions: 'Mentions since yesterday', waiting: 'Also waiting for you', detail: 'Detail' },
+    panels: { summary: 'Agent results', calendar: 'Calendar', agenda: 'Agenda', jobs: 'Jobs', goals: 'Goals for today', mentions: 'Mentions since yesterday', waiting: 'Also waiting for you', detail: 'Detail' },
     summary: (c) => [c.review ? `${c.review} ${c.review === 1 ? 'draft waits' : 'drafts wait'} for you` : null, c.done ? `${c.done} done` : null,
       c.working ? `${c.working} working` : null, c.failed ? `${c.failed} failed` : null].filter(Boolean).join(' · ') || 'No agent job yet.',
     summaryAll: (n) => `All ${n} agent ${n === 1 ? 'job has' : 'jobs have'} a result.`,
@@ -282,6 +282,58 @@ export const COPY = {
     siteFull: 'At most 10 websites.',
     remove: 'Remove',
     noSources: 'The sources could not be read.',
+    /** The Agenda month (G25 to G27): the month on top, the agenda of a day or a week under it, the meeting's memory. */
+    ag: {
+      title: 'Agenda',
+      loading: 'Reading the month…',
+      prev: 'Earlier month',
+      later: 'Later month',
+      thisMonth: 'This month',
+      weekNo: (n) => `W${n}`,
+      weekOf: (n) => `Week ${n}`,
+      weekHint: (n) => `Show the agenda of week ${n}`,
+      dayHint: (label, key) => `Show the agenda of ${label}${key ? '. Matters most: ' + key : ''}`,
+      lens: { overview: 'Overview', full: 'Full', key: 'Key', ready: 'Prep', free: 'Free' },
+      lensHelp: {
+        overview: 'Each day: how full it is, the meeting that matters and your prep.',
+        full: 'The bar is 09:00 to 18:00. Each block is a meeting. Dark blocks are important.',
+        key: 'The one meeting of the day that matters, when there is one.',
+        ready: 'Prep done out of prep needed. Red: too little free time before the meeting.',
+        free: 'Free blocks of 90 minutes or more.',
+      },
+      busy: (min) => (min >= 60 ? `${Math.floor(min / 60)} h${min % 60 ? ' ' + (min % 60) + ' min' : ''}` : `${min} min`),
+      freeBlocks: (n) => `${n} free ${n === 1 ? 'block' : 'blocks'}`,
+      noFree: 'No long free block',
+      readyBadge: (done, need) => `${done}/${need}`,
+      readyWord: { ok: 'prep done', warn: 'prep left', risk: 'prep at risk' },
+      noNotes: (n) => `${n} no notes`,
+      star: '★',
+      lit: (title, n) => `${title}: ${n} ${n === 1 ? 'day' : 'days'} marked on the month.`,
+      empty: 'Nothing is remembered yet. Press Prepare my day: the session reads your calendar 90 days back and 31 days ahead.',
+      emptyMonth: 'No meetings remembered for this month.',
+      unread: 'The month could not be read.',
+      tiles: { busy: 'In meetings', key: 'Matters most', ready: 'Prep' },
+      noKey: 'Nothing stands out',
+      noPrep: 'Nothing to prepare',
+      noMeetings: 'No meetings.',
+      routine: (n) => `+${n} repeating, nothing for you`,
+      hideRoutine: 'Hide the repeating ones',
+      kindWord: { one: 'One-to-one', onboard: 'Onboarding', group: 'Group meeting' },
+      why: { present: 'You present.', decide: 'You decide.', external: 'People from outside the company join.', exec: 'Leadership joins.', many: (n) => `${n} people join.`, routine: 'It repeats, and nothing in it is for you.' },
+      means: 'What it means',
+      before: 'Before this meeting',
+      prepLine: (done, need) => `${done} of ${need} prep steps done.`,
+      readyNote: { ok: 'Your prep is done.', warn: 'Some prep is left, and there is time for it.', risk: 'The free time before it is short for the prep left.' },
+      series: (past, coming) => `Held ${past} ${past === 1 ? 'time' : 'times'} so far · ${coming} to come.`,
+      once: 'It happens once.',
+      lastTime: (date) => `Last time · ${date}`,
+      noLast: 'No notes from the last time.',
+      afterNotes: 'Notes',
+      openLines: 'Still open',
+      noNotesYet: 'No notes for this meeting.',
+      people: (n) => `${n} people`,
+      today: 'Today',
+    },
   },
   /** The Acceptance Gate card (D12): the PM's own act on a run. */
   accept: {

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

@@ -28,6 +28,7 @@ import { pmGet, pmPost } from './http.js';
 import { FIXTURE } from './state.js';
 import { COPY } from './today-copy.js';
 import { goalRows, goalAdd, goalDetail, addGoal, goalsSig } from './today-goals.js';
+import { agendaPanel, meetingDetail, memoryBlock, refreshAgenda, agendaSig, onAgenda } from './today-agenda.js';
 
 const D = COPY.day;
 const SLOW_MS = 30000;
@@ -73,6 +74,8 @@ async function load(ws) {
   const next = out && out.ok ? { data: out, error: null } : { data: prev ? prev.data : null, error: (out && out.error) || D.unreached };
   cache.set(ws, next);
   if (!prev || dataSig(prev.data) !== dataSig(next.data) || prev.error !== next.error) rerender();
+  // the month follows the brief and the clock: it is read again with the day
+  refreshAgenda();
   schedule();
 }
 
@@ -378,6 +381,13 @@ function eventChip(e) {
 function calendar(ctx) {
   const { m } = ctx;
   if (!m.events.length) return panel('calendar', null, note(m.run && m.stage === 'reading' ? D.readingJobs : D.noCalendar));
+  return panel('calendar', null, calendarRows(ctx));
+}
+
+/** Today's meetings from the brief, with a line at the current time: the agenda of today, and the calendar panel. */
+function calendarRows(ctx) {
+  const { m } = ctx;
+  if (!m.events.length) return null;
   const rows = [];
   let nowShown = false;
   const nowRow = () => el('li', { class: 'td-day__nowrow', 'data-day': 'now', 'aria-hidden': 'true' }, D.now(hhmm(m.now)));
@@ -389,7 +399,14 @@ function calendar(ctx) {
     { 'data-past': e.ended ? 'true' : null, 'data-goal-tie': n ? 'true' : null }));
   }
   if (!nowShown) rows.push(nowRow());
-  return panel('calendar', null, el('ul', { class: 'td-day__rows', 'data-day-list': 'calendar' }, ...rows));
+  return el('ul', { class: 'td-day__rows', 'data-day-list': 'calendar' }, ...rows);
+}
+
+/* The Agenda month (G25 to G27): today-agenda.js draws it with the helpers of this section. An older workspace server
+ * has no agenda route: then the day's calendar panel shows, as before. */
+function agenda(ctx) {
+  const h = { panel, sel: ui.sel, todayRows: () => calendarRows(ctx), rowBtn: (type, id, parts, mods) => rowBtn(ctx, type, id, parts, mods) };
+  return agendaPanel(ctx, h) || calendar(ctx);
 }
 
 function jobRow(ctx, j) {
@@ -525,6 +542,7 @@ function eventDetail(ctx, e) {
     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,
     !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,
@@ -777,6 +795,7 @@ function detail(ctx) {
     if (s.type === 'channel') return channelDetail(ctx, s.id);
     if (s.type === 'step') return stepDetail(ctx, Math.max(0, Math.min(3, Number(s.id) || 0)));
     if (s.type === 'sources') return sourcesDetail(ctx);
+    if (s.type === 'meeting') return meetingDetail(ctx, s.id, { dhead });
     return null;
   };
   kids = find(sel);
@@ -798,6 +817,7 @@ export function daySection({ ws, setState, openIni, owed, here, all } = {}) {
   // 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="day"]')) setState({}); };
+  onAgenda(() => rerender());
   ensure(ws);
   const c = cache.get(ws) || {};
   const m = model(c.data, { here: here || null, all: !!all });
@@ -828,12 +848,12 @@ export function daySection({ ws, setState, openIni, owed, here, all } = {}) {
     c.error ? el('p', { class: 'td-day__run td-day__run--failed', role: 'status', 'data-day': 'error' }, D.refused(c.error)) : null,
     m.d && m.d.legacy ? note(D.oldServer) : null,
     el('div', { class: 'td-day__cols' },
-      el('div', { class: 'td-day__left' }, summaryPanel(ctx), goalsPanel(ctx), calendar(ctx), jobsPanel(ctx), mentionsPanel(ctx), waitingPanel(owed)),
+      el('div', { class: 'td-day__left' }, summaryPanel(ctx), goalsPanel(ctx), agenda(ctx), jobsPanel(ctx), mentionsPanel(ctx), waitingPanel(owed)),
       detail(ctx)));
 }
 
 export function daySig(ws) {
   const c = cache.get(ws) || {};
   return JSON.stringify([ui.open, ui.sel, ui.mtab, ui.openSrc, ui.showIgn, ui.showIgnDigests, [...ui.revising], [...ui.busy], c.error, runs.get(ws) || null, [...seen].length])
-    + dataSig(c.data) + goalsSig();
+    + dataSig(c.data) + goalsSig() + agendaSig();
 }

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

@@ -21,6 +21,7 @@ import { COPY } from './today-copy.js';
 const G = COPY.goals;
 const D = COPY.day;
 let draft = '';
+let lastAdded = null;   // { key, at }: the text of the last goal sent, so a double commit adds it once
 const prepared = new Map();     // step ref -> { key, branch, item_id, prompt_sha, initiative_id, ws } (a plan shown, not yet queued)
 
 async function press(ctx, body) {
@@ -69,10 +70,15 @@ export function goalAdd(ctx) {
   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; }
+      // a rebuild while the text is typed can commit it twice: once as the old field leaves the page, once on Enter.
+      // The second commit of the text just added clears the field and adds nothing.
+      const key = String(v).trim().toLowerCase();
+      if (lastAdded && lastAdded.key === key && Date.now() - lastAdded.at < 10000) { draft = ''; f.control.value = ''; ctx.rerender(); return; }
+      lastAdded = { key, at: Date.now() };
       // 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(); }
+      else { lastAdded = null; 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;

package/workspace/server.js

@@ -95,6 +95,7 @@ const judgmentLib = require('./lib/judgment');
 const proactiveLib = require('./lib/proactive');
 const learnLib = require('./lib/learn');
 const briefLib = require('./lib/brief');
+const calMemLib = require('./lib/calendar-memory');
 const goalsLib = require('./lib/goals');
 const dayRunLib = require('./lib/day-run');
 const todayLib = require('./lib/today');
@@ -302,7 +303,8 @@ const TOKEN = BIND.token || null;                     // non-loopback peers must
 const onlineMode = require('./lib/online-mode');
 const accessJwt = require('./lib/access-jwt');
 const accessKeys = require('./lib/access-keys');
-const ONLINE = { settings: onlineMode.read(STATE), keys: null, keysTeam: null, fetchKeys: accessKeys.fetchCerts, find: onlineMode.findCloudflared };
+const ONLINE = { settings: onlineMode.read(STATE), keys: null, keysTeam: null, fetchKeys: accessKeys.fetchCerts, find: onlineMode.findCloudflared,
+  lastRefusal: null };   // { reason, at } of the last refused sign-in: a fixed reason word only, never the assertion or a claim (D08)
 const tunnel = onlineMode.createTunnel({ stateDir: STATE, find: () => ONLINE.find() });
 /** The public hostname the guards admit right now: the environment's, else the Online switch's while it is on. */
 function publicHost() { return BIND.publicHost || (ONLINE.settings.on ? ONLINE.settings.host : null); }
@@ -331,21 +333,26 @@ function applyOnline() {
 /** The D89 decision for one request: { ok: true } or { ok: false, reason }. The assertion is never logged (D08). */
 async function accessVerdict(headers) {
   const s = ONLINE.settings; const store = ONLINE.keys;
-  if (!store) return { ok: false, reason: 'no keys' };
+  if (!store) { const v = { ok: false, reason: 'no keys' }; noteVerdict(v); return v; }
   try { await store.ensure(); } catch { /* the store records its own error */ }
   const token = (headers || {})['cf-access-jwt-assertion'];
   const opts = { keyFor: store.keyFor, teamDomain: s.team, audience: s.audience, email: s.email, now: Math.floor(Date.now() / 1000) };
   let v = accessJwt.verify(token, opts);
   if (!v.ok && v.reason === 'unknown key' && v.kid && await store.refetchFor(v.kid)) v = accessJwt.verify(token, opts);
+  noteVerdict(v);
   return v;
 }
+/** Keep the reason of the last refusal for Settings › Online, so the PM can see which check failed. A pass clears it. */
+function noteVerdict(v) {
+  ONLINE.lastRefusal = v && v.ok ? null : { reason: String((v && v.reason) || 'unknown'), at: new Date().toISOString() };
+}
 /** The Online record and state, as GET /api/online returns it. Nothing secret is in it: the fields are not credentials. */
 function onlineView(req) {
   const s = ONLINE.settings;
   return {
     ok: true, on: s.on, host: s.host, tunnel: s.tunnel, team: s.team, audience: s.audience, email: s.email,
     complete: onlineMode.complete(s), envHost: BIND.publicHost || null, cloudflared: !!ONLINE.find(),
-    running: tunnel.status(), keys: ONLINE.keys ? ONLINE.keys.status() : null,
+    running: tunnel.status(), keys: ONLINE.keys ? ONLINE.keys.status() : null, lastRefusal: ONLINE.lastRefusal,
     canChange: onlineChangeAllowed(req),
   };
 }
@@ -453,13 +460,6 @@ function profileOverlay(profile) {
 }
 
 const SCROLLBACK = 200_000;                            // bytes of ring buffer per session
-const SCROLLBACK_SLACK = 32_768;                       // how far the ring may run over before a trim (appendBuf)
-// PTY output goes on the wire at most once per this window per session (queueOutput). node-pty
-// hands over whatever one read() returned, which for an agent CLI repainting its screen is many
-// small chunks — each one a JSON frame, a WebSocket message and a parse in the browser. The first
-// chunk after a quiet spell is sent at once, so a keystroke's echo is never delayed by it.
-const OUTPUT_COALESCE_MS = 4;
-const OUTPUT_COALESCE_MAX = 64 * 1024;                 // …and flushed at once past this, so a flood stays bounded
 // How often the server re-broadcasts the session list while anything is alive (see heartbeat()).
 // 2s is chosen against what it drives: the state dot and the quiet clock. QUIET_AFTER_MS is 30s, so
 // a 2s cadence puts the worst-case error in "quiet 31s" at one tick — under the rounding the UI
@@ -1456,7 +1456,13 @@ function parseHead(full) {
     }
   }
   const alsoIds = [...new Set(also.filter((x) => /^[A-Za-z0-9][\w.-]*$/.test(x)))];
+  // scan-consistency R3 — the files a RECORD names in its frontmatter (`prd_path`, `explainer_path`, `design_path`, …).
+  // Only the record role reads them (see docMeta); they are the strongest tie a document can have to an initiative.
+  const fmBlock = /^---\r?\n([\s\S]*?)(?:\r?\n---|$)/.exec(head);
+  const named = fmBlock ? [...fmBlock[1].matchAll(/^[a-z_]*_path[ \t]*:[ \t]*["']?([^"'\s][^"'\n]*?)["']?[ \t]*$/gm)]
+    .map((m) => m[1].trim().replace(/^\.?\//, '')).filter((x) => x && !x.split('/').includes('..')) : [];
   return {
+    named,
     initiative: id ? id[1] : (alsoIds[0] || null),
     also: alsoIds,
     recordId: rid ? rid[1] : null,
@@ -1522,6 +1528,7 @@ function docMeta(root, full) {
     // frontmatter wins; the filename convention is the fallback, never the override
     initiative: head.initiative || (role === 'record' ? head.recordId : null) || null,
     also: role === 'record' ? [] : (head.also || []),
+    named: role === 'record' ? (head.named || []) : [],
     stem, title: head.title || null,
     kr: head.kr || null, lane: head.lane || null,
     dest: head.dest || null,
@@ -1575,6 +1582,19 @@ function initiativeIndex(root) {
   // a filename stem is promoted to a group only when it matches a declared id or when
   // several artifacts share it, so a lone research note never invents an initiative.
   const declared = new Set(metas.map((m) => m.initiative).filter(Boolean));
+  // scan-consistency R3 — a document a record NAMES (`explainer_path: planning/explainers/x.md`) belongs to that record's
+  // initiative, whatever its file name. Before this the join read only declarations and file names, so an explainer or
+  // a design whose name differs from the id was attributed to nothing and the initiative showed its record alone (62 of
+  // 283 here). When two records name one file, the first in path order keeps it; the other still lists it as shared.
+  const namedBy = new Map();
+  const alsoNamed = new Map();
+  for (const m of metas.filter((x) => x.role === 'record' && x.initiative).sort((a, b) => a.path.localeCompare(b.path))) {
+    for (const rel of m.named || []) {
+      if (!namedBy.has(rel)) namedBy.set(rel, m.initiative);
+      else if (namedBy.get(rel) !== m.initiative) { if (!alsoNamed.has(rel)) alsoNamed.set(rel, new Set()); alsoNamed.get(rel).add(m.initiative); }
+    }
+  }
+  const relOf = (m) => String(m.path).split(path.sep).join('/');
   const byStem = new Map();
   for (const m of metas) if (!m.initiative) byStem.set(m.stem, (byStem.get(m.stem) || 0) + 1);
   const groups = new Map();
@@ -1603,6 +1623,7 @@ function initiativeIndex(root) {
   const prefixOwner = (stem) => capturing.find((id) => stem.length > id.length + 1 && stem.startsWith(id + '-')) || null;
   const keyFor = (m) => {
     if (m.initiative) return m.initiative;
+    if (namedBy.has(relOf(m))) return namedBy.get(relOf(m));
     if (declared.has(m.stem)) return m.stem;
     // the convention join: `jira-sync-prd.md` + `jira-sync-eval-rubric.md` are one unit
     if ((byStem.get(m.stem) || 0) > 1) return m.stem;
@@ -1617,7 +1638,7 @@ function initiativeIndex(root) {
     g.artifacts.push(art);
     // overhaul-r2 C1 — listed under every OTHER initiative it names too (it does not lend them a
     // title, an anchor or a lane: those stay the record's and its primary owner's)
-    for (const other of m.also || []) {
+    for (const other of [...(m.also || []), ...(alsoNamed.get(relOf(m)) || [])]) {
       if (other === k) continue;
       if (!groups.has(other)) groups.set(other, { id: other, title: null, kr: null, lane: null, artifacts: [] });
       groups.get(other).artifacts.push({ ...art, shared: true });
@@ -2843,11 +2864,7 @@ function trimBuf(buf, limit) {
 
 function appendBuf(s, data) {
   s.buf += data;
-  // Trimmed with SLACK, not on every byte past the limit. Once a busy session's ring is full, a trim
-  // per chunk flattens and scans the whole 200 KB string for each few bytes an agent CLI repaints —
-  // a spinner alone is dozens of chunks a second. Letting the ring run SCROLLBACK_SLACK over and then
-  // cutting it back to SCROLLBACK does the same work once per 32 KB of output.
-  if (s.buf.length > SCROLLBACK + SCROLLBACK_SLACK) s.buf = trimBuf(s.buf, SCROLLBACK);
+  if (s.buf.length > SCROLLBACK) s.buf = trimBuf(s.buf, SCROLLBACK);
   s.bufDirty = true;                    // the periodic writer skips a session that is not dirty
   // Parser 2's whole input: the moment output last arrived. `quiet` is derived from this, never
   // from reading the bytes — which is why it is the only one of the five that cannot misread.
@@ -2855,46 +2872,6 @@ function appendBuf(s, data) {
   s.parsed = null;                      // buffer moved; the cached parse is stale
 }
 
-/**
- * Put PTY output on the wire as at most ONE frame per OUTPUT_COALESCE_MS per session.
- *
- * Leading edge, then a window: a chunk that arrives when nothing has been sent recently goes out at
- * once — a keystroke's echo is never held back — and opens a window in which further chunks are
- * gathered and sent together when it closes. A burst (an agent CLI repainting its screen) therefore
- * costs one frame per window instead of one per node-pty read, and a lone echo costs nothing.
- *
- * The bytes reach the ring (`appendBuf`) at the same moment they reach the clients, never before:
- * a client that attaches in between gets `buf` without the pending bytes and then the flush, so it
- * sees every byte exactly once and in order. Anything that writes to `buf` directly while output may
- * be pending (the exit note) calls `flushOutput` first for the same reason.
- */
-function queueOutput(s, data) {
-  if (!data) return;
-  if (s._out) s._out += data; else s._out = data;
-  if (!s._outTimer) { sendOutput(s); s._outTimer = setTimeout(() => closeOutputWindow(s), OUTPUT_COALESCE_MS); return; }
-  if (s._out.length >= OUTPUT_COALESCE_MAX) sendOutput(s);
-}
-function closeOutputWindow(s) {
-  s._outTimer = null;
-  if (!s._out) return;
-  // Output kept arriving through the window: send it, and keep gathering for one more window.
-  sendOutput(s);
-  s._outTimer = setTimeout(() => closeOutputWindow(s), OUTPUT_COALESCE_MS);
-}
-function flushOutput(s) {
-  if (s._outTimer) { clearTimeout(s._outTimer); s._outTimer = null; }
-  sendOutput(s);
-}
-function sendOutput(s) {
-  const data = s._out;
-  if (!data) return;
-  s._out = '';
-  appendBuf(s, data);
-  if (!s.clients || !s.clients.size) return;
-  const frame = JSON.stringify({ t: 'data', id: s.id, data });
-  for (const c of s.clients) if (c.readyState === 1) c.send(frame);
-}
-
 // Platform-correct guidance when a spawn fails. On macOS `posix_spawnp failed` is almost always
 // node-pty's prebuilt `spawn-helper` missing its executable bit (prebuild extraction drops it) —
 // the binary is fine, just not +x. The server auto-restores it at startup and `npm run doctor`
@@ -3128,7 +3105,8 @@ function attachPty(s, { seed = false } = {}) {
     onOutput: (pane, text) => {
       if (paneId && pane !== paneId) return;              // only this session's pane
       if (s._reattempts) s._reattempts = 0;               // a working attach clears the retry budget
-      queueOutput(s, text);
+      appendBuf(s, text);
+      for (const c of s.clients) if (c.readyState === 1) c.send(JSON.stringify({ t: 'data', id: s.id, data: text }));
     },
   });
   p.onData((d) => parser.feed(d));
@@ -3136,7 +3114,6 @@ function attachPty(s, { seed = false } = {}) {
   // on the client PTY's own window size.
   client.resize(s.cols || 80, s.rows || 24);
   p.onExit(({ exitCode }) => {
-    flushOutput(s);   // whatever the pane said last lands before a reconnect or the exit note
     s.pty = null;
     // Our PTY is the tmux CLIENT: it exits when the pane process ends AND on a mere detach. If
     // the tmux session is still alive, the process lives on — reconnect (bounded, to never spin).
@@ -3378,9 +3355,11 @@ function spawnSession({ name, agent, cwd, ws, origin, initialInput, profile, ini
   announceStateHealth(s);
   announceTree(s);   // registered first: a session's co-tenancy question includes itself in the map
   announceModel(s);
-  p.onData((d) => queueOutput(s, d));
+  p.onData((d) => {
+    appendBuf(s, d);
+    for (const c of s.clients) if (c.readyState === 1) c.send(JSON.stringify({ t: 'data', id, data: d }));
+  });
   p.onExit(({ exitCode }) => {
-    flushOutput(s);   // the last bytes the process wrote come before the exit note, in the ring and on the wire
     s.state = 'exited'; s.pty = null;
     const fast = Date.now() - startedMs < 800;   // exited almost immediately → surface a hint
     s.note = fast
@@ -3879,6 +3858,15 @@ function dayTick() {
   if (JSON.stringify(run) !== before) writeDayRun(run);
 }
 // ── end of the today day run helpers ─────────────────────────────────────────────────────────────────────────────
+/* The calendar the Agenda remembers (G23): one file beside the briefs, written only by the brief route. */
+const CAL_MEMORY = () => path.join(STATE, 'calendar-memory.json');
+function readCalMemory() {
+  try { return JSON.parse(fs.readFileSync(CAL_MEMORY(), 'utf8')); } catch { return null; }
+}
+function writeCalMemory(m) {
+  const f = CAL_MEMORY(); const tmp = `${f}.${process.pid}.tmp`;
+  fs.mkdirSync(STATE, { recursive: true }); fs.writeFileSync(tmp, JSON.stringify(m) + '\n'); fs.renameSync(tmp, f);
+}
 
 // ── 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
@@ -7637,6 +7625,13 @@ async function handleRequest(req, res) {
       item_repos: goalsLib.itemRepos({ day: readGoalsDay(date), brief, placeRepos: st.placeRepos || {} }),
       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 : [] } });
   }
+  /* The Agenda month (G25 to G27): read-only. The calendar memory and today's brief, joined by lib/calendar-memory.js. */
+  if (p === '/api/proactive/agenda' && req.method === 'GET') {
+    const now = Date.now();
+    const month = url.searchParams.get('month') || undefined;
+    if (month !== undefined && !/^\d{4}-\d{2}$/.test(month)) return json(res, { ok: false, error: 'month must be YYYY-MM' }, 400);
+    return json(res, calMemLib.agendaMonth({ memory: readCalMemory(), brief: briefOfDay(briefLib.localDate(now)), month, now }));
+  }
   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);
@@ -7740,6 +7735,14 @@ 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);
+      // The calendar memory rides with the brief (G23): checked first, so a refused memory stores nothing at all.
+      let mem = null;
+      if (body.memory !== undefined) {
+        if (v.brief.sources.calendar !== 'read') return json(res, { ok: false, error: 'a calendar memory was given but calendar is not reported as read' }, 400);
+        const mv = calMemLib.validateMemory(body.memory, { now: Date.now() });
+        if (!mv.ok) return json(res, { ok: false, error: mv.error }, 400);
+        mem = mv.memory;
+      }
       // `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;
       let stored = null; try { stored = JSON.parse(fs.readFileSync(path.join(dir, v.brief.date + '.json'), 'utf8')); } catch { /* none yet */ }
@@ -7752,10 +7755,15 @@ async function handleRequest(req, res) {
       }
       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); }
+      let remembered = null; let memoryError = null;
+      if (mem) {
+        try { const mm = calMemLib.mergeMemory(readCalMemory(), mem, { now: Date.now() }).memory; writeCalMemory(mm); remembered = { events: mem.events.length, from: mem.from, to: mem.to }; }
+        catch (e) { warnWriteFail('calendar memory', e); memoryError = 'the brief was saved, but the calendar memory could not be saved'; }
+      }
       // 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 } : {}) });
+      return json(res, { ok: true, brief: out, ...(merged ? { merged } : {}), ...(remembered ? { remembered } : {}), ...(memoryError ? { memory_error: memoryError } : {}) });
     }
     if (req.method === 'GET') {
       const now = Date.now(); const st = proSettings();
@@ -8241,7 +8249,7 @@ function httpGuard(req, res) {
     accessVerdict(req.headers).then((v) => {
       if (v.ok) return handleRequest(req, res);
       res.writeHead(403, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
-      res.end(JSON.stringify({ ok: false, error: 'your Cloudflare sign-in could not be verified for this workspace' }));
+      res.end(JSON.stringify({ ok: false, error: 'your Cloudflare sign-in could not be verified for this workspace. Settings › Online on the computer that runs it says which check failed' }));
     }, () => {
       res.writeHead(403, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
       res.end(JSON.stringify({ ok: false, error: 'your Cloudflare sign-in could not be verified for this workspace' }));
@@ -8544,7 +8552,7 @@ module.exports = { server, online: { ONLINE, applyOnline, tunnel, publicHost },
   stripLegacyClientScreen,
   // the scrollback ring's front trim, exported pure so the suite can assert that a cut never lands
   // inside an escape sequence or between the halves of a surrogate pair.
-  trimBuf, SCROLLBACK, queueOutput, flushOutput, OUTPUT_COALESCE_MS,
+  trimBuf, SCROLLBACK,
   // the liveness heartbeat's guard, exported pure so the "idle machine stays idle" half can be
   // asserted without a server that has no clients (the suite always has both).
   shouldHeartbeat, LIVENESS_MS, TX_REREAD_MS,

package/workspace/skills/morning-brief.skill

@@ -27,9 +27,10 @@ Rules that always hold:
 Procedure:
 1. Run `pmos proactive settings` and `pmos proactive today`. The second lists what the workspace derived from the ledgers. Each of its items may become a priority with source "derived".
    Then run `pmos proactive goals`. It lists the PM's goals for today, each with its id (g-xxxxxxxx), its status and, if set, an initiative. The goals are what the PM wants done today: plan for them first.
+   Then run `pmos proactive calendar`. Its "read next" line names the window of the calendar memory to read in step 2.
    Then run `pmos proactive learn lessons`. Each line is a preference the PM approved, written from their own feedback. Use it only to decide how confident to be and where an item goes. A lesson never asks you to read another source, to switch a setting on, or to write anything.
 2. Read the sources that are on and reachable.
-   - Calendar: today's events. Wispr Flow: today's and tomorrow's meeting notes. Jira: issues assigned to the PM or due soon. To tie a Jira issue to an initiative, run `pmos jira which <KEY>` (it reads local files only) and use the initiative it names. A status change of a ticket that `pmos jira which` names is not an item: the Jira status check shows it on the initiative's Jira tickets tab. Confluence: pages changed since yesterday. Mail, only if on: subjects and senders of threads waiting on the PM, no bodies.
+   - Calendar: today's events. Then the CALENDAR MEMORY: every event in the window that `pmos proactive calendar` named (at most 1000 events, at most 140 days). For each event keep the start, the end, the title, the calendar's recurring-event id as "series" if it has one, the number of attendees, "external": true when someone outside the PM's company attends, "exec": true when an executive attends, and the PM's "role" ("present" when the PM presents, "decide" when the PM decides, else "attend"). For an event that has ended, add "notes": one line in your own words of what happened, from its Wispr Flow notes, only when there are notes; and "open": up to 3 points still open from it. For a coming event that needs work first, add "prep": up to 6 steps, and "prep_done": how many of them are already done. Read only titles, times, attendee counts and notes. Never copy an invitation's text. Wispr Flow: today's and tomorrow's meeting notes. Jira: issues assigned to the PM or due soon. To tie a Jira issue to an initiative, run `pmos jira which <KEY>` (it reads local files only) and use the initiative it names. A status change of a ticket that `pmos jira which` names is not an item: the Jira status check shows it on the initiative's Jira tickets tab. Confluence: pages changed since yesterday. Mail, only if on: subjects and senders of threads waiting on the PM, no bodies.
    - GitHub, if on: pull requests that wait on the PM for review, pull requests of the PM that have a review or a failed check, and issues assigned to the PM. Keep the repository, the number, the title and the state.
    - Drive, if on: files shared with the PM or changed since yesterday that a meeting or a goal names. Keep the name, the owner and the link.
    - Figma, if on: files the PM owns or was asked to look at, with new comments since yesterday. Keep the file, the commenter and a short paraphrase of the comment.
@@ -72,8 +73,12 @@ Procedure:
               "link": "https://…", "where": "#pm-team", "who": "…", "about": "…", "ask": "…", "reply_needed": true, "how": "…", "kind": "you|approve|auto"}],
     "digests": [{"source": "slack|jira|confluence", "name": "#pm-team", "link": "https://…", "decisions": ["…"], "open": ["…"], "goals": ["…"]}],
     "places": [{"source": "slack|jira|confluence", "name": "#pm-team", "link": "https://…"}],
+    "memory": {"from": "YYYY-MM-DD", "to": "YYYY-MM-DD",
+               "events": [{"start": "<ISO>", "end": "<ISO>", "title": "…", "series": "<recurring id or omit>", "attendees": 2, "external": false, "exec": false, "role": "present|decide|attend",
+                           "notes": "<ended only>", "open": ["…"], "prep": ["<coming only>"], "prep_done": 0}]},
     "judgment": {"used": false}}
    ```
+   "memory" is optional: give it only when calendar is "read". Its "from" and "to" are the window you read, and every event's start is inside it. The workspace replaces the days of that window in what it remembers.
    "places" holds at most 200 entries, each a name of at most 120 characters, only for a source that is "read". A digest has at most 5 decisions, 5 open questions and 5 goal lines, each at most 140 characters, and at most 30 digests. Write a digest only for a place with scope watch, and only for a source that is "read". Only report calendar events if calendar is "read". Only give an item a source that is "read" (or "derived"). Only use a goal id that `pmos proactive goals` listed today: the workspace refuses any other. Leave out a field you cannot fill: an empty string is worse than no field.
 5. Run `pmos proactive brief submit --file <that file>`. If it is refused, read the reason, fix the file and submit once more. Do not work around a refusal.
 6. Finish by saying in three lines how many goals have a step and which have none, how many priorities and worth-asking items you submitted, and which sources were not reached.

package/workspace/test-files.json

@@ -10,6 +10,7 @@
   "modules": [
     "proactive.test.js",
     "goals.test.js",
+    "agenda.test.js",
     "day-run.test.js",
     "focus.test.js",
     "handoff.test.js",
@@ -109,6 +110,7 @@
     "test.js": 48,
     "proactive.test.js": 4,
     "goals.test.js": 6,
+    "agenda.test.js": 5,
     "day-run.test.js": 6,
     "focus.test.js": 1,
     "handoff.test.js": 1,

package/workspace/test-lists/scan-consistency.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "scan-consistency: delivery attribution by change, stage frontier, Files sources and the breakdown read from the spec.",
+  "modules": ["scan-consistency.test.js"],
+  "seconds": { "scan-consistency.test.js": 10 }
+}