create-pmos 0.59.2 → 0.60.0

package/workspace/lib/plan-tree.js

@@ -175,6 +175,42 @@ function owedFor(group, steps, def) {
   return null;
 }
 
+/**
+ * The index of the furthest stage with evidence (scan-consistency R2): the last stage that holds a step the ladder
+ * reads `done`. -1 when no stage has one.
+ *
+ * WHY THE STEPPER NEEDS IT. The current stage used to be the FIRST stage with an open step. A step skipped long ago — a
+ * `priors` citation nobody wrote, a contract never logged before the build — then pinned the initiative at Spec or
+ * Contract for ever, while the build had merged and the PM had accepted it: 90 built initiatives read Spec on this
+ * repository, and 51 accepted ones read Intake, Spec, Contract or Build. Work moves forward past a gap; the gap stays a
+ * fact. So the current stage is the first stage with an open step AT OR AFTER the frontier, and an earlier stage that
+ * still has an open step reads `skipped` (its owed row is kept), never `done`.
+ */
+function frontierOf(stages, steps) {
+  const done = new Set((steps || []).filter((s) => s && s.status === 'done').map((s) => s.key));
+  // Accepted work is finished whatever its leftover steps (initiative-display.js rule 2): the frontier is past the end,
+  // so no stage is current and every stage with an open step reads `skipped`. A document lane is finished once it is
+  // approved and no handoff is still open.
+  const by = new Map((steps || []).filter(Boolean).map((s) => [s.key, s.status]));
+  if (by.get('accept') === 'done' || (by.get('approved') === 'done' && !OPEN(by.get('handoff') || 'na'))) return stages.length;
+  let at = -1;
+  stages.forEach((s, i) => { if (s.steps.some((k) => done.has(k))) at = i; });
+  return at;
+}
+
+/**
+ * The stage an initiative is in now, from its ladder steps, by the same rule the Breakdown and the sheet's stepper use:
+ * { id, label } of the first stage at or after the frontier with an open step, or null when no stage has one.
+ */
+function currentStage(root, initiative, steps, def) {
+  const stages = stagesFor(root, initiative);
+  const front = frontierOf(stages, steps);
+  for (let i = Math.max(front, 0); i < stages.length; i++) {
+    if (owedFor(stages[i], steps, def) !== null) return { id: stages[i].id, label: stages[i].label };
+  }
+  return null;
+}
+
 /**
  * The progress label (R6), shared by the layout, the fold's progressOf and the CLI. Proposed and withdrawn items never
  * count; when nothing is kept yet but an agent proposed items, it says so instead of a bare "no breakdown".
@@ -309,7 +345,8 @@ function layout({ root, initiative, fold, ladder, now }) {
   const counted = (list) => list.filter((it) => !it.proposed);
 
   let firstOpenSeen = false;
-  const stageRows = stages.map((s) => {
+  const frontier = steps ? frontierOf(stages, steps) : -1;
+  const stageRows = stages.map((s, i) => {
     const inStage = visibleItems.filter((it) => it.stage === s.id).sort(treeOrder);
     const real = counted(inStage);
     const total = real.length;
@@ -324,10 +361,12 @@ function layout({ root, initiative, fold, ladder, now }) {
     // `state` and `owed` are not derived, so they are left out: the client keeps them from its last full
     // response. A ladder that was asked for but failed gives `current:false`, `state:null`, `owed:null`.
     if (steps) {
-      const current = owed !== null && !firstOpenSeen;
+      // A stage behind the frontier with a step still open was passed over, not finished (see frontierOf).
+      const skipped = owed !== null && i < frontier;
+      const current = owed !== null && !skipped && !firstOpenSeen;
       row.current = current;
-      row.state = current ? 'current' : (firstOpenSeen ? 'later' : 'done');
-      if (owed !== null) firstOpenSeen = true;
+      row.state = current ? 'current' : skipped ? 'skipped' : (firstOpenSeen ? 'later' : 'done');
+      if (owed !== null && !skipped) firstOpenSeen = true;
     } else if (ladderIncluded) {
       row.current = false;
       row.state = null;
@@ -376,5 +415,5 @@ function layout({ root, initiative, fold, ladder, now }) {
 
 module.exports = {
   STAGE_GROUPS, STEP_NOUN, OWED_ACTOR, OPEN, DONE_WINDOW_MS, INIT_RE, NOT_MERGED_LABEL, withFactory,
-  mainTree, recordPath, profileAndLane, viewGroup, stagesFor, stageIdsFor, resolveStage, owedFor, nounFor, byLabel, progressLabel, layout, historyText,
+  mainTree, recordPath, profileAndLane, viewGroup, stagesFor, stageIdsFor, resolveStage, owedFor, frontierOf, currentStage, nounFor, byLabel, progressLabel, layout, historyText,
 };

package/workspace/lib/proactive-cli.js

@@ -15,6 +15,7 @@
  *                           [--website URL] [--no-website URL]
  *   pmos proactive brief submit --file PATH [--merge]
  *   pmos proactive brief schedule [--repo PATH]
+ *   pmos proactive calendar                              what the calendar memory holds, and the window the next read covers
  *   pmos proactive goals [list] | add TEXT [--initiative ID] | done N | drop N | reopen N | remove N | plan [--repo PATH]
  *   pmos proactive day [--repo PATH]                     the day run: its stage, its tasks and the daytime check
  *   pmos proactive day show TASK                         one task with its item, draft and revision notes (what day-task reads)
@@ -35,7 +36,7 @@ const path = require('path');
 const { execFileSync } = require('child_process');
 const { parseArgs } = require('./schedule-cli');
 
-const COMMANDS = { proactive: ['today', 'scan', 'settings', 'feedback', 'brief', 'goals', 'prepare', 'learn', 'day'] };
+const COMMANDS = { proactive: ['today', 'scan', 'settings', 'feedback', 'brief', 'goals', 'prepare', 'learn', 'day', 'calendar'] };
 const BRIEF_SOURCES = ['calendar', 'wispr', 'mail', 'slack', 'jira', 'confluence', 'github', 'drive', 'figma', 'website'];
 const onOff = (v, what) => (v === 'on' || v === 'true' ? true : v === 'off' || v === 'false' ? false : { err: `${what} takes on or off` });
 
@@ -355,6 +356,18 @@ async function run(argv, { call, say, cwd = process.cwd() }) {
     if (t.cards_error) say('! Today could not be read: ' + t.cards_error);
     return 0;
   }
+  if (verb === 'calendar') {
+    // Read-only: what the Agenda remembers, and which window the morning brief reads next (G23).
+    const r = await call('GET', '/api/proactive/agenda');
+    if (!r || r.ok === false) return fail((r && r.error) || 'the server did not answer');
+    const day = (n) => { const d = new Date(Date.now() + n * 86400000); return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`; };
+    const m = r.memory;
+    const stale = !m || !m.updated_at || Date.now() - Date.parse(m.updated_at) > 7 * 86400000 || !m.from || m.from > day(-80);
+    if (m && m.events) say(`calendar memory: ${m.events} events from ${m.from} to ${m.to}, updated ${String(m.updated_at || '').slice(0, 16).replace('T', ' ')}`);
+    else say('calendar memory: empty');
+    say(stale ? `read next: the wide window, from ${day(-90)} to ${day(31)}` : `read next: from ${day(0)} to ${day(31)} (the earlier days are remembered)`);
+    return 0;
+  }
   if (verb === 'brief') {
     const sub = pos[0] || 'show';
     if (sub === 'submit') {
@@ -366,6 +379,8 @@ async function run(argv, { call, say, cwd = process.cwd() }) {
       if (!r || r.ok === false) return fail(`refused — ${(r && r.error) || 'the server did not answer'}. Nothing was stored.`);
       if (merge) say(`merged into the brief for ${r.brief.date} — ${r.merged ? r.merged.found : 0} new, ${r.merged ? r.merged.resolved : 0} resolved; it now holds ${r.brief.priorities.length} priorities, ${r.brief.worth_asking.length} worth asking`);
       else say(`stored the brief for ${r.brief.date} — ${r.brief.priorities.length} priorities, ${r.brief.worth_asking.length} worth asking`);
+      if (r.memory_error) say('! ' + r.memory_error);
+      if (r.remembered) say(`remembered ${r.remembered.events} calendar events from ${r.remembered.from} to ${r.remembered.to}`);
       return 0;
     }
     if (sub === 'schedule') {

package/workspace/lib/routes-initiatives.js

@@ -7,6 +7,8 @@
  *   GET  /api/initiatives/<id>/export?ws=           → { ok, id, markdown }   (lib/breakdown-export.js; nothing is written)
  *   POST /api/initiatives    { ws, title, lane, anchor, intent?, id?, from?, specimen_test?, surface_check? }
  *                                                    → { ok, id, path, written, sig }   New initiative (requirePagePress)
+ *   POST /api/initiatives/rescan { ws }          → { ok, started, running }   read the repository again now (requirePagePress);
+ *                                                    nothing is written: the cached rows go stale and one derivation starts
  *   POST /api/placements     { ws, events: [placed | created | adopted | dropped] }
  *                                                    → { ok, written, sig }   fixtures/initiatives-api/post-ok.json
  *   POST /api/measurements   { ws, events: [measured] } → { ok, written, sig }
@@ -42,10 +44,14 @@ const rowsLib = require('./initiative-rows.js');
 const writer = require('./initiative-writer.js');
 const breakdownExport = require('./breakdown-export.js');
 const consoleState = require('./console-state');
+const initiativeFiles = require('./initiative-files');
+const jiraTickets = require('./jira-tickets.js');
 
 const HORIZON_RANK = { now: 0, next: 1, later: 2 };
 const FILE_KEYS = [['brief_path', 'brief', 'Brief'], ['prd_path', 'prd', 'PRD'], ['rubric_path', 'rubric', 'Rubric'], ['doc_path', 'doc', 'Document']];
 const cap = (s) => (s ? s[0].toUpperCase() + s.slice(1) : s);
+const GIT_GROUP_LABEL = { code: 'Code', tests: 'Test', documents: 'Document', other: 'File' };
+const GIT_FILES_MAX = 80;
 
 /** The signature of everything a read answers from, taken before the read. */
 function sigOf(root) {
@@ -96,9 +102,14 @@ function frameOf(w, rows, { now, sessions = [] } = {}) {
   return { root, rules, placed, fold, meas, join, anchors, accepted, byId, now, sessions };
 }
 
-/** The stage of a workflow row as the R4 stage group it falls in: { id, label }. */
+/** The stage of a workflow row as the R4 stage group it falls in: { id, label }. The stage the work is IN is read from the
+ *  ladder steps by plan-tree.js currentStage, the rule the sheet's stepper draws (scan-consistency R2), so a list row and
+ *  its sheet never name two different stages. Accepted work, and a row without steps, keep the engine's stage. */
 function stageOf(root, rec) {
   const raw = rec.stage || null;
+  if (raw !== 'accepted' && Array.isArray(rec.steps)) {
+    try { const cur = planTree.currentStage(root, rec.id, rec.steps, null); if (cur && cur.label) return cur; } catch { /* fall through */ }
+  }
   if (!raw) return { id: null, label: 'Unknown' };
   try {
     const st = planTree.stagesFor(root, rec.id).find((s) => s.id === raw || s.steps.includes(raw));
@@ -139,10 +150,14 @@ function rowOf(F, rec) {
   const p = F.placed.byInit[id];
   const a = F.anchors.resolve(rec.anchor);
   const ctx = displayCtx(F, rec, id);
-  const d = display.displayOf({ ...rec, last_activity: rec.last_activity }, ctx);
+  // Without the steps: display's owed step is the FIRST open one, which names a step skipped long ago; who the sheet
+  // waits on comes from the layout's current stage (sheetOf), so the row's word and the stepper agree.
+  const d = display.displayOf({ ...rec, steps: undefined, last_activity: rec.last_activity }, ctx);
   const measurement = measurements.latest(F.meas, a.token || '') || (rec.anchor ? measurements.latest(F.meas, String(rec.anchor).trim()) : null);
   const h = health.healthOf({ id, row: rec, fold: ctx.fold, placement: ctx.placement, measurement, factory: factoryJoin.factoryOf(F.join, id), rules: F.rules, now: F.now });
-  const pr = planItems.progressOf(F.fold, id);
+  let pr = planItems.progressOf(F.fold, id);
+  // No planned item: the breakdown the repository's own spec lists, labelled with its source (derivedBreakdown).
+  if (!pr.total && !pr.proposed) { const d = derivedBreakdown(F.root, rec, { progress: pr }); if (d) pr = d.progress; }
   return {
     id, title: rec.title || id, lane: rec.lane, anchor: a.anchor, anchor_kind: a.kind,
     horizon: p.horizon, rank: p.rank, confirmed: p.confirmed, dormant: p.dormant, check_by: p.check_by,
@@ -240,13 +255,13 @@ function listOf(w, F) {
   };
 }
 
-function sheetOf(w, F, rec) {
+function sheetOf(w, F, rec, opts = {}) {
   const root = F.root;
   const row = rowOf(F, rec);
   let lad = null;
   try { lad = consoleState.ladder({ root, id: rec.id }); } catch (e) { lad = { ok: false, error: String((e && e.message) || e) }; }
   const lay = planTree.layout({ root, initiative: rec.id, fold: F.fold, ladder: lad, now: F.now });
-  const stepper = lay.stages.map((s) => ({ id: s.id, label: s.label, state: s.state === 'current' ? 'current' : s.state === 'done' ? 'done' : 'todo' }));
+  const stepper = lay.stages.map((s) => ({ id: s.id, label: s.label, state: s.state === 'current' ? 'current' : s.state === 'done' ? 'done' : s.state === 'skipped' ? 'skipped' : 'todo', owed: s.state === 'skipped' && s.owed ? s.owed.noun : null }));
   let waiting = null;
   if (row.display.waitingOn) {
     waiting = { on: row.display.waitingOn, act: row.display.act, action: row.display.waitingOn === 'pm' ? { label: 'Open gate', kind: 'gate', target: null } : { label: 'Hand to agent', kind: 'handoff', target: rec.id } };
@@ -263,12 +278,144 @@ function sheetOf(w, F, rec) {
     const file = planTree.recordPath(root, rec.id);
     if (loaded.ok && file) fm = loaded.engine.parseLeadingFrontmatter(fs.readFileSync(file, 'utf8')) || {};
   } catch { fm = {}; }
-  const files = FILE_KEYS.filter(([k]) => typeof fm[k] === 'string' && fm[k].trim()).map(([k, kind, label]) => ({ kind, label, path: String(fm[k]).trim() }));
+  const files = filesOf(root, rec, fm, opts);
+  const derived = derivedBreakdown(root, rec, lay);
   const verb = { now: 'Moved to Now', next: 'Moved to Next', later: 'Moved to Later' };
   const history = F.placed.moves.filter((m) => m.init === rec.id)
     .map((m) => ({ at: m.at, by: actorLib.pageName(m.by), text: m.from === null && m.to === 'later' ? 'Added to Later' : verb[m.to] }))
     .reverse();
-  return { initiative: row, stepper, waiting, files, history, cli: { now: `pmos initiative now ${rec.id}`, export: `pmos initiative export ${rec.id}` } };
+  return { initiative: row, stepper, waiting, files, derived, history, cli: { now: `pmos initiative now ${rec.id}`, export: `pmos initiative export ${rec.id}` } };
+}
+
+/**
+ * Every file that belongs to one initiative (scan-consistency R3), in three sources, each row saying which:
+ *   record          the record itself and every `*_path` its frontmatter names (prd, rubric, brief, explainer, design, …)
+ *   knowledge-graph the documents the library's initiative index joins to it (server.js initiativeIndex: a declared
+ *                   initiative_id, the record's own paths, the file-name convention, the declared-id prefix)
+ *   git             the files the commits for it changed (lib/initiative-files.js: its branch, and trunk commits naming it)
+ * A path is listed once, under its first source. A git read that fails is a `{ kind: 'note' }` row, never an empty list.
+ */
+function filesOf(root, rec, fm, opts) {
+  const out = [];
+  const seen = new Set();
+  const exists = (rel) => { try { return fs.statSync(path.join(root, rel)).isFile(); } catch { return false; } };
+  // A path the record names is listed even when it is absent, marked `missing` (a dangling pointer is a fact to see);
+  // the other two sources list only files that exist.
+  const push = (row) => {
+    const p = String(row.path || '').trim().replace(/^\.?\//, '');
+    if (!p || seen.has(p) || p.split('/').includes('..')) return;
+    const there = exists(p);
+    if (!there && row.source !== 'record') return;
+    seen.add(p);
+    out.push(there ? { ...row, path: p } : { ...row, path: p, missing: true });
+  };
+  for (const [k, kind, label] of FILE_KEYS) if (typeof fm[k] === 'string' && fm[k].trim()) push({ kind, label, path: String(fm[k]).trim(), source: 'record' });
+  for (const [k, v] of Object.entries(fm || {})) {
+    if (!/_path$/.test(k) || typeof v !== 'string' || !v.trim() || FILE_KEYS.some(([fk]) => fk === k)) continue;
+    const kind = k.replace(/_path$/, '');
+    push({ kind, label: cap(kind.replace(/_/g, ' ')), path: v.trim(), source: 'record' });
+  }
+  if (rec.record) push({ kind: 'record', label: 'Record', path: String(rec.record), source: 'record' });
+  let groups = [];
+  try { groups = opts && opts.initiativeIndex ? (opts.initiativeIndex(root).initiatives || []) : []; } catch { groups = []; }
+  const g = groups.find((x) => x && x.id === rec.id);
+  for (const a of (g && g.artifacts) || []) {
+    const role = String(a.role || 'doc');
+    push({ kind: role.replace(/\s+/g, '-').toLowerCase(), label: role === 'doc' ? 'Document' : cap(role), path: String(a.path || '').split(path.sep).join('/'), source: 'knowledge-graph', shared: !!a.shared });
+  }
+  let git = null;
+  try { git = initiativeFiles.filesFor(root, rec.id, { exclude: seen }); } catch (e) { git = { ok: false, reason: String((e && e.message) || e).slice(0, 120) }; }
+  if (git && git.ok) {
+    const items = git.items.filter((x) => x.where === 'head');
+    for (const x of items.slice(0, GIT_FILES_MAX)) push({ kind: x.group, label: GIT_GROUP_LABEL[x.group] || 'File', path: x.path, source: 'git', commits: x.commits });
+    if (items.length > GIT_FILES_MAX) out.push({ kind: 'note', label: `${items.length - GIT_FILES_MAX} more files changed for it are not listed`, path: '', source: 'git' });
+  } else if (git) {
+    out.push({ kind: 'note', label: 'The files git changed for it could not be read', path: '', source: 'git', reason: git.reason || null });
+  }
+  return out;
+}
+
+/**
+ * The work breakdown read from the repository when nobody has planned one (scan-consistency R4).
+ *
+ * The Breakdown is the plan-items ledger, and on this repository not one initiative has a ledger line, so every
+ * Breakdown read empty although the PRDs list the work. When the ledger holds no item for the initiative, this reads the
+ * items of the spec the record names (lib/jira-tickets.js items: the user stories and story files) and, when it has none,
+ * the top-level entries of its Requirements section. Each item's state is the initiative's, from the ladder: `done` once
+ * the PM accepted it, `review` once its build is evidenced, `todo` before that. That is a stated inference about the
+ * whole initiative, not a claim about each item, so every answer carries its basis. Nothing is written: Plan and Keep
+ * stay the way a breakdown enters the ledger.
+ */
+const REQ_SECTION = /^(?:functional\s+)?requirements\b|^deliverables\b|^work\s+items?\b/i;
+// an item's name: up to its first sentence end, dash or colon, so a requirement written as a paragraph reads as a title
+const firstSentence = (t) => String(t || '').split(/(?<=[a-z0-9)`'"])[.:]\s|\s[—–]\s/i)[0].replace(/[.:;]$/, '').trim();
+const NOT_AN_ITEM = /^(?:in|out|in scope|out of scope|non[- ]goals?|notes?|open questions?|risks?|constraints?)$/i;
+function requirementItems(text) {
+  const lines = String(text || '').replace(/^---\n[\s\S]*?\n---\n?/, '').split('\n');
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const m = /^(#{2,4})\s+(?:\d+[.)]?\s+)?(.+?)\s*$/.exec(lines[i]);
+    if (!m || !REQ_SECTION.test(m[2].replace(/[*_`]/g, '').trim())) continue;
+    const level = m[1].length;
+    const body = [];
+    for (let j = i + 1; j < lines.length; j++) {
+      const h = /^(#{1,6})\s/.exec(lines[j]);
+      if (h && h[1].length <= level) break;
+      body.push(lines[j]);
+    }
+    // The section's own top-level entries, before its first subheading; else its subheadings, minus the ones that
+    // name a part of the section rather than a piece of work (Non-goals, In, Out).
+    const sub = '#'.repeat(level + 1) + ' ';
+    const firstSub = body.findIndex((l) => /^#{2,6}\s/.test(l));
+    for (const l of firstSub < 0 ? body : body.slice(0, firstSub)) {
+      const b = /^(?:[-*]|\d+[.)])\s+(.+)$/.exec(l) || /^(\*\*[A-Z]{1,3}-?\d{1,3}[a-z]?\b.+)$/.exec(l);   // a list entry, or a paragraph led by **R-1 …**
+      if (b) out.push(b[1]);
+    }
+    if (!out.length) for (const l of body) if (l.startsWith(sub) && !NOT_AN_ITEM.test(l.slice(sub.length).replace(/[*_`]/g, '').trim())) out.push(l.slice(sub.length));
+    if (out.length) break;
+  }
+  return out.map((t) => {
+    const clean = t.replace(/\[([^\]]*)\]\([^)]*\)/g, '$1').replace(/[*`_]/g, '').trim();
+    const idm = /^([A-Z]{1,3}-?\d{1,3}[a-z]?)\b\s*[·:.\-—–)]?\s*(.*)$/.exec(clean);
+    const title = firstSentence((idm ? idm[2] : clean).replace(/^[—–-]\s*/, ''));
+    return { ref: idm ? idm[1] : null, title: (title || clean).slice(0, 140) };
+  }).filter((x) => x.title);
+}
+function derivedBreakdown(root, rec, lay) {
+  const p = lay && lay.progress ? lay.progress : null;
+  if (p && (p.total || p.proposed)) return null;
+  let rfm = {};
+  try {
+    const loaded = consoleState.loadEngine();
+    const file = planTree.recordPath(root, rec.id);
+    if (loaded.ok && file) rfm = loaded.engine.parseLeadingFrontmatter(fs.readFileSync(file, 'utf8')) || {};
+  } catch { rfm = {}; }
+  let items = [];
+  let source = null;
+  try {
+    const st = jiraTickets.items(root, rec.id);
+    if (st && st.ok && st.items.length) { items = st.items.map((x) => ({ ref: x.id, title: firstSentence(x.title) })); source = st.sources.join(', '); }
+  } catch { items = []; }
+  if (!items.length) {
+    for (const k of ['prd_path', 'doc_path', 'brief_path']) {
+      const rel = typeof rfm[k] === 'string' ? rfm[k].trim() : '';
+      if (!rel) continue;
+      let text = null;
+      try { text = fs.readFileSync(path.join(root, rel), 'utf8'); } catch { text = null; }
+      if (text == null) continue;
+      items = requirementItems(text);
+      if (items.length) { source = rel; break; }
+    }
+  }
+  if (!items.length) return null;
+  const steps = Array.isArray(rec.steps) ? rec.steps : [];
+  const done = (k) => steps.some((x) => x.key === k && x.status === 'done');
+  const state = rec.accepted || done('accept') || done('approved') ? 'done' : done('build') || done('draft') ? 'review' : 'todo';
+  const basis = state === 'done' ? 'the PM accepted this initiative'
+    : state === 'review' ? 'its build is on the trunk and acceptance is open' : 'no build is evidenced on the trunk yet';
+  const list = items.slice(0, 60).map((x, i) => ({ id: x.ref || `item-${i + 1}`, ref: x.ref || null, title: x.title, state }));
+  const n = list.length;
+  return { source, basis, state, items: list, progress: { done: state === 'done' ? n : 0, total: n, proposed: 0, label: `${state === 'done' ? n : 0} of ${n} · from ${source.split(',')[0].split('/').pop()}` } };
 }
 
 // ── HTTP ─────────────────────────────────────────────────────────────────────────────────────────
@@ -356,7 +503,7 @@ async function handle(req, res, url, ctx) {
       if (id) {
         const rec = F.byId.get(id);
         if (!rec || !F.placed.byInit[id]) { ctx.json(res, { ok: false, error: `no work-lane initiative ${id} in this repository` }, 404); return true; }
-        ctx.json(res, { ...head, sig, now: new Date(now).toISOString(), ...sheetOf(w, F, rec) });
+        ctx.json(res, { ...head, sig, now: new Date(now).toISOString(), ...sheetOf(w, F, rec, { initiativeIndex: ctx.initiativeIndex }) });
         return true;
       }
       const body = view === 'list' ? listOf(w, F) : roadmapOf(w, F);
@@ -375,6 +522,15 @@ async function handle(req, res, url, ctx) {
   const w = ctx.getWs(wsParam);
   if (!w || (wsParam && w.id !== wsParam)) { ctx.json(res, { ok: false, status: 404, error: 'no such workspace' }, 404); return true; }
 
+  if (p === '/api/initiatives/rescan') {
+    const g = guard.requirePagePress(req, body);
+    if (!g.ok) return answer(ctx, res, g), true;
+    initiativeFiles.forget(w.root);
+    const r = rowsLib.rescan(w.root);
+    if (ctx.invalidateNeedsAgg) ctx.invalidateNeedsAgg(w.id);
+    ctx.json(res, { ok: true, ws: w.id, started: r.started, running: r.running });
+    return true;
+  }
   if (p === '/api/initiatives') {
     const g = guard.requirePagePress(req, body);
     if (!g.ok) return answer(ctx, res, g), true;
@@ -401,4 +557,4 @@ async function handle(req, res, url, ctx) {
   return true;
 }
 
-module.exports = { prefixes: ['/api/initiatives', '/api/placements', '/api/measurements'], handle, sigOf, rowOf, frameOf, roadmapOf, listOf, sheetOf, unrecordedOf };
+module.exports = { prefixes: ['/api/initiatives', '/api/placements', '/api/measurements'], handle, sigOf, rowOf, frameOf, roadmapOf, listOf, sheetOf, unrecordedOf, filesOf, requirementItems, derivedBreakdown };

package/workspace/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.59.2",
+  "version": "0.60.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.59.2",
+  "version": "0.60.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/public/index.html

@@ -129,7 +129,7 @@
     <button type="button" data-seq="right" aria-label="Right arrow"><svg class="pmc-icon" width="16" height="16" aria-hidden="true" focusable="false" data-icon="arrow-right"><use href="#lucide-arrow-right"></use></svg></button>
   </div>
   <nav class="mobnav" id="mobNav" aria-label="Destinations">
-    <button type="button" class="mobnav-b" data-dest="today" aria-current="page"><span class="l">Today</span><span class="mobnav-n" id="mobTodayCount" hidden></span></button>
+    <button type="button" class="mobnav-b" data-dest="today" aria-current="page"><span class="l">Agenda</span><span class="mobnav-n" id="mobTodayCount" hidden></span></button>
     <button type="button" class="mobnav-b" data-dest="initiatives" aria-current="false"><span class="l">Initiatives</span></button>
     <button type="button" class="mobnav-b" data-dest="board" aria-current="false"><span class="l">Board</span></button>
     <button type="button" class="mobnav-b" data-dest="reports" aria-current="false"><span class="l">Reports</span></button>

package/workspace/public/pm/components.css

@@ -1761,6 +1761,29 @@
 .in-stepper__step[data-state="done"] {
   color: var(--foreground);
 }
+.in-stepper__step[data-state="skipped"] {
+  color: var(--warning);
+}
+.in-files,
+.in-derived {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.in-files {
+  gap: 16px;
+}
+.in-derived {
+  margin-bottom: 16px;
+}
+.in-files__title,
+.in-derived__title {
+  margin: 0;
+  font-size: 12px;
+  line-height: 16px;
+  font-weight: 600;
+  color: var(--muted-foreground);
+}
 .in-waiting {
   display: flex;
   align-items: center;
@@ -2651,6 +2674,53 @@
 .td-day__sites { list-style: none; margin: 0; padding: 0; display: grid; gap: 4px; }
 .td-day__sites li { display: flex; align-items: center; justify-content: space-between; gap: 8px; min-width: 0; }
 .td-day__sites li span { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+/* the Agenda month (today-agenda.js, G25 to G27): weeks of 8 columns, the week number and seven day cells */
+.td-ag__mhead { display: flex; align-items: center; gap: 6px; }
+.td-ag__mlabel { min-width: 120px; font-size: 14px; text-align: center; color: var(--foreground); }
+.td-ag__lens { flex-wrap: wrap; max-width: 100%; }
+.td-ag__grid { display: grid; gap: 2px; }
+.td-ag__wk { display: grid; grid-template-columns: 36px repeat(7, minmax(0, 1fr)); gap: 2px; }
+.td-ag__wk--head { font: 11px var(--mono); color: var(--muted-foreground); text-transform: uppercase; }
+.td-ag__wd { padding: 0 4px; }
+.td-day .td-ag__wno { height: auto; min-height: 64px; padding: 0; font: 11px var(--mono); letter-spacing: 0; color: var(--muted-foreground); }
+.td-day .td-ag__wno[aria-pressed="true"] { background: var(--accent); color: var(--foreground); border-color: var(--ring); }
+.td-day .td-ag__cell {
+  display: grid; align-items: start; justify-content: stretch; height: auto; min-height: 64px; padding: 4px;
+  border: 1px solid var(--border); background: var(--background); text-align: left; text-transform: none; letter-spacing: 0;
+  font-weight: 400; white-space: normal;
+}
+.td-day .td-ag__cell[data-out="true"] { opacity: 0.45; }
+.td-day .td-ag__cell[data-weekend="true"] { background: var(--muted); }
+.td-day .td-ag__cell[data-today="true"] { border: 2px solid var(--foreground); }
+.td-day .td-ag__cell[aria-pressed="true"] { background: var(--accent); border-color: var(--ring); }
+.td-day .td-ag__cell[data-lit="true"] { box-shadow: inset 0 0 0 2px var(--warning); }
+.td-ag__in { display: grid; gap: 3px; min-width: 0; }
+.td-ag__num { font: 12px var(--mono); color: var(--foreground); font-variant-numeric: tabular-nums; }
+.td-ag__cell[data-past="true"] .td-ag__num { color: var(--muted-foreground); }
+.td-ag__strip { position: relative; height: 6px; background: var(--muted); }
+.td-ag__blk { position: absolute; top: 0; bottom: 0; left: var(--td-ag-l, 0); width: var(--td-ag-w, 0); background: var(--muted-foreground); }
+.td-ag__blk--imp { background: var(--foreground); }
+.td-ag__blk--free { background: var(--ring); }
+.td-ag__key, .td-ag__meta, .td-ag__nonotes { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: 11px; line-height: 14px; }
+.td-ag__key { font-weight: 600; color: var(--foreground); }
+.td-ag__meta { color: var(--muted-foreground); }
+.td-ag__nonotes { color: var(--warning); }
+.td-ag__ready { justify-self: start; padding: 0 4px; font: 11px/16px var(--mono); border: 1px solid var(--border); color: var(--foreground); }
+.td-ag__ready[data-ag-ready="warn"] { border-color: var(--warning); color: var(--warning); }
+.td-ag__ready[data-ag-ready="risk"] { border-color: var(--destructive); background: var(--destructive); color: var(--background); }
+.td-ag__agenda { display: grid; gap: 8px; padding-top: 8px; border-top: 1px solid var(--border); }
+.td-ag__ah { margin: 0; font-size: 14px; color: var(--foreground); }
+.td-ag__tiles { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 6px; }
+.td-ag__tile { display: grid; gap: 2px; min-width: 0; padding: 6px 8px; background: var(--muted); }
+.td-ag__tile b { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: 14px; color: var(--foreground); }
+.td-ag__tile[data-ag-ready="risk"] b { color: var(--destructive); }
+.td-ag__tile[data-ag-ready="warn"] b { color: var(--warning); }
+.td-ag__tk { font: 11px var(--mono); text-transform: uppercase; color: var(--muted-foreground); }
+.td-ag__wday { display: grid; gap: 2px; }
+.td-ag__wday h4 { display: flex; align-items: center; gap: 6px; margin: 4px 0 0; font-size: 12px; color: var(--foreground); }
+.td-ag__last summary { cursor: pointer; font-size: 12px; color: var(--muted-foreground); }
+.td-ag__last summary:focus-visible { outline: 2px solid color-mix(in oklab, var(--ring) 50%, var(--foreground)); outline-offset: 2px; }
+@media (pointer: coarse) { .td-ag__last summary { min-height: 44px; } }
 /* the goal detail keeps the steps the goals section showed (G6): Today cards and the agent steps that can be prepared */
 .td-goal__steps { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 6px; }
 .td-goal__step { display: flex; flex-wrap: wrap; align-items: center; gap: 4px 8px; }

package/workspace/public/pm/dest-initiatives.js

@@ -18,6 +18,7 @@ import { wsOf } from './data.js';
 import { setInitiativeOpener, registerCommand, initiativesViews, initiativesViewCtx, openDestination } from './registry.js';
 import { COPY } from './initiatives-copy.js';
 import { getRoadmap, grantScopes } from './initiatives-api.js';
+import { rescanRepo } from './initiatives-ui.js';
 import { mountRoadmap } from './roadmap.js';
 import { mountList } from './initiative-list.js';
 import { openSheet } from './initiative-sheet.js';
@@ -32,6 +33,10 @@ registerCommand({
   id: 'initiatives-new', label: COPY.newInitiative, hint: 'Add one to Later', cli: 'pmos initiative new "<title>" --anchor <kr>',
   run: () => { openDestination('initiatives'); try { window.dispatchEvent(new CustomEvent('pmos:initiatives-new')); } catch { /* no window */ } },
 });
+registerCommand({
+  id: 'initiatives-rescan', label: COPY.rescan, hint: COPY.rescanHint,
+  run: () => { openDestination('initiatives'); try { window.dispatchEvent(new CustomEvent('pmos:initiatives-rescan')); } catch { /* no window */ } },
+});
 registerCommand({ id: 'initiatives-list', label: 'Initiatives as a list', hint: 'By objective', cli: 'pmos initiative list', run: () => { try { window.localStorage.setItem('pmos.initiatives.view', 'list'); } catch { /* no storage */ } openDestination('initiatives'); try { window.dispatchEvent(new CustomEvent('pmos:initiatives-view', { detail: 'list' })); } catch { /* no window */ } } });
 
 const BUILT_IN = ['roadmap', 'list'];
@@ -57,10 +62,11 @@ export function mountDestination(host, ctx) {
     host.replaceChildren(r.root);
     const reloadView = () => { if (r.handle && r.handle.reload) r.handle.reload(); refreshRows(r, ws); };
     r.onChanged = reloadView;
-    // The three listeners are kept on r so disposeDestination can take them off: a closed tab must not keep its host alive.
+    // The listeners are kept on r so disposeDestination can take them off: a closed tab must not keep its host alive.
     r.listeners = [
       ['pmos:initiatives-changed', () => { if (roots.get(host) === r) r.onChanged(); }],
       ['pmos:initiatives-new', () => { if (roots.get(host) === r) r.openNew(); }],
+      ['pmos:initiatives-rescan', () => { if (roots.get(host) === r && ws) rescanRepo(ws); }],
       ['pmos:initiatives-view', (e) => { if (roots.get(host) === r && e.detail) { r.view = e.detail; r.draw(r.ctx); } }],
     ];
     for (const [name, fn] of r.listeners) window.addEventListener(name, fn);

package/workspace/public/pm/dest-settings.js

@@ -204,6 +204,7 @@ function onlineSection() {
     lines.push(el('p', { class: 'fr-set__note', 'data-fr': 'online-tunnel' },
       r.running ? P.onlineRunning : r.lastExit ? P.onlineExited(r.lastExit.code) : P.onlineStarting));
     if (d.keys && !d.keys.keys) lines.push(el('p', { class: 'fr-set__note', 'data-fr': 'online-keys' }, d.keys.lastError ? P.onlineKeysError(d.keys.lastError) : P.onlineKeysWait));
+    if (d.lastRefusal) lines.push(el('p', { class: 'fr-set__note', 'data-fr': 'online-refused', role: 'status' }, P.onlineRefused(d.lastRefusal.reason, d.lastRefusal.at)));
   }
   if (!d.canChange) return section('online', P.online, [...lines, el('p', { class: 'fr-set__note' }, P.onlineRemote)]);
   const f = (key, label, placeholder) => field({

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

@@ -22,7 +22,7 @@ export const COPY = {
   },
   nav: {
     label: 'Destinations',
-    today: 'Today',
+    today: 'Agenda',
     initiatives: 'Initiatives',
     board: 'Board',
     reports: 'Reports',
@@ -115,7 +115,7 @@ export const COPY = {
   },
   page: {
     title: 'Settings',
-    intro: 'Settings for this workspace. Your work is in Today, Initiatives, Board and Reports.',
+    intro: 'Settings for this workspace. Your work is in Agenda, Initiatives, Board and Reports.',
     repos: 'Repositories',
     reposEmpty: 'No repository is registered. Add one to start.',
     add: 'Add repository',
@@ -170,6 +170,18 @@ export const COPY = {
     onlineEnv: (host) => `Online at https://${host}/, set by PMOS_PUBLIC_HOST when the workspace started. It signs in with the token. Restart the workspace without PMOS_PUBLIC_HOST to use this switch.`,
     onlineRemote: 'Only the computer that runs the workspace can change this.',
     onlineUnread: 'The Online settings did not load.',
+    onlineRefused: (reason, at) => `The last sign-in at the public address was refused${at ? ` (${at.slice(11, 16)} UTC)` : ''}: ${({
+      malformed: 'Cloudflare sent no sign-in, or one PMOS cannot read. Check that the Access application covers the public address.',
+      algorithm: 'the sign-in was not signed the way Cloudflare Access signs.',
+      'unknown key': 'it was signed with a key this team does not publish. Check the team domain.',
+      'no keys': 'Cloudflare\'s sign-in keys are not loaded. Check the team domain.',
+      signature: 'its signature did not match. Check the team domain.',
+      issuer: 'it came from another Cloudflare team. Check the team domain.',
+      audience: 'it was for another Access application. Check the audience (AUD) tag: copy it from the application for the public address.',
+      expired: 'it had expired, or this computer\'s clock is wrong. Sign in again.',
+      'not yet valid': 'it is not valid yet, so this computer\'s clock is probably wrong.',
+      email: 'you signed in with another email. The email field must be the address you sign in to Cloudflare with.',
+    })[reason] || reason}`,
     updates: 'Updates',
     updatesCheck: 'Check for updates',
     updatesChecking: 'Checking for updates…',