create-pmos 0.134.0 → 0.135.0

package/workspace/lib/routes-brief-page.js

@@ -1,7 +1,7 @@
 'use strict';
 /* routes-brief-page.js — GET /api/brief-page[?ws=<id>&now=ISO] (console3 Briefing as the brief, PRD briefing-brief R2, R3, R8).
  *
- *   → { ok, date, today: [meeting], needs: [row], decisions_error? }
+ *   → { ok, date, me?, today: [meeting], needs: [row], decisions_error? }   me: the PM's first name from git config user.name, or null
  *
  * READ ONLY, and built only from what PMOS already holds. Nothing is invented.
  *   today   one row per meeting of the local day, in time order, from the cached calendar events (routes-calendar-import.js readEvents,
@@ -21,6 +21,7 @@
  * has it. A deferred item ('Not yet') is left out until its defer date or time. Writes go through the existing pm-items routes. */
 const path = require('path');
 const pmItems = require('./pm-items.js');
+const { repoScript } = require('./repo-script.js');
 
 const pad = (n) => String(n).padStart(2, '0');
 const localDate = (d) => `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
@@ -153,9 +154,17 @@ function notesAdapter(runtimeDir) {
   };
 }
 
+/** The PM's first name for the greeting: the first word of `git config user.name` where PMOS runs. null when git holds none (the page then greets without a name). */
+function firstName(cwd) {
+  try {
+    const n = String(require('child_process').execFileSync('git', ['config', 'user.name'], { cwd, encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'] })).trim().split(/\s+/)[0];
+    return n && n.length <= 40 ? n : null;
+  } catch { return null; }
+}
+
 module.exports = {
   prefixes: ['/api/brief-page'],
-  build, todayAgenda, needsOf, evidenceFor, deferred,
+  build, todayAgenda, needsOf, evidenceFor, deferred, firstName,
   handle: async (req, res, url, ctx) => {
     if (url.pathname !== '/api/brief-page') return false;
     if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
@@ -174,10 +183,10 @@ module.exports = {
         const root = (w && w.root) || path.resolve(__dirname, '..', '..');
         const iso = localDate(now);
         const facts = await require('./facts-async.js').readFactsAsync(root, { today: iso });
-        const sig = path.resolve(__dirname, '..', '..', 'scripts', 'signals');
-        cards = require(path.join(sig, 'index.js')).present(facts, { lens: 'Unblock', zoom: 'week', today: iso }).cards || [];
+        cards = require(repoScript('signals/index.js')).present(facts, { lens: 'Unblock', zoom: 'week', today: iso }).cards || [];
       } catch (e) { decisionsError = 'the decisions could not be read: ' + (e && e.message ? e.message : String(e)); }
       const out = build({ now: now.toISOString() }, { events, items, cards, decisionsError, notes: dir ? notesAdapter(dir) : {} });
+      if (out.body && out.body.ok) out.body.me = firstName(path.resolve(__dirname, '..', '..'));
       ctx.json(res, out.body, out.status);
     } catch (e) {
       ctx.json(res, { ok: false, error: 'the brief page could not be built: ' + (e && e.message ? e.message : String(e)) }, 500);

package/workspace/lib/routes-briefing.js

@@ -1,8 +1,12 @@
 'use strict';
-/* routes-briefing.js — GET /api/briefing?lens=Plan|Unblock|Close|Reflect&zoom=day|week|month[&now=ISO] (console3 wave C1).
+/* routes-briefing.js — GET /api/briefing?lens=Plan|Unblock|Close|Reflect&zoom=day|week|month[&scope=brief|rep][&now=ISO] (console3 wave C1).
  *
- *   { ok, lens, zoom, cards, ticker, banner, own_needs }
- *   own_needs: the PM's own items overdue or due today, as needs rows (lib/needs-overdue.js), overdue first. Additive; the page shows them above the cards.
+ *   { ok, scope, lens, zoom, cards, ticker, banner, own_needs }
+ *   scope: whose deck asks. brief (or none) runs the engine's briefing detectors, rep its reports detectors (console3-deck-flow-fixes).
+ *          Any other scope answers no cards, so a page never shows another page's cards.
+ *   own_needs: the PM's own items overdue or due today, as needs rows (lib/needs-overdue.js), overdue first. Briefing scope only; the page shows them above the cards.
+ *   notices: the drafts a dashboard schedule made in the last 7 days that are still in the outbox (lib/report-schedules.js noticesOf).
+ *            Additive; the bell lists them after the cards, and each opens Reports > Drafts.
  *
  * `cards` are the engine's selected cards (scripts/signals present() over readRepoFacts of the repo root), with the card
  * anatomy untouched. `ticker` is one line per top card, built from the card's own headline and deadline. `banner` is the
@@ -10,9 +14,12 @@
  * { ok:false, error } with 500 and never throws out of the handler.
  */
 const path = require('path');
+const { repoScript } = require('./repo-script.js');
 
 const LENSES = ['Plan', 'Unblock', 'Close', 'Reflect'];
 const ZOOMS = ['day', 'week', 'month'];
+// the engine's detector pages for each deck that asks (scripts/signals/detectors.js `page`)
+const SCOPE_PAGES = { brief: ['briefing'], rep: ['reports'] };
 
 function lensFor(date) {
   const h = date.getHours();
@@ -38,9 +45,8 @@ function factsOnce(eng, root, iso) {
 
 function loadEngine() {
   // the engine is this repo's; `root` only says which repo's initiatives it reads
-  const sig = path.resolve(__dirname, '..', '..', 'scripts', 'signals');
-  const { present } = require(path.join(sig, 'index.js'));
-  const { readRepoFacts } = require(path.join(sig, 'facts.js'));
+  const { present } = require(repoScript('signals/index.js'));
+  const { readRepoFacts } = require(repoScript('signals/facts.js'));
   return { present, readRepoFacts };
 }
 
@@ -52,12 +58,15 @@ function briefing(query, opts = {}) {
   if (isNaN(now.getTime())) now = new Date();
   const lens = LENSES.includes(q.lens) ? q.lens : lensFor(now);
   const zoom = ZOOMS.includes(q.zoom) ? q.zoom : 'week';
+  const scope = q.scope ? String(q.scope) : 'brief';
+  const pages = SCOPE_PAGES[scope];
+  if (!pages) return { code: 200, body: { ok: true, scope, lens, zoom, cards: [], ticker: [], banner: null } };
   try {
     const eng = (opts.load || loadEngine)(root);
     const iso = now.getFullYear() + '-' + String(now.getMonth() + 1).padStart(2, '0') + '-' + String(now.getDate()).padStart(2, '0');
     const facts = opts.load ? eng.readRepoFacts(root, { today: iso }) : factsOnce(eng, root, iso);
     let useLens = lens;
-    let cards = eng.present(facts, { lens, zoom, today: iso }).cards || [];
+    let cards = eng.present(facts, { lens, zoom, today: iso, pages }).cards || [];
     // When the clock's lens has no card, show the lens that has the most (ties keep the clock's lens). On the real repo
     // this is usually all four empty: the briefing detectors read promised dates, forecasts, holders and the like, and no
     // initiative record carries them yet. The answer then stays empty and says so by fallback_lens being absent.
@@ -65,12 +74,12 @@ function briefing(query, opts = {}) {
     if (!cards.length && !q.lens) {
       for (const l of LENSES) {
         if (l === lens) continue;
-        const c = eng.present(facts, { lens: l, zoom, today: iso }).cards || [];
+        const c = eng.present(facts, { lens: l, zoom, today: iso, pages }).cards || [];
         if (c.length > cards.length) { cards = c; useLens = l; fallback = true; }
       }
     }
     const banner = cards.find((c) => c.pinned && c.tag === 'Critical') || null;
-    return { code: 200, body: { ok: true, lens: useLens, zoom, cards, ticker: tickerOf(cards), banner, ...(fallback ? { fallback_lens: true } : {}) } };
+    return { code: 200, body: { ok: true, scope, lens: useLens, zoom, cards, ticker: tickerOf(cards), banner, ...(fallback ? { fallback_lens: true } : {}) } };
   } catch (e) {
     return { code: 500, body: { ok: false, error: 'the signal engine failed: ' + (e && e.message ? e.message : String(e)) } };
   }
@@ -78,7 +87,7 @@ function briefing(query, opts = {}) {
 
 module.exports = {
   prefixes: ['/api/briefing'],
-  briefing, lensFor, tickerOf,
+  briefing, lensFor, tickerOf, SCOPE_PAGES,
   handle: async (req, res, url, ctx) => {
     if (url.pathname !== '/api/briefing') return false;
     if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
@@ -96,12 +105,14 @@ module.exports = {
     const eng = loadEngine();
     const out = briefing(q, { root: useRoot, load: () => ({ present: eng.present, readRepoFacts: () => facts }) });
     // additive: the PM's own overdue and due-today items, as needs rows beside the engine's cards (lib/needs-overdue.js); a read failure leaves the list empty
-    if (out.code === 200) {
+    if (out.code === 200 && out.body.scope === 'brief') {
       try {
         const pmItems = require('./pm-items.js');
         const file = path.join(ctx.runtimeDir, 'pm-items', 'items.jsonl');
         out.body.own_needs = require('./needs-overdue.js').overdueNeeds(pmItems.fold(pmItems.readLines(file)), iso);
       } catch { out.body.own_needs = []; }
+      // additive: a draft a dashboard schedule made in the last 7 days, still in the outbox, is a notice on the bell (lib/report-schedules.js). Nothing was sent.
+      try { out.body.notices = require('./report-schedules.js').noticesOf(require('./outbox-store.js').readOutbox(ctx.runtimeDir)); } catch { out.body.notices = []; }
     }
     ctx.json(res, out.body, out.code);
     return true;

package/workspace/lib/routes-c3-init.js

@@ -10,9 +10,10 @@
 const fs = require('fs');
 const path = require('path');
 const roadmapOps = require('./routes-roadmap-ops.js');
-const records = require(path.join(__dirname, '..', '..', 'scripts', 'records', 'index.js'));
-const roadmap = require(path.join(__dirname, '..', '..', 'scripts', 'roadmap-ops.js'));
-const breakdown = require(path.join(__dirname, '..', '..', 'scripts', 'breakdown-ops.js'));
+const { repoScript } = require('./repo-script.js');
+const records = require(repoScript('records/index.js'));
+const roadmap = require(repoScript('roadmap-ops.js'));
+const breakdown = require(repoScript('breakdown-ops.js'));
 
 function readPeople(runtimeDir) {
   try {

package/workspace/lib/routes-c3-life.js

@@ -13,7 +13,8 @@
  * Repo facts are not read here (readRepoFacts is synchronous and slow); only two small JSONL files and the existence of named files are. */
 const fs = require('fs');
 const path = require('path');
-const records = require(path.join(__dirname, '..', '..', 'scripts', 'records', 'index.js'));
+const { repoScript } = require('./repo-script.js');
+const records = require(repoScript('records/index.js'));
 
 const REPO = path.join(__dirname, '..', '..');
 const DAY = 86400000;

package/workspace/lib/routes-c3-reports.js

@@ -6,6 +6,9 @@
  *                                                          and scope, id, today echoed. 400 on a bad scope or a missing id; 404 for an id nothing holds.
  *   POST /api/report-dashboards/layout { key, reports }  → { ok, key, reports, layouts }   reports: null resets the key to its default.
  *                                                          400 on an unknown key or report id; 403 without a page press.
+ *   POST /api/report-dashboards/schedule { key, plan, audience } → { ok, key, schedule, schedules }   plan: none|weekly|monthly; none removes it.
+ *                                                          400 on a bad key, plan or audience; 403 without a page press. (lib/report-schedules.js)
+ *   runDue(ctx, now)                                     the server tick: each due schedule appends ONE draft to the outbox. Nothing is sent.
  *
  * Initiatives come from the workspace's facts (lib/facts-async.js), like routes-calendar-views.js. Key results, bets and hypotheses
  * come from the same records as routes-c3-strategy.js. The handlers are pure over their inputs so a test needs no server.
@@ -14,24 +17,32 @@ const path = require('path');
 const guard = require('./pm-guard.js');
 const strategy = require('./routes-c3-strategy.js');
 const rd = require('./report-dashboards.js');
+const rs = require('./report-schedules.js');
+const RF = require('./report-frame.js');
+const { repoScript } = require('./repo-script.js');
 
 const fail = (status, error, extra) => ({ status, body: { ok: false, error, ...(extra || {}) } });
 const pad = (n) => String(n).padStart(2, '0');
 const todayStr = () => { const d = new Date(); return d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate()); };
 const cap = (s) => (s ? s.charAt(0).toUpperCase() + s.slice(1) : s);
 
-/** boards and initiatives from the facts. A board is boardOf(ini, slug); its title is its id, capitalised. */
-function catalogue(facts, slug) {
+/** boards and initiatives from the facts. With `index` (the Initiatives board model, routes-boards.js boardIndex) an
+ * initiative sits on the board the Initiatives page shows it on, and a board keeps its name there. Without it a board is
+ * boardOf(ini, slug) and its title is its id, capitalised. */
+function catalogue(facts, slug, index) {
   const inis = ((facts && facts.inis) || []).filter((i) => i && i.id);
-  const initiatives = inis.map((i) => ({ id: String(i.id), title: String(i.title || i.id), board: rd.boardOf(i, slug) }));
+  const boardOf = (i) => (index ? index.of(String(i.id)) : rd.boardOf(i, slug));
+  const initiatives = inis.map((i) => ({ id: String(i.id), title: String(i.title || i.id), board: boardOf(i) }));
+  const names = new Map(index ? index.boards.map((b) => [b.id, b.title]) : []);
   const seen = new Map();
-  initiatives.forEach((i) => { if (i.board && !seen.has(i.board)) seen.set(i.board, { id: i.board, title: cap(i.board) }); });
+  initiatives.forEach((i) => { if (i.board && !seen.has(i.board)) seen.set(i.board, { id: i.board, title: names.get(i.board) || cap(i.board) }); });
   return { boards: [...seen.values()], initiatives };
 }
 
-function list({ facts, runtimeDir, slug }) {
-  const c = catalogue(facts, slug);
-  return { status: 200, body: { ok: true, library: rd.LIBRARY, layouts: rd.readLayouts(runtimeDir), defaults: rd.DEFAULTS, boards: c.boards, initiatives: c.initiatives } };
+function list({ facts, runtimeDir, slug, index, now }) {
+  const c = catalogue(facts, slug, index);
+  return { status: 200, body: { ok: true, library: rd.LIBRARY, layouts: rd.readLayouts(runtimeDir), defaults: rd.DEFAULTS, boards: c.boards, initiatives: c.initiatives,
+    schedules: rs.viewOf(rs.readSchedules(runtimeDir), now || new Date()), plans: rs.PLANS } };
 }
 
 /** query { scope, id }; deps { facts, build() → the c3-strategy body, today, slug, hypotheses }. */
@@ -41,14 +52,14 @@ function data(query, deps) {
   if (scope !== 'portfolio') {
     if (typeof id !== 'string' || !id) return fail(400, 'id is required for the ' + scope + ' scope');
     if (!rd.validId(id)) return fail(400, 'id is not a valid id');
-    const c = catalogue(deps.facts, deps.slug);
+    const c = catalogue(deps.facts, deps.slug, deps.index);
     const found = scope === 'board' ? c.boards.some((b) => b.id === id) : c.initiatives.some((i) => i.id === id);
     if (!found) return fail(404, 'no ' + scope + ' has the id ' + id);
   }
   const today = deps.today || todayStr();
   try {
     const body = deps.build(today);
-    return { status: 200, body: rd.scopeFilter(body, deps.facts, scope, id || null, today, { slug: deps.slug, hypotheses: deps.hypotheses }) };
+    return { status: 200, body: rd.scopeFilter(body, deps.facts, scope, id || null, today, { slug: deps.slug, hypotheses: deps.hypotheses, boardOf: deps.index ? (i) => deps.index.of(String(i.id)) : undefined }) };
   } catch (e) { return fail(500, String((e && e.message) || e)); }
 }
 
@@ -62,6 +73,70 @@ function layout(req, body, runtimeDir) {
   return { status: 200, body: { ok: true, key: body.key, reports: r.layouts[body.key] || null, layouts: r.layouts } };
 }
 
+function schedule(req, body, runtimeDir, now = new Date()) {
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) return fail(g.status, g.error);
+  const r = rs.saveSchedule(runtimeDir, { key: body.key, plan: body.plan, audience: body.audience, ws: body.ws == null || body.ws === '' ? null : body.ws }, now);
+  if (!r.ok) return fail(/could not be saved|no runtime/.test(r.error) ? 500 : 400, r.error);
+  const view = rs.viewOf(r.schedules, now);
+  return { status: 200, body: { ok: true, key: body.key, schedule: view[body.key] || null, schedules: view } };
+}
+
+/* The dashboard's title as the page names it (c3-reports.js dashTitle): Portfolio, Board: <title>, Initiative: <title>. */
+function titleOf(key, c) {
+  if (key === 'portfolio') return 'Portfolio';
+  const i = key.indexOf(':'); const scope = key.slice(0, i); const id = key.slice(i + 1);
+  const x = (scope === 'board' ? c.boards : c.initiatives).find((b) => b.id === id);
+  return (scope === 'board' ? 'Board: ' : 'Initiative: ') + (x ? x.title || x.id : id);
+}
+
+/**
+ * Run one schedule: the dashboard's data for its scope, its current layout (or the scope's default), the frame and text the Share sheet
+ * makes, then ONE outbox draft. deps { facts, slug, build(today), hypotheses, runtimeDir, today }. Returns { ok, entry } | { ok:false, error }.
+ */
+function runOne(sched, deps, now = new Date()) {
+  const key = sched.key;
+  const scope = key === 'portfolio' ? 'portfolio' : key.slice(0, key.indexOf(':'));
+  const id = scope === 'portfolio' ? null : key.slice(key.indexOf(':') + 1);
+  const r = data({ scope, id }, deps);
+  if (r.status !== 200) return { ok: false, error: r.body.error || 'the dashboard could not be read' };
+  const layouts = rd.readLayouts(deps.runtimeDir);
+  const ids = Object.prototype.hasOwnProperty.call(layouts, key) ? layouts[key] : rd.DEFAULTS[scope];
+  const reports = ids.map((x) => rd.LIBRARY.find((l) => l.id === x)).filter(Boolean);
+  const c = catalogue(deps.facts, deps.slug, deps.index);
+  const F = RF.frameOf({ title: titleOf(key, c), reports, raw: r.body, audience: sched.audience, today: r.body.today });
+  try { return { ok: true, entry: rs.makeDraft(deps.runtimeDir, sched, F, RF.draftBody(F), now) }; }
+  catch (e) { return { ok: false, error: 'the draft could not be saved: ' + String((e && e.message) || e) }; }
+}
+
+/** The tick. lastRun moves first, so a slow read never runs the same slot twice; the outcome is written after. */
+let running = false;
+async function runDue(ctx, now = new Date()) {
+  if (running || !ctx || !ctx.runtimeDir) return [];
+  running = true;
+  const done = [];
+  try {
+    for (const s of rs.dueOf(rs.readSchedules(ctx.runtimeDir), now)) {
+      rs.markRun(ctx.runtimeDir, s.key, { lastRun: now.toISOString() });
+      let out;
+      try {
+        const w = ctx.getWs(s.ws || null);
+        if (!w) throw new Error('no workspace is registered');
+        const slug = w.id || (w.root ? path.basename(path.resolve(w.root)) : null);
+        const facts = await (ctx.readFacts || readFacts)(w);
+        const root = rootOf(ctx);
+        let hypotheses = [];
+        try { hypotheses = require(repoScript('records/index.js')).list(root, 'hypotheses'); } catch { hypotheses = []; }
+        out = runOne(s, { facts, slug, hypotheses, runtimeDir: ctx.runtimeDir, today: ctx.today,
+          build: ctx.build || ((today) => strategy.build(root, path.join(ctx.runtimeDir, 'signals', 'signals.jsonl'), today)) }, now);
+      } catch (e) { out = { ok: false, error: String((e && e.message) || e) }; }
+      rs.markRun(ctx.runtimeDir, s.key, out.ok ? { last_status: 'ok', last_error: null, last_draft: out.entry.id } : { last_status: 'failed', last_error: out.error });
+      done.push({ key: s.key, ...out });
+    }
+  } finally { running = false; }
+  return done;
+}
+
 const rootOf = (ctx) => (ctx && ctx.recordsDir) || path.join((ctx && ctx.repoRoot) || path.join(__dirname, '..', '..'), 'planning', 'records');
 
 async function readFacts(w) {
@@ -70,7 +145,7 @@ async function readFacts(w) {
 
 module.exports = {
   prefixes: ['/api/report-dashboards'],
-  catalogue, list, data, layout,
+  catalogue, list, data, layout, schedule, runOne, runDue,
   handle: async (req, res, url, ctx) => {
     const p = url.pathname;
     const send = (r) => { ctx.json(res, r.body, r.status); return true; };
@@ -88,12 +163,14 @@ module.exports = {
       let facts;
       try { facts = await readFacts(w); }
       catch (e) { return send(fail(500, 'the dashboards could not read the repository: ' + (e && e.message ? e.message : String(e)))); }
-      if (p === '/api/report-dashboards') return send(list({ facts, runtimeDir: ctx.runtimeDir, slug }));
+      let index = null;   // the Initiatives board model; without it (no module, or a read error) boardOf decides
+      try { index = require('./routes-boards.js').boardIndex(ctx, w); } catch { index = null; }
+      if (p === '/api/report-dashboards') return send(list({ facts, runtimeDir: ctx.runtimeDir, slug, index }));
       const root = rootOf(ctx);
       let hypotheses = [];
-      try { hypotheses = require('../../scripts/records/index.js').list(root, 'hypotheses'); } catch { hypotheses = []; }
+      try { hypotheses = require(repoScript('records/index.js')).list(root, 'hypotheses'); } catch { hypotheses = []; }
       return send(data({ scope: url.searchParams.get('scope'), id: url.searchParams.get('id') }, {
-        facts, slug, hypotheses,
+        facts, slug, hypotheses, index,
         build: (today) => strategy.build(root, path.join(ctx.runtimeDir || '.', 'signals', 'signals.jsonl'), today),
       }));
     }
@@ -103,6 +180,12 @@ module.exports = {
       if (!got.ok) return send(fail(400, 'invalid JSON body'));
       return send(layout(req, got.body || {}, ctx.runtimeDir));
     }
+    if (p === '/api/report-dashboards/schedule') {
+      if (req.method !== 'POST') return send(fail(405, 'POST only'));
+      const got = await ctx.readJson(req);
+      if (!got.ok) return send(fail(400, 'invalid JSON body'));
+      return send(schedule(req, got.body || {}, ctx.runtimeDir));
+    }
     return false;
   },
 };

package/workspace/lib/routes-c3-strategy.js

@@ -17,9 +17,10 @@
  * reader is used, so the route never starts a cold repository read. A number that no record holds is null, never invented. */
 const path = require('path');
 const fs = require('fs');
-const records = require(path.join(__dirname, '..', '..', 'scripts', 'records', 'index.js'));
-const sigRules = require(path.join(__dirname, '..', '..', 'scripts', 'signal-rules.js'));
-const ledger = require(path.join(__dirname, '..', '..', 'scripts', 'trust', 'ledger.js'));
+const { repoScript } = require('./repo-script.js');
+const records = require(repoScript('records/index.js'));
+const sigRules = require(repoScript('signal-rules.js'));
+const ledger = require(repoScript('trust/ledger.js'));
 
 const EARLY = 0.10;     // the repository's early-warning share (scripts/calendar-model.js EARLY_WARNING)
 const OFF = 0.50;       // behind the line by half the span or more reads as off course

package/workspace/lib/routes-c3-timeline.js

@@ -23,9 +23,10 @@
  */
 const path = require('path');
 const planItems = require('./plan-items.js');
-const F = require('../../scripts/plan-forecast.js');
+const { repoScript } = require('./repo-script.js');
+const F = require(repoScript('plan-forecast.js'));
 const roadmapOps = require('./routes-roadmap-ops.js');
-const breakdown = require(path.join(__dirname, '..', '..', 'scripts', 'breakdown-ops.js'));
+const breakdown = require(repoScript('breakdown-ops.js'));
 
 const localYmd = (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
 const DAY = 86400000;

package/workspace/lib/routes-calendar-import.js

@@ -11,8 +11,9 @@
  * File: <runtime>/calendar-import/events.jsonl (append only, scripts/trust/ledger.js). */
 const path = require('path');
 const guard = require('./pm-guard.js');
-const CI = require('../../scripts/calendar-import.js');
-const L = require('../../scripts/trust/ledger.js');
+const { repoScript } = require('./repo-script.js');
+const CI = require(repoScript('calendar-import.js'));
+const L = require(repoScript('trust/ledger.js'));
 
 const fileOf = (runtimeDir) => path.join(runtimeDir, 'calendar-import', 'events.jsonl');
 const fail = (status, error) => ({ status, body: { ok: false, error } });

package/workspace/lib/routes-calendar-views.js

@@ -2,7 +2,8 @@
 /* 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, today,
- *       layers, layers_total, layers_note, free, context, context_total }     (the last six: lib/calendar-layers.js)
+ *       layers, layers_total, layers_note, free, context, context_total,      (lib/calendar-layers.js)
+ *       tidy, tidy_total, tidy_note }                                          (lib/calendar-tidy.js: suggestions in words, no write)
  *
  * 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,8 +14,10 @@
  * Until one is, events = [] and events_source is 'none'. KRS: no KR metric series is stored in the repo, so the strategy lens
  * gets none and says so. */
 const path = require('path');
-const model = require('../../scripts/calendar-model.js');
+const { repoScript } = require('./repo-script.js');
+const model = require(repoScript('calendar-model.js'));
 const layersLib = require('./calendar-layers.js');
+const tidyLib = require('./calendar-tidy.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())}`; };
 
@@ -44,7 +47,9 @@ function handle(query, deps = {}) {
     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 } };
+    const tidy = tidyLib.tidyFrom({ range, today: nowDay, nowMs, events, eventsSource: source, inis, gantt,
+      planItems: dated.planItems || items.planItems || [] });
+    return { status: 200, body: { ok: true, view, range, unit: b.unit, cells: b.cells, gantt, strategy, events_source: source, today: nowDay, ...extra, ...tidy } };
   } catch (e) {
     return { status: 500, body: { ok: false, error: String(e && e.message || e) } };
   }
@@ -70,7 +75,7 @@ function readers(root, runtimeDir) {
       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 R = require(repoScript('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);

package/workspace/lib/routes-doc-health.js

@@ -12,7 +12,8 @@
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
-const H = require('../../scripts/doc-health.js');
+const { repoScript } = require('./repo-script.js');
+const H = require(repoScript('doc-health.js'));
 
 const ROOT = path.resolve(__dirname, '..', '..');
 const bad = (error, status = 400) => ({ status, body: { ok: false, error } });

package/workspace/lib/routes-doc-sheet.js

@@ -19,7 +19,8 @@ const fs = require('fs');
 const path = require('path');
 const guard = require('./pm-guard.js');
 const applyChange = require('./apply-change.js');
-const S = require('../../scripts/doc-sheet.js');
+const { repoScript } = require('./repo-script.js');
+const S = require(repoScript('doc-sheet.js'));
 
 const ROOT = path.resolve(__dirname, '..', '..');
 const fail = (status, error, extra) => ({ status, body: { ok: false, error, ...(extra || {}) } });

package/workspace/lib/routes-forecast.js

@@ -15,7 +15,8 @@
 const fs = require('fs');
 const path = require('path');
 const planItems = require('./plan-items.js');
-const F = require('../../scripts/plan-forecast.js');
+const { repoScript } = require('./repo-script.js');
+const F = require(repoScript('plan-forecast.js'));
 
 const DEFAULT_PPW = 5;
 const localYmd = (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;

package/workspace/lib/routes-hooks.js

@@ -14,8 +14,9 @@ const fs = require('fs');
 const path = require('path');
 const actor = require('./actor.js');
 const runAnswers = require('./run-answers.js');
-const C = require('../../scripts/reply-contract/reply-contract.js');
-const R = require('../../scripts/replies.js');
+const { repoScript } = require('./repo-script.js');
+const C = require(repoScript('reply-contract/reply-contract.js'));
+const R = require(repoScript('replies.js'));
 
 const EVENTS = ['SessionStart', 'PreToolUse', 'PermissionRequest', 'Stop', 'Notification', 'SessionEnd'];
 const ALIASES = { 'session-start': 'SessionStart', 'pre-tool': 'PreToolUse', 'permission-request': 'PermissionRequest', stop: 'Stop', notification: 'Notification', 'session-end': 'SessionEnd' };

package/workspace/lib/routes-initiatives.js

@@ -57,7 +57,8 @@ const tidy = require('./tidy-documents.js');
 const jevDocs = require('./jev-documents.js');
 const tsSettings = require('./typesafe-settings');
 const docCatCorrections = require('./doc-category-corrections');
-const { nineStages } = require('../../scripts/nine-stages.js');   // pure label layer; never workflow-state.js (it runs its CLI on require)
+const { repoScript } = require('./repo-script.js');
+const { nineStages } = require(repoScript('nine-stages.js'));   // pure label layer; never workflow-state.js (it runs its CLI on require)
 
 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']];

package/workspace/lib/routes-intake.js

@@ -4,7 +4,8 @@
  * Drafts only. Creating the initiative stays with createInitiative, which refuses an unanchored create. */
 const path = require('path');
 const guard = require('./pm-guard.js');
-const intake = require('../../scripts/intake.js');
+const { repoScript } = require('./repo-script.js');
+const intake = require(repoScript('intake.js'));
 
 const ROOT = path.resolve(__dirname, '..', '..');