create-pmos 0.130.0 → 0.131.0

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/routes-calendar-views.js

@@ -1,7 +1,8 @@
 'use strict';
 /* routes-calendar-views.js — GET /api/calendar-views?view=day|week|month|quarter|year&date=YYYY-MM-DD&ws=<id> (console3 wave C2).
  *
- *   → { ok, view, range, cells, unit, gantt, strategy, events_source }
+ *   → { ok, view, range, cells, unit, gantt, strategy, events_source, today,
+ *       layers, layers_total, layers_note, free, context, context_total }     (the last six: lib/calendar-layers.js)
  *
  * READ ONLY. Initiatives come from the signal engine's repo reader (scripts/signals/facts.js readRepoFacts), required inside
  * the handler so a failure answers 500 { ok:false } and never reaches the server. The date and the plan come from the records:
@@ -13,10 +14,12 @@
  * gets none and says so. */
 const path = require('path');
 const model = require('../../scripts/calendar-model.js');
+const layersLib = require('./calendar-layers.js');
 
 const today = () => { const d = new Date(); const p = (n) => String(n).padStart(2, '0'); return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`; };
 
-/** The pure handler. deps: { readFacts(root), readEvents?(range), readKrs?(), today } so tests need no repo. */
+/** The pure handler. deps: { readFacts(), readEvents?(range), readKrs?(), today, nowMs?, readDated?(range), readItems?(),
+ *  readContextSources?() } so tests need no repo. A dep that is missing gives its source as empty, said in layers_note. */
 function handle(query, deps = {}) {
   const view = (query && query.view) || 'month';
   const date = (query && query.date) || (deps.today || today());
@@ -33,13 +36,118 @@ function handle(query, deps = {}) {
     const nowDay = deps.today || today();
     const gantt = model.ganttRows(inis, view, date, { today: nowDay });
     const strategy = view === 'quarter' || view === 'year' ? model.strategyLens(inis, krs, nowDay) : null;
-    return { status: 200, body: { ok: true, view, range, unit: b.unit, cells: b.cells, gantt, strategy, events_source: source, today: nowDay } };
+    const dated = typeof deps.readDated === 'function' ? (deps.readDated(range) || {}) : {
+      unavailable: { plan_items: 'no reader is wired', releases: 'no reader is wired', reports: 'no reader is wired', own: 'no reader is wired' } };
+    // the initiatives come from the facts this handler already holds, so every caller gets their promised dates
+    if (!dated.initiatives && !(dated.unavailable && dated.unavailable.initiatives)) dated.initiatives = inis;
+    const items = typeof deps.readItems === 'function' ? (deps.readItems() || {}) : {};
+    const src = typeof deps.readContextSources === 'function' ? (deps.readContextSources() || {}) : {};
+    const nowMs = Number.isFinite(deps.nowMs) ? deps.nowMs : (deps.today ? undefined : Date.now());
+    const extra = layersLib.build({ range, today: nowDay, nowMs, events, dated, src, own: items.own, planItemsDue: items.planItems });
+    return { status: 200, body: { ok: true, view, range, unit: b.unit, cells: b.cells, gantt, strategy, events_source: source, today: nowDay, ...extra } };
   } catch (e) {
     return { status: 500, body: { ok: false, error: String(e && e.message || e) } };
   }
 }
 
+/* ── the readers behind the layers, free time and context (each source on its own: one that cannot be read is named in
+ *    layers_note and gives nothing; it never takes the answer down) ────────────────────────────────────────────────── */
+const reason = (e) => String((e && e.message) || e).slice(0, 160);
+
+function readers(root, runtimeDir) {
+  let plan = null;
+  const planFold = () => { if (!plan) plan = require('./plan-items.js').readFold(root); return plan; };
+  const planRows = () => Object.values(planFold().items).filter((p) => !(p.proposed && !p.kept));
+  let ownLines = null;
+  const ownRows = () => {
+    if (!ownLines) ownLines = require('./pm-items.js').readLines(path.join(runtimeDir, 'pm-items', 'items.jsonl'));
+    return require('./pm-items.js').fold(ownLines);
+  };
+  const planItem = (p) => ({ id: p.id, initiative: p.initiative, title: p.title, due: p.due, milestone: !!p.milestone, state: p.state });
+  return {
+    readDated(range) {
+      const unavailable = {};
+      const out = { unavailable };
+      try { out.planItems = planRows().map(planItem); } catch (e) { unavailable.plan_items = 'the plan ledger could not be read: ' + reason(e); }
+      try {
+        const R = require('../../scripts/releases.js');
+        const f = path.join(runtimeDir, 'releases', 'releases.jsonl');
+        let lines = []; try { lines = require('fs').readFileSync(f, 'utf8').split('\n').filter(Boolean); } catch { lines = []; }
+        out.releases = R.foldReleases(lines);
+      } catch (e) { unavailable.releases = 'the releases file could not be read: ' + reason(e); }
+      try {
+        const RN = require('./report-needs.js');
+        out.reports = RN.reportsOf(root).reports.map((r) => ({ cadence: r.cadence, slot: r.slot, issued: r.issued ? { at: r.issued.at } : null }));
+        out.reportSchedules = reportSchedules(RN, range);
+      } catch (e) { unavailable.reports = 'the report folders could not be read: ' + reason(e); }
+      try { out.own = ownRows().map((o) => ({ id: o.id, title: o.title, due: o.due, done: !!o.done })); } catch (e) { unavailable.own = 'your items could not be read: ' + reason(e); }
+      return out;
+    },
+    readItems() {
+      const out = { own: [], planItems: [] };
+      try { out.planItems = planRows().map(planItem); } catch { /* the plan ledger is named in layers_note */ }
+      try { out.own = ownRows().map((o) => ({ id: o.id, title: o.title, due: o.due, done: !!o.done, priority: o.priority || null })); } catch { /* likewise */ }
+      return out;
+    },
+    readContextSources() {
+      const src = { notes: [], planItems: [], ownItems: [] };
+      try { src.planItems = planRows().map((p) => ({ id: p.id, initiative: p.initiative, title: p.title, createdAt: p.createdAt, doneAt: p.doneAt })); } catch { /* no plan ledger: no moved items */ }
+      try { src.ownItems = ownRows().map((o) => ({ id: o.id, title: o.title, initiative: o.initiative || null, created_at: o.created_at || null, done_at: o.done_at || null })); } catch { /* no own items */ }
+      try { src.notes = linkedNotes(runtimeDir); } catch { /* no notes: no decisions or actions */ }
+      return src;
+    },
+  };
+}
+
+/** The dates a report schedule fires on, from the range start, using the same slot math the scheduler runs on. */
+function reportSchedules(RN, range) {
+  const logic = require('./schedule-logic.js');
+  const out = [];
+  const t0 = new Date();
+  const today = `${t0.getFullYear()}-${String(t0.getMonth() + 1).padStart(2, '0')}-${String(t0.getDate()).padStart(2, '0')}`;
+  const first = range && range.start > today ? range.start : today;
+  const from = new Date(Number(first.slice(0, 4)), Number(first.slice(5, 7)) - 1, Number(first.slice(8, 10)));
+  for (const s of RN.readSchedules()) {
+    if (!s || !s.enabled) continue;
+    const cadence = RN.cadenceOfSchedule(s);
+    if (!cadence) continue;
+    const dates = [];
+    let at = from;
+    for (let i = 0; i < 62; i++) {
+      const next = logic.nextRun(s, at);
+      if (!next) break;
+      const d = new Date(next);
+      const ds = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+      if (range && ds > range.end) break;
+      dates.push(ds);
+      at = new Date(d.getTime() + 1000);
+    }
+    out.push({ id: String(s.id || s.name || cadence), name: s.name, cadence, dates: [...new Set(dates)] });
+  }
+  return out;
+}
+
+/** Notes linked to a calendar event, read straight from the notes folder (no import, no write). */
+function linkedNotes(runtimeDir) {
+  const fs = require('fs');
+  const dir = path.join(runtimeDir, 'notes');
+  const out = [];
+  for (const f of fs.readdirSync(dir).filter((x) => x.endsWith('.json'))) {
+    let n; try { n = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8')); } catch { continue; }
+    if (!n || !n.id || !n.meeting || n.meeting.kind !== 'event') continue;
+    const fin = n.final_notes && typeof n.final_notes === 'object' ? n.final_notes : null;
+    const sec = n.summary && n.summary.sections ? n.summary.sections : null;
+    const pick = (a, b) => (Array.isArray(a) && a.length ? a : Array.isArray(b) ? b : []);
+    out.push({ id: n.id, title: n.title || '', private: !!n.private, initiative: n.initiative && n.initiative.id ? String(n.initiative.id) : null,
+      meeting: { event_id: n.meeting.event_id || null, start: n.meeting.start, title: n.meeting.title },
+      decisions: pick(fin && fin.decisions, sec && sec.decisions).map((x) => ({ text: x && x.text })),
+      actions: pick(fin && fin.actions, sec && sec.actions).map((x) => ({ text: x && x.text, owner: x && x.owner || null, due: x && x.due || null })) });
+  }
+  return out;
+}
+
 module.exports = {
+  readers,
   prefixes: ['/api/calendar-views'],
   handlePure: handle,
   handle: async (req, res, url, ctx) => {
@@ -54,6 +162,7 @@ module.exports = {
     const out = handle({ view: url.searchParams.get('view') || undefined, date: url.searchParams.get('date') || undefined }, {
       readFacts: () => facts,
       readEvents: () => require('./routes-calendar-import.js').readEvents(ctx.runtimeDir),
+      ...readers(root, ctx.runtimeDir),
     });
     ctx.json(res, out.body, out.status);
     return true;