create-pmos 0.178.0 → 0.180.0

package/workspace/lib/report-finder.js

@@ -0,0 +1,156 @@
+'use strict';
+/* report-finder.js — the weekly look for the reports a PM already sends (initiative report-workspace, PRD section 4).
+ *
+ *   off(env)                              → true when PMOS_REPORT_FIND=off (or 0, false, no)
+ *   weekStart(ms)                         → the Monday 00:00 (local) of the week that holds `ms`
+ *   dueNow(state, now, { open })          → { ok } | { ok: false, why }       may the run start now?
+ *   nextRun(state, now, { dayEnd })       → ms | null                          when the next run starts (null: off, or no source on)
+ *   findPrompt(skill, run, ctx)           → the prompt of the run
+ *   create(deps) → { tick(opts), active() }
+ *
+ * THE RULE. Weekly means Monday 09:00 on this machine's clock, inside the working hours (lib/driver-run.js dayCheckOpen: the day-check window and
+ * the quiet hours). A run that missed 09:00 starts at the first tick inside the working hours of that Monday. A Monday the server did not run is
+ * not caught up. AT MOST ONE RUN PER WEEK: any run that started this week, whether it ended well or not, ends the week's turn. With every source
+ * off, or the finder set to Off, nothing runs. `PMOS_REPORT_FIND=off` does none of it. The run is headless and never a pane.
+ *
+ * ONE RUN FOR THE MACHINE. The PM's calendar, Slack and mail are the same whichever repository is open, so the run belongs to the HOME workspace
+ * (deps.homeId) and files its findings in that repository's report-setups.jsonl. The run reads (kind report-find, lib/headless.js) and files with
+ * `pmos report propose`; it has no tool that sends, posts or fetches the web. The server gives it PMOS_REPORT_FILE and PMOS_REPORT_RUN, which the
+ * model cannot change, so it files as the find run it is and nothing else.
+ *
+ * deps: { workspaces() → [w], isLead(w), homeId() → id | null, settings() → proactive settings, inQuiet(now, quiet) → bool, headlessOff() → bool, env,
+ *         spawn(spec) → session row, stop(session), promptFor(skillId) → skill body | null, warn(what, err) }
+ * `spawn(spec)` gets { name, ws, origin, initialInput, env, onDone }; it returns the session row ({ id, state, headless, note }).
+ */
+const RS = require('./report-setups.js');
+const driverRun = require('./driver-run.js');
+
+const flagOff = (v) => /^(off|0|false|no)$/i.test(String(v || '').trim());
+const off = (env) => flagOff((env || process.env).PMOS_REPORT_FIND);
+const SLOT = '09:00';
+const oneLine = (s, max) => String(s == null ? '' : s).replace(/\s+/g, ' ').trim().slice(0, max);
+const hhmm = (ms) => { const d = new Date(ms); return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`; };
+const slotMs = (ms) => { const d = new Date(ms); const [h, m] = SLOT.split(':').map(Number); d.setHours(h, m, 0, 0); return d.getTime(); };
+
+/** The Monday 00:00 (local) of the week that holds `ms`. */
+function weekStart(ms) {
+  const d = new Date(ms);
+  d.setHours(0, 0, 0, 0);
+  d.setDate(d.getDate() - ((d.getDay() + 6) % 7));
+  return d.getTime();
+}
+const sourcesOn = (state) => RS.FINDER_SOURCES.filter((k) => state.finder.sources[k]);
+const ranThisWeek = (state, now) => state.finds.some((f) => f.start && Date.parse(f.start) >= weekStart(now));
+const isOpenRun = (state) => state.finds.some((f) => !f.end);
+
+/** May a run start now? `open` is the day-check window and quiet hours as one boolean (lib/driver-run.js dayCheckOpen). */
+function dueNow(state, now, { open = true } = {}) {
+  if (state.finder.cadence === 'off') return { ok: false, why: 'off' };
+  if (!sourcesOn(state).length) return { ok: false, why: 'no-sources' };
+  if (new Date(now).getDay() !== 1) return { ok: false, why: 'not-monday' };
+  if (now < slotMs(now)) return { ok: false, why: 'before-09' };
+  if (!open) return { ok: false, why: 'outside-working-hours' };
+  if (isOpenRun(state)) return { ok: false, why: 'running' };
+  if (ranThisWeek(state, now)) return { ok: false, why: 'done-this-week' };
+  return { ok: true };
+}
+
+/** When the next run starts, in ms, or null. A run that is due now and has not started starts at the next tick, so the answer is `now`. */
+function nextRun(state, now, { dayEnd = '18:00' } = {}) {
+  if (state.finder.cadence === 'off' || !sourcesOn(state).length) return null;
+  const done = ranThisWeek(state, now);
+  for (let k = 0; k < 15; k++) {
+    const d = new Date(now); d.setDate(d.getDate() + k);
+    const day = d.getTime();
+    if (d.getDay() !== 1) continue;
+    if (k === 0) {
+      if (done) continue;
+      if (now < slotMs(day)) return slotMs(day);
+      if (hhmm(now) < dayEnd) return now;
+      continue;
+    }
+    return slotMs(day);
+  }
+  return null;
+}
+
+/** The prompt of the run: the skill, the run id, the sources that are on, and what the run must skip. Nothing of the repository's private text. */
+function findPrompt(skill, run, { sources, setups = [], dismissed = [], now = Date.now() } = {}) {
+  const on = RS.FINDER_SOURCES.filter((k) => sources && sources[k]);
+  const offList = RS.FINDER_SOURCES.filter((k) => !(sources && sources[k]));
+  const list = (a, none) => (a.length ? a.map((x) => `- ${oneLine(x, 120)}`).join('\n') : `- ${none}`);
+  return `${skill}\n\nThis run:\n- Run: ${run}\n- Today: ${new Date(now).toISOString().slice(0, 10)}\n- Sources that are ON (read these only): ${on.join(', ') || 'none'}\n- Sources that are OFF (do not read them): ${offList.join(', ') || 'none'}\n`
+    + `- Reports already set up (do not propose them):\n${list(setups, 'none')}\n- Not a report (the PM said so; skip these patterns and names):\n${list(dismissed, 'none')}\n\n`
+    + 'File each proposal with `pmos report propose --json -`. File at most 5. Send nothing.';
+}
+
+function create(deps) {
+  const active = new Map();   // run id → { w, file, session }
+  const warn = deps.warn || (() => {});
+
+  /** The run ended (or never started): write its find-end line. */
+  function ended(run, file, r, now) {
+    const res = (r && r.result) || {};
+    const ok = !!(r && !r.timedOut && !r.stopped && r.code === 0 && res.ok && !res.isError);
+    try { RS.findEnd(file, { run, ok, error: ok ? null : (r && r.note) || 'the run failed', now }); } catch (e) { warn('report find end', e); }
+    active.delete(run);
+  }
+
+  function start(w, file, state, now) {
+    const skill = deps.promptFor('report-find');
+    const run = RS.findStart(file, { now });
+    active.set(run, { w, file, session: null });
+    if (!skill) { ended(run, file, { code: 1, note: 'the report-find skill is not installed', result: {} }, now); return; }
+    const st = RS.fold(RS.readLines(file));
+    const prompt = findPrompt(skill, run, { sources: st.finder.sources, now,
+      setups: [...st.setups.values()].map((s) => s.name),
+      dismissed: [...st.dismissed.patterns, ...[...st.dismissed.names].map((n) => `name:${n}`)] });
+    let session = null;
+    try {
+      session = deps.spawn({ name: 'Report finder', ws: w.id, origin: `report-find:${run}`, initialInput: prompt + '\r',
+        env: { PMOS_REPORT_FILE: file, PMOS_REPORT_RUN: `find:${run}` }, onDone: (r) => ended(run, file, r) });
+    } catch (e) { warn('report find', e); }
+    if (!session || session.state === 'exited' || session.headless !== 'report-find') {
+      // A start that did not become a headless run (no `claude` on the PATH, a refused model choice, a pane because headless is off) is a failed run.
+      if (session && session.headless !== 'report-find' && session.state !== 'exited' && deps.stop) { try { deps.stop(session); } catch { /* best effort */ } }
+      if (active.has(run)) ended(run, file, { code: 1, note: (session && session.note) || 'the run could not start as a background run', result: {} }, now);
+      return;
+    }
+    const cur = active.get(run);
+    if (cur) cur.session = session.id;
+  }
+
+  function tick({ now = Date.now(), env } = {}) {
+    if (off(env || deps.env)) return { off: true };
+    const summary = { closed: 0, started: 0 };
+    const settings = deps.settings();
+    const home = deps.homeId ? deps.homeId() : null;
+    for (const w of deps.workspaces()) {
+      let lead = false;
+      try { lead = !!deps.isLead(w) && (!home || w.id === home); } catch { lead = false; }
+      if (!lead) continue;
+      let file = null;
+      try { file = RS.ledgerFile(w.root); } catch { file = null; }
+      if (!file) continue;
+      try {
+        let state = RS.fold(RS.readLines(file));
+        // A run that was alive when the server stopped is over.
+        for (const f of state.finds) {
+          if (f.end || active.has(f.run)) continue;
+          RS.findEnd(file, { run: f.run, ok: false, error: 'interrupted: the workspace restarted', now });
+          summary.closed++;
+        }
+        if (deps.headlessOff()) continue;   // the finder never runs in a pane
+        if (active.size) continue;
+        state = RS.fold(RS.readLines(file));
+        const open = driverRun.dayCheckOpen(settings, now, deps.inQuiet);
+        if (dueNow(state, now, { open }).ok) { start(w, file, state, now); summary.started++; break; }
+      } catch (e) { warn('report find tick', e); }
+    }
+    return summary;
+  }
+
+  return { tick, active: () => [...active.keys()] };
+}
+
+module.exports = { create, off, weekStart, dueNow, nextRun, findPrompt, sourcesOn, SLOT };

package/workspace/lib/report-needs.js

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