create-pmos 0.211.0 → 0.212.0

package/workspace/server.js

@@ -79,6 +79,9 @@ const validateLib = require('./lib/validate.js');
 const pageAgent = require('./lib/page-agent.js');   // page-starts-agent — the fixed prompts a page press may start
 const scanRunLib = require('./lib/scan-run.js');   // horizon-scan — the watch list suggest run and the scheduled scans, in the 60-second tick
 const reportFinderLib = require('./lib/report-finder.js');   // report-workspace — the weekly look for the reports the PM already sends
+const refreshLib = require('./lib/refresh.js');        // data-refresh-settings — the sources, their schedules and the refresh log
+const refreshRunLib = require('./lib/refresh-run.js'); // data-refresh-settings — the engine bound to this server (created by the tick below)
+let refreshRun = null;
 const driverRunLib = require('./lib/driver-run.js');   // initiative-driver — wakes, the unblock sweep and the runs, in the 60-second tick
 const headlessLib = require('./lib/headless.js');   // workspace-headless-jobs — which jobs run as `claude -p`, and with which tools
 const liveNotes = require('./lib/live-notes.js');   // jev-live-notes — reads and appends a repository's live-notes ledger; no network
@@ -1945,7 +1948,7 @@ let kitBusy = null;          // workspace-kit-update: the one kit or app update
 const autoSync = require('./lib/auto-sync').createAutoSync({
   roots: () => [...new Set([...workspaces.values()].map((w) => w.root))],
   busy: syncing,
-  onDone: (root) => boardCache.invalidate(root),
+  onDone: (root, out) => { boardCache.invalidate(root); try { if (refreshRun) refreshRun.codeRun('sync', { trigger: 'change', result: out && out.ok ? 'done' : 'failed', got: out && out.ok ? (out.message || 'synced') : null, error: out && !out.ok ? out.message || 'the sync failed' : null }); } catch { /* the log is not the sync's business */ } },
   label: `${os.hostname()} (auto-sync)`,
 });
 // workspace-data-freshness (R2 to R4): the facts cache is kept in the runtime state folder, and ONE change detector per
@@ -1958,7 +1961,13 @@ const freshness = require('./lib/freshness.js').create({
   workspaces: () => [...workspaces.values()],
   schedules: () => readSchedules(),
   factsStatus: (root) => factsAsync.status(root),
-  onChange: (w) => { boardCache.board(w.root, { refreshNow: true }); factsAsync.refresh(w.root); },
+  onChange: (w) => {
+    // data-refresh-settings: the repository source is the rebuild on change; switched off in Data refresh, a change rebuilds nothing.
+    if (refreshRun && !refreshRun.jobGate('repo').ok) return;
+    boardCache.board(w.root, { refreshNow: true }); factsAsync.refresh(w.root);
+    if (refreshRun) refreshRun.codeRun('repo', { trigger: 'change', ws: w.id, got: 'a change in the repository' });
+  },
+  scheduleOf: (skill) => (refreshRun && refreshRun.managedSkill(skill) ? refreshRun.scheduleOfSkill(skill) : undefined),
   pollMs: Math.max(250, Number(process.env.PMOS_FRESH_POLL_MS) || 10000),
   stableMs: Math.max(0, Number(process.env.PMOS_FRESH_STABLE_MS) || 3000),
 });
@@ -2621,7 +2630,62 @@ const coreDocsTick = () => {
       proSettings, inQuiet: (now, quiet) => proactiveLib.inQuietHours(now, quiet), isLead: (w) => isPlanNeedsTree(w) }, Number.isFinite(t) ? { now: t } : {});
   } catch (e) { warnWriteFail('core documents tick', e); }
 };
-try { const _tick = setInterval(() => { checkDueSchedules(); proactiveTick(); try { prepareTick({ manual: false }); } catch { /* the next tick tries again */ } try { dayTick(); } catch (e) { warnWriteFail('day run tick', e); } autoSync.tick().catch(() => {}); dashboardScheduleTick(); driverTick(); scanTick(); reportFinderTick(); coreDocsTick(); reportDesignTick(); }, TICK_MS); if (_tick.unref) _tick.unref(); } catch {}
+// data-refresh-settings: the refresh engine. It starts the skill sources that are due (calendar, Jira, work assigned to you, tracker,
+// the morning brief), writes the refresh log, and gates the job ticks below: a job that is off, or whose input is still running, waits.
+const REFRESH_BOOT = Date.now();
+refreshRun = refreshRunLib.create({
+  stateDir: STATE,
+  now: () => { const t = process.env.PMOS_REFRESH_NOW ? Date.parse(process.env.PMOS_REFRESH_NOW) : NaN; return Number.isFinite(t) ? t + (Date.now() - REFRESH_BOOT) : Date.now(); },
+  homeWs: () => { const h = homeWorkspace(); return h ? h.id : null; },
+  proactive: () => proSettings(),
+  schedules: { read: readSchedules, write: writeSchedules },
+  startSkill: (wsId, skill, name, origin) => startSkillSession(wsId, skill, name, origin),
+  sessionAlive: (id) => { const x = sessions.get(String(id || '')); return !!x && x.state !== 'exited'; },
+  freshRows: (wsIdArg) => { const w = getWs(wsIdArg || ''); return w ? freshness.sources({ id: w.id, root: w.root, repoStateDir: (() => { try { return stateDirFor(w); } catch { return null; } })() }) : []; },
+  copyPaths: (id, wsIdArg) => {
+    const w = getWs(wsIdArg || '');
+    if (id === 'mywork') return [path.join(STATE, 'my-work', 'read.json')];
+    if (id === 'jira' && w) { let d = null; try { d = stateDirFor(w); } catch { d = null; } return d ? [path.join(d, 'tracker', 'jira')] : []; }
+    return [];
+  },
+  tell: ({ source, label, error, ws }) => {
+    const w = getWs(ws || '') || homeWorkspace(); const nf = w ? needsFileFor(w) : null; if (!nf) return;
+    let needs = []; try { needs = JSON.parse(fs.readFileSync(nf, 'utf8')); } catch { needs = []; }
+    needs.push({ run_id: `refresh-${source}-${Date.now()}`, kind: 'refresh', initiative_id: label, question: `${label} could not refresh: ${String(error).slice(0, 300)} See Settings, Data refresh.` });
+    fs.writeFileSync(nf, JSON.stringify(needs)); invalidateNeedsAgg(w.id);
+  },
+  setDayCheckEvery: (every) => {
+    let raw = {}; try { raw = JSON.parse(fs.readFileSync(PRO_SETTINGS(), 'utf8')); } catch { raw = {}; }
+    const cur = proSettings();
+    const n = proactiveLib.normalizeSettings({ ...raw, dayCheck: { ...cur.dayCheck, every: Number(every) } });
+    if (!n.ok) throw new Error(n.error);
+    fs.mkdirSync(STATE, { recursive: true }); fs.writeFileSync(PRO_SETTINGS(), JSON.stringify(n.settings) + '\n');
+  },
+  setRepoWatch: (on) => { for (const w of workspaces.values()) freshness.setEnabled(w.root, on); },
+  jobs: {
+    daycheck: () => {
+      const date = briefLib.localDate(Date.now()); const run = readDayRun(date);
+      if (!run) return { ok: false, error: 'There is no plan for today yet. Press Prepare my day first; the day check reads that plan.' };
+      const c = startDayCheck(run, 'pressed', Date.now());
+      if (!c.ok) return { ok: false, error: c.error };
+      writeDayRun(c.run); return { ok: true, started: 'session', session: c.session };
+    },
+    scan: (wsIdArg) => { const w = getWs(wsIdArg || '') || homeWorkspace(); if (!w) return { ok: false, error: 'no workspace' }; const r = scanner.startNow(w, {}, { by: 'pm' }); return r.ok ? { ok: true } : { ok: false, status: r.status, error: r.error }; },
+    coredocs: () => { let m; try { m = require('./lib/routes-core-docs.js'); } catch { return { ok: false, error: 'core documents are not installed' }; }
+      m.tick({ getWs, stateDirFor, workspaceList: () => [...workspaces.values()], runtimeDir: STATE, selfRoot: EMBEDDED_SELF ? SELF_ROOT : null, initiativeIndex,
+        spawnSession, stopSession: (id) => { const x = sessions.get(String(id || '')); if (x && x.child) stopHeadless(x); }, invalidateNeedsAgg,
+        proSettings, inQuiet: () => false, isLead: (w) => isPlanNeedsTree(w) }, { force: true });
+      return { ok: true }; },
+    driver: () => { const r = driver.tick({ sweepNow: true }); return r && r.off ? { ok: false, error: 'The initiative driver is switched off on this computer.' } : { ok: true }; },
+    finder: () => reportFinder.runNow(),
+    signals: () => { const t0 = Date.now(); const r = proactiveScan({ manual: true }); refreshRun.codeRun('signals', { trigger: 'pressed', took_ms: Date.now() - t0, got: r && r.ok ? `${r.appended || 0} new signals` : null, result: r && r.ok ? 'done' : 'failed', error: r && r.ok ? null : (r && r.error) || 'the scan failed' }); return { ok: true, started: 'done' }; },
+    repo: () => { for (const w of workspaces.values()) { boardCache.board(w.root, { refreshNow: true }); factsAsync.refresh(w.root, { force: true }); } refreshRun.codeRun('repo', { trigger: 'pressed', got: 'board and initiative facts rebuilt' }); return { ok: true, started: 'rebuild' }; },
+    sync: () => { autoSync.tick().then((out) => { const ran = (out || []).filter(Boolean); refreshRun.codeRun('sync', { trigger: 'pressed', result: ran.every((x) => x.ok) ? 'done' : 'failed', got: ran.length ? `${ran.length} repositories synced` : 'nothing to sync', error: ran.filter((x) => !x.ok).map((x) => x.message).join('; ') || null }); }).catch(() => {}); return { ok: true, started: 'sync' }; },
+  },
+  warn: (what, e) => warnWriteFail(what, e),
+});
+const gated = (id, fn) => () => { let g = { ok: true }; try { g = refreshRun.jobGate(id); } catch { g = { ok: true }; } if (g.ok) fn(); };
+try { const _tick = setInterval(() => { checkDueSchedules(); proactiveTick(); try { prepareTick({ manual: false }); } catch { /* the next tick tries again */ } try { dayTick(); } catch (e) { warnWriteFail('day run tick', e); } try { refreshRun.tick(); } catch (e) { warnWriteFail('refresh tick', e); } gated('sync', () => autoSync.tick().catch(() => {}))(); dashboardScheduleTick(); gated('driver', driverTick)(); gated('scan', scanTick)(); gated('finder', reportFinderTick)(); gated('coredocs', coreDocsTick)(); reportDesignTick(); }, TICK_MS); if (_tick.unref) _tick.unref(); } catch {}
 
 // ── Sessions: real PTYs, owned by the server, with disk-backed scrollback + metadata. ──
 /** @type {Map<string, {id,ws,name,agent,cwd,state,note,created,pty,buf,cols,rows,clients:Set}>} */
@@ -3408,6 +3472,7 @@ function attachPty(s, { seed = false } = {}) {
       : `exited (code ${exitCode})`;
     appendBuf(s, `\r\n\x1b[38;5;244m[${s.note}]\x1b[0m\r\n`);
     persist(s); pushSessions();
+    noteSessionEnd(s);
   });
   return p;
 }
@@ -3583,6 +3648,7 @@ function startHeadless(base, workdir, kind, launchArgs, env, initialInput, addDi
     persist(s); pushSessions();
     // page-starts-agent: a caller that started this run from the page reads its result here (a proposal, never a write).
     if (typeof onDone === 'function') { try { onDone({ result: r, code, signal, timedOut, stopped: !!s.stoppedByPm, note: s.note }); } catch (e) { warnWriteFail('headless result', e); } }
+    noteSessionEnd(s);
   });
   child.stdin.on('error', () => {});
   child.stdin.end(prompt);
@@ -3603,7 +3669,15 @@ function killHeadless(child, sig) {
   try { process.kill(-child.pid, sig); } catch { try { child.kill(sig); } catch {} }
 }
 
-function spawnSession({ name, agent, cwd, ws, origin, initialInput, profile, initiative, modelAsk, planItem, workType, autoDelete, launchFlags, addDirs, onDone, scratch, extraEnv, writePaths }) {
+// data-refresh-settings: every session passes the refresh engine on its way out, so a background refresh writes its start line
+// (lib/refresh-run.js started: only an origin it knows is logged). The end is noted where a session exits (noteSessionEnd).
+function spawnSession(opts) {
+  const s = spawnSessionInner(opts);
+  try { if (s && refreshRun) refreshRun.started(s); } catch (e) { warnWriteFail('refresh log (start)', e); }
+  return s;
+}
+function noteSessionEnd(s) { try { if (refreshRun) refreshRun.ended(s); } catch (e) { warnWriteFail('refresh log (end)', e); } }
+function spawnSessionInner({ name, agent, cwd, ws, origin, initialInput, profile, initiative, modelAsk, planItem, workType, autoDelete, launchFlags, addDirs, onDone, scratch, extraEnv, writePaths }) {
   const id = nextSessionId();
   /* pm-os-absorb Run 1 — every AGENT session gets a token, `<id>.<8 hex>`, in its environment as PMOS_SESSION, and
    * PMOS_BIN, this workspace's own bin/pmos.js. `pmos item` run inside it is then attributed `agent:<token>` (the token
@@ -3790,6 +3864,7 @@ function spawnSession({ name, agent, cwd, ws, origin, initialInput, profile, ini
       : `exited (code ${exitCode})`;
     appendBuf(s, `\r\n\x1b[38;5;244m[${s.note}]\x1b[0m\r\n`);
     persist(s); pushSessions();
+    noteSessionEnd(s);
   });
   feed(s);
   persist(s); pushSessions(); pushWorkspaces();
@@ -4345,7 +4420,7 @@ function dayTick() {
   if (a.ok) run = a.run;
   run = startDayTasks(run, now);
   const due = dayRunLib.checkDue(run, { settings: proSettings(), now, events: brief ? brief.calendar || [] : [] });
-  if (due.due) { const c = startDayCheck(run, due.reason, now); if (c.ok) run = c.run; }
+  if (due.due && refreshRun.jobGate('daycheck').ok) { const c = startDayCheck(run, due.reason, now); if (c.ok) run = c.run; }
   run.checks.next = due.next;
   if (JSON.stringify(run) !== before) writeDayRun(run);
 }
@@ -4364,13 +4439,15 @@ function myWorkRead(wsId) {
   return { ok: true, session: s.id };
 }
 /** Refresh now (workspace-data-freshness R7): start skill `skillId` in a session of repository `wsId`, as myWorkRead does. */
-function startSkillSession(wsId, skillId, name) {
+function startSkillSession(wsId, skillId, name, origin) {
   const w = getWs(wsId);
   if (!w) return { ok: false, status: 400, error: 'no workspace' };
   const task = taskById(skillId, w.root);
   if (!task || task.kind !== 'agent' || !task.prompt) return { ok: false, status: 409, error: `the ${skillId} skill is not installed for this repository` };
   const prompt = skillStore.retargetFiling(task.prompt, filingContract(w));
-  const s = spawnSession({ name, agent: task.agent || 'claude', ws: w.id, origin: 'source-refresh', initialInput: prompt + '\r',
+  // data-refresh-settings: a refresh of a source runs as `refresh:<source>`, so the refresh log records it whoever pressed it.
+  const src = refreshLib.SKILL_OF.get(skillId);
+  const s = spawnSession({ name, agent: task.agent || 'claude', ws: w.id, origin: origin || (src ? 'refresh:' + src : 'source-refresh'), initialInput: prompt + '\r',
     modelAsk: { scheduleTier: null, skillTier: task.tier || null, skill: task.skill } });
   if (!s || s.state === 'exited') return { ok: false, status: 500, error: (s && s.note) || 'the refresh session could not start' };
   return { ok: true, session: s.id };
@@ -4593,7 +4670,12 @@ function proactiveTick() {
   const now = Date.now();
   if (now - proLastScan < PRO_SCAN_EVERY_MS) return;
   proLastScan = now;
-  try { proactiveScan({ manual: false }); } catch (e) { warnWriteFail('proactive scan', e); }
+  if (refreshRun.jobGate('signals').ok) {
+    try {
+      const r = proactiveScan({ manual: false });
+      if (r && !r.skipped) refreshRun.codeRun('signals', { trigger: 'schedule', took_ms: Date.now() - now, got: `${r.appended || 0} new signals` });
+    } catch (e) { warnWriteFail('proactive scan', e); refreshRun.codeRun('signals', { trigger: 'schedule', result: 'failed', error: String((e && e.message) || e) }); }
+  }
   try { learnWeekly({ manual: false }); } catch (e) { warnWriteFail('proactive weekly review', e); }
 }
 
@@ -6662,6 +6744,8 @@ async function handleRequest(req, res) {
     const list = readSchedules(); const made = []; const kept = [];
     for (const def of set) {
       if (!taskById(def.skill, w.root)) { kept.push({ skill: def.skill, why: 'the skill is not installed' }); continue; }
+      // data-refresh-settings (R3): a refresh skill is scheduled in Settings › Data refresh. The set turns its source on there.
+      if (refreshRun.managedSkill(def.skill)) { const turned = refreshRun.ensureOn(refreshRun.managedSkill(def.skill), w.id); kept.push({ skill: def.skill, why: turned ? 'turned on in Settings, Data refresh' : 'already on in Settings, Data refresh', refresh: refreshRun.managedSkill(def.skill) }); continue; }
       if (list.some((x) => x.ws === w.id && x.skill === def.skill)) { kept.push({ skill: def.skill, why: 'already scheduled' }); continue; }
       const norm = scheduleLogic.normalizeSchedule({ ...def, task: def.skill });
       if (!norm.ok) { kept.push({ skill: def.skill, why: norm.error }); continue; }
@@ -8384,9 +8468,11 @@ async function handleRequest(req, res) {
       if (!taskById('morning-brief', w.root)) return json(res, { ok: false, error: 'the morning-brief skill is not installed for this repository' }, 409);
       const norm = scheduleLogic.normalizeSchedule({ ...SEED_SETS.brief[0], task: 'morning-brief' });
       if (!norm.ok) return json(res, { ok: false, error: norm.error }, 500);
-      sched = { id: 'sc-' + Date.now().toString(36) + 'g', ws: w.id, ...norm.schedule, profile: null, lastRun: null, lastStatus: null };
-      sched.nextRun = scheduleLogic.nextRun(sched);
+      // data-refresh-settings (R3): the brief's schedule lives in Settings › Data refresh. The entry kept here only carries this run.
+      sched = { id: 'sc-' + Date.now().toString(36) + 'g', ws: w.id, ...norm.schedule, profile: null, lastRun: null, lastStatus: null, enabled: false, endedReason: 'Moved to Settings › Data refresh' };
+      sched.nextRun = null;
       const list = readSchedules(); list.unshift(sched); writeSchedules(list); seeded = true;
+      try { refreshRun.ensureOn('brief', w.id); } catch (e) { warnWriteFail('refresh settings (brief)', e); }
     }
     const result = fireSchedule(sched);
     // A session that could not start is recorded as already ended, so the page says why instead of waiting on a read.
@@ -8634,6 +8720,8 @@ async function handleRequest(req, res) {
       // A brief for a day the PM pressed "Prepare my day": its agent priorities become tasks and start (G13), and a merge
       // closes the check that sent it (G22).
       try { dayAfterBrief(out.date, merged); } catch (e) { warnWriteFail('day run after the brief', e); }
+      // data-refresh-settings: a full brief ends the morning brief's refresh run (its session stays open after it submits).
+      if (body.merge !== true) { try { refreshRun.briefDone(`${(out.items || []).length} items`); } catch (e) { warnWriteFail('refresh log (brief)', e); } }
       return json(res, { ok: true, brief: out, ...(merged ? { merged } : {}), ...(remembered ? { remembered } : {}), ...(memoryError ? { memory_error: memoryError } : {}) });
     }
     if (req.method === 'GET') {
@@ -9082,7 +9170,9 @@ async function handleRequest(req, res) {
     // c3-initiative-boards: the PMOS checkout this server is embedded in, whose default board keeps its derived ladder
     selfRoot: EMBEDDED_SELF ? SELF_ROOT : null,
     // horizon-scan-portfolio: Scan now, Stop and an approved research proposal start and end runs in the scanner; scanClock fixes its clock in the suites
-    scanner, scanClock })) return;
+    scanner, scanClock,
+    // data-refresh-settings: Settings › Data refresh (lib/routes-refresh.js)
+    refreshRun })) return;
   res.writeHead(404); res.end('not found');
 }
 

package/workspace/test-lists/data-refresh-settings.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "initiative data-refresh-settings: the refresh engine (lib/refresh.js) and its routes on a real server (lib/routes-refresh.js, lib/refresh-run.js).",
+  "modules": ["refresh.test.js", "refresh-routes.test.js"],
+  "seconds": { "refresh.test.js": 2, "refresh-routes.test.js": 25 }
+}