create-pmos 0.210.0 → 0.212.0

package/workspace/public/pm/c3-shell.js

@@ -15,29 +15,18 @@ import { row, button } from './primitives.js';
 import { pmGet } from './http.js';
 import { ensureC3Css, c3ic, c3Phone, mountPmWork } from './pm-work-view.js';
 import { mountBriefing, showCard, flipBack } from './briefing-deck.js';
-import { mountCalendarViews } from './calendar-views.js';
 import { todaySection } from './c3-brief-today.js';
 import { needsSection, needsCount } from './c3-brief-needs.js';
 import { scanSection } from './c3-scan.js';
 import { reportFoundSection } from './c3-report-store.js';
 import { pulse } from './c3-brief-pulse.js';
 import { loadBriefPage, onBriefPage } from './c3-brief-data.js';
-import { mountLifecycle } from './lifecycle-lens.js';
-import { mountForecast } from './timeline-forecast-view.js';
-import { mountReleases } from './releases-view.js';
-import { mountReports, showReportsView } from './c3-reports.js';
 import { createDock } from './c3-dock.js';
 import { reviewSection, footLine, rowApi, BX, toast, setNeedsTitle, hooks as briefHooks } from './c3-brief.js';
 import { openSheet } from './c3-sheet.js';
 import { mountCalPopupTrigger } from './c3-calpop.js';
-import { planNode, dueCard, crossLinks, newInitLine } from './c3-plan.js';
-import { initiativesViewCtx } from './registry.js';
-import { mount as mountRoadmap } from './c3-roadmap.js';
-import { mount as mountBreakdown } from './c3-breakdown.js';
+import { planNode } from './c3-plan.js';
 import { ic } from './c3-terminal-icons.js';
-import { mount as mountTickets, badge as ticketsBadge } from './c3-tickets.js';
-import { mount as mountDocs, badge as docsBadge } from './c3-docs.js';
-import { mount as mountSignals, badge as signalsBadge } from './c3-signals.js';
 import { mountDaypart } from './c3-daypart.js';
 import { mountAmbient } from './c3-ambient.js';
 import { mountTicker } from './shell-ticker.js';
@@ -45,20 +34,12 @@ import { mountBell, openBellList } from './shell-bell.js';
 import { onBriefing, loadBriefing } from './shell-ticker.js';
 import { registry, filterPalette, rowStep } from './briefing-model.js';
 import { freshnessLine } from './freshness-line.js';
-import { mountInitiatives } from './c3-initiatives.js';
-import { mountSettings, gearIcon, applyLook } from './c3-settings.js';
+import { gearIcon, applyLook } from './c3-look.js';
 import { mountQuiet } from './c3-quiet.js';
-import { mountPhone, phoneWanted } from './c3-phone.js';
 
 /* In demo mode each tab's deck asks for its own cards (the mockup draws a different deck per tab); real mode sends no scope. Reports always sends its own (repTab). */
 const sc = (name) => (DEMO ? name : undefined);
 const TABS = [['brief', 'Briefing', 'sun'], ['cal', 'Calendar', 'cal'], ['work', 'Work', 'todo'], ['init', 'Initiatives', 'init'], ['rep', 'Reports', 'report']];
-/* The mockup's eight Initiatives views, in its order: Lifecycle, Roadmap, Breakdown, Timeline (= Forecast), Tickets, Releases, Documents, Signals. */
-const INITS = [['lifecycle', 'Lifecycle', mountLifecycle, 'init'], ['roadmap', 'Roadmap', mountRoadmap, 'flag'], ['breakdown', 'Breakdown', mountBreakdown, 'tree'], ['forecast', 'Timeline', mountForecast, 'cal'],
-  ['tickets', 'Tickets', mountTickets, 'check'], ['releases', 'Releases', mountReleases, 'out'], ['documents', 'Documents', mountDocs, 'doc'], ['signals', 'Signals', mountSignals, 'alert']];
-/* The five views of this page's own (c3-roadmap.js ... c3-signals.js) draw the Plan lens in their own left column, as Lifecycle does. A view with a `badge` gets a count on its button. */
-const OWN = new Set(['roadmap', 'breakdown', 'tickets', 'documents', 'signals']);
-const BADGES = { tickets: ticketsBadge, documents: docsBadge, signals: signalsBadge };
 const THEME_KEY = 'pmos.c3.theme';
 const q = new URLSearchParams(location.search);
 const store = { get(k) { try { return localStorage.getItem(k); } catch { return null; } }, set(k, v) { try { localStorage.setItem(k, v); } catch { /* no storage */ } } };
@@ -66,7 +47,7 @@ const DEMO = q.get('demo') === '1';   // demo mode: c3-demo.js answers the page'
 /* The dock's open or folded choice, kept on this device. No choice yet: folded. */
 const dockPref = () => store.get('pmos.c3.dock') === 'open';
 const keepDock = () => store.set('pmos.c3.dock', S.dockOpen ? 'open' : 'folded');
-const S = { demo: DEMO, ws: q.get('ws') || '', workspaces: [], tab: 'brief', theme: 'light', panes: {}, mounted: {}, init: 'lifecycle', initRows: null, dockOpen: true, wide: true };
+const S = { demo: DEMO, ws: q.get('ws') || '', workspaces: [], tab: 'brief', theme: 'light', panes: {}, mounted: {}, dockOpen: true, wide: true };
 
 /* A view reads a route with no ws and the server answers for its home workspace. This page names one, so a GET to /api/ with no ws gets it. */
 function withWs() {
@@ -152,12 +133,15 @@ function toggleMore() {
 }
 /* The phone companion (c3-phone.js): at 640px or less it fills the page and the desktop grid is hidden. There is no Full console:
  * the old choice (pmos.c3.phone = 'desk', stored before 2026-10-13) is cleared so no phone stays on the desktop pages. */
+/* as c3-phone.js phoneWanted, without loading that module on a desktop */
+const phoneWanted = () => typeof matchMedia === 'function' && matchMedia('(max-width:640px)').matches && store.get('pmos.c3.testDesk') !== 'desk';
 function syncPhone() {
   if (store.get('pmos.c3.phone')) store.set('pmos.c3.phone', '');
-  const want = phoneWanted(store);
+  const want = phoneWanted();
   if (want && !S.phone) {
     S.root.classList.add('c3-phone-on');
-    S.phone = mountPhone(S.root, { ws: S.ws, demo: S.demo });
+    const p = S.phone = { dispose: () => { p.gone = true; } };   // the companion's code loads first (c3-phone.js); narrowing back before it lands cancels it
+    import('./c3-phone.js').then((m) => { if (p.gone || S.phone !== p) return; S.phone = m.mountPhone(S.root, { ws: S.ws, demo: S.demo }); }).catch(() => { if (S.phone === p) { S.phone = null; S.root.classList.remove('c3-phone-on'); } });
   } else if (!want && S.phone) {
     S.phone.dispose(); S.phone = null;
     S.root.classList.remove('c3-phone-on');
@@ -319,12 +303,12 @@ function lensChanged(l) {
 if (typeof window !== 'undefined') window.addEventListener('pmos:go-tab', (e) => {
   const d = (e && e.detail) || {}; if (!d.tab) return;
   showTab(d.tab, true);
-  if (d.tab === 'settings' && d.section && S.settings) S.settings.show(d.section);
-  if (d.tab === 'rep' && d.view) showReportsView(d.view);
+  if (d.tab === 'settings' && d.section) settingsReady().then((st) => st.show(d.section), () => {});
+  if (d.tab === 'rep' && d.view) reportsView(d.view);
 });
 function goTarget(t) {
   /* a dashboard schedule's notice (routes-briefing.js notices): Reports, then its Drafts tab */
-  if (t && t.tab && BUILD[t.tab]) { showTab(t.tab, true); if (t.tab === 'rep' && t.view) showReportsView(t.view); return; }
+  if (t && t.tab && BUILD[t.tab]) { showTab(t.tab, true); if (t.tab === 'rep' && t.view) reportsView(t.view); return; }
   showTab('brief', true);
   if (!t) return;
   if (t.card !== undefined && t.card !== null) { showCard(S.deckHost, t.card); return; }
@@ -363,7 +347,7 @@ function paletteItems() {
     ...TABS.map(([id, label, icon]) => ({ label, kind: 'place', icon, run: () => showTab(id, true) })),
     { label: 'Settings', kind: 'place', icon: 'shield', run: () => showTab('settings', true) }];
   for (const k of Object.keys(registry('people') || {})) { const p = registry('people')[k]; items.push({ label: p.n + ' · ' + p.role, kind: 'person', icon: 'user', run: () => openPerson(k) }); }
-  for (const d of registry('docs') || []) items.push({ label: d.n, kind: 'document', icon: d.icon || 'doc', run: () => { showTab('init', true); const b = S.initSeg && S.initSeg.querySelector('[data-c3-init="documents"]'); if (b) b.click(); } });
+  for (const d of registry('docs') || []) items.push({ label: d.n, kind: 'document', icon: d.icon || 'doc', run: () => showTab('init', true) });
   for (const x of S.palSessions || []) items.push({ label: (x.branch || x.tree || '') ? ((x.branch || String(x.tree).split('/').pop()) + ' · ' + x.name) : x.name, kind: 'session', icon: 'branch', run: () => openSession(x) });
   return items;
 }
@@ -457,78 +441,44 @@ function dock() {
 }
 /* The dock is open on the Briefing and folded away on the other tabs. A folded dock leaves no rail (PM, 2026-10-12): the header's Sessions button, Ctrl J and the More menu reach it. */
 function syncDock() {
+  const opening = S.dockEl.hidden && S.dockOpen;
   S.dockEl.hidden = !S.dockOpen;
+  if (opening && S.dockStarted) S.dock.refresh();   // a folded dock reads only the runs; opening it reads the tree (c3-dock.js refresh)
 }
 
 /* ── the other tabs ── */
-function initTab(pane) {
-  S.initSeg = el('div', { class: 'seg', role: 'group', 'aria-label': 'Initiatives views', 'data-c3pg': 'init-switch', style: 'overflow-x:auto;max-width:100%' });
-  S.initHosts = {};
-  const ws = () => S.workspaces.find((w) => w.id === S.ws) || {};
-  const reload = () => { S.initRows = null; S.mounted = Object.fromEntries(Object.entries(S.mounted).filter(([k]) => !k.startsWith('init-'))); loadInitRows().then(() => showInit(S.init)); };
-  const add = newInitLine({ get repo() { return ws().root || null; }, ws: S.ws, get rows() { return (S.initRows && S.initRows.rows) || []; }, onAdded: reload });
-  const bar = el('div', { class: 'calbar' }, S.initSeg);
-  const body = el('div', { class: 'c3pg-initbody' });
-  for (const [id] of INITS) { S.initHosts[id] = el('div', { 'data-in-host': id, hidden: true }); body.append(S.initHosts[id]); }
-  pane.append(add, bar, body);
-  S.initNote = el('p', { class: 'dim mono', style: 'font-size:var(--fs-2)', role: 'status', 'data-c3pg': 'init-note' }, 'Reading the repository');
-  body.prepend(S.initNote);
-  drawInitSwitch();
-  loadInitRows().then(() => { showInit(S.init); loadBadges(); });
-}
-/* The counts on the sub-view buttons: each view's own `badge(ctx)` (a number, or null when it cannot say). */
-function loadBadges() {
-  const ws = S.workspaces.find((w) => w.id === S.ws) || {};
-  const ctx = { repo: ws.root || null, ws: S.ws, rows: (S.initRows && S.initRows.rows) || [] };
-  S.badges = S.badges || {};
-  for (const [id, fn] of Object.entries(BADGES)) Promise.resolve().then(() => fn(ctx)).then((n) => { S.badges[id] = Number(n) || 0; drawInitSwitch(); }, () => { /* no count */ });
-}
-function drawInitSwitch() {
-  S.initSeg.replaceChildren(...INITS.map(([id, label, mount, icon]) => {
-    const n = S.badges && S.badges[id];
-    return el('button', { type: 'button', 'aria-pressed': String(S.init === id), 'data-c3-init': id, onclick: () => showInit(id) }, c3ic(icon, 'sm'), label, n ? [' ', el('span', { class: 'bdg', 'data-c3-init-badge': id }, String(n))] : null);
-  }));
-}
-/* The roadmap read answers { pending } while the repository is still being read. Ask again until it has rows, and say so meanwhile. */
-async function loadInitRows() {
-  for (let n = 0; n < 40; n++) {
-    const r = await pmGet('/api/initiatives?ws=' + encodeURIComponent(S.ws) + '&view=roadmap');
-    if (r && r.horizons) {
-      S.initRows = { rows: [...(r.horizons.now || []), ...(r.horizons.next || []), ...(r.horizons.later || []), ...(r.dormant || [])], sig: r.sig || null, strategy: r.strategy || null };
-      S.initNote.hidden = true;
-      return;
-    }
-    if (!(r && r.pending)) {
-      S.initRows = { rows: [], sig: null };
-      S.initNote.hidden = false;
-      S.initNote.textContent = 'The initiatives could not be read' + (r && r.error ? ': ' + r.error : '.');
-      return;
-    }
-    S.initNote.hidden = false; S.initNote.textContent = 'Reading the repository';
-    await new Promise((res) => setTimeout(res, 4000));
-  }
-  S.initRows = { rows: [], sig: null };
-  S.initNote.textContent = 'The repository is taking long to read. Reload in a moment for the initiatives.';
-}
-function showInit(id) {
-  S.init = id; drawInitSwitch();
-  const ws = S.workspaces.find((w) => w.id === S.ws) || {};
-  for (const [k, , mount] of INITS) {
-    if (!mount) continue;
-    S.initHosts[k].hidden = k !== id;
-    if (k === id && !S.mounted['init-' + k] && S.initRows) {
-      S.mounted['init-' + k] = true;
-      const ctx = { ...initiativesViewCtx({ repo: ws.root || null, ws: S.ws, rows: S.initRows.rows, sig: S.initRows.sig, openInitiative: () => location.assign('/classic.html'), setState: () => {} }), strategy: S.initRows.strategy, plan: planNode(sc(OWN.has(k) ? 'init-' + k : 'init')), links: crossLinks((t) => showTab(t, true)) };
-      if (k === 'lifecycle' || OWN.has(k)) mount(S.initHosts[k], Object.freeze(ctx));
-      else { const view = el('div'); S.initHosts[k].replaceChildren(ctx.plan, view); mount(view, Object.freeze({ ...ctx, plan: null })); }
-    }
-  }
-}
 /* Reports: the headline deck on top (the Plan deck of the Reports scope), then the three tabs (Dashboards, Reports, Charts; c3-reports.js).
  * The Reports deck always names its scope, so real mode gets the engine's report signals and never the Briefing's cards (console3-deck-flow-fixes). */
-function repTab(pane) { mountReports(pane, { ws: S.ws, pmGet, deck: (h) => h.append(planNode('rep')) }); }
+function repTab(pane) { return import('./c3-reports.js').then((m) => m.mountReports(pane, { ws: S.ws, pmGet, deck: (h) => h.append(planNode('rep')) })); }
+/* Reports opens on a view (Drafts, a dashboard). Before the tab has loaded, c3-reports.js keeps the view and opens on it. */
+const reportsView = (v) => import('./c3-reports.js').then((m) => m.showReportsView(v));
 
-const BUILD = { brief: briefTab, cal: (p) => mountCalendarViews(p, { view: 'week', page: true, scope: sc('cal'), deck: planNode('cal', { bare: true }) }), work: (p) => { mountPmWork(p, { go: (t) => showTab(t, true), ws: S.ws }); }, init: (p) => mountInitiatives(p, { ws: S.ws, workspaces: S.workspaces, demo: DEMO, showTab }), rep: repTab };
+/* Each tab's code loads the first time the tab is shown (c3-desktop-light-load): the page starts with the Briefing's modules only.
+ * The Work tab's module (pm-work-view.js) is already loaded for the console's shared helpers. */
+const BUILD = { brief: briefTab,
+  cal: (p) => import('./calendar-views.js').then((m) => m.mountCalendarViews(p, { view: 'week', page: true, scope: sc('cal'), deck: planNode('cal', { bare: true }) })),
+  work: (p) => { mountPmWork(p, { go: (t) => showTab(t, true), ws: S.ws }); },
+  init: (p) => import('./c3-initiatives.js').then((m) => m.mountInitiatives(p, { ws: S.ws, workspaces: S.workspaces, demo: DEMO, showTab })),
+  rep: repTab };
+/* A tab whose code could not load says so in its pane, and the next press tries again. */
+function build(id) {
+  S.mounted[id] = Promise.resolve().then(() => BUILD[id](S.panes[id])).catch((e) => {
+    delete S.mounted[id];
+    S.panes[id].replaceChildren(el('p', { class: 'dim mono c3s2', role: 'status', 'data-c3pg': 'tab-error' }, 'This page could not load: ' + String((e && e.message) || e) + '. Open the tab again to retry.'));
+  });
+}
+/* Settings loads on its first opening (c3-settings.js). `then(fn)` runs fn with the mounted Settings. */
+function settingsReady() {
+  if (!S.settingsLoad) {
+    S.settingsCtx = { ws: S.ws, workspaces: S.workspaces, theme: S.theme, themePref: S.themePref, setTheme, goTab: (t, v) => { showTab(t, true); if (t === 'rep' && v) reportsView(v); }, section: q.get('section') || '', root: S.root };
+    S.settingsLoad = import('./c3-settings.js').then((m) => { S.settings = m.mountSettings(S.panes.settings, S.settingsCtx); return S.settings; });
+    S.settingsLoad.catch((e) => {
+      S.settingsLoad = null;
+      S.panes.settings.replaceChildren(el('p', { class: 'dim mono c3s2', role: 'status', 'data-c3pg': 'tab-error' }, 'Settings could not load: ' + String((e && e.message) || e) + '. Open Settings again to retry.'));
+    });
+  }
+  return S.settingsLoad;
+}
 
 function showTab(id, push) {
   if (!BUILD[id] && id !== 'settings') id = 'brief';
@@ -543,9 +493,9 @@ function showTab(id, push) {
   if (S.gearBtn) S.gearBtn.setAttribute('aria-pressed', String(id === 'settings'));
   if (id === 'settings') {
     S.ttl.replaceChildren(gearIcon('lg'), 'Settings'); document.title = 'Settings · PMOS console';
-    if (!S.settings) { S.settingsCtx = { ws: S.ws, workspaces: S.workspaces, theme: S.theme, themePref: S.themePref, setTheme, goTab: (t, v) => { showTab(t, true); if (t === 'rep' && v) showReportsView(v); }, section: q.get('section') || '', root: S.root }; S.settings = mountSettings(S.panes.settings, S.settingsCtx); }
+    if (!S.settings) settingsReady();
     else S.settings.refresh();
-  } else if (!S.mounted[id]) { S.mounted[id] = true; BUILD[id](S.panes[id]); }
+  } else if (!S.mounted[id]) build(id);
   S.root.dataset.tab = id;
   S.dockOpen = S.wide && id === 'brief' && dockPref(); syncDock();   // the dock starts folded (c3-quiet-pages); Ctrl J or the More menu opens it, and the choice is kept
   S.pageView.classList.remove('view'); void S.pageView.offsetWidth; S.pageView.classList.add('view');
@@ -565,22 +515,27 @@ function briefCount() {
   onBriefing((x) => { b = x; upd(); }); onBriefPage((x) => { page = x; upd(); });
   loadBriefing(); if (S.tab !== 'brief') loadBriefPage();
 }
+/* The Briefing's first read has answered (or 4 s have passed), and the browser has a free moment. */
+function afterBriefing() {
+  const idle = () => new Promise((res) => (typeof requestIdleCallback === 'function' ? requestIdleCallback(() => res(), { timeout: 1500 }) : setTimeout(res, 200)));
+  return Promise.race([loadBriefing(), new Promise((res) => setTimeout(res, 4000))]).then(idle, idle);
+}
 async function askCount() {
   if (S.demo) { setBdg(S.initBdg, 4); return; }
-  const j = await pmGet('/api/needs?ws=' + encodeURIComponent(S.ws)).catch(() => null);
+  const j = await pmGet('/api/needs?ws=' + encodeURIComponent(S.ws) + '&kind=triage').catch(() => null);   // only the triage rows: the badge counts them
   if (!j || !Array.isArray(j.needs)) return;
   setBdg(S.initBdg, j.needs.filter((r) => r && r.kind === 'triage').length);
 }
 
 async function workCount() {
-  const j = await pmGet('/api/pm-items').catch(() => null);
-  if (!j || !j.ok || !j.lists) return;
+  const j = await pmGet('/api/pm-items?counts=1').catch(() => null);   // the counts alone; the Work page reads the lists when it opens
+  if (!j || !j.ok || !(j.lists || j.counts)) return;
   if (j.counts && typeof j.counts.inbox === 'number') {   // the Work page's own counts: what is to process (inbox) plus what is on today
     const w = j.counts.inbox + (Number(j.counts.today) || 0);
     S.workBdg.textContent = String(w); S.workBdg.hidden = w === 0;
     return;
   }
-  const n = (j.lists.triage || []).length + (S.demo ? 0 : (j.lists.today || []).length);   // the mockup's Work badge counts what is to triage
+  const L = j.lists || {}; const n = (L.triage || []).length + (S.demo ? 0 : (L.today || []).length);   // the mockup's Work badge counts what is to triage
   S.workBdg.textContent = String(n); S.workBdg.hidden = n === 0;
 }
 
@@ -628,7 +583,8 @@ async function boot() {
   if (q.get('studio') && /^[a-z][a-z0-9-]{0,39}$/.test(q.get('studio'))) { if (!start) start = 'rep'; import('./c3-design-studio.js').then((m) => m.openStudio({ ws: S.ws, id: q.get('studio'), name: '' })).catch(() => { /* the studio is not available */ }); }
   if (!S.userNav) showTab(start || 'brief', false);   // a press during the read above (the gear, a tab) wins over the start page
   new ResizeObserver(moveInd).observe(S.tabNav);
-  workCount(); briefCount(); askCount(); S.dock.start();
+  briefCount(); S.dock.start(); S.dockStarted = true;
+  afterBriefing().then(() => { workCount(); askCount(); });   // the Work and Initiatives counts wait until the Briefing has its own reads
   setInterval(() => { S.sub.textContent = dateLine(); }, 30000);
 }
 

package/workspace/replaced-tests.json

@@ -173,6 +173,17 @@
         "B1 with nothing stored, status says absent",
         "B5 status never carries the key or its length"
       ]
+    },
+    {
+      "id": "STD-REFRESH",
+      "file": "workspace/proactive.test.js",
+      "run": "data-refresh-settings",
+      "ref": "planning/prd/data-refresh-settings-prd.md R3 (the PM said Build on 2026-10-14)",
+      "reason": "R3 moves the morning brief's schedule from schedules.json to Settings › Data refresh. The brief set no longer writes a schedule; it turns the brief source on, daily at 06:45. H8 now asserts that through GET /api/refresh, and I7 accepts the CLI's new 'already on in Settings, Data refresh' line.",
+      "names": [
+        "H8 one press creates the daily 06:45 morning-brief schedule once; a second press adds nothing",
+        "I7 `brief schedule` reports that the schedule already exists"
+      ]
     }
   ],
   "entries": [

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; }
@@ -6971,8 +7055,12 @@ async function handleRequest(req, res) {
         ? { count: strict.empty ? 0 : strict.data.items.length, error: null }
         : { count: null, error: strict.error } });
     }
+    // ?kind=a,b keeps only those kinds (the console's Initiatives badge counts triage; the Briefing's agent rows read three kinds):
+    // the full queue is large and most readers want a few rows of it (c3-desktop-light-load).
+    const kinds = String(url.searchParams.get('kind') || '').split(',').map((k) => k.trim()).filter(Boolean);
+    const queue = strict.ok ? strict.all : readNeeds(w);
     return json(res, {
-      needs: strict.ok ? strict.all : readNeeds(w),
+      needs: kinds.length && Array.isArray(queue) ? queue.filter((n) => n && kinds.includes(n.kind)) : queue,
       state: strict.ok ? { ok: true } : { ok: false, error: strict.error },
       by_ws: needsByWorkspace(),
     });
@@ -8380,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.
@@ -8630,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') {
@@ -9078,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/c3-desktop-light-load.json

@@ -0,0 +1,6 @@
+{
+  "_comment": "Initiative c3-desktop-light-load: the desktop console loads the Briefing's code and reads only, each tab's code on its first opening, the folded dock reads only the runs, the badges read counts, the pulse reads the gantt rows alone, no read twice on open.",
+  "modules": ["light-load.test.js"],
+  "panels": ["c3-light-load-test.js"],
+  "seconds": { "light-load.test.js": 15, "c3-light-load-test.js": 60 }
+}

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 }
+}