create-pmos 0.179.0 → 0.181.0

package/workspace/lib/route-modules.js

@@ -70,6 +70,7 @@ const MODULES = Object.freeze([
   'routes-stage-tools',   // stage-tools-records: the records the PM edits per stage, what PMOS holds per stage, the sprint burndown
   'routes-driver',        // initiative-driver: the Agent strip's data, Keep, Send back, Drop, Pause and the board mode (driver.jsonl)
   'routes-scan',          // horizon-scan: a board's watch list, cadence and last scan, the day's scan for the Briefing, the PM's watch and cadence presses (scan.jsonl)
+  'routes-report-setups', // report-workspace: recurring reports, the Ask box, the finder, the report documents and their export (report-setups.jsonl)
 ]);
 const PM_DIR = path.join(__dirname, '..', 'public', 'pm');
 const MODULE_NAME = /^[a-z0-9][a-z0-9-]*\.js$/;

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

@@ -9,6 +9,7 @@
  *   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.
+ *                                                        A key that is a recurring report now (report-workspace) is skipped: lib/routes-report-setups.js drafts it.
  *
  * 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.
@@ -91,10 +92,10 @@ function titleOf(key, c) {
 }
 
 /**
- * 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 }.
+ * The frame of a dashboard (its data, its current layout or the scope's default, the frame the Share sheet makes): { ok, F } | { ok:false, error }.
+ * sched { key, audience }; deps { facts, slug, build(today), hypotheses, runtimeDir, today }; `title` replaces the dashboard's own title.
  */
-function runOne(sched, deps, now = new Date()) {
+function frameFor(sched, deps, title) {
   const key = sched.key;
   const scope = key === 'portfolio' ? 'portfolio' : key.slice(0, key.indexOf(':'));
   const id = scope === 'portfolio' ? null : key.slice(key.indexOf(':') + 1);
@@ -104,11 +105,35 @@ function runOne(sched, deps, now = new Date()) {
   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) }; }
+  return { ok: true, F: RF.frameOf({ title: title || titleOf(key, c), reports, raw: r.body, audience: sched.audience, today: r.body.today }) };
+}
+
+/** Run one schedule: the frame, then ONE outbox draft. deps as frameFor. Returns { ok, entry } | { ok:false, error }. */
+function runOne(sched, deps, now = new Date()) {
+  const f = frameFor(sched, deps);
+  if (!f.ok) return f;
+  try { return { ok: true, entry: rs.makeDraft(deps.runtimeDir, sched, f.F, RF.draftBody(f.F), now) }; }
   catch (e) { return { ok: false, error: 'the draft could not be saved: ' + String((e && e.message) || e) }; }
 }
 
+/** The deps frameFor needs for one workspace, read now. ctx { getWs, runtimeDir, today, readFacts, build }. The tick here and lib/routes-report-setups.js use it. */
+async function depsFor(ctx, wsId) {
+  const w = ctx.getWs(wsId || 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, wsId || null);
+  let hypotheses = [];
+  try { hypotheses = require(repoScript('records/index.js')).list(root, 'hypotheses'); } catch { hypotheses = []; }
+  return { facts, slug, hypotheses, runtimeDir: ctx.runtimeDir, today: ctx.today,
+    build: ctx.build || ((today) => strategy.build(root, path.join(ctx.runtimeDir, 'signals', 'signals.jsonl'), today)) };
+}
+
+/** True when the key is a recurring report now (lib/report-setups.js dashboardKeys). A repository that cannot be read holds nothing. */
+function handled(ctx, s) {
+  try { const w = ctx.getWs(s.ws || null); return !!w && require('./report-setups.js').dashboardKeys(w.root).has(s.key); } catch { return false; }
+}
+
 /** 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()) {
@@ -117,19 +142,12 @@ async function runDue(ctx, now = new Date()) {
   const done = [];
   try {
     for (const s of rs.dueOf(rs.readSchedules(ctx.runtimeDir), now)) {
+      // A key that became a recurring report (lib/report-setups.js) is drafted there, as a document. This tick leaves it alone.
+      if (handled(ctx, s)) continue;
       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, s.ws || null);
-        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) }; }
+      try { out = runOne(s, await depsFor(ctx, s.ws || null), 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 });
     }
@@ -146,7 +164,7 @@ async function readFacts(w) {
 
 module.exports = {
   prefixes: ['/api/report-dashboards'],
-  catalogue, list, data, layout, schedule, runOne, runDue,
+  catalogue, list, data, layout, schedule, frameFor, depsFor, runOne, runDue,
   handle: async (req, res, url, ctx) => {
     const p = url.pathname;
     const send = (r) => { ctx.json(res, r.body, r.status); return true; };

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

@@ -8,12 +8,14 @@
  * of every relative Markdown link it cites (a save or a "still current" mark in the document sheet counts as a change), and the last change of each ADR a `D<n>` id in its text names. Everything
  * else (requiredHeadings, data, readers, current, staleAfterDays) comes only from `context` in the body; a check without
  * its input answers "not enough input". No write routes in this wave.
+ * A document under reports/<cadence>/ also gets the three report checks (lib/report-checks.js) appended to `health.checks`; passed and total count them.
  */
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const { repoScript } = require('./repo-script.js');
 const H = require(repoScript('doc-health.js'));
+const RC = require('./report-checks.js');
 
 const ROOT = path.resolve(__dirname, '..', '..');
 const bad = (error, status = 400) => ({ status, body: { ok: false, error } });
@@ -71,7 +73,19 @@ function check(root, body, runtimeDir) {
   const context = { ...given, sources: sources.length ? sources : given.sources,
     decisionChanges: Object.keys(decisionChanges).length ? decisionChanges : given.decisionChanges };
   const doc = { text, type: given.type || body.type, changed };
-  return { status: 200, body: { ok: true, path: relOut, health: H.healthOf(doc, context) } };
+  const health = H.healthOf(doc, context);
+  // A report document (<state>/reports/<cadence>/<slot>.md) is also held to three report checks (lib/report-checks.js): numbers have a source,
+  // dates are written in full, and Decisions and Risk watch are present when the report's definition lists them.
+  if (RC.isReportPath(relOut)) {
+    let listed = [];
+    try { listed = RC.listedOf(fs.readFileSync(path.join(path.dirname(path.dirname(full)), 'definitions', RC.cadenceOfPath(relOut) + '.md'), 'utf8')); } catch { listed = []; }
+    const extra = RC.reportChecks(text, { listed });
+    health.checks = health.checks.concat(extra);
+    const answered = health.checks.filter((k) => k.pass !== null);
+    health.passed = answered.filter((k) => k.pass).length;
+    health.total = answered.length;
+  }
+  return { status: 200, body: { ok: true, path: relOut, health } };
 }
 
 module.exports = {

package/workspace/lib/routes-report-setups.js

@@ -0,0 +1,368 @@
+'use strict';
+/* routes-report-setups.js — the Reports workspace's routes (initiative report-workspace, PRD sections 2 to 6).
+ *
+ *   GET  /api/report-setups?ws        → { setups: [{ id, name, purpose, audience, source, output, schedule, label, next_draft, last_issued, status, cycles,
+ *                                                     copy: { kind, state: none|in-step|pmos-ahead|copy-changed|not-checked, url } }],
+ *                                         findings: [{ id, name, why, evidence: [{ kind, text }], confidence: likely|not-sure, proposal }],
+ *                                         asks: [{ id, text, state: running|ready|failed, changed, proposal, error }],
+ *                                         finder: { cadence, sources: { calendar, slack, mail, drive }, last_run, next_run } }
+ *   POST /api/report-setups/ask        { ws, text }                          → { ok, id }       starts the report-setup run (headless)
+ *   POST /api/report-setups/change     { ws, id, text }                      → { ok }           a correction to a proposal; a second run revises it
+ *   POST /api/report-setups/cancel     { ws, id }                            → { ok }
+ *   POST /api/report-setups/setup      { ws, ask? | finding?, proposal? }    → { ok, setup, first_draft }   THE press that sets a report up
+ *   POST /api/report-setups/dismiss    { ws, finding }                       → { ok }           "Not a report"
+ *   POST /api/report-setups/pause | resume { ws, id }                         → { ok, setup }
+ *   POST /api/report-setups/from-dashboard { ws, key, name, output, schedule, audience } → { ok, setup }
+ *   POST /api/report-setups/finder     { ws, cadence?, sources? }            → { ok, finder }
+ *   GET  /api/report-documents?ws     → { docs: [{ path, id, setup, name, slot, state: draft|issued, source, output, made_by: schedule|you|agent, v, copy }] }
+ *   GET  /api/report-export?ws&path&fmt=pptx|xlsx|docx|csv   → the file, Content-Disposition: attachment. PDF is printed by the browser: there is no route.
+ *
+ * WHO SETS A REPORT UP. Only a PM press does. Every POST passes pm-guard requirePagePress, and a request that carries an agent session header is
+ * refused first (403), as routes-scan.js does. A proposal from the Ask box or from the finder is DATA in report-setups.jsonl: the report-setup
+ * and report-find runs (lib/headless.js) file it with `pmos report propose` and have no tool that writes anything else. Nothing here, and nothing
+ * those runs do, sends anything outward (D65: the factory is propose-only).
+ *
+ * A DOCUMENT is any <state>/reports/<cadence>/<slot>.md, one-offs included, joined to issues.jsonl. Its `id` is "<cadence>/<slot>"; `setup` is the
+ * recurring report that made it (the cadence folder is the setup id), or null for a one-off. `made_by` reads the file's own `made_by` line; with
+ * none, a setup's folder says "schedule" and a one-off says "you". `v` is 1 plus the saves the document sheet kept for the file. `copy` is the linked
+ * copy's state from lib/doc-sync-store.js (kind: the output's copy kind; state: none | in-step | pmos-ahead | copy-changed | not-checked).
+ *
+ * TICK. tick(ctx, now) moves the old dashboard schedules into recurring reports (once per repository), then drafts each due dashboard-sourced setup
+ * as a document under <state>/reports/<id>/<slot>.md. The server calls it before the old dashboard tick, which then skips the migrated keys.
+ * ctx adds to the usual route ctx: { scheduleStore: { read, write }, skillPrompt(id, w), stopSession(id), workspaceList() }.
+ */
+const fs = require('fs');
+const path = require('path');
+const guard = require('./pm-guard.js');
+const RS = require('./report-setups.js');
+const RN = require('./report-needs.js');
+const RC = require('./report-checks.js');
+const RX = require('./report-export.js');
+const RF = require('./report-finder.js');
+const logic = require('./schedule-logic.js');
+const docSync = require('./doc-sync.js');
+const headless = require('./headless.js');
+
+const text = (v) => (typeof v === 'string' ? v : '');
+const bad = (status, error) => ({ status, body: { ok: false, error } });
+const POSTS = ['ask', 'change', 'cancel', 'setup', 'dismiss', 'pause', 'resume', 'from-dashboard', 'finder'];
+const MADE_BY = ['schedule', 'you', 'agent'];
+
+const runs = new Map();   // ask id → session id, for the report-setup runs this server started
+
+function wsOf(ctx, id) {
+  const w = ctx.getWs(id || null);
+  return w && (!id || w.id === id) ? w : null;
+}
+const isHome = (ctx, w) => { const h = ctx.getWs(null); return !!h && h.id === w.id; };
+const dayEnd = (ctx) => { try { const s = ctx.proSettings ? ctx.proSettings() : null; return (s && s.dayCheck && s.dayCheck.end) || '18:00'; } catch { return '18:00'; } };
+const finderClock = (env) => { const t = (env || process.env).PMOS_REPORT_FIND_NOW ? Date.parse((env || process.env).PMOS_REPORT_FIND_NOW) : NaN; return Number.isFinite(t) ? t : null; };
+
+// ── the old dashboard schedules become recurring reports, once ───────────────────────────────────────────
+/** Move this workspace's dashboard schedules into setups. Nothing to move: nothing is written (no state folder is made). Idempotent: a marker line. */
+function ensureMigrated(ctx, w, now = new Date()) {
+  if (!ctx.runtimeDir) return null;
+  try {
+    const st = RS.stateOf(w.root);
+    if (st.migrated) return null;
+    const rs = require('./report-schedules.js');
+    const mine = Object.values(rs.readSchedules(ctx.runtimeDir)).filter((s) => (s.ws ? s.ws === w.id : isHome(ctx, w)));
+    if (!mine.length) return null;
+    let outbox = [];
+    try { outbox = require('./outbox-store.js').readOutbox(ctx.runtimeDir); } catch { outbox = []; }
+    return RS.migrate(w.root, { runtimeDir: ctx.runtimeDir, wsId: w.id, isHome: isHome(ctx, w), outbox, now });
+  } catch { return null; }
+}
+
+// ── what the page reads ──────────────────────────────────────────────────────────────────────────────────
+function copyOf(link, kind) {
+  if (!link) return { kind: kind || null, state: 'none', url: null };
+  const state = link.signal === 'same' ? 'in-step' : link.signal === 'ahead' ? 'pmos-ahead' : (link.signal === 'behind' || link.signal === 'diverged') ? 'copy-changed' : 'not-checked';
+  return { kind: link.kind, state, url: link.target || null };
+}
+function copyIndex(root) {
+  const idx = new Map();
+  try { const v = require('./doc-sync-store.js').view(root); if (v.ok) for (const d of v.docs) idx.set(d.path, d.links); } catch { /* no link store */ }
+  return idx;
+}
+function linkFor(idx, rel, output) {
+  const links = idx.get(rel) || [];
+  const want = docSync.copyKindOf(output);
+  return links.find((l) => l.kind === want) || links[0] || null;
+}
+
+function documentsOf(ctx, w) {
+  const root = w.root;
+  const st = RS.stateOf(root);
+  const r = RN.reportsOf(root);
+  const idx = copyIndex(root);
+  let revs = [];
+  try { revs = fs.readFileSync(path.join(ctx.runtimeDir, 'doc-sheet', 'revisions.jsonl'), 'utf8').split('\n').filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean); } catch { revs = []; }
+  const saves = new Map();
+  for (const e of revs) if (e && typeof e.rev === 'number' && e.path) saves.set(e.path, (saves.get(e.path) || 0) + 1);
+  const abs = path.resolve(root);
+  const docs = [];
+  for (const x of r.reports) {
+    const fm = RN.frontmatter(path.join(abs, x.path));
+    const setup = st.setups.get(x.cadence) || null;
+    const output = fm.output || (setup && setup.output) || null;
+    docs.push({
+      path: x.path, id: `${x.cadence}/${x.slot}`, setup: setup ? setup.id : null,
+      name: setup ? setup.name : (fm.title || x.cadence), slot: x.slot, state: x.issued ? 'issued' : 'draft',
+      source: fm.source || (setup ? setup.source : 'work'), output,
+      made_by: MADE_BY.includes(fm.made_by) ? fm.made_by : (setup ? 'schedule' : 'you'),
+      v: 1 + (saves.get(x.path) || 0), copy: copyOf(linkFor(idx, x.path, output), docSync.copyKindOf(output)),
+    });
+  }
+  return { docs, reports: r.reports };
+}
+
+function setupOut(s, now, docsOf, idx) {
+  const mine = (docsOf.reports || []).filter((x) => x.cadence === s.id);
+  const issued = mine.filter((x) => x.issued).map((x) => x.slot).sort().pop() || null;
+  const latest = mine.slice().sort((a, b) => (a.slot < b.slot ? 1 : -1))[0] || null;
+  let next = null;
+  if (s.status === 'active') { try { const n = RS.nextDraftAt(s.schedule, s.last_run, now); next = n ? n.toISOString() : null; } catch { next = null; } }
+  return {
+    id: s.id, name: s.name, purpose: s.purpose, audience: s.audience, source: s.source, output: s.output, schedule: s.schedule, label: RS.scheduleLabel(s.schedule),
+    next_draft: next, last_issued: issued, status: s.status, cycles: mine.length,
+    copy: copyOf(latest ? linkFor(idx, latest.path, s.output) : null, docSync.copyKindOf(s.output)),
+  };
+}
+
+function finderOut(ctx, st, now) {
+  const last = st.finds.length ? st.finds[st.finds.length - 1] : null;
+  const clock = finderClock() != null ? finderClock() : now;
+  const next = RF.off(process.env) ? null : RF.nextRun(st, clock, { dayEnd: dayEnd(ctx) });
+  return { cadence: st.finder.cadence, sources: { ...st.finder.sources }, last_run: last ? last.start : null, next_run: next == null ? null : new Date(next).toISOString() };
+}
+
+/** A running ask whose run this server no longer holds (the server restarted) is over. */
+function settleStale(file, st, now) {
+  let changed = false;
+  for (const a of st.asks.values()) {
+    if (a.state !== 'running' || runs.has(a.id) || now - Date.parse(a.started) < 90000) continue;
+    RS.askEnd(file, { id: a.id, ok: false, error: 'The run stopped when the workspace restarted. Ask again.' });
+    changed = true;
+  }
+  return changed;
+}
+
+function listAnswer(ctx, w, now) {
+  const file = RS.ledgerFile(w.root);
+  let st = RS.fold(RS.readLines(file));
+  if (settleStale(file, st, now)) st = RS.fold(RS.readLines(file));
+  const docsOf = documentsOf(ctx, w);
+  const idx = copyIndex(w.root);
+  return {
+    setups: [...st.setups.values()].map((s) => setupOut(s, new Date(now), docsOf, idx)),
+    findings: RS.openFindings(st).map((f) => ({ id: f.id, name: f.name, why: f.why, evidence: f.evidence, confidence: f.confidence, proposal: f.proposal })),
+    asks: [...st.asks.values()].map((a) => ({ id: a.id, text: a.text, state: a.state, changed: !!a.changed, proposal: a.proposal, error: a.error })),
+    finder: finderOut(ctx, st, now),
+  };
+}
+
+// ── the report-setup run ─────────────────────────────────────────────────────────────────────────────────
+function askPrompt(skill, ask, extra) {
+  const lines = [`- Ask: ${ask.id}`, `- Today: ${new Date().toISOString().slice(0, 10)}`, `- Request: ${ask.text}`];
+  if (extra && extra.correction) lines.push(`- Correction: ${extra.correction}`, `- Current proposal: ${JSON.stringify(extra.proposal || {})}`);
+  return `${skill}\n\nThis request:\n${lines.join('\n')}\n\nFile ONE proposal with \`pmos report propose --json -\`. Send nothing.\r`;
+}
+
+/** Start (or restart, for a correction) the run of an ask. → { ok } | { ok: false, status, error } */
+function startRun(ctx, w, file, ask, extra) {
+  if (typeof ctx.spawnSession !== 'function') return { ok: false, status: 409, error: 'this workspace cannot start sessions' };
+  const origin = `report-setup:${ask.id}`;
+  if (headless.kindFor({ agent: 'claude', origin }) !== 'report-setup') return { ok: false, status: 409, error: 'Background runs are switched off here (PMOS_HEADLESS=off), so this page cannot start the request.' };
+  const skill = typeof ctx.skillPrompt === 'function' ? ctx.skillPrompt('report-setup', w) : null;
+  if (!skill) return { ok: false, status: 500, error: 'the report-setup skill is not installed' };
+  const s = ctx.spawnSession({ name: 'Report setup', agent: 'claude', ws: w.id, origin, initialInput: askPrompt(skill, ask, extra),
+    extraEnv: { PMOS_REPORT_FILE: file, PMOS_REPORT_RUN: `setup:${ask.id}` },
+    onDone: (r) => {
+      runs.delete(ask.id);
+      const res = (r && r.result) || {};
+      const ok = !!(r && !r.timedOut && !r.stopped && r.code === 0 && res.ok && !res.isError);
+      try { RS.askEnd(file, { id: ask.id, ok, error: ok ? null : (r && r.note) || 'the run failed' }); } catch { /* the next read settles it */ }
+    } });
+  if (!s || s.state === 'exited' || s.headless !== 'report-setup') {
+    if (s && s.headless !== 'report-setup' && s.state !== 'exited' && typeof ctx.stopSession === 'function') { try { ctx.stopSession(s.id); } catch { /* best effort */ } }
+    return { ok: false, status: 409, error: 'The request could not start: ' + ((s && s.note) || 'no background run') };
+  }
+  runs.set(ask.id, s.id);
+  return { ok: true };
+}
+
+// ── the tick ─────────────────────────────────────────────────────────────────────────────────────────────
+let ticking = false;
+/** Migrate, then draft each due dashboard-sourced setup as a document. ctx { getWs, workspaceList, runtimeDir, … }. → [{ id, slot, ok, error? }] */
+async function tick(ctx, now = new Date()) {
+  if (ticking || !ctx || !ctx.runtimeDir) return [];
+  ticking = true;
+  const done = [];
+  try {
+    const list = typeof ctx.workspaceList === 'function' ? ctx.workspaceList() : [ctx.getWs(null)].filter(Boolean);
+    for (const w of list) {
+      if (!w || !w.root) continue;
+      ensureMigrated(ctx, w, now);
+      let st;
+      try { st = RS.stateOf(w.root); } catch { continue; }
+      for (const s of st.setups.values()) {
+        if (s.status !== 'active' || !String(s.source).startsWith('dashboard:')) continue;
+        const sched = RS.scheduleOf(s);
+        if (!logic.isDue(sched, now)) continue;
+        const slotAt = logic.lastSlot(sched, now);
+        if (!slotAt) continue;
+        const slot = RS.localDay(slotAt);
+        if (s.drafted.some((d) => d.slot === slot)) continue;
+        let out;
+        try {
+          const c3 = require('./routes-c3-reports.js');
+          const deps = await c3.depsFor({ ...ctx, getWs: (id) => (id === w.id || id == null ? w : ctx.getWs(id)) }, w.id);
+          const f = c3.frameFor({ key: RS.keyOfSource(s.source), audience: s.audience }, deps, s.name);
+          if (!f.ok) out = f;
+          else {
+            const w2 = RS.writeDocument(w.root, s, slot, RS.frameMarkdown(s, f.F, slot, now), { now });
+            out = w2.ok ? { ok: true } : { ok: false, error: w2.error, existed: w2.status === 409 };
+          }
+        } catch (e) { out = { ok: false, error: String((e && e.message) || e) }; }
+        done.push({ id: s.id, slot, ...out });
+      }
+    }
+  } finally { ticking = false; }
+  return done;
+}
+
+// ── the handler ──────────────────────────────────────────────────────────────────────────────────────────
+function exportAnswer(ctx, res, w, url) {
+  const rel = text(url.searchParams.get('path'));
+  const fmt = text(url.searchParams.get('fmt'));
+  if (fmt === 'pdf') return bad(400, 'PDF is printed by the browser. Use Print in the document.');
+  if (!Object.prototype.hasOwnProperty.call(RX.FORMATS, fmt)) return bad(400, `fmt must be one of ${Object.keys(RX.FORMATS).join(', ')}`);
+  if (!RC.isReportPath(rel)) return bad(400, 'path must be a report document: <state>/reports/<cadence>/<slot>.md');
+  const abs = path.resolve(w.root);
+  const full = path.resolve(abs, rel);
+  if (!full.startsWith(abs + path.sep)) return bad(404, 'outside workspace');
+  let md;
+  try {
+    const real = fs.realpathSync(full);
+    if (!real.startsWith(fs.realpathSync(abs) + path.sep)) return bad(404, 'outside workspace');
+    md = fs.readFileSync(real, 'utf8');
+  } catch { return bad(404, 'no such document'); }
+  const out = RX.exportOf(md, fmt);
+  if (!out.ok) return bad(500, out.error);
+  return { status: 200, file: out };
+}
+
+async function handle(req, res, url, ctx) {
+  const p = url.pathname;
+  const send = (r) => { ctx.json(res, r.body, r.status); return true; };
+  const isDocs = p === '/api/report-documents' || p.startsWith('/api/report-documents/');
+  const isExport = p === '/api/report-export' || p.startsWith('/api/report-export/');
+  const sub = isDocs ? 'documents' : isExport ? 'export' : p.replace(/^\/api\/report-setups\/?/, '');
+
+  if (isDocs || isExport || (sub === '' && req.method === 'GET')) {
+    if (req.method !== 'GET') return send(bad(405, 'GET only'));
+    if ((isDocs && p !== '/api/report-documents') || (isExport && p !== '/api/report-export')) return send(bad(404, 'no such report route'));
+    const w = wsOf(ctx, url.searchParams.get('ws'));
+    if (!w) return send(bad(404, 'no such workspace'));
+    const now = Date.now();
+    ensureMigrated(ctx, w, new Date(now));
+    if (isExport) {
+      const r = exportAnswer(ctx, res, w, url);
+      if (!r.file) return send(r);
+      const f = r.file;
+      res.writeHead(200, { 'Content-Type': f.mime, 'Content-Length': f.buffer.length, 'Content-Disposition': `attachment; filename="${f.name}"`, 'Cache-Control': 'no-store' });
+      res.end(f.buffer);
+      return true;
+    }
+    if (isDocs) return send({ status: 200, body: { docs: documentsOf(ctx, w).docs } });
+    return send({ status: 200, body: listAnswer(ctx, w, now) });
+  }
+  if (!POSTS.includes(sub)) return send(bad(404, 'no such report route'));
+  if (req.method !== 'POST') return send(bad(405, 'POST only'));
+
+  const read = await ctx.readJson(req);
+  if (!read.ok) return send(bad(400, 'the body is not JSON'));
+  const body = read.body || {};
+  if (req.headers && req.headers['x-pmos-session']) return send(bad(403, 'an agent session cannot set up, change or dismiss a report. Only a press on the page does'));
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) return send(bad(g.status, g.error));
+  const w = wsOf(ctx, text(body.ws));
+  if (!w) return send(bad(404, 'no such workspace'));
+  const root = w.root;
+  const file = RS.ledgerFile(root);
+  const opts = { by: g.actor, wsId: w.id, scheduleStore: ctx.scheduleStore };
+  const fail = (r) => send(bad(r.status || 400, r.error));
+
+  if (sub === 'ask') {
+    if (typeof ctx.spawnSession !== 'function' || headless.kindFor({ agent: 'claude', origin: 'report-setup:probe' }) !== 'report-setup') {
+      return send(bad(409, 'Background runs are switched off here (PMOS_HEADLESS=off), so this page cannot start the request.'));
+    }
+    const a = RS.askStart(file, { text: body.text, ws: w.id, by: g.actor });
+    if (!a.ok) return fail(a);
+    const ask = RS.fold(RS.readLines(file)).asks.get(a.id);
+    const s = startRun(ctx, w, file, ask);
+    if (!s.ok) { RS.askCancel(file, { id: a.id, by: g.actor }); return fail(s); }
+    return send({ status: 200, body: { ok: true, id: a.id } });
+  }
+  if (sub === 'change') {
+    const c = RS.askChange(file, { id: text(body.id), text: body.text, by: g.actor });
+    if (!c.ok) return fail(c);
+    const ask = RS.fold(RS.readLines(file)).asks.get(text(body.id));
+    const s = startRun(ctx, w, file, ask, { correction: String(body.text).replace(/\s+/g, ' ').trim(), proposal: c.ask.proposal });
+    if (!s.ok) { RS.askEnd(file, { id: ask.id, ok: false, error: s.error }); return fail(s); }
+    return send({ status: 200, body: { ok: true } });
+  }
+  if (sub === 'cancel') {
+    const id = text(body.id);
+    const r = RS.askCancel(file, { id, by: g.actor });
+    if (!r.ok) return fail(r);
+    const sid = runs.get(id);
+    runs.delete(id);
+    if (sid && typeof ctx.stopSession === 'function') { try { ctx.stopSession(sid); } catch { /* the run ends by itself */ } }
+    return send({ status: 200, body: { ok: true } });
+  }
+  if (sub === 'setup') {
+    const st = RS.fold(RS.readLines(file));
+    let from = null; let base = null;
+    if (body.ask) { const a = st.asks.get(text(body.ask)); if (!a) return send(bad(404, 'no such request')); from = { ask: a.id }; base = a.proposal; }
+    else if (body.finding) { const f = st.findings.get(text(body.finding)); if (!f || f.state !== 'open') return send(bad(404, 'no such finding')); from = { finding: f.id }; base = f.proposal; }
+    const proposal = body.proposal && typeof body.proposal === 'object' && !Array.isArray(body.proposal) ? body.proposal : base;
+    if (!proposal) return send(bad(400, 'say which request or finding to set up, or give the proposal'));
+    const r = RS.setUp(root, { ...proposal, ...(from ? { from } : {}) }, opts);
+    if (!r.ok) return fail(r);
+    const docsOf = { reports: [] };
+    return send({ status: 200, body: { ok: true, setup: setupOut(r.setup, new Date(), docsOf, new Map()), first_draft: r.first_draft } });
+  }
+  if (sub === 'dismiss') {
+    const r = RS.dismissFinding(file, { id: text(body.finding), by: g.actor });
+    if (!r.ok) return fail(r);
+    return send({ status: 200, body: { ok: true } });
+  }
+  if (sub === 'pause' || sub === 'resume') {
+    const r = RS[sub](root, text(body.id), opts);
+    if (!r.ok) return fail(r);
+    return send({ status: 200, body: { ok: true, setup: setupOut(r.setup, new Date(), documentsOf(ctx, w), copyIndex(root)) } });
+  }
+  if (sub === 'from-dashboard') {
+    const key = text(body.key);
+    if (!require('./report-dashboards.js').validKey(key)) return send(bad(400, 'key must be portfolio, board:<id> or initiative:<id>'));
+    const source = `dashboard:${key}`;
+    if ([...RS.fold(RS.readLines(file)).setups.values()].some((s) => s.source === source)) return send(bad(409, 'that dashboard is a recurring report already'));
+    const name = text(body.name).trim() || RS.dashTitle(key);
+    const audience = text(body.audience).trim();
+    const proposal = { name, purpose: `The ${name} dashboard as a report for ${audience || 'its readers'}.`, audience, source, output: text(body.output) || 'pdf',
+      schedule: body.schedule, sources: [`The ${name} dashboard`], sections: RS.FRAME.slice(), learned_from: 'Set up from the dashboard.', fixes: [] };
+    const r = RS.setUp(root, proposal, opts);
+    if (!r.ok) return fail(r);
+    return send({ status: 200, body: { ok: true, setup: setupOut(r.setup, new Date(), { reports: [] }, new Map()) } });
+  }
+  if (sub === 'finder') {
+    const r = RS.setFinder(file, { cadence: body.cadence, sources: body.sources, by: g.actor });
+    if (!r.ok) return fail(r);
+    return send({ status: 200, body: { ok: true, finder: finderOut(ctx, RS.fold(RS.readLines(file)), Date.now()) } });
+  }
+  return send(bad(404, 'no such report route'));
+}
+
+module.exports = { prefixes: ['/api/report-setups', '/api/report-documents', '/api/report-export'], handle, tick, ensureMigrated, documentsOf, listAnswer, copyOf };

package/workspace/lib/schedule-logic.js

@@ -101,7 +101,7 @@ function finishReason(schedule, now = new Date()) {
   return null;
 }
 // Is the schedule due to fire at `now`? Enabled + a slot in (lastRun, now]. For bi-weekly, also
-// require ≥ 13 days since lastRun (weekly slots, fired every other week).
+// require the slot to be ≥ 12.5 days after lastRun (weekly slots, fired every other week).
 function isDue(schedule, now = new Date()) {
   if (!schedule || !schedule.enabled) return false;
   if (finishReason(schedule, now)) return false;
@@ -111,8 +111,11 @@ function isDue(schedule, now = new Date()) {
   if (last && last >= slot) return false;
   // A one-off fires inside its grace window, once; after that it is missed (see isMissed), never caught up.
   if (schedule.cadence === 'once') return !last && (now - slot) <= ONCE_GRACE_MS;
+  // The SLOT must be about two weeks after the last run, not the clock: counting from `now` fired a day early on the second cycle
+  // (13 days after a 09:00:30 fire is a Tuesday 09:00:30, and the newest slot then is the Wednesday before) and drifted a day each cycle.
+  // Half a day of slack lets a slot fire after a run a few minutes late. A slot a week after the last run is far outside it.
   if (schedule.cadence === 'bi-weekly' && last) {
-    if ((now - last) / 86400000 < 13) return false;
+    if ((slot - last) / 86400000 < 12.5) return false;
   }
   return true;
 }

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.179.0",
+  "version": "0.181.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.179.0",
+      "version": "0.181.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

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

package/workspace/public/pm/c3-demo-rep2.js

@@ -43,8 +43,23 @@ function propView(id, p, cur) {
       return { name, kind: !a ? 'added' : !b ? 'removed' : 'changed', before: a ? a.body : '', after: b ? b.body : '', current: c ? c.body : null, stale: a ? !c || c.body !== a.body : !!c }; }) };
 }
 
+/* Report documents (initiative report-workspace): c3-demo-rs.js seeds the markdown of each cycle, its revisions, its open proposals and its checks here, so
+ * the document sheet reads them through the routes below. A path seeded here is answered as written; nothing else about the routes changes. */
+const SEEDED = {};    // path -> the health answer { passed, total, checks }
+export function seedDoc(path, revs, healthAnswer) {
+  DOCS[path] = { revs: revs.map((r, i) => ({ rev: i + 1, v: 'v' + (i + 1), by: r.by || 'claude-code/session', at: r.at || '2026-10-08T08:12:00.000Z', why: r.why || 'Drafted by PMOS', text: r.text, ...(r.via ? { via: r.via, text_by: r.text_by || 'agent' } : {}) })), events: [] };
+  if (healthAnswer) SEEDED[path] = healthAnswer;
+}
+export function seedProposal(id, path, o) {
+  const d = DOCS[path]; const before = d.revs[d.revs.length - 1].text;
+  PROPS[id] = { path, prompt: o.prompt, after: o.after, hash: hashOf(o.after), before, state: o.state || 'proposed', why: o.why || null };
+}
+export function reviseDoc(path, by, why, text) { if (DOCS[path]) push(path, by, why, text); }
+export const docText = (path) => (DOCS[path] ? DOCS[path].revs[DOCS[path].revs.length - 1].text : '');
+
 /* the mockup's docHealth for a report that is still a draft: Fresh passes, Complete does not (a draft), Traced passes, and the claims check. */
 function health(path) {
+  if (SEEDED[path]) return SEEDED[path];
   const R = window.__c3repix; const [fam, rep, aud] = path.slice(PREFIX.length, -3).split('-');
   const stale = fam === 'communications' || !R ? 0 : R.sections(fam, rep, aud).filter((s) => s.st === 'stale').length;
   const C = [{ id: 'fresh', pass: true, reason: 'Updated today' },