create-pmos 0.210.0 → 0.212.0

package/workspace/lib/refresh-run.js

@@ -0,0 +1,300 @@
+'use strict';
+/* refresh-run.js — the refresh engine bound to a running server (initiative data-refresh-settings, PRD R3 to R8, R10).
+ *
+ *   const run = create(host)
+ *   run.tick(now)                       each minute: start the skill sources that are due, write skip lines, end lost runs, prune once a day
+ *   run.started(session) · run.ended(session)   every background session passes here; one with a refresh origin is logged (start, end)
+ *   run.briefDone(got)                  a morning brief arrived: its run is done (the brief session stays open after it submits)
+ *   run.codeRun(id, { result, got, error, took_ms, trigger })   one line pair for a run with no session (signals, repository, Git sync)
+ *   run.jobGate(id, now)                may job `id` run its tick now (off, or an input still running)
+ *   run.runNow(id, { ws, withInputs })  Refresh now; with inputs, the old ones first and this one once they end
+ *   run.rows(ws) · run.setSource(id, patch) · run.setRules(patch) · run.ensureOn(id, ws) · run.settings() · run.log()
+ *
+ * lib/refresh.js decides; this file holds the state between minutes and calls the host. The host is server.js:
+ *   { stateDir, now?, homeWs(), proactive() → { quiet, dayCheck: { start, end, every } }, schedules: { read, write },
+ *     startSkill(wsId, skill, name, origin) → { ok, session?, error? }, jobs: { [id]: (ws) → { ok, error? } },
+ *     freshRows(ws) → [freshness row], copyPaths(id, ws) → [path], tell({ source, label, error, ws }), sessionAlive(id) → bool,
+ *     setDayCheckEvery(every), setRepoWatch(on), warn(what, e) }
+ * Nothing here calls out of this machine: a skill source's run is the PM's own agent session, with the PM's connections.
+ */
+const R = require('./refresh.js');
+
+const PRUNE_EVERY_MS = 24 * 3600 * 1000;
+const LOST_MS = 6 * 3600 * 1000;   // a run with no live session and no end after this long is written as interrupted
+
+function create(host) {
+  const now = () => (host.now ? host.now() : Date.now());
+  const dir = host.stateDir;
+  const warn = (what, e) => { try { if (host.warn) host.warn(what, e); } catch { /* nothing to tell */ } };
+  const expect = new Map();      // source id → { trigger, note, inputs } for the start the engine itself is making now
+  const jobWait = new Map();     // job id → ms it started waiting for an input
+  let lastPrune = 0;
+
+  /* ── settings, with the one-time move of the seed schedules (R3) ── */
+  function settings() {
+    let s = R.readSettings(dir);
+    if (!s.migrated) {
+      try {
+        const m = R.migrate(s, host.schedules.read(), { homeWs: host.homeWs() });
+        if (m.adopted.length) host.schedules.write(m.schedules);
+        R.writeSettings(dir, m.settings);
+        s = R.withDefaults(m.settings);
+      } catch (e) { warn('refresh settings (moving the schedules)', e); }
+    }
+    // The day check's minutes have one home: the proactive settings.
+    const every = String(((host.proactive() || {}).dayCheck || {}).every || '60');
+    s.sources.daycheck.s = { kind: 'every', every: ['30', '60'].includes(every) ? every : '60', work: true };
+    return s;
+  }
+  const win = () => { const d = (host.proactive() || {}).dayCheck || {}; return { start: d.start || '08:00', end: d.end || '18:00' }; };
+  const quiet = () => { const q = (host.proactive() || {}).quiet; return q && q.start && q.end ? q : null; };
+  const log = () => R.foldLog(R.readLog(dir));
+
+  /* ── the state of each source between minutes ── */
+  const openOf = (st) => (st && st.open && typeof st.open === 'object' ? st.open : {});
+  const running = (st) => Object.keys(openOf(st)).length > 0;
+  function inputStateFn(set, state, t) {
+    return (id) => {
+      const x = set.sources[id]; const st = state[id] || {};
+      if (!x || !x.on) return 'off';
+      if (running(st)) return 'running';
+      if (st.waiting_since || st.pending) return 'waiting';
+      const src = R.BY_ID.get(id);
+      if (src && src.run === 'skill') {
+        const slot = R.lastSlot(x.s, t, win());
+        if (slot != null && (st.last_slot == null || slot > st.last_slot) && t - slot < 2 * 3600 * 1000) return 'due';
+      }
+      return 'ok';
+    };
+  }
+  const runningCount = (state) => Object.values(state).reduce((n, st) => n + Object.keys(openOf(st)).length, 0);
+  function snapshot(id, set, state, t) {
+    const src = R.BY_ID.get(id); if (!src || !src.uses.length) return [];
+    const f = log(); const is = inputStateFn(set, state, t);
+    return src.uses.map((u) => { const l = f.lastRun(u); return { id: u, state: is(u), at: l ? (l.end_at || l.start_at) : null, result: l ? l.result : null }; });
+  }
+
+  /* ── a session started or ended ── */
+  const skillOfSchedule = (id) => { try { const x = host.schedules.read().find((y) => y.id === id); return x ? x.skill : null; } catch { return null; } };
+  function started(s) {
+    if (!s) return;
+    const id = R.sourceOfOrigin(s.origin, { skillOfSchedule });
+    if (!id) return;
+    const t = now();
+    const set = settings(); const state = R.readState(dir);
+    const ex = expect.get(id) || {}; expect.delete(id);
+    const st = state[id] || {};
+    const run = R.newRun(id, t);
+    const trigger = ex.trigger || (String(s.origin).startsWith('schedule:') ? 'schedule' : String(s.origin).startsWith('refresh:') ? 'pressed' : 'schedule');
+    const inputs = snapshot(id, set, state, t);
+    state[id] = { ...st, open: { ...openOf(st), [s.id]: { run, at: t, trigger } }, started_at: t, trigger, waiting_since: null, waiting_for: [], pending: null };
+    if (ex.slot != null) state[id].last_slot = ex.slot;
+    R.writeState(dir, state);
+    R.append(dir, { source: id, ws: s.ws || null, ev: 'start', run, trigger, session: s.id, inputs, ...(ex.note ? { note: ex.note } : {}) }, t);
+    if (s.state === 'exited') ended(s);
+  }
+  /** End the open run of session `s`. `over` sets the result for a run whose session has no outcome of its own. */
+  function ended(s, over) {
+    if (!s) return;
+    const state = R.readState(dir);
+    const id = Object.keys(state).find((k) => openOf(state[k])[s.id]);
+    if (!id) return;
+    const t = now();
+    const st = state[id]; const o = openOf(st)[s.id];
+    let result; let got = null; let error = null;
+    if (over) { result = over.result; got = over.got || null; error = over.error || null; }
+    else if (s.outcome) { result = s.outcome.ok ? 'done' : /Stopped by you/.test(s.outcome.why || '') ? 'interrupted' : 'failed'; got = s.outcome.headline || null; error = s.outcome.ok ? null : s.outcome.why; }
+    else if (id === 'brief') { result = 'failed'; error = 'The session ended without submitting a brief' + (s.note ? ` (${s.note})` : '') + '.'; }
+    else { result = /code 0\)$/.test(s.note || '') ? 'done' : 'failed'; error = result === 'failed' ? s.note || 'the session ended' : null; }
+    const rest = { ...openOf(st) }; delete rest[s.id];
+    const rules = settings().rules;
+    let copy = null;
+    const src = R.BY_ID.get(id);
+    if (result === 'done' && src && src.copy) { try { copy = R.keepCopy(dir, id, host.copyPaths(id, s.ws), t); } catch (e) { warn('refresh copy', e); } }
+    const next = { ...st, open: rest, last_end: t, last_result: result };
+    if (result === 'done') { next.retry_at = null; next.retried = false; }
+    const scheduled = ['schedule', 'catch-up', 'retry'].includes(o.trigger);
+    if (result === 'failed' && scheduled && src && src.run === 'skill' && rules.retry !== 'no' && !st.retried) { next.retry_at = t + Number(rules.retry) * 60000; next.retried = true; }
+    else if (result === 'failed' && o.trigger === 'retry') next.retry_at = null;
+    state[id] = next;
+    R.writeState(dir, state);
+    R.append(dir, { source: id, ws: s.ws || null, ev: 'end', run: o.run, result, took_ms: t - o.at, got, error, ...(copy ? { copy } : {}) }, t);
+    if (result === 'failed' && scheduled && rules.tell === 'brief' && !next.retry_at) {
+      try { host.tell({ source: id, label: src ? src.label : id, error: error || 'it failed', ws: s.ws || null }); } catch (e) { warn('refresh failure note', e); }
+    }
+  }
+  /** The morning brief arrived: the brief run that is open is done. */
+  function briefDone(got) {
+    const state = R.readState(dir); const st = state.brief;
+    for (const sid of Object.keys(openOf(st))) ended({ id: sid, ws: null }, { result: 'done', got: got || 'Briefing saved' });
+  }
+  /** A run with no session: one start line and one end line (signals, the repository rebuild, Git sync). */
+  function codeRun(id, { result = 'done', got = null, error = null, took_ms = null, trigger = 'change', ws = null } = {}) {
+    if (!R.BY_ID.has(id)) return;
+    const t = now(); const run = R.newRun(id, t);
+    const ex = expect.get(id); if (ex) { trigger = ex.trigger || trigger; expect.delete(id); }
+    R.append(dir, { source: id, ws, ev: 'start', run, trigger }, took_ms != null ? t - took_ms : t);
+    R.append(dir, { source: id, ws, ev: 'end', run, result, took_ms, got, error }, t);
+  }
+
+  /* ── the tick ── */
+  function tick(t = now()) {
+    const set = settings(); const state = R.readState(dir); const rules = set.rules;
+    let changed = false;
+    // A run whose session is gone with no end (the server restarted under it) is written as interrupted.
+    for (const [id, st] of Object.entries(state)) {
+      for (const [sid, o] of Object.entries(openOf(st))) {
+        let alive = true; try { alive = host.sessionAlive(sid); } catch { alive = true; }
+        if (!alive || t - o.at > LOST_MS) {
+          delete st.open[sid]; st.retry_at = null; changed = true;
+          R.append(dir, { source: id, ev: 'end', run: o.run, result: 'interrupted', took_ms: t - o.at, error: alive ? 'no end after 6 hours' : 'the session was gone (PMOS restarted, or the session was closed)' }, t);
+        }
+      }
+    }
+    if (changed) R.writeState(dir, state);
+    const first = !tick.seen; tick.seen = true;
+    for (const src of R.SOURCES.filter((x) => x.run === 'skill')) {
+      const cur = R.readState(dir);
+      const st = { ...(cur[src.id] || {}), running: running(cur[src.id]) };
+      const d = R.decide(src, st, { now: t, settings: set, rules, win: win(), quiet: quiet(), runningCount: runningCount(cur), inputState: inputStateFn(set, cur, t), first });
+      if (d.act === 'none') continue;
+      const ws = (set.sources[src.id] && set.sources[src.id].ws) || (st.pending && st.pending.ws) || host.homeWs();
+      if (d.act === 'skip') {
+        cur[src.id] = { ...(cur[src.id] || {}), last_slot: d.slot };
+        R.writeState(dir, cur);
+        if (!d.quiet) R.append(dir, { source: src.id, ws, ev: 'skip', trigger: 'schedule', note: d.why }, t);
+        continue;
+      }
+      if (d.act === 'wait') {
+        const x = cur[src.id] || {};
+        if (!x.waiting_since || JSON.stringify(x.waiting_for || []) !== JSON.stringify(d.waiting || [])) {
+          cur[src.id] = { ...x, waiting_since: x.waiting_since || t, waiting_for: d.waiting || [], waiting_why: d.why || null };
+          R.writeState(dir, cur);
+        }
+        continue;
+      }
+      start(src, ws, { trigger: d.trigger, slot: d.slot, note: d.note });
+    }
+    if (t - lastPrune > PRUNE_EVERY_MS) {
+      lastPrune = t;
+      try { const p = R.prune(dir, rules.keep, t); if (p.lines || p.copies) warn('refresh log', { message: `removed ${p.lines} lines and ${p.copies} copies older than ${rules.keep} days` }); } catch (e) { warn('refresh log prune', e); }
+    }
+  }
+  function start(src, ws, { trigger, slot, note }) {
+    expect.set(src.id, { trigger, slot, note });
+    let r;
+    try { r = host.startSkill(ws, src.skill, `${src.label} · refresh`, 'refresh:' + src.id); } catch (e) { r = { ok: false, error: String((e && e.message) || e) }; }
+    if (expect.has(src.id)) {
+      // Nothing started (no session was made): write it as a failed run so it shows, and keep the slot so it is not tried every minute.
+      expect.delete(src.id);
+      const t = now(); const run = R.newRun(src.id, t); const cur = R.readState(dir);
+      cur[src.id] = { ...(cur[src.id] || {}), last_slot: slot != null ? slot : (cur[src.id] || {}).last_slot, waiting_since: null, waiting_for: [], pending: null, last_result: 'failed' };
+      R.writeState(dir, cur);
+      R.append(dir, { source: src.id, ws, ev: 'start', run, trigger }, t);
+      R.append(dir, { source: src.id, ws, ev: 'end', run, result: 'failed', took_ms: 0, error: (r && r.error) || 'could not start' }, t);
+    }
+    return r || { ok: false, error: 'could not start' };
+  }
+
+  /* ── job gates ── */
+  function jobGate(id, t = now()) {
+    const set = settings(); const state = R.readState(dir);
+    const g = R.jobGate(id, { now: t, settings: set, inputState: inputStateFn(set, state, t), waitingSince: jobWait.get(id) || null });
+    if (g.ok) { const w0 = jobWait.get(id); jobWait.delete(id); if (w0 && t - w0 >= R.WAIT_MS) expect.set(id, { trigger: 'schedule', note: 'Waited 30 min for its inputs, then ran without them' }); }
+    else if (g.why === 'waiting' && !jobWait.has(id)) jobWait.set(id, t);
+    return g;
+  }
+
+  /* ── presses ── */
+  function runNow(id, { ws, withInputs } = {}) {
+    const src = R.BY_ID.get(id);
+    if (!src) return { ok: false, status: 400, error: 'source must be one of ' + R.SOURCES.map((x) => x.id).join(', ') };
+    const set = settings(); const t = now();
+    const startedInputs = [];
+    if (withInputs) {
+      const rows = rowsFor(ws, set, t);
+      const me = rows.find((r) => r.id === id);
+      for (const inp of me ? me.built_on : []) {
+        if (inp.state === 'off') continue;
+        const r = runNow(inp.id, { ws });
+        if (r.ok) startedInputs.push(inp.id);
+      }
+    }
+    if (src.run === 'skill') {
+      const state = R.readState(dir);
+      if (running(state[id])) return { ok: false, status: 409, error: `${src.label} is already refreshing` };
+      const busy = src.uses.filter((u) => ['running', 'waiting', 'due'].includes(inputStateFn(set, state, t)(u)));
+      if (busy.length) {
+        state[id] = { ...(state[id] || {}), pending: { trigger: 'pressed', at: t, ws: ws || null }, waiting_since: t, waiting_for: busy };
+        R.writeState(dir, state);
+        return { ok: true, source: id, waiting: busy, inputs: startedInputs };
+      }
+      const r = start(src, ws || (set.sources[id] && set.sources[id].ws) || host.homeWs(), { trigger: 'pressed' });
+      return r.ok ? { ok: true, source: id, started: 'session', session: r.session, inputs: startedInputs } : { ok: false, status: r.status || 500, error: r.error };
+    }
+    const job = host.jobs && host.jobs[id];
+    if (!job) return { ok: false, status: 409, error: `${src.label} cannot be started from here` };
+    expect.set(id, { trigger: 'pressed' });
+    let r; try { r = job(ws); } catch (e) { r = { ok: false, error: String((e && e.message) || e) }; }
+    if (!r || !r.ok) { expect.delete(id); return { ok: false, status: (r && r.status) || 409, error: (r && r.error) || 'it could not start' }; }
+    return { ok: true, source: id, started: r.started || 'job', ...(r.session ? { session: r.session } : {}), inputs: startedInputs };
+  }
+  function setSource(id, patch) {
+    const src = R.BY_ID.get(id);
+    if (!src) return { ok: false, error: 'source must be one of ' + R.SOURCES.map((x) => x.id).join(', ') };
+    if (patch.on !== undefined && typeof patch.on !== 'boolean') return { ok: false, error: 'on must be true or false' };
+    let norm = null;
+    if (patch.schedule !== undefined) { norm = R.normalize(src, patch.schedule); if (!norm.ok) return norm; }
+    if (patch.on === undefined && !norm) return { ok: false, error: 'give on, schedule or both' };
+    const set = R.readSettings(dir);
+    const cur = set.sources[id];
+    if (typeof patch.on === 'boolean') cur.on = patch.on;
+    if (norm && id === 'daycheck') { try { host.setDayCheckEvery(norm.s.every); } catch (e) { return { ok: false, error: 'the day check could not be saved' }; } }
+    else if (norm) cur.s = norm.s;
+    if (id === 'repo' && typeof patch.on === 'boolean') { try { host.setRepoWatch(patch.on); } catch (e) { warn('repository watch', e); } }
+    R.writeSettings(dir, set);
+    // A schedule change starts the clock from now: a slot that passed before the change is not run late.
+    if (norm && id !== 'daycheck') { const st = R.readState(dir); const sl = R.lastSlot(norm.s, now(), win()); st[id] = { ...(st[id] || {}), last_slot: sl, retry_at: null }; R.writeState(dir, st); }
+    if (patch.on === true && src.run === 'skill') { const st = R.readState(dir); const sl = R.lastSlot(cur.s, now(), win()); st[id] = { ...(st[id] || {}), last_slot: sl }; R.writeState(dir, st); }
+    return { ok: true, source: id };
+  }
+  function setRules(patch) {
+    const n = R.normalizeRules(patch); if (!n.ok) return n;
+    const set = R.readSettings(dir); set.rules = { ...set.rules, ...n.patch }; R.writeSettings(dir, set);
+    return { ok: true, rules: set.rules };
+  }
+  /** A seed set or Prepare my day asked for a managed skill: turn its source on instead of adding a schedule (R3). */
+  function ensureOn(id, ws) {
+    const set = R.readSettings(dir); const cur = set.sources[id]; if (!cur) return false;
+    const was = cur.on; cur.on = true; if (ws && !cur.ws) cur.ws = ws;
+    set.migrated = true;
+    R.writeSettings(dir, set);
+    if (!was) { const st = R.readState(dir); st[id] = { ...(st[id] || {}), last_slot: R.lastSlot(cur.s, now(), win()) }; R.writeState(dir, st); }
+    return !was;
+  }
+
+  /* ── rows ── */
+  const FRESH_OF = { 'my-work': 'my-work', calendar: 'calendar', jira: 'jira', tracker: 'tracker', initiatives: 'initiatives' };
+  function rowsFor(ws, set, t) {
+    const state = R.readState(dir);
+    const view = {};
+    for (const [k, v] of Object.entries(state)) view[k] = { ...v, running: running(v) };
+    let fr = []; try { fr = host.freshRows(ws) || []; } catch { fr = []; }
+    const fresh = new Map(fr.filter((x) => FRESH_OF[x.id]).map((x) => [x.id, x]));
+    return R.rowsOf({ now: t, settings: set, state: view, log: log(), fresh, win: win(), quiet: quiet(), jobSchedule: host.jobSchedule || null, ws });
+  }
+  function rows(ws) { const set = settings(); return { rules: set.rules, quiet: quiet(), window: win(), rows: rowsFor(ws, set, now()) }; }
+  /** What lib/freshness.js shows as a skill's schedule, now that the schedule lives here. */
+  function scheduleOfSkill(skill) {
+    const id = R.SKILL_OF.get(skill); if (!id) return null;
+    const set = settings(); const x = set.sources[id]; const st = R.readState(dir)[id] || {};
+    const l = log().lastRun(id);
+    const next = x.on ? R.nextSlot(x.s, now(), win()) : null;
+    return { cadence: x.on ? R.textOf(x.s) : 'off', time: null, day: null, next_run: next ? new Date(next).toISOString() : null,
+      last_run: l ? l.start_at : null, last_status: l ? (l.result === 'failed' ? 'fail' : l.result === 'done' ? 'ok' : 'started') : st.last_result || null };
+  }
+
+  return { tick, started, ended, briefDone, codeRun, jobGate, runNow, setSource, setRules, ensureOn, rows, settings, log, scheduleOfSkill, managedSkill: (skill) => R.SKILL_OF.get(skill) || null };
+}
+
+module.exports = { create };