create-pmos 0.211.0 → 0.212.0

package/workspace/public/pm/c3-quiet.css

@@ -77,7 +77,12 @@
 .c3 .c3top{position:absolute;top:0;right:0;left:auto;align-items:center !important;gap:10px;z-index:3;padding:0 !important;margin:0 !important;min-height:44px;background:transparent}
 .c3 .c3top > div:first-child{display:flex;align-items:center;gap:8px;order:1}
 .c3 .c3top .sub{font-size:var(--fs-1);margin:0}
-.c3 .c3top .fr-fresh.qt-open{position:absolute;top:44px;right:0;background:var(--card);border:1px solid var(--border);border-radius:8px;padding:8px 10px;flex-wrap:wrap;max-width:560px;box-shadow:0 6px 24px rgb(0 0 0 / .08)}
+.c3 .c3top .fr-fresh.qt-open{position:absolute;top:44px;right:0;background:var(--card);border:1px solid var(--border);border-radius:8px;padding:8px 10px;box-shadow:0 6px 24px rgb(0 0 0 / .08)}
+/* The open line is a list: one source per row, then the refresh icon with its note. Wrapped inline, a row broke mid-list and left a dot at its end. */
+.c3 .c3top .fr-fresh.qt-open{display:grid !important;grid-template-columns:auto 1fr;align-items:center;gap:6px 8px;width:max-content;max-width:min(360px,calc(100vw - 24px));white-space:nowrap}
+.c3 .c3top .fr-fresh.qt-open > [data-fr-line]{grid-column:1 / -1}
+.c3 .c3top .fr-fresh.qt-open > .fr-fresh__sep{display:none}
+.c3 .c3top .fr-fresh.qt-open > .fr-fresh__note{white-space:normal}
 .c3 nav.c3tabs{margin-top:0 !important;min-height:44px}
 /* Row 2: one context bar per page */
 .c3 .qt-ctx{display:flex !important;align-items:center;gap:10px;flex-wrap:wrap}

package/workspace/public/pm/c3-settings.css

@@ -72,3 +72,14 @@
 /* The effects of two Day and time settings, on the console root. */
 [data-c3-tint="off"][data-daypart]{background-image:none!important}
 [data-c3-strip="off"] .c3pg-daylight{display:none!important}
+/* Data refresh: the source icon sits in the title line; the schedule editor opens under the row. */
+.c3 .c3set .rf-row .tt{display:flex;align-items:center;gap:var(--sp-2)}
+.c3 .c3set .rf-ed{margin-top:var(--sp-3);padding-top:var(--sp-2);border-top:1px solid var(--border)}
+.c3 .c3set .rf-ed .acts select+select,.c3 .c3set .rf-ed .acts select{margin-right:4px}
+.c3 .c3set .rf-ed .mk-lbl{margin:var(--sp-2) 0 2px;text-transform:uppercase}
+.c3 .c3set .rf-row .fold .c3set-b{margin-left:auto}
+@media (max-width:860px){
+  .c3 .c3set .list>.nrow.st-row.rf-row{grid-template-columns:minmax(0,1fr)}
+  .c3 .c3set .list>.nrow.st-row.rf-row>.acts{justify-content:flex-start}
+}
+.c3.ph .c3set .nrow.st-row .acts{grid-column:auto;justify-content:flex-start}

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

@@ -16,6 +16,7 @@
  *   about you         GET and POST /api/proactive/settings {name, about:{role, work, duties}} (the Welcome page writes the same)
  *   running sessions  GET /api/sessions                         calendar import  POST /api/sources/refresh {source:'calendar'}
  *   versions          GET /api/kit/status · POST /api/kit/check, /api/kit/update, /api/kit/upgrade-app (then GET /api/sessions until the new version)
+ *   data refresh      GET /api/refresh?ws · POST /api/refresh/source, /rules, /run, /run-all · GET /api/refresh/log, /log.csv
  * Every other setting is in the settings store: GET /api/settings and POST /api/settings (lib/settings-store.js).
  * A board's own workflow is edited on the board; here are only the templates new boards start from.
  * Nothing here asks for or shows a key or a password. */
@@ -38,6 +39,7 @@ export const SECTIONS = Object.freeze([
   ['workspaces', 'Workspaces', 'repo', 'A workspace is one repository PMOS works in. Settings marked Workspace apply to the one picked at the top of this page.'],
   ['boards', 'Boards and workflows', 'cols', 'The templates and defaults new boards start from. A board\'s own workflow is edited on the board, in Initiatives.'],
   ['connectors', 'Connectors', 'org', 'PMOS keeps no passwords or keys for these. Your Claude session reaches each tool through the connectors of its profile.'],
+  ['refresh', 'Data refresh', 'undo', 'What PMOS reads and writes on a schedule: pick what refreshes, when and how often, and see when each one last ran.'],
   ['recording', 'Recording', 'mic', 'How meetings are transcribed. This is the one place to check when a transcript looks wrong.'],
   ['time', 'Day and time', 'sun', 'The Briefing follows your clock. These settings say what your day looks like.'],
   ['sharing', 'Sharing', 'mail', 'Who reports go to, and how. Each report\'s schedule is set in Reports, under Set up.'],
@@ -55,9 +57,7 @@ export const LABELS = Object.freeze({
   'board.template': ['Defaults', 'Template for new boards', 'A new board copies this template. You can change its workflow on the board afterwards.', { product: 'Product', project: 'Project', simple: 'Simple' }],
   'board.rules': ['Defaults', 'Order rules on boards', 'You move cards between stages. When a card skips a step, such as Build before a spec exists, the card shows a warning (decision D3).', { warn: 'Warn on the card', off: 'Off' }],
   'conn.cal.window': ['Google Calendar', 'Import window', 'How far back and ahead your session imports events.', { '7-14': 'Past 7 days, next 14', '14-30': 'Past 14 days, next 30', '30-60': 'Past 30 days, next 60' }],
-  'conn.cal.refresh': ['Google Calendar', 'Refresh', 'When your session imports events again.', { open: 'When I open Calendar', hour: 'Every hour', manual: 'Only when I import' }],
   'conn.cal.private': ['Google Calendar', 'Private events', 'Events marked private in Google Calendar.', { busy: 'Show as busy', hide: 'Hide', title: 'Show titles' }],
-  'conn.jira.refresh': ['Jira', 'Refresh ticket status', 'Jira owns ticket status. PMOS reads it back on this schedule.', { open: 'When I open a board', 15: 'Every 15 min', manual: 'Only when I sync' }],
   'conn.wispr.wait': ['Wispr Flow', 'Wait before fetching', 'Wispr Flow needs a few minutes to finish its notes after a meeting.', { 2: '2 minutes', 5: '5 minutes', 10: '10 minutes' }],
   'conn.sender': ['Sending', 'Sender for shared dashboards', 'Your session sends through this connector. Until you pick one, a scheduled share is a ready draft.', { none: 'None', slack: 'Slack', gmail: 'Gmail drafts' }],
   'rec.sources': ['Live transcript', 'Listen to', 'The meeting is the sound from your call app. The mic is you.', { both: 'Mic and meeting', mic: 'Mic only', meeting: 'Meeting only' }],
@@ -140,7 +140,7 @@ const bt = (attrs, ...kids) => {
 
 const ZONES = ['Asia/Jakarta', 'Asia/Makassar', 'Asia/Jayapura', 'Asia/Singapore', 'Asia/Kuala_Lumpur', 'Asia/Bangkok', 'Asia/Tokyo', 'Asia/Kolkata', 'Australia/Sydney', 'Europe/London', 'Europe/Berlin', 'America/New_York', 'America/Los_Angeles', 'UTC'];
 /* Choices the mockup draws as a select even though they are short. */
-const AS_SELECT = new Set(['conn.cal.window', 'conn.cal.refresh', 'conn.jira.refresh', 'conn.wispr.wait']);
+const AS_SELECT = new Set(['conn.cal.window', 'conn.wispr.wait']);
 const qs = (o) => Object.entries(o).filter(([, v]) => v != null && v !== '').map(([k, v]) => k + '=' + encodeURIComponent(v)).join('&');
 
 export function mountSettings(host, ctx = {}) {
@@ -149,6 +149,7 @@ export function mountSettings(host, ctx = {}) {
     sec: SECTIONS.some((s) => s[0] === ctx.section) ? ctx.section : 'about', q: '', ws: ctx.ws || '', data: null, err: {},
     engine: null, people: null, consent: null, online: null, profiles: null, typesafe: null, kits: {}, kitBusy: null, app: { phase: null, error: '' }, about: null, running: null,
     tplEdit: null, wsEdit: null, wsDrop: null, addPath: '',
+    rf: null, rfLog: null, rfSig: '', rfFilter: 'all', rfEdit: null, rfAsk: null, rfErr: {}, rfAllBusy: false, rfLoading: false, logSource: '', logResult: '',
   };
   const root = el('div', { class: 'brief c3set', 'data-c3set': '' });
   const nav = el('ul', { class: 'list', role: 'list', 'data-c3set-nav': '' });
@@ -181,7 +182,7 @@ export function mountSettings(host, ctx = {}) {
   }
   async function loadEngine() { const r = await pmGet('/api/notes/engine?' + qs({ ws: M.ws })); M.engine = r && r.ok ? r : { error: (r && r.error) || 'not read' }; draw(); }
   async function loadWs() {
-    M.people = null; M.consent = null; draw();
+    M.people = null; M.consent = null; M.rf = null; M.rfLog = null; M.rfEdit = null; M.rfAsk = null; draw();
     await Promise.all([loadStore(), loadEngine(),
       M.ws ? pmGet('/api/people?' + qs({ ws: M.ws })).then((r) => { M.people = r && r.ok !== false && r.settings ? { on: !!r.settings.calendar_names } : { error: (r && r.error) || 'not read' }; }) : null,
       M.ws ? pmGet('/api/validate/repo?' + qs({ ws: M.ws })).then((r) => { M.consent = r && r.ok !== false ? { on: !!r.consent } : { error: (r && r.error) || 'not read' }; }) : null]);
@@ -263,7 +264,7 @@ export function mountSettings(host, ctx = {}) {
       el('div', { class: 'nb' },
         forId ? el('label', { class: 'tt', for: forId }, label) : el('span', { class: 'tt' }, label),
         scope || changed ? el('div', { class: 'chips' }, scope ? scopeTag(scope) : null, changed ? el('span', { class: 'st-dot', title: 'Changed from the default' }) : null) : null,
-        h ? help(h) : null,
+        h ? help(...[].concat(h)) : null,
         env ? el('div', { class: 'fold w', 'data-c3set-env': env.env }, c3ic('alert', 'sm'), el('span', null, el('b', { class: 'mono' }, env.env + '=' + env.value), ' is set where PMOS starts. ' + env.effect + ' Remove it from your shell profile, then restart PMOS.')) : null,
         lock ? fold('lock', lock) : null,
         note ? help(note) : null,
@@ -403,6 +404,7 @@ export function mountSettings(host, ctx = {}) {
     const profs = (M.profiles && M.profiles.profiles) || [];
     return select(id, 'Default profile', [['', 'None'], ...profs.map((x) => [x.id, x.label && x.label !== x.id ? x.label + ' (' + x.id + ')' : x.id])], profileNow().id || '', chooseProfile);
   };
+  const refreshLink = (key, label, h) => frame({ key, label, help: h, control: secLink('refresh', 'Data refresh') });
   function connectorsSec() {
     const { id, x } = profileNow();
     const mcp = x ? x.mcp : [];
@@ -423,13 +425,13 @@ export function mountSettings(host, ctx = {}) {
       help('Profiles are listed in ', secLink('sessions', 'Claude sessions'), '.')], { ic: 'user', attrs: { 'data-c3set-profile': '' } }),
       sect('Google Calendar', [list([
         notYet('conn.cal.list', 'Calendars to import', 'Pick which of your calendars the import reads.', 'Choosing calendars comes later. Today the import reads the calendars your session can see.', 'computer'),
-        storeRow('conn.cal.window'), storeRow('conn.cal.refresh'), storeRow('conn.cal.private'),
+        storeRow('conn.cal.window'), refreshLink('conn.cal.refresh', 'Refresh schedule', 'When the calendar is read again is set in Data refresh.'), storeRow('conn.cal.private'),
         M.ws ? extRow('people.names', people && !people.error ? swBtn(people.on, EXT['people.names'][2], async () => { const r = await pmPost('/api/people/decide', { ws: M.ws, act: 'setting', calendar_names: !people.on }); if (r && r.ok !== false) { people.on = !people.on; toast('Saved: attendee names'); } else M.err['people.names'] = (r && r.error) || 'Not saved.'; draw(); }) : el('span', { class: 'dim' }, people ? people.error : 'Reading'), { scope: 'ws' }) : null]),
       el('div', { class: 'iacts' }, btn('Import now', { ic: 'undo', disabled: !M.ws || !has(/calendar/i), onclick: async () => { const r = await pmPost('/api/sources/refresh', { ws: M.ws, source: 'calendar' }); toast(r && r.ok ? 'Import started in your Claude session. Events appear in Calendar when it finishes.' : ((r && r.error) || 'The import did not start.')); } }),
         el('span', { class: 'dim st-help' }, via(has(/calendar/i), 'calendar') + ' PMOS never edits your calendar.'))], { ic: 'cal', right: reach(has(/calendar/i)) }),
       sect('Jira', [list([notYet('jira.map', 'Jira project for each board', 'A board backed by a Jira project mirrors its sprints and reads ticket status from it, with each Jira status mapped to a board stage.', 'Mapping boards and statuses comes with the Initiatives update.', 'board')]),
         help(via(has(/atlassian|jira/i), 'Jira'))], { ic: 'org', right: reach(has(/atlassian|jira/i)) }),
-      group('Jira behaviour', [storeRow('conn.jira.refresh'),
+      group('Jira behaviour', [refreshLink('conn.jira.refresh', 'Refresh ticket status', 'When Jira is read again is set in Data refresh.'),
         lockedRow('jira.push', 'Creating or updating tickets', 'PMOS drafts tickets from the PRD. Nothing reaches Jira until you select it (D88).', 'You approve every push', 'ws'),
         lockedRow('jira.sprints', 'Sprints and burndown', 'A board backed by Jira shows its sprints. Native sprints are only for boards with no tracker (D5).', 'Mirrored from Jira, read-only', 'board')], 'org'),
       sect('Wispr Flow', [list([w ? extRow('notes.wispr', swBtn(w.wispr !== false, EXT['notes.wispr'][2], () => notesSwitch({ wispr: w.wispr === false }, 'notes.wispr', { wispr: w.wispr !== false }), { disabled: !!override('notes.wispr') }), { scope: 'computer' }) : null, storeRow('conn.wispr.wait')]),
@@ -691,7 +693,229 @@ export function mountSettings(host, ctx = {}) {
     return [sect('PMOS app', [list([appRow])], { ic: 'cloud', attrs: { 'data-c3set-app': '' } }), sect('Kit in each workspace', [list(rows)], { ic: 'repo', count: rows.length }), groupOf('updates', 'When', 'cloud')];
   }
 
-  const BUILD = { about: aboutSec, workspaces: workspacesSec, boards: boardsSec, connectors: () => [...connectorsSec(), finderBlock(M.ws)], recording: recordingSec, time: timeSec, sharing: sharingSec, access: accessSec, sessions: sessionsSec, privacy: privacySec, appearance: appearanceSec, updates: updatesSec };
+  /* ── Data refresh: every source PMOS reads or writes on a schedule (PRD data-refresh-settings R9).
+     GET /api/refresh?ws · POST /api/refresh/source, /rules, /run, /run-all · GET /api/refresh/log, /log.csv. One home: Connectors links here. ── */
+  const RF_GROUPS = [['tools', 'From your tools', 'org', 'Read through your Claude session. PMOS holds no keys for these.'], ['pmos', 'Written by PMOS', 'spark', 'Background runs that write cards, documents and proposals.'], ['change', 'Kept in step on every change', 'repo', 'No schedule: these follow your files as they change.']];
+  const RF_ST = { recent: ['Recent', 'ok'], old: ['Old', 'warn'], failed: ['Failed', 'warn'], running: ['Refreshing now', 'acc'], waiting: ['Waiting', 'acc'], off: ['Off', ''], never: ['Not yet', ''] };
+  const RF_KIND = { manual: 'When I press', every: 'Every few minutes', daily: 'Daily', weekdays: 'Working days', weekly: 'Weekly' };
+  const RF_DAYS = [['Mon', 'Monday'], ['Tue', 'Tuesday'], ['Wed', 'Wednesday'], ['Thu', 'Thursday'], ['Fri', 'Friday'], ['Sat', 'Saturday'], ['Sun', 'Sunday']];
+  const RF_EVERY = { 10: '10 min', 15: '15 min', 30: '30 min', 60: 'hour', 120: '2 hours', 240: '4 hours' };
+  const RF_HOURS = []; for (let h = 5; h <= 22; h++) for (const m of ['00', '30']) RF_HOURS.push(String(h).padStart(2, '0') + ':' + m);
+  const RF_DOW = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']; const RF_MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+  const pad2 = (n) => String(n).padStart(2, '0');
+  /** Local time: HH:MM for today, "Mon 06:30" within a week, "Sun 11 Oct 06:30" beyond. */
+  function fmtAt(iso) {
+    const d = iso ? new Date(iso) : null; if (!d || isNaN(d)) return '';
+    const t = pad2(d.getHours()) + ':' + pad2(d.getMinutes()); const n = new Date();
+    if (d.toDateString() === n.toDateString()) return t;
+    if (Math.abs(d - n) < 6 * 864e5) return RF_DOW[d.getDay()] + ' ' + t;
+    return RF_DOW[d.getDay()] + ' ' + d.getDate() + ' ' + RF_MON[d.getMonth()] + ' ' + t;
+  }
+  const fmtTook = (ms) => { if (ms == null) return ''; const s = Math.max(1, Math.round(ms / 1000)); return s < 60 ? s + ' s' : Math.floor(s / 60) + ' min' + (s % 60 ? ' ' + (s % 60) + ' s' : ''); };
+  const rfRows = () => (M.rf && M.rf.rows) || [];
+  const rfRow = (id) => rfRows().find((x) => x.id === id);
+  const rfName = (id) => { const x = rfRow(id); return x ? x.label : id; };
+  const rfNames = (ids) => (ids || []).map(rfName).join(', ');
+  const needsLook = (r) => r.on && (r.state === 'failed' || r.state === 'old');
+  const sig = (s) => JSON.stringify(s);
+
+  async function loadRf(force) {
+    const [r, lg] = await Promise.all([pmGet('/api/refresh?' + qs({ ws: M.ws })), pmGet('/api/refresh/log?' + qs({ source: M.logSource, result: M.logResult, limit: 50 }))]);
+    const next = r && r.ok ? r : { error: (r && r.error) || 'The refresh schedule could not be read.' };
+    const log = lg && lg.ok ? { total: lg.total, runs: lg.runs || [] } : { error: (lg && lg.error) || 'The log could not be read.' };
+    const s = sig([next, log]); const same = s === M.rfSig; M.rfSig = s; M.rf = next; M.rfLog = log;
+    const a = document.activeElement;
+    const busy = !force && (M.rfEdit || M.rfAsk || (a && body.contains(a) && a.tagName === 'SELECT'));
+    if (force || (!same && !busy)) draw();
+  }
+  /* Poll while the section shows; stop when another section, a search or another page is on screen. */
+  let rfTimer = null;
+  function rfWatch() {
+    const on = M.sec === 'refresh' && !M.q;
+    if (rfTimer && (!on || !root.isConnected)) { clearInterval(rfTimer); rfTimer = null; }
+    if (on && !rfTimer) rfTimer = setInterval(() => { if (M.sec === 'refresh' && !M.q && root.isConnected && root.offsetParent) loadRf(false); }, 15000);
+    if (on && !M.rf && !M.rfLoading) { M.rfLoading = true; loadRf(true).finally(() => { M.rfLoading = false; }); }
+  }
+  const rfAfter = async () => { await loadRf(true); };
+
+  async function rfSetOn(r, on) {
+    M.rfAsk = null;
+    const res = await pmPost('/api/refresh/source', { id: r.id, on });
+    if (!res || !res.ok) { M.rfErr[r.id] = (res && res.error) || 'Not saved.'; draw(); return; }
+    delete M.rfErr[r.id]; await rfAfter();
+    toast((on ? 'Turned on: ' : 'Turned off: ') + r.label, async () => { await pmPost('/api/refresh/source', { id: r.id, on: !on }); await rfAfter(); });
+  }
+  async function rfSaveSchedule(r, sch, lead) {
+    const old = r.schedule;
+    const res = await pmPost('/api/refresh/source', { id: r.id, schedule: sch });
+    if (!res || !res.ok) { const msg = (res && res.error) || 'Not saved.'; if (M.rfEdit && M.rfEdit.id === r.id) M.rfEdit.err = msg; else M.rfErr[r.id] = msg; draw(); return false; }
+    M.rfEdit = null; delete M.rfErr[r.id]; await rfAfter();
+    const nr = rfRow(r.id);
+    toast(lead + ': ' + r.label + (nr ? ', ' + nr.schedule_text : ''), old ? async () => { await pmPost('/api/refresh/source', { id: r.id, schedule: old }); await rfAfter(); } : undefined);
+    return true;
+  }
+  async function rfRunNow(r, withInputs) {
+    const body = { id: r.id, ws: M.ws }; if (withInputs) body.with_inputs = true;
+    const res = await pmPost('/api/refresh/run', body);
+    if (!res || !res.ok) { toast((res && res.error) || r.label + ' did not start.'); await rfAfter(); return; }
+    await rfAfter();
+    toast(res.waiting && res.waiting.length ? r.label + ' starts when ' + rfNames(res.waiting) + ' has finished.' : 'Refreshing ' + r.label + '. You can leave this page.');
+  }
+  async function rfRunAll() {
+    M.rfAllBusy = true; draw();
+    const res = await pmPost('/api/refresh/run-all', { ws: M.ws });
+    M.rfAllBusy = false; await rfAfter();
+    if (!res || !res.ok) { toast((res && res.error) || 'Refresh all did not start.'); return; }
+    const bad = (res.failed || []).length;
+    toast('Refreshing ' + (res.started || []).length + ' sources.' + (bad ? ' ' + bad + ' did not start: ' + res.failed.map((f) => rfName(f.id) + ' (' + f.error + ')').join(', ') + '.' : ''));
+  }
+  async function rfSaveRule(key, value, label) {
+    const old = M.rf.rules[key];
+    const res = await pmPost('/api/refresh/rules', { [key]: value });
+    if (!res || !res.ok) { M.err['rf.' + key] = (res && res.error) || 'Not saved.'; draw(); return; }
+    delete M.err['rf.' + key]; if (res.rules) M.rf.rules = res.rules; await rfAfter();
+    toast('Saved: ' + label, async () => { await pmPost('/api/refresh/rules', { [key]: old }); await rfAfter(); });
+  }
+
+  /* the editor's draft is cleaned to the shape the API takes */
+  const cleanSchedule = (d) => d.kind === 'manual' ? { kind: 'manual' }
+    : d.kind === 'every' ? { kind: 'every', every: String(d.every), work: !!d.work }
+      : d.kind === 'weekly' ? { kind: 'weekly', day: d.day, times: [d.times[0]] } : { kind: d.kind, times: d.times.slice() };
+  function openEditor(r) {
+    const s = r.schedule || r.default || { kind: r.kinds[0] };
+    M.rfEdit = { id: r.id, err: '', d: { kind: s.kind, times: (s.times || []).slice(), day: s.day || 'Mon', every: String(s.every || (r.every || [])[0] || '60'), work: !!s.work } };
+    draw();
+  }
+  function setKind(r, k) {
+    const d = M.rfEdit.d; d.kind = k;
+    if (k === 'every' && !(r.every || []).includes(d.every)) d.every = (r.every || ['60'])[0];
+    if (['daily', 'weekdays', 'weekly'].includes(k) && !d.times.length) d.times = ['09:00'];
+    if (k === 'weekly') d.times = d.times.slice(0, 1);
+    M.rfEdit.err = ''; draw();
+  }
+  const timeOpts = (v) => (RF_HOURS.includes(v) ? RF_HOURS : [...RF_HOURS, v].sort()).map((h) => [h, h]);
+
+  /** One run of the log: when, which source, the result, how long and what it got. */
+  function runLine(run, withSource) {
+    const res = run.result; const bad = res === 'failed' || res === 'interrupted';
+    const tone = res === 'done' ? 'ok' : bad ? 'warn' : res === 'skipped' ? '' : 'acc';
+    const label = res === 'done' ? 'Done' : res === 'failed' ? 'Failed' : res === 'skipped' ? 'Skipped' : res === 'interrupted' ? 'Interrupted' : 'Running';
+    return el('li', { class: 'nrow', 'data-c3set-rfrun': run.run || '' },
+      el('span', { class: cx('ki', bad && 't-warn') }, c3ic(bad ? 'alert' : !res ? 'wait' : 'check', 'sm')),
+      el('div', { class: 'nb' }, el('span', { class: 'tt' }, (withSource ? rfName(run.source) + ' · ' : '') + fmtAt(run.start_at)),
+        el('div', { class: 'chips' }, tag(label, tone), run.took_ms != null ? chip('took ' + fmtTook(run.took_ms)) : null, run.trigger ? chip(run.trigger) : null, run.got ? chip(run.got) : null, run.note ? chip(run.note) : null),
+        run.error ? fold('alert', run.error, 'w') : null));
+  }
+
+  function rfEditor(r) {
+    const E = M.rfEdit; const d = E.d; const win = (M.rf && M.rf.window) || { start: '09:00', end: '18:00' };
+    const rows = [];
+    if (r.kinds.length > 1) rows.push(frame({ key: 'rf.kind', label: 'How often', control: seg('How often', r.kinds.map((k) => [k, RF_KIND[k] || k]), d.kind, (k) => setKind(r, k)) }));
+    if (d.kind === 'every') rows.push(frame({ key: 'rf.every', label: 'Every', forId: 'c3set-rf-every', control: select('c3set-rf-every', 'How often', (r.every || []).map((v) => [v, RF_EVERY[v] || v + ' min']), d.every, (v) => { d.every = v; draw(); }) }));
+    if (d.kind === 'daily' || d.kind === 'weekdays') {
+      rows.push(frame({ key: 'rf.times', label: 'At', help: d.kind === 'weekdays' ? 'Monday to Friday.' : '',
+        control: [...d.times.flatMap((t, i) => [select('c3set-rf-time-' + i, 'Time ' + (i + 1), timeOpts(t), t, (v) => { d.times[i] = v; d.times = [...new Set(d.times)].sort(); draw(); }),
+          d.times.length > 1 ? bt({ type: 'button', class: 'ib sm', 'aria-label': 'Remove ' + t, onclick: () => { d.times.splice(i, 1); draw(); } }, c3ic('x', 'sm')) : null]),
+        d.times.length < 4 ? btn('Add a time', { variant: 'ghost', ic: 'plus', attrs: { 'data-c3set-rf-addtime': '' }, onclick: () => { const last = d.times[d.times.length - 1]; const h = Math.min(22, +last.slice(0, 2) + 4); let t = pad2(h) + ':' + last.slice(3); for (const o of RF_HOURS) { if (!d.times.includes(t)) break; t = o; } if (!d.times.includes(t)) d.times = [...d.times, t].sort(); draw(); } }) : null] }));
+    }
+    if (d.kind === 'weekly') rows.push(frame({ key: 'rf.day', label: 'On', control: [select('c3set-rf-day', 'Day', RF_DAYS, d.day, (v) => { d.day = v; draw(); }), select('c3set-rf-time-0', 'Time', timeOpts(d.times[0]), d.times[0], (v) => { d.times = [v]; draw(); })] }));
+    if (d.kind === 'every') rows.push(frame({ key: 'rf.work', label: 'Only in working hours', help: [win.start + ' to ' + win.end + ', set in ', secLink('time', 'Day and time'), '. Outside them this waits for the next slot.'],
+      control: swBtn(d.work, 'Only in working hours', () => { d.work = !d.work; draw(); }) }));
+    const hist = (r.runs || []).slice(0, 5).map((x) => runLine(x, false));
+    const isDef = !r.default || sig(r.schedule) === sig(r.default);
+    return el('div', { class: 'rf-ed', 'data-c3set-rf-editor': r.id },
+      list(rows),
+      el('div', { class: 'mk-lbl dim st-help' }, 'Last runs'),
+      hist.length ? list(hist) : help('Nothing has run yet.'),
+      E.err ? el('div', { class: 'fold w', role: 'alert', 'data-c3set-rf-err': '' }, c3ic('alert', 'sm'), el('span', null, E.err)) : null,
+      el('div', { class: 'iacts' }, btn('Save', { variant: 'primary', attrs: { 'data-c3set-rf-save': r.id }, onclick: () => rfSaveSchedule(r, cleanSchedule(d), 'Saved') }),
+        btn('Cancel', { variant: 'ghost', onclick: () => { M.rfEdit = null; draw(); } }),
+        isDef ? null : btn('Back to default', { variant: 'ghost', ic: 'undo', attrs: { 'data-c3set-rf-default': r.id }, onclick: () => rfSaveSchedule(r, r.default, 'Back to the default') })));
+  }
+
+  function rfSourceRow(r) {
+    const [lab, tone] = RF_ST[r.state] || ['', ''];
+    const open = !!(M.rfEdit && M.rfEdit.id === r.id); const asking = M.rfAsk === r.id; const running = r.state === 'running';
+    const l = r.last;
+    const how = r.how === 'tool' ? 'Your Claude session reads it' + (profileNow().id ? ' through profile ' + profileNow().id : '') : r.how === 'bg' ? 'A background Claude run writes it' : 'Code on this computer, no model';
+    const lastRes = !l ? 'It has not run yet.' : running || !l.result ? 'It is running now.' : l.result === 'failed' ? 'Last result: failed.' : l.result === 'skipped' ? 'The last run was skipped' + (l.note ? ': ' + l.note : '') + '.'
+      : l.result === 'interrupted' ? 'The last run was interrupted.' : 'Last result: ' + (l.got || 'done') + (l.took_ms != null ? ', took ' + fmtTook(l.took_ms) : '') + '.';
+    const lastChip = running && l ? 'Started ' + fmtAt(l.start_at) : l ? 'Last refreshed ' + fmtAt(l.at || l.start_at) : 'Never refreshed';
+    const nextChip = r.state === 'waiting' ? 'Waiting for ' + rfNames(r.waiting_for) : r.on && r.next_at ? 'Next ' + fmtAt(r.next_at) : null;
+    const relation = [r.uses.length ? 'Uses: ' + rfNames(r.uses) + '.' : null, r.used_by.length ? 'Used by: ' + rfNames(r.used_by) + '.' : null].filter(Boolean).join(' ');
+    const ask = asking ? el('div', { class: 'fold w', role: 'alert', 'data-c3set-rf-ask': r.id }, c3ic('alert', 'sm'),
+      el('span', null, 'If you turn off ' + r.label + ': ' + r.impact + (r.used_by.length ? ' These use it: ' + rfNames(r.used_by) + '.' : ''))) : null;
+    const nb = [
+      el('span', { class: 'tt' }, el('span', { class: cx('ki', r.on && r.state === 'failed' && 't-warn') }, c3ic(r.ic, 'sm')), r.label),
+      el('div', { class: 'chips' }, tag(lab, tone), chip(lastChip), chip(r.schedule_text), nextChip ? chip(nextChip) : null),
+      help(r.what + ' ' + how + '. ' + lastRes),
+      relation ? help(relation) : null,
+      r.set_in ? help('Set in ' + r.set_in + '.') : null,
+      r.on && r.state === 'failed' ? fold('alert', (l && l.error) || 'The last run failed.', 'w', r.group === 'tools' ? btn('Open Connectors', { variant: 'ghost', ic: 'next', onclick: () => goSec('connectors') }) : null) : null,
+      r.on && r.state === 'old' && l && l.note ? fold('clock', l.note) : null,
+      r.built_on.length ? el('div', { class: 'fold', 'data-c3set-rf-builton': r.id }, c3ic('clock', 'sm'),
+        el('span', null, 'This builds on older data: ' + r.built_on.map((b) => b.label + (b.state && b.state !== 'recent' ? ' (' + (RF_ST[b.state] || [b.state])[0].toLowerCase() + ')' : '')).join(', ') + '.'),
+        btn('Refresh inputs first', { variant: 'ghost', ic: 'undo', disabled: !r.on || running, attrs: { 'data-c3set-rf-inputs': r.id }, onclick: () => rfRunNow(r, true) })) : null,
+      ask,
+      M.rfErr[r.id] ? el('div', { class: 'fold w', role: 'alert' }, c3ic('alert', 'sm'), el('span', null, M.rfErr[r.id])) : null,
+      open ? rfEditor(r) : null];
+    const acts = asking
+      ? [btn('Turn off', { variant: 'primary', attrs: { 'data-c3set-rf-off-go': r.id }, onclick: () => rfSetOn(r, false) }), btn('Keep it on', { variant: 'ghost', onclick: () => { M.rfAsk = null; draw(); } })]
+      : [swBtn(r.on, (r.on ? 'Turn off ' : 'Turn on ') + r.label, () => { if (r.on) { M.rfAsk = r.id; draw(); } else rfSetOn(r, true); }, { 'data-c3set-rf-on': r.id }),
+        btn(running ? 'Refreshing' : 'Refresh now', { ic: 'undo', disabled: !r.on || running, attrs: { 'data-c3set-rf-now': r.id }, onclick: () => rfRunNow(r, false) }),
+        r.kinds.length ? btn(open ? 'Close' : 'Schedule', { variant: 'ghost', ic: open ? 'fold' : 'clock', attrs: { 'data-c3set-rf-open': r.id }, onclick: () => { if (open) M.rfEdit = null; else openEditor(r); draw(); } }) : null];
+    return el('li', { class: 'nrow st-row rf-row', 'data-c3set-rf': r.id }, el('div', { class: 'nb' }, ...nb.filter(Boolean)), el('div', { class: 'acts' }, ...acts.filter(Boolean)));
+  }
+
+  function rfRules() {
+    const R = M.rf.rules; const win = M.rf.window; const q = M.rf.quiet;
+    const rule = (key, label, h, control) => frame({ key: 'rf.' + key, label, help: h, scope: 'computer', control, err: M.err['rf.' + key] });
+    return sect('Rules for every refresh', [list([
+      rule('catchup', 'Catch up after PMOS was closed', 'When PMOS starts and a refresh was missed while it was closed, it runs once right away instead of waiting for the next slot.', swBtn(R.catchup, 'Catch up after PMOS was closed', () => rfSaveRule('catchup', !R.catchup, 'catch up'))),
+      rule('retry', 'When a refresh fails', 'Failures show on the source here and in the line under the page title.', select('c3set-rf-retry', 'When a refresh fails', [['15', 'Try again once after 15 min'], ['60', 'Try again once after an hour'], ['no', 'Wait for the next slot']], R.retry, (v) => rfSaveRule('retry', v, 'when a refresh fails'))),
+      rule('tell', 'Tell me about a failed refresh', 'A card on the Briefing names the source and what to do.', seg('Tell me about a failed refresh', [['brief', 'On the Briefing'], ['here', 'Only here']], R.tell, (v) => rfSaveRule('tell', v, 'tell me about a failed refresh'))),
+      rule('max', 'Background runs at once', 'Runs that use Claude wait in line beyond this number.', select('c3set-rf-max', 'Background runs at once', [['1', '1'], ['2', '2'], ['3', '3'], ['5', '5']], R.max, (v) => rfSaveRule('max', v, 'background runs at once'))),
+      rule('keep', 'Keep the log for', 'Older lines of the refresh log are deleted. The export holds every line that is kept.', select('c3set-rf-keep', 'Keep the log for', [['30', '30 days'], ['90', '90 days'], ['365', 'A year'], ['forever', 'Forever']], R.keep, (v) => rfSaveRule('keep', v, 'keep the log'))),
+      frame({ key: 'rf.quiet', label: 'Quiet hours', scope: 'computer', help: 'No scheduled refresh starts in quiet hours. A refresh you press still runs. Quiet hours are set in the proactive settings, not here.', control: chip(q ? q.start + ' to ' + q.end : 'None') }),
+      frame({ key: 'rf.window', label: 'Background working hours', scope: 'computer', help: ['Background runs that follow working hours use these. They are set in ', secLink('time', 'Day and time'), '.'], control: chip(win ? win.start + ' to ' + win.end : '') })])], { ic: 'clock', attrs: { 'data-c3set-rf-rules': '' } });
+  }
+
+  function rfLogCard() {
+    const L = M.rfLog || {};
+    const f = { source: M.logSource, result: M.logResult };
+    const href = '/api/refresh/log.csv' + (qs(f) ? '?' + qs(f) : '');
+    const setF = (k, v) => { if (k === 'source') M.logSource = v; else M.logResult = v; loadRf(true); };
+    const filters = el('div', { class: 'iacts' },
+      select('c3set-rf-log-source', 'Source', [['', 'All sources'], ...rfRows().map((x) => [x.id, x.label])], M.logSource, (v) => setF('source', v)),
+      select('c3set-rf-log-result', 'Result', [['', 'Any result'], ['done', 'Done'], ['failed', 'Failed'], ['skipped', 'Skipped'], ['interrupted', 'Interrupted']], M.logResult, (v) => setF('result', v)),
+      el('a', { class: 'chip2 lk', href, download: 'pmos-refresh-log.csv', 'data-c3set-rf-export': '' }, c3ic('out', 'sm'), 'Export'));
+    const runs = L.runs || [];
+    return sect('Refresh log', [filters, L.error ? fold('alert', L.error, 'w') : runs.length ? list(runs.map((x) => runLine(x, true))) : fold(null, M.logSource || M.logResult ? 'No run matches.' : 'Nothing has been refreshed yet.'),
+      L.total > runs.length ? help('Showing the newest ' + runs.length + ' of ' + L.total + '. Export has every line.') : null], { ic: 'clock', count: L.total != null ? L.total : null, attrs: { 'data-c3set-rf-log': '' } });
+  }
+
+  function refreshSec() {
+    const D = M.rf;
+    if (!D) return [fold(null, 'Reading the refresh schedule.')];
+    if (D.error) return [fold('alert', D.error, 'w')];
+    const rows = D.rows || [];
+    const on = rows.filter((r) => r.on); const bad = rows.filter(needsLook); const run = rows.filter((r) => r.state === 'running');
+    const next = on.filter((r) => r.next_at).sort((a, b) => new Date(a.next_at) - new Date(b.next_at))[0];
+    const sum = on.length + ' of ' + rows.length + ' on · ' + on.filter((r) => r.state === 'recent').length + ' recent' + (bad.length ? ' · ' + bad.length + ' need a look' : '') + (run.length ? ' · ' + run.length + ' refreshing now' : '');
+    const top = sect('Overview', [el('div', { class: 'st-now', 'data-c3set-rf-sum': '' }, sum),
+      help((next ? 'Next: ' + next.label + ' at ' + fmtAt(next.next_at) + '. ' : '') + 'PMOS refreshes only while it is running on this computer. The same states show in the line under the page title.'),
+      el('div', { class: 'iacts' }, seg('Show', [['all', 'All'], ['needs', 'Needs a look' + (bad.length ? ' (' + bad.length + ')' : '')], ['off', 'Off']], M.rfFilter, (v) => { M.rfFilter = v; draw(); }),
+        btn(M.rfAllBusy ? 'Starting' : 'Refresh all now', { ic: 'undo', disabled: M.rfAllBusy || !on.length, attrs: { 'data-c3set-rf-all': '' }, onclick: rfRunAll }))],
+    { ic: 'undo', right: tag(bad.length ? bad.length + ' need a look' : 'All recent', bad.length ? 'warn' : 'ok') });
+    const pick = (r) => M.rfFilter === 'all' || (M.rfFilter === 'needs' && needsLook(r)) || (M.rfFilter === 'off' && !r.on);
+    const cards = RF_GROUPS.map(([g, t, ic, intro]) => {
+      const gr = rows.filter((r) => r.group === g && pick(r));
+      return gr.length ? sect(t, [help(intro), list(gr.map(rfSourceRow))], { ic, count: gr.length, attrs: { 'data-c3set-rf-card': g } }) : null;
+    });
+    return [top, ...(cards.some(Boolean) ? cards : [fold(null, M.rfFilter === 'off' ? 'Every source is on.' : 'Nothing needs a look. Every source refreshed on time.')]), rfRules(), rfLogCard()];
+  }
+
+  const BUILD = { about: aboutSec, workspaces: workspacesSec, boards: boardsSec, connectors: () => [...connectorsSec(), finderBlock(M.ws)], refresh: refreshSec, recording: recordingSec, time: timeSec, sharing: sharingSec, access: accessSec, sessions: sessionsSec, privacy: privacySec, appearance: appearanceSec, updates: updatesSec };
 
   function searchView() {
     const hits = rowsMatching(M.q);
@@ -744,7 +968,7 @@ export function mountSettings(host, ctx = {}) {
     // never rebuild under a field the PM is typing in
     const a = document.activeElement;
     if (a && body.contains(a) && ((a.tagName === 'INPUT' && a.type === 'text') || a.tagName === 'TEXTAREA')) { if (!draw.pending) { draw.pending = true; a.addEventListener('blur', drawAfterBlur, { once: true }); } return; }
-    paintNav();
+    paintNav(); rfWatch();
     if (M.q) { body.replaceChildren(...searchView().filter(Boolean)); return; }
     const [id, title, ic, intro] = SECTIONS.find((s) => s[0] === M.sec);
     const needsStore = id !== 'about';

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": [