create-pmos 0.129.0 → 0.131.0

package/workspace/guide/my-work.md

@@ -1,7 +1,7 @@
 ---
 type: Guide
 title: "My work: every Jira ticket and WBS item assigned to you, ranked, briefed to an agent, approved in Agenda"
-timestamp: 2026-10-07
+timestamp: 2026-10-11
 ---
 
 # My work
@@ -68,3 +68,78 @@ Agenda shows one card, **N items need your brief**, when items wait in To brief.
 | `pmos my-work submit --file <read.json>` | The my-work-read skill submits its read. |
 
 None of these briefs an agent or takes an item. Do that in My work.
+
+## The Work page: your own items in six views
+
+The Work page holds the items you add for yourself. These are your own to-dos, such as "send Dana the new date". The server decides where each item shows, so one item is never in two views.
+
+The six views follow the OmniFocus style. The **Work** tab badge counts Inbox plus Today.
+
+| View | What it holds |
+|---|---|
+| Inbox | Items with no date, not yet decided. Give each one a date, a defer date or a job, mark it waiting, move it to Someday, or drop it. |
+| Today | Items due today or overdue, and every flagged item. Overdue items come first, then flagged items, then the rest by due date. |
+| Upcoming | Items that arrive in the future. A later due date or a defer date puts an item here. The next 7 days are grouped by day, then **Later**. |
+| Waiting | Items where you wait for someone. The item that has waited longest comes first. |
+| Someday | Items you parked. They do not appear anywhere else. |
+| Review | Items in Inbox, Someday or Waiting that nobody touched for 7 days. The most stale item comes first. |
+
+An item goes to the first view that fits these rules, in this order. Parked is Someday. Waiting on someone is Waiting. A defer date after today is Upcoming. Flagged is Today. Due today or earlier is Today. A later due date is Upcoming. An undated item whose defer date has arrived is Today. No date is Inbox.
+
+### Defer and flag
+
+A defer date means "not before this day". The item stays in Upcoming and shows **Not before** with the date. On that day it moves to Today by itself. A due date is when the work must be done. A defer date is when you start.
+
+Flag an item to put it in Today now, whatever its date. Remove the flag to send it back.
+
+### Focus
+
+Focus sits at the top of Today. PMOS suggests up to three jobs for the day and gives the reason for each, for example "2 items overdue, 1 flagged".
+
+PMOS groups the Today items by their job. An item with no job is its own group. It ranks a group by how late its items are, and by whether they are due today, flagged, P1 or work outside PMOS. It uses rules only and calls no model.
+
+For each suggestion, you accept it, change it or reject it. An accepted job stays at the top of Today for the day. A rejected job does not come back that day. Focus starts empty each new day.
+
+### Work outside PMOS
+
+Some items are not done in PMOS, such as "talk to Ana" or "set up a meeting with Raj". Mark these as offline work and name the person. An offline item offers three actions:
+
+- **Done.** Add a one-line outcome if you want to keep it.
+- **Not yet.** Choose later today, tomorrow or next week. Tomorrow and next week set a defer date, and the item returns to Today on that day. Next week means the next Monday. Later today reminds you in 3 hours.
+- **Drop.**
+
+An offline item can carry evidence that it is done, for example a meeting that took place. The row then says **Looks done?** and shows a **Confirm** button. PMOS never marks an item done by itself. You press Confirm.
+
+### Review
+
+Review is a weekly pass. It shows one item at a time. Press **Keep** to leave the item as it is and clear it from the queue for 7 days. Press **Change** to edit it. Press **Drop** to remove it. Any change to an item also clears it from the queue.
+
+### Link to a team task
+
+A Work item can link to the plan item it advances. The link shows on the item with the title of the plan item. Closing the plan item is a separate step, in the initiative.
+
+### Where decisions go
+
+A decision or an approval only you can make is not a Work item. It shows in Briefing, under **Needs you**.
+
+## Using the Work page
+
+The Work page in the console has six views: **Inbox**, **Today**, **Upcoming**, **Waiting**, **Someday** and **Review**. Each view button shows how many items it holds.
+
+Each item is in one view only. The rule, in order: an item in Someday stays in Someday. An item that waits on a person is in Waiting. An item with a Not before date after today is in Upcoming. A flagged item is in Today. An item due today or earlier is in Today. An item due later is in Upcoming. An item with no date is in Inbox.
+
+Decisions are not on the Work page. They have their own place in the console.
+
+**Today** starts with a Focus band. It suggests up to 3 items. Select **Accept** to pin one, **Not today** to remove the suggestion, or **Unpin** to remove a pinned item. You can edit the title of a pinned item.
+
+**Upcoming** shows one block for each of the next 7 days, then **Later**.
+
+**Review** shows the items in Inbox, Waiting and Someday that nobody changed for 7 days or more, one at a time, the oldest first. For each item, select **Keep**, **Change** or **Drop**. When no items remain, the view shows **Review done**.
+
+Open an item to use these actions: **Flag**, **Not before** (a date), **Someday** or **Bring back**, **Waiting** (a name) or **Stop waiting**, **Done** and **Drop**.
+
+An item marked **outside PMOS** is work you do yourself, for example a talk with a person. It shows the person's name. Write the result in one line and select **Done**, or select **Not yet** and then **Later today**, **Tomorrow** or **Next week**. The item shows how many times you moved it. When PMOS finds evidence that the work is done, the item shows **Looks done?** and the evidence. Select **Confirm** to close it.
+
+Each action shows **Undo** for a short time.
+
+When you type a new line, the chip below the box tells you the view where the line will go.

package/workspace/lib/calendar-layers.js

@@ -0,0 +1,372 @@
+'use strict';
+/* calendar-layers.js — the pure part of the console3 Calendar page's server answer (initiative calendar-time-page, R2 to R5, R8).
+ *
+ *   layersFrom(dated, range, today)                  → { layers, layers_total, layers_note }   dated items inside the range
+ *   freeFrom(events, range, today, opts)             → { min_minutes, day_start, day_end, days, count }
+ *   contextFrom(events, range, src, opts)            → { context, context_total }              keyed by event id
+ *   build({ range, today, nowMs, events, dated, src, view })   all three, for routes-calendar-views.js
+ *
+ * No I/O and no clock: `today` comes in as 'YYYY-MM-DD', `nowMs` as a number. Nothing is invented. A source with no reader
+ * is named in layers_note with the reason, and gives no item. Meetings are not layers; they stay in `cells`.
+ *
+ * INPUT SHAPES (plain data; the route reads them from the repository and the per-user store).
+ *   dated = { initiatives:[{id,title,promised,done}], planItems:[{id,initiative,title,due,milestone,state}],
+ *             releases:[{id,type,fix_version,deploy_at,release_at}], reports:[{cadence,slot,issued}],
+ *             reportSchedules:[{id,name,cadence,dates:['YYYY-MM-DD']}], own:[{id,title,due,done}], unavailable:{ source: why } }
+ *   src   = { notes:[{id,title,private,meeting:{event_id,start,title},initiative,decisions:[{text}],actions:[{text,owner,due}]}],
+ *             planItems:[{id,initiative,title,createdAt,doneAt}], ownItems:[{id,title,initiative,created_at,done_at}] }
+ *   event = the imported event ({ id, at, end, title, initiative, pm_notes, agent_prep_notes, prep, prep_done, steps }).
+ *
+ * TONE. bad: past its date and not done. warn: due today up to 2 days ahead and not done. ok: done. Otherwise null.
+ * FREE TIME. Working days only (Monday to Friday), from DAY_START to DAY_END, a block of min_minutes or more (calendar-memory's
+ * dayLoad). Days before today are left out: free time that has passed cannot be used. An event with a date and no time (all day)
+ * does not block; an event with no end lasts 30 minutes. Quarter and Year answer days:[] and the count only. */
+const memory = require('./calendar-memory.js');
+
+const DAY_MS = 86400000;
+const LAYER_CAP = 400;
+const CONTEXT_CAP = 60;
+const MIN_BLOCK = memory.FREE_BLOCK;     // 90
+const PER_STEP = memory.PER_STEP;        // 30 minutes of free time for each prep step left
+const PER_DAY = 60;                      // minutes of a whole working day before the meeting that count toward its prep
+const DAY_START = 9 * 60;
+const DAY_END = 18 * 60;
+const WARN_DAYS = 2;
+const SUGGEST_DAYS = 7;
+const WINDOW_MS = 48 * 3600000;
+const PER_KIND = { decision: 6, action: 6, moved: 8, prepared: 8, todo: 8 };
+const LIGHT_VIEWS = ['quarter', 'year'];
+
+const pad = (n) => String(n).padStart(2, '0');
+const isDay = (s) => typeof s === 'string' && /^\d{4}-\d{2}-\d{2}/.test(s) && !Number.isNaN(Date.parse(s.slice(0, 10) + 'T00:00:00Z'));
+const day10 = (s) => String(s).slice(0, 10);
+const hasTime = (s) => typeof s === 'string' && /T\d{2}:\d{2}/.test(s);
+const ymdMs = (s) => Date.parse(day10(s) + 'T00:00:00Z');
+const addDays = (s, n) => new Date(ymdMs(s) + n * DAY_MS).toISOString().slice(0, 10);
+const diffDays = (a, b) => Math.round((ymdMs(a) - ymdMs(b)) / DAY_MS);
+const dow = (s) => new Date(ymdMs(s)).getUTCDay();                  // 0 Sunday
+const isWorkday = (s) => dow(s) >= 1 && dow(s) <= 5;
+const hhmm = (m) => `${pad(Math.floor(m / 60))}:${pad(m % 60)}`;
+const localMs = (s) => { const [y, m, d] = day10(s).split('-').map(Number); return new Date(y, m - 1, d).getTime(); };
+const localDay = (ms) => { const d = new Date(ms); return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`; };
+const minuteOfDay = (ms) => { const d = new Date(ms); return d.getHours() * 60 + d.getMinutes(); };
+const str = (v) => (typeof v === 'string' ? v.trim() : '');
+const norm = (t) => String(t || '').toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').trim();
+const inRange = (d, range) => d >= range.start && d <= range.end;
+const overlaps = (a, b, range) => a <= range.end && b >= range.start;
+
+/* ── layers ────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function toneOf(date, done, today) {
+  if (done) return 'ok';
+  if (date < today) return 'bad';
+  if (diffDays(date, today) <= WARN_DAYS) return 'warn';
+  return null;
+}
+
+function layersFrom(dated, range, today) {
+  const d = dated || {};
+  const out = [];
+  const note = {};
+  const dateless = {};                       // source -> items that carry a date at all (in range or not)
+  const inside = {};                         // source -> items inside the range
+  const put = (source, x) => {
+    dateless[source] = (dateless[source] || 0) + 1;
+    const end = x.end && x.end > x.date ? x.end : null;
+    if (!overlaps(x.date, end || x.date, range)) return;
+    inside[source] = (inside[source] || 0) + 1;
+    const { end: _e, ...rest } = x;
+    out.push(end ? { ...rest, end } : rest);
+  };
+  const unavailable = d.unavailable && typeof d.unavailable === 'object' ? d.unavailable : {};
+  const why = (source, fallback) => { if (unavailable[source]) note[source] = String(unavailable[source]); else if (fallback) note[source] = fallback; };
+
+  // initiatives: the promised date
+  if (unavailable.initiatives) why('initiatives');
+  else {
+    let n = 0;
+    for (const i of d.initiatives || []) {
+      if (!i || !i.id || !isDay(i.promised)) continue;
+      n++;
+      const date = day10(i.promised);
+      put('initiatives', { id: `ini:${i.id}:promised`, date, kind: 'milestone', layer: 'milestones', title: str(i.title) || i.id, tone: toneOf(date, !!i.done, today), ref: { type: 'initiative', id: i.id }, initiative: i.id });
+    }
+    if (!n) why('initiatives', 'no initiative has a promised date');
+  }
+  // plan items: a milestone or a due date
+  if (unavailable.plan_items) why('plan_items');
+  else {
+    let n = 0;
+    for (const p of d.planItems || []) {
+      if (!p || !p.id || !isDay(p.due)) continue;
+      n++;
+      const date = day10(p.due);
+      put('plan_items', { id: `plan:${p.id}:${p.milestone ? 'milestone' : 'due'}`, date, kind: p.milestone ? 'milestone' : 'due', layer: 'milestones', title: str(p.title) || p.id,
+        tone: toneOf(date, p.state === 'done', today), ref: { type: 'plan-item', id: p.id }, ...(p.initiative ? { initiative: p.initiative } : {}) });
+    }
+    if (!n) why('plan_items', 'no plan item has a due date');
+  }
+  // releases
+  if (unavailable.releases) why('releases');
+  else {
+    let n = 0;
+    for (const r of d.releases || []) {
+      if (!r || !r.id) continue;
+      const dep = isDay(r.deploy_at) ? day10(r.deploy_at) : null; const rel = isDay(r.release_at) ? day10(r.release_at) : null;
+      const date = dep || rel; if (!date) continue;
+      n++;
+      const last = rel || dep;
+      put('releases', { id: `rel:${r.id}`, date, ...(last > date ? { end: last } : {}), kind: 'release', layer: 'releases', title: str(r.fix_version) || `Release ${str(r.type) || r.id}`,
+        tone: null, ref: { type: 'release', id: r.id } });
+    }
+    if (!n) why('releases', 'no release has a deploy or release date');
+  }
+  // reports: the issue date of a report file, and the next runs of a report schedule
+  if (unavailable.reports) why('reports');
+  else {
+    let n = 0;
+    for (const r of d.reports || []) {
+      if (!r || !r.cadence || !isDay(r.slot)) continue;
+      const date = r.issued && isDay(r.issued.at) ? day10(r.issued.at) : day10(r.slot);
+      n++;
+      put('reports', { id: `report:${r.cadence}:${day10(r.slot)}`, date, kind: 'report', layer: 'reports', title: `${r.cadence} report${r.issued ? '' : ' (not issued)'}`,
+        tone: r.issued ? 'ok' : null, ref: { type: 'report', id: `${r.cadence}/${day10(r.slot)}` } });
+    }
+    for (const s of d.reportSchedules || []) {
+      if (!s || !s.id) continue;
+      for (const dt of s.dates || []) {
+        if (!isDay(dt)) continue;
+        n++;
+        put('reports', { id: `report-sched:${s.id}:${day10(dt)}`, date: day10(dt), kind: 'report', layer: 'reports', title: `${str(s.name) || s.cadence || s.id} (scheduled)`, tone: null,
+          ref: { type: 'report', id: s.cadence || s.id } });
+      }
+    }
+    if (!n) why('reports', 'no report file and no report schedule gives an issue date');
+  }
+  // the PM's own items with a due date: markers only
+  if (unavailable.own) why('own');
+  else {
+    let n = 0;
+    for (const o of d.own || []) {
+      if (!o || !o.id || !isDay(o.due)) continue;
+      n++;
+      const date = day10(o.due);
+      put('own', { id: `own:${o.id}`, date, kind: 'own', layer: 'mine', title: str(o.title) || o.id, tone: toneOf(date, !!o.done, today), ref: { type: 'item', id: o.id } });
+    }
+    if (!n) why('own', 'none of your own items has a due date');
+  }
+  out.sort((a, b) => (a.date < b.date ? -1 : a.date > b.date ? 1 : a.title < b.title ? -1 : a.title > b.title ? 1 : a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  const layers = out.slice(0, LAYER_CAP);
+  // a source that read fine but has nothing inside this range says so too, so an empty layer is never a silent one
+  for (const source of ['initiatives', 'plan_items', 'releases', 'reports', 'own']) {
+    if (note[source]) continue;
+    if (dateless[source] && !inside[source]) note[source] = 'nothing dated falls inside this range';
+  }
+  return { layers, layers_total: out.length, layers_note: note };
+}
+
+/* ── free time ─────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+/** An event as a span in epoch ms, or null for an all-day event or one with no usable start. */
+function spanOf(e) {
+  if (!e || !hasTime(e.at || e.start)) return null;
+  const s = Date.parse(e.at || e.start);
+  if (!Number.isFinite(s)) return null;
+  let f = e.end ? Date.parse(e.end) : s + 30 * 60000;
+  if (!Number.isFinite(f) || f < s) f = s + 30 * 60000;
+  return { s, f };
+}
+
+/** Meetings that touch `date`, as minutes of that day. */
+function minutesOn(spans, date) {
+  const a = localMs(date); const b = a + DAY_MS;
+  const out = [];
+  for (const sp of spans) {
+    if (sp.f <= a || sp.s >= b) continue;
+    out.push({ from: sp.s <= a ? 0 : minuteOfDay(sp.s), to: sp.f >= b ? 1440 : minuteOfDay(sp.f) });
+  }
+  return out;
+}
+
+/** Free minutes inside working hours between two minutes of a day, given the merged busy intervals. */
+function freeBetween(merged, from, until) {
+  const a = Math.max(DAY_START, from); const b = Math.min(DAY_END, until);
+  if (b <= a) return 0;
+  let busy = 0;
+  for (const [s, e] of merged) busy += Math.max(0, Math.min(e, b) - Math.max(s, a));
+  return b - a - busy;
+}
+
+/** The prep steps of an event: { steps:[text], done:n }. Reads prep / prep_done, else steps.before. */
+function prepOf(e) {
+  if (!e) return { steps: [], done: 0 };
+  if (Array.isArray(e.prep) && e.prep.length) {
+    const steps = e.prep.map((x) => str(typeof x === 'string' ? x : x && (x.t || x.text))).filter(Boolean);
+    const done = Math.min(steps.length, Math.max(0, Number(e.prep_done) || 0));
+    return { steps, done, doneFlags: steps.map((_, i) => i < done) };
+  }
+  const before = e.steps && Array.isArray(e.steps.before) ? e.steps.before : [];
+  const steps = before.map((x) => str(x && (x.t || x.text))).filter(Boolean);
+  const flags = before.filter((x) => str(x && (x.t || x.text))).map((x) => !!x.done);
+  return { steps, done: flags.filter(Boolean).length, doneFlags: flags };
+}
+
+function nextWorkday(date) { let d = addDays(date, 1); while (!isWorkday(d)) d = addDays(d, 1); return d; }
+
+function freeFrom(events, range, today, opts = {}) {
+  const view = range.view;
+  const nowMs = Number.isFinite(opts.nowMs) ? opts.nowMs : localMs(today);
+  const spans = (events || []).map((e) => ({ e, ...(spanOf(e) || {}) })).filter((x) => x.s !== undefined);
+  const memo = new Map();
+  const loadOf = (date) => { if (!memo.has(date)) memo.set(date, memory.dayLoad(minutesOn(spans, date))); return memo.get(date); };
+
+  // prep at risk: a coming event with steps left and less free time before it than PER_STEP for each step
+  const risky = [];
+  for (const x of spans) {
+    const p = prepOf(x.e);
+    const left = p.steps.length - p.done;
+    if (!left || x.f <= nowMs) continue;
+    const date = localDay(x.s);
+    const startMin = minuteOfDay(x.s);
+    let free = freeBetween(loadOf(date).merged, date === today ? minuteOfDay(nowMs) : DAY_START, startMin);
+    for (let dd = today; dd < date; dd = addDays(dd, 1)) {
+      if (!isWorkday(dd)) continue;
+      free += Math.min(PER_DAY, freeBetween(loadOf(dd).merged, dd === today ? minuteOfDay(nowMs) : DAY_START, DAY_END));
+    }
+    if (free < left * PER_STEP) risky.push({ id: x.e.id, title: str(x.e.title) || 'a meeting', date, s: x.s, left });
+  }
+  risky.sort((a, b) => a.s - b.s);
+
+  // items due soon, most pressing first: overdue and nearest due date, then the higher priority, then the title
+  const prio = (p) => (/^P[1-3]$/.test(String(p || '')) ? Number(String(p)[1]) : 9);
+  const due = [];
+  for (const o of opts.own || []) if (o && o.id && !o.done && isDay(o.due)) due.push({ id: o.id, type: 'item', title: str(o.title) || o.id, due: day10(o.due), p: prio(o.priority) });
+  for (const p of opts.planItems || []) if (p && p.id && p.state !== 'done' && isDay(p.due)) due.push({ id: p.id, type: 'plan-item', title: str(p.title) || p.id, due: day10(p.due), p: 5 });
+  due.sort((a, b) => (a.due < b.due ? -1 : a.due > b.due ? 1 : a.p - b.p || (a.title < b.title ? -1 : a.title > b.title ? 1 : a.id < b.id ? -1 : 1)));
+
+  const usedEvent = new Set(); const usedItem = new Set();
+  const suggest = (date, block) => {
+    const next = nextWorkday(date);
+    const hit = risky.find((r) => !usedEvent.has(r.id) && (r.date === next || (r.date === date && r.s >= localMs(date) + block.from * 60000)));
+    if (hit) {
+      usedEvent.add(hit.id);
+      return { text: `Prepare for "${hit.title}": ${hit.left} ${hit.left === 1 ? 'step is' : 'steps are'} left and little free time remains before it.`, ref: { type: 'event', id: hit.id } };
+    }
+    const top = due.find((x) => !usedItem.has(x.id) && diffDays(x.due, date) <= SUGGEST_DAYS);
+    if (top) {
+      usedItem.add(top.id);
+      return { text: top.due < date ? `Work on "${top.title}". It was due ${top.due}.` : `Work on "${top.title}". It is due ${top.due}.`, ref: { type: top.type, id: top.id } };
+    }
+    return null;
+  };
+
+  const days = []; let count = 0;
+  const light = LIGHT_VIEWS.includes(view);
+  for (let dd = range.start < today ? today : range.start; dd <= range.end; dd = addDays(dd, 1)) {
+    if (!isWorkday(dd)) continue;
+    const blocks = loadOf(dd).gaps.map(([a, b]) => ({ from: hhmm(a), to: hhmm(b), minutes: b - a, _a: a, _b: b }));
+    count += blocks.length;
+    if (light) continue;
+    const out = blocks.map((b) => ({ from: b.from, to: b.to, minutes: b.minutes, suggestion: suggest(dd, { from: b._a, to: b._b }) }));
+    if (out.length) days.push({ date: dd, blocks: out });
+  }
+  return { min_minutes: MIN_BLOCK, day_start: hhmm(DAY_START), day_end: hhmm(DAY_END), days, count };
+}
+
+/* ── context ───────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function noteMatches(n, e) {
+  const m = n && n.meeting;
+  if (!m) return false;
+  if (m.event_id && e.id && String(m.event_id) === String(e.id)) return true;
+  const a = Date.parse(m.start); const b = Date.parse(e.at || e.start);
+  return Number.isFinite(a) && Number.isFinite(b) && Math.floor(a / 60000) === Math.floor(b / 60000) && norm(m.title) === norm(e.title);
+}
+
+function referencesEvent(text, e) {
+  const t = norm(text);
+  if (!t) return false;
+  if (e.id && t.includes(norm(e.id)) && norm(e.id).length >= 6) return true;
+  const title = norm(e.title);
+  return title.length >= 4 && t.includes(title);
+}
+
+function movedBy(e, eventEnd, src) {
+  const lo = eventEnd; const hi = eventEnd + WINDOW_MS;
+  const within = (iso) => { const t = Date.parse(iso); return Number.isFinite(t) && t >= lo && t <= hi; };
+  const out = [];
+  const same = (ini, text) => (ini && e.initiative && ini === e.initiative) || referencesEvent(text, e);
+  for (const p of src.planItems || []) {
+    if (!p || !p.id || !same(p.initiative, p.title)) continue;
+    if (within(p.createdAt)) out.push({ kind: 'moved', text: `Created plan item: ${str(p.title) || p.id}`, ref: { type: 'plan-item', id: p.id }, at: p.createdAt });
+    if (within(p.doneAt)) out.push({ kind: 'moved', text: `Closed plan item: ${str(p.title) || p.id}`, ref: { type: 'plan-item', id: p.id }, at: p.doneAt });
+  }
+  for (const o of src.ownItems || []) {
+    if (!o || !o.id || !same(o.initiative, o.title)) continue;
+    if (within(o.created_at)) out.push({ kind: 'moved', text: `Created your item: ${str(o.title) || o.id}`, ref: { type: 'item', id: o.id }, at: o.created_at });
+    if (within(o.done_at)) out.push({ kind: 'moved', text: `Closed your item: ${str(o.title) || o.id}`, ref: { type: 'item', id: o.id }, at: o.done_at });
+  }
+  out.sort((a, b) => Date.parse(a.at) - Date.parse(b.at) || (a.text < b.text ? -1 : 1));
+  return out;
+}
+
+function capKinds(items) {
+  const n = {};
+  return items.filter((x) => { n[x.kind] = (n[x.kind] || 0) + 1; return n[x.kind] <= (PER_KIND[x.kind] || 8); });
+}
+
+function contextFrom(events, range, src, opts = {}) {
+  const s = src || {};
+  const today = opts.today;
+  const nowMs = Number.isFinite(opts.nowMs) ? opts.nowMs : localMs(today);
+  const inside = [];
+  for (const e of events || []) {
+    const at = e && (e.at || e.start);
+    if (!e || !e.id || !isDay(at)) continue;
+    const a = day10(at); const b = e.end && isDay(e.end) ? day10(e.end) : a;
+    if (overlaps(a, b < a ? a : b, range)) inside.push(e);
+  }
+  const mid = (e) => (spanOf(e) ? spanOf(e).s : localMs(e.at || e.start));
+  inside.sort((x, y) => Math.abs(mid(x) - nowMs) - Math.abs(mid(y) - nowMs) || (String(x.id) < String(y.id) ? -1 : 1));
+  const context = {};
+  for (const e of inside.slice(0, CONTEXT_CAP)) {
+    const sp = spanOf(e);
+    const endMs = sp ? sp.f : localMs(e.end && isDay(e.end) ? e.end : e.at) + DAY_MS;     // an all-day event ends at the end of its day
+    const past = endMs <= nowMs;
+    const notes = (s.notes || []).filter((n) => noteMatches(n, e));
+    const items = [];
+    if (past) {
+      for (const n of notes) {
+        if (n.private) continue;                       // a private note shows its title and nothing of its content
+        for (const d of n.decisions || []) if (str(d && d.text)) items.push({ kind: 'decision', text: str(d.text), ref: { type: 'note', id: n.id } });
+        for (const a of n.actions || []) {
+          if (!str(a && a.text)) continue;
+          const tail = [a.owner && `owner: ${a.owner}`, a.due && `due: ${a.due}`].filter(Boolean).join(', ');
+          items.push({ kind: 'action', text: str(a.text) + (tail ? ` (${tail})` : ''), ref: { type: 'note', id: n.id } });
+        }
+      }
+      const moved = movedBy({ ...e, initiative: e.initiative || (notes.find((n) => n.initiative) || {}).initiative || null }, endMs, s);
+      items.push(...moved);
+    } else {
+      const p = prepOf(e);
+      p.steps.forEach((t, i) => items.push({ kind: p.doneFlags && p.doneFlags[i] ? 'prepared' : 'todo', text: t, ref: { type: 'event', id: e.id } }));
+      if (str(e.agent_prep_notes)) items.push({ kind: 'prepared', text: 'Prep notes from your agent session are saved.', ref: { type: 'event', id: e.id } });
+      for (const m of e.pm_notes || []) if (str(m && m.text)) items.push({ kind: 'prepared', text: `Your note: ${str(m.text)}`, ref: { type: 'event', id: e.id }, ...(m.at ? { at: m.at } : {}) });
+      for (const n of notes) items.push({ kind: 'prepared', text: `A meeting note is linked: ${str(n.title) || n.id}`, ref: { type: 'note', id: n.id } });
+    }
+    const kept = capKinds(items);
+    context[e.id] = { phase: past ? 'past' : 'upcoming', held: kept.length > 0, items: kept };
+  }
+  return { context, context_total: inside.length };
+}
+
+/* ── all three ─────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function build({ range, today, nowMs, events, dated, src, own, planItemsDue }) {
+  const l = layersFrom(dated, range, today);
+  const free = freeFrom(events, range, today, { nowMs, own: own || (dated && dated.own) || [], planItems: planItemsDue || (dated && dated.planItems) || [] });
+  const c = contextFrom(events, range, src, { today, nowMs });
+  return { layers: l.layers, layers_total: l.layers_total, layers_note: l.layers_note, free, context: c.context, context_total: c.context_total };
+}
+
+module.exports = { layersFrom, freeFrom, contextFrom, build, toneOf, prepOf, spanOf, LAYER_CAP, CONTEXT_CAP, MIN_BLOCK, WINDOW_MS };

package/workspace/lib/pm-items.js

@@ -6,6 +6,10 @@
  * and the fold of the whole file is the current list. Stage is never stored; a list is derived from the due
  * date, priority and waiting-on fields by placement() below.
  *
+ * The Work page (console3) reads a second placement, workPlacement(), into five views: inbox, today, upcoming,
+ * waiting, someday. placement() and its five lists stay for the old routes. A sixth view, Review, is a queue
+ * (reviewQueue) of items nobody has touched for a week. fold() stamps `touched_at` from the event's `at`.
+ *
  * SINGLE WRITER: appendEvent() is the only function that writes the file. Callers pass the event; they never
  * choose `at` or `by` themselves (attribution comes from the call path, as in plan-items.js).
  */
@@ -14,6 +18,11 @@ const path = require('path');
 
 const UNDO_MS = 8000;
 const LISTS = ['waiting', 'today', 'week', 'triage', 'later'];
+const WORK_LISTS = ['inbox', 'today', 'upcoming', 'waiting', 'someday'];
+const REVIEW_DAYS = 7;
+const REVIEW_FROM = ['inbox', 'someday', 'waiting'];
+// A legacy list_override (set by /move) maps onto the Work views.
+const LEGACY_TO_WORK = { today: 'today', triage: 'inbox', waiting: 'waiting', week: 'upcoming', later: 'someday' };
 const WEEKDAYS = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
 
 const DUE_WORD = /\b(?:due|by)\s+(today|tomorrow|sun(?:day)?|mon(?:day)?|tue(?:s(?:day)?)?|wed(?:nesday)?|thu(?:r(?:s(?:day)?)?)?|fri(?:day)?|sat(?:urday)?)\b/i;
@@ -66,15 +75,71 @@ function placement(item, today) {
   return 'later';
 }
 
+// Place an item in one of the five Work views (console3 PRD R2). The one place this is decided; the client never
+// copies an item between views. `today` is a Date. Rules, in order: a legacy override, parked is Someday, waiting
+// on someone is Waiting, a defer date after today is Upcoming, flagged is Today, due today or earlier is Today,
+// a later due date is Upcoming, no date is Inbox. One addition to R2, for R6 ("the item returns to Today on that
+// date"): an undated item whose defer date has arrived is Today, not Inbox.
+function workPlacement(item, today) {
+  if (item.list_override && LEGACY_TO_WORK[item.list_override]) return LEGACY_TO_WORK[item.list_override];
+  if (item.parked) return 'someday';
+  if (item.waiting_on) return 'waiting';
+  const t = iso(today);
+  if (item.defer && item.defer > t) return 'upcoming';
+  if (item.flagged) return 'today';
+  if (item.due && item.due <= t) return 'today';
+  if (item.due) return 'upcoming';
+  if (item.defer) return 'today';
+  return 'inbox';
+}
+
+const PRIORITY_RANK = { P1: 1, P2: 2, P3: 3 };
+const prio = (i) => PRIORITY_RANK[i.priority] || 9;
+const cmpStr = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+// The day an Upcoming item arrives: its defer date while that is still ahead, else its due date.
+function arrivesOn(item, todayIso) { return item.defer && item.defer > todayIso ? item.defer : (item.due || ''); }
+
+// Sort one Work view. today: overdue first (oldest first), then flagged, then by due date. upcoming: by arrival
+// day. inbox and someday: newest first. waiting: the one waited on longest first.
+function sortWorkList(name, items, today) {
+  const t = iso(today);
+  const byNew = (a, b) => cmpStr(b.created_at || '', a.created_at || '');
+  const out = [...items];
+  if (name === 'today') {
+    const group = (i) => (i.due && i.due < t ? 0 : i.flagged ? 1 : 2);
+    out.sort((a, b) => group(a) - group(b) || cmpStr(a.due || '9999', b.due || '9999') || prio(a) - prio(b) || byNew(a, b));
+  } else if (name === 'upcoming') {
+    out.sort((a, b) => cmpStr(arrivesOn(a, t) || '9999', arrivesOn(b, t) || '9999') || prio(a) - prio(b) || byNew(a, b));
+  } else if (name === 'waiting') {
+    out.sort((a, b) => cmpStr(a.waiting_since || a.created_at || '', b.waiting_since || b.created_at || ''));
+  } else out.sort(byNew);
+  return out;
+}
+
+// The review queue: open items in Inbox, Someday or Waiting that nobody touched for `days` days, most stale first.
+// `now` is a Date. An item with no readable touched_at is left out, never guessed.
+function reviewQueue(items, now, days = REVIEW_DAYS) {
+  const today = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+  const cutoff = now.getTime() - days * 86400000;
+  const stamp = (i) => Date.parse(i.touched_at || i.created_at || '');
+  return items
+    .filter((i) => !i.done && REVIEW_FROM.includes(workPlacement(i, today)) && Number.isFinite(stamp(i)) && stamp(i) <= cutoff)
+    .sort((a, b) => stamp(a) - stamp(b));
+}
+
 // Fold the event lines into the current items, keyed by id. A dropped or deleted item is removed.
 function fold(lines) {
   const items = new Map();
   for (const ev of lines) {
     if (!ev || !ev.id) continue;
-    if (ev.event === 'created') items.set(ev.id, { ...ev.fields, id: ev.id, source: ev.source || 'local', created_at: ev.at });
-    else if (ev.event === 'edited' && items.has(ev.id)) items.set(ev.id, { ...items.get(ev.id), ...ev.fields });
-    else if (ev.event === 'done' && items.has(ev.id)) items.set(ev.id, { ...items.get(ev.id), done: true, done_at: ev.at });
-    else if (ev.event === 'reopened' && items.has(ev.id)) items.set(ev.id, { ...items.get(ev.id), done: false, done_at: null });
+    if (ev.event === 'created') items.set(ev.id, { ...ev.fields, id: ev.id, source: ev.source || 'local', created_at: ev.at, touched_at: ev.at });
+    else if (ev.event === 'edited' && items.has(ev.id)) items.set(ev.id, { ...items.get(ev.id), ...ev.fields, touched_at: ev.at });
+    else if (ev.event === 'done' && items.has(ev.id)) {
+      const outcome = typeof ev.outcome === 'string' && ev.outcome.trim() ? { outcome: ev.outcome.trim() } : {};
+      items.set(ev.id, { ...items.get(ev.id), done: true, done_at: ev.at, touched_at: ev.at, ...outcome });
+    }
+    else if (ev.event === 'reopened' && items.has(ev.id)) items.set(ev.id, { ...items.get(ev.id), done: false, done_at: null, touched_at: ev.at });
+    else if (ev.event === 'kept' && items.has(ev.id)) items.set(ev.id, { ...items.get(ev.id), touched_at: ev.at });
     else if (ev.event === 'dropped' || ev.event === 'deleted') items.delete(ev.id);
   }
   return [...items.values()];
@@ -92,7 +157,7 @@ function removalEvent(item, now) {
 function undoEvent(lines, id, now = new Date()) {
   const removal = [...lines].reverse().find((ev) => ev && ev.id === id && (ev.event === 'deleted' || ev.event === 'dropped'));
   if (!removal || !removal.snapshot || !canUndo(removal.at, now)) return null;
-  const { id: _id, source, created_at, ...fields } = removal.snapshot;
+  const { id: _id, source, created_at, touched_at, ...fields } = removal.snapshot;
   return { event: 'created', id, fields, source: source || 'local', restored: true };
 }
 
@@ -112,4 +177,4 @@ function readLines(file) {
   return fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } });
 }
 
-module.exports = { UNDO_MS, LISTS, parseLine, placement, fold, removalEvent, undoEvent, canUndo, appendEvent, readLines };
+module.exports = { UNDO_MS, LISTS, WORK_LISTS, REVIEW_DAYS, workPlacement, sortWorkList, reviewQueue, arrivesOn, parseLine, placement, fold, removalEvent, undoEvent, canUndo, appendEvent, readLines };

package/workspace/lib/report-needs.js

@@ -216,4 +216,4 @@ function sig(w) {
   return [reportsOf(w.root).sig, schedulesStamp(), kill, hour].join(':');
 }
 
-module.exports = { kinds, rowsFor, sig, rowsAt, reportsOf, cadenceOfSkill, cadenceOfSchedule, blobSha, reportsDir, KILL_FILE, GRACE_MS };
+module.exports = { kinds, rowsFor, sig, rowsAt, reportsOf, readSchedules, cadenceOfSkill, cadenceOfSchedule, blobSha, reportsDir, KILL_FILE, GRACE_MS };

package/workspace/lib/route-modules.js

@@ -48,6 +48,7 @@ const MODULES = Object.freeze([
   'routes-forecast',      // console3 B5: forecast, critical path, time machine and capacity (read-only)
   'routes-calendar-views', // console3 C2: Day/Week/Month/Quarter/Year cells, Gantt and the strategy lens (read-only)
   'routes-briefing',      // console3 C1: the day-part Briefing cards from the signal engine (read-only)
+  'routes-brief-page',    // console3 Briefing as the brief: Today agenda and Needs you (read-only; writes go through routes-pm-items)
   'routes-report-facts',  // console3 D: GET /api/report-families/facts (read-only, real data only)
   'routes-records',       // console3 E1a: ideas, hypotheses, decisions, KR metrics, bets (GET list; page-press add/edit/reading)
   'routes-doc-sheet',     // console3 E1c: document sheet: revisions, edit with why, propose and accept by hash