create-pmos 0.211.0 → 0.212.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.211.0",
+  "version": "0.212.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@d5e2b69
+kernel-source: pmos@316d11d
 assembled: 2026-10-14
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-14T02:17:42Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T02:50:31Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-10-14T02:17:42Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T02:50:31Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-14T02:17:42Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T02:50:31Z"}
 status: stable
 ---
 

package/workspace/c3-settings-test.js

@@ -27,7 +27,7 @@ const finish = async (code) => {
 };
 process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
 
-const SECTIONS = ['about', 'workspaces', 'boards', 'connectors', 'recording', 'time', 'sharing', 'access', 'sessions', 'privacy', 'appearance', 'updates'];
+const SECTIONS = ['about', 'workspaces', 'boards', 'connectors', 'refresh', 'recording', 'time', 'sharing', 'access', 'sessions', 'privacy', 'appearance', 'updates'];
 
 async function waitFor(page, fn, arg, ms = 8000) {
   try { await page.waitForFunction(fn, arg, { timeout: ms }); return true; } catch { return false; }
@@ -66,7 +66,7 @@ async function waitFor(page, fn, arg, ms = 8000) {
   /* ── B: every section draws ── */
   await waitFor(page, () => !!document.querySelector('[data-c3set-section] .st-row'));
   ok('B0 Settings opens on About you, drawn as console3 section cards', await waitFor(page, () => !!document.querySelector('[data-c3set-section="about"] .card.sect .list .nrow.st-row #c3set-you-name')));
-  ok('B1 the nav lists twelve sections', (await page.$$eval('[data-c3set-nav] [data-c3set-sec]', (b) => b.length)) === SECTIONS.length);
+  ok('B1 the nav lists every section', (await page.$$eval('[data-c3set-nav] [data-c3set-sec]', (b) => b.length)) === SECTIONS.length);
   for (const id of SECTIONS) {
     await page.click(`[data-c3set-nav] [data-c3set-sec="${id}"]`);
     const drew = await waitFor(page, (s) => { const x = document.querySelector('[data-c3set-section="' + s + '"]'); return x && x.querySelectorAll('.st-row, .sect, .fold').length > 0; }, id, 4000);
@@ -107,6 +107,57 @@ async function waitFor(page, fn, arg, ms = 8000) {
   await page.click('[data-c3set-nav] [data-c3set-sec="access"]');
   ok('D7 phone pairing shows, turned off, with the reason', await waitFor(page, () => { const r = document.querySelector('[data-c3set-row="access.pair"]'); return !!r && !!r.querySelector('button:disabled') && !!r.querySelector('.fold'); }));
 
+
+  /* ── R: Data refresh (data-refresh-settings R9) ── */
+  await page.goto(BASE + '/c3.html?tab=settings');
+  await waitFor(page, () => !!document.querySelector('[data-c3set-nav] [data-c3set-sec="connectors"]'));
+  await page.click('[data-c3set-nav] [data-c3set-sec="connectors"]');
+  ok('R1 Connectors links to Data refresh instead of holding its schedule', await waitFor(page, () => { const a = document.querySelector('[data-c3set-row="conn.cal.refresh"]'); const b = document.querySelector('[data-c3set-row="conn.jira.refresh"]'); return !!a && !!b && !!a.querySelector('button.lk') && /Data refresh/.test(a.textContent) && !a.querySelector('select') && !b.querySelector('select'); }));
+  await page.click('[data-c3set-row="conn.cal.refresh"] button.lk');
+  ok('R2 the link opens the Data refresh section', await waitFor(page, () => !!document.querySelector('[data-c3set-section="refresh"] [data-c3set-rf-card]')));
+  ok('R3 the section draws 13 source rows in three cards', await waitFor(page, () => document.querySelectorAll('[data-c3set-section="refresh"] [data-c3set-rf]').length === 13 && document.querySelectorAll('[data-c3set-rf-card]').length === 3));
+  ok('R3b the overview, the rules and the log are there', await page.evaluate(() => !!document.querySelector('[data-c3set-rf-sum]') && !!document.querySelector('[data-c3set-rf-all]') && !!document.querySelector('[data-c3set-rf-rules]') && !!document.querySelector('[data-c3set-rf-log]')));
+  ok('R3c a source with its own home says where, and has no editor button', await page.evaluate(() => { const r = document.querySelector('[data-c3set-rf="scan"]'); return !!r && /Set in Initiatives/.test(r.textContent) && !r.querySelector('[data-c3set-rf-open]'); }));
+  ok('R3d the filter Off lists the sources that are off', await (async () => { await page.click('[data-c3set-section="refresh"] .seg [data-v="off"]'); const n = await page.evaluate(() => document.querySelectorAll('[data-c3set-rf]').length); await page.click('[data-c3set-section="refresh"] .seg [data-v="all"]'); return n > 0 && n < 13; })());
+
+  // turning on needs no question
+  await page.click('[data-c3set-rf-on="calendar"]');
+  ok('R4 turning a source on posts on:true and shows a toast with Undo', await waitFor(page, () => { const t = document.querySelector('[data-c3-toast]'); return !!t && /Turned on: Calendar/.test(t.textContent) && !!t.querySelector('[data-c3-toast-action]'); }));
+  ok('R4b the server has it on', await waitFor(page, async () => { const j = await (await fetch('/api/refresh')).json(); return j.rows.find((x) => x.id === 'calendar').on === true; }));
+
+  // the schedule editor posts the schedule
+  await page.click('[data-c3set-rf-open="calendar"]');
+  ok('R5 Schedule opens the editor under the row', await waitFor(page, () => !!document.querySelector('[data-c3set-rf="calendar"] [data-c3set-rf-editor]')));
+  await page.selectOption('#c3set-rf-time-0', '07:00');
+  const posted = page.waitForRequest((q) => q.url().endsWith('/api/refresh/source') && q.method() === 'POST' && /schedule/.test(q.postData() || ''), { timeout: 8000 }).catch(() => null);
+  await page.click('[data-c3set-rf-save="calendar"]');
+  const req = await posted; const body = req ? JSON.parse(req.postData()) : null;
+  ok('R6 Save posts {id, schedule} with the new time', body && body.id === 'calendar' && body.schedule.kind === 'daily' && body.schedule.times[0] === '07:00', JSON.stringify(body));
+  ok('R6b the save says so in a toast with Undo', await waitFor(page, () => { const t = document.querySelector('[data-c3-toast]'); return !!t && /Saved: Calendar/.test(t.textContent) && /07:00/.test(t.textContent) && !!t.querySelector('[data-c3-toast-action]'); }));
+  ok('R6c the row shows the new schedule', await waitFor(page, () => /07:00/.test((document.querySelector('[data-c3set-rf="calendar"] .chips') || {}).textContent || '')));
+
+  // turning a source off asks first and names what it affects
+  await page.click('[data-c3set-rf-on="jira"]');
+  await waitFor(page, async () => (await (await fetch('/api/refresh')).json()).rows.find((x) => x.id === 'jira').on === true);
+  await page.click('[data-c3set-rf-on="jira"]');
+  ok('R7 turning off asks first and names the impact and what uses it', await waitFor(page, () => { const a = document.querySelector('[data-c3set-rf-ask="jira"]'); return !!a && /Sprint summaries stop/.test(a.textContent) && /Core documents/.test(a.textContent) && /Initiative driver/.test(a.textContent); }));
+  ok('R7b nothing changed yet', await page.evaluate(async () => (await (await fetch('/api/refresh')).json()).rows.find((x) => x.id === 'jira').on === true));
+  await page.click('[data-c3set-rf-off-go="jira"]');
+  ok('R7c confirming posts off and shows a toast with Undo', await waitFor(page, async () => { const j = await (await fetch('/api/refresh')).json(); const t = document.querySelector('[data-c3-toast]'); return j.rows.find((x) => x.id === 'jira').on === false && !!t && /Turned off: Jira/.test(t.textContent) && !!t.querySelector('[data-c3-toast-action]'); }));
+
+  // the rules
+  await page.selectOption('#c3set-rf-max', '2');
+  ok('R8 a rule is saved through POST /api/refresh/rules', await waitFor(page, async () => (await (await fetch('/api/refresh')).json()).rules.max === '2'));
+  ok('R8b the rules card shows quiet and working hours read-only', await page.evaluate(() => { const r = document.querySelector('[data-c3set-row="rf.quiet"]'); const w = document.querySelector('[data-c3set-row="rf.window"]'); return !!r && !!w && !r.querySelector('select, input') && /09:00 to 18:00/.test(w.textContent); }));
+
+  // the log
+  const ran = await page.evaluate(async () => { const { pmPost } = await import('/pm/http.js'); const w = (await (await fetch('/api/refresh')).json()).ws; return pmPost('/api/refresh/run', { id: 'signals', ws: w }); });
+  ok('R9 a refresh can be pressed', ran && ran.ok, JSON.stringify(ran));
+  ok('R9b the log view lists the run, newest first, with Export', await waitFor(page, () => { const l = document.querySelector('[data-c3set-rf-log]'); return !!l && l.querySelectorAll('[data-c3set-rfrun]').length > 0 && /Signals/.test(l.textContent) && /\/api\/refresh\/log\.csv/.test((l.querySelector('[data-c3set-rf-export]') || {}).href || ''); }, null, 20000));
+  await page.selectOption('#c3set-rf-log-result', 'failed');
+  ok('R9c filtering by result puts it in the Export link', await waitFor(page, () => /result=failed/.test((document.querySelector('[data-c3set-rf-export]') || {}).href || '')));
+  await page.selectOption('#c3set-rf-log-result', '');
+
   /* ── E: theme ── */
   await page.click('[data-c3set-nav] [data-c3set-sec="appearance"]');
   await waitFor(page, () => !!document.querySelector('[data-c3set-row="look.theme"] [data-v="dark"]'));

package/workspace/guide/data-freshness.md

@@ -1,7 +1,7 @@
 ---
 type: Guide
 title: "Data freshness: how the workspace keeps up to date, and how old each source is"
-timestamp: 2026-10-12
+timestamp: 2026-10-14
 ---
 
 # Data freshness
@@ -15,18 +15,18 @@ The workspace checks each registered repository every 10 seconds for a change: a
 - **Initiatives** (Briefing, Calendar and the reports) are read in a separate process, so the workspace keeps answering while it reads. While a read runs, the pages show the last result. The result is kept on this machine, so after a restart the pages open at once with the last result and a new read starts only if the repository changed.
 - **Board and My work** are folded in a separate thread for the same reason.
 
-To stop the checks for one repository, press **Stop watching this repository** in Settings › Data freshness. The pages then show what was read last, and **Refresh** reads it again. Press **Watch this repository for changes** to start the checks again.
+To stop the checks, turn off **Repository and initiatives** in Settings › Data refresh. This stops them for every registered repository. The pages then show what was read last, and **Refresh now** reads it again. Turn it on to start the checks again.
 
 ## Jira, calendar, My work and tracker items
 
-The workspace holds no password or token, and it never calls these services. An agent session reads each one with your own connection, on a schedule or when you press **Refresh**:
+The workspace holds no password or token, and it never calls these services. An agent session reads each one with your own connection, on the schedule set in **Settings › Data refresh**, or when you press **Refresh**:
 
 | Source | Skill | Default schedule | Shown as old after |
 |---|---|---|---|
-| Calendar | calendar-sync | 06:30 and 12:30 every day (set `calendar`) | 8 hours |
-| Jira status | jira-sync | 06:30 every day (set `jira`) | 26 hours |
-| My work | my-work-read | when you press Read again | 26 hours |
-| Tracker items | tracker-refresh | Friday 15:30 (set `tracker`) | 8 days |
+| Calendar | calendar-sync | 06:30 and 12:30 every day | 8 hours |
+| Jira status | jira-sync | 06:30 every day | 26 hours |
+| My work | my-work-read | when you press Refresh | 26 hours |
+| Tracker items | tracker-refresh | Friday 15:30 | 8 days |
 
 The calendar-sync skill reads today and the next 14 days, read-only, and saves the events with this command:
 
@@ -52,4 +52,31 @@ Each page shows a short line that says when each source was last read, for examp
 - A watched repository is not named, because the workspace checks it every few seconds.
 - The refresh icon at the end of the line reads every source again: the initiatives on this machine, and an agent read for Calendar, Jira status, My work and tracker items. A source that is switched off or is being read already is left alone. A short note says how many reads started, or which could not start.
 
-Settings › Data freshness shows every source in one table: when it was read, its state, its schedule, and **Refresh**.
+## Settings › Data refresh
+
+**Settings › Data refresh** is the one place that says what PMOS refreshes and when. It lists 13 sources in three groups: from your tools (Calendar, Jira, work assigned to you, tracker files), written by PMOS (the morning briefing, the day check, the horizon scan, core documents, the initiative driver, the report finder, signals) and on change (the repository and Git sync).
+
+For each source you can:
+
+- Turn it on or off. Before a source goes off, PMOS lists what it affects, for example "The initiative driver cannot see ticket moves".
+- Set its schedule (the tool sources and the briefing): only when you press Refresh, every 15 minutes to 4 hours, daily or on working days at up to four times, or weekly. The day check runs every 30 or 60 minutes. The horizon scan and the report finder keep their schedules where they are set today, and the row says where.
+- Press **Refresh now**. A source whose inputs are old offers **Refresh inputs first**.
+- See when it last refreshed, the result, what it got or the error, the next run, what it uses and what uses it.
+
+The schedules that the recommended sets made in schedules.json for these five skills move here once, on the first start. Each old entry is switched off with the reason "Moved to Settings › Data refresh". A recommended set or **Prepare my day** now turns the source on here instead of adding a schedule.
+
+### The order of refreshes
+
+A refresh waits for the sources it uses. The briefing waits for work assigned to you; core documents wait for the repository, Jira and the horizon scan; the driver waits for the repository, Jira and core documents. While an input is running or due, the refresh waits for up to 30 minutes, then it runs anyway and its log line says which input it did not wait for. An input that failed or is off does not hold anything: the refresh uses the last good data, and the row shows it under "Built on old data".
+
+### The rules
+
+- **Catch up**: a refresh missed while PMOS was closed runs once when PMOS starts. Off, the missed slot is skipped and written to the log.
+- **Retry**: a failed scheduled refresh is tried once more after 15 or 60 minutes.
+- **Tell me**: a failed scheduled refresh adds one item to Needs you on the Briefing.
+- **Runs at once**: at most this many scheduled refreshes run together. A refresh you press is never held.
+- No scheduled refresh starts in your quiet hours; the background jobs keep to the day check's working hours.
+
+### The refresh log
+
+Every background run is written to `refresh-log.jsonl` in your runtime folder on this computer: a start line and an end line with the result, the time it took, what it got and the error. A skipped slot writes a line with the reason. The start line records each input's state and when it last refreshed. A done refresh of Jira or of work assigned to you keeps a copy of what it read, so you can see what PMOS knew at any time. Lines and copies older than the keep setting (30, 90 or 365 days, or forever; 90 by default) are removed once a day. The log view filters by source and result, and **Export** downloads it as CSV.

package/workspace/guide/index.md

@@ -44,7 +44,7 @@ On a desktop the workspace is one frame. [Layout](layout.md) explains each part.
 - [Start the workspace without a terminal](launcher.md): the PMOS app, the login item and `pmos launcher`.
 - [Jira tickets](jira.md): Jira tickets drafted from the PRD, pushed when you select them, and their status.
 - [My work](my-work.md): the work assigned to you, its order, the brief to an agent, and `pmos my-work`.
-- [Data freshness](data-freshness.md): when each source is read again, how old it is, and `pmos calendar`.
+- [Data freshness](data-freshness.md): when each source is read again, how old it is, Settings › Data refresh and its log, and `pmos calendar`.
 - [People](people.md): the people you work with in a repository, how they get there, and `pmos people`.
 - [Docs](docs.md): whether each linked document is the same as, ahead of or behind its Google Docs and Confluence copy.
 - [Calendar popup](calendar-popup.md): open the full calendar over any page of the console with the calendar button or the C key, and close it.

package/workspace/lib/driver-run.js

@@ -128,7 +128,8 @@ function create(deps) {
     } catch (e) { warn('driver run end', e); }
   }
 
-  function tick({ now = Date.now(), env } = {}) {
+  /* `sweepNow` (Refresh now, data-refresh-settings R8) runs the unblock sweep at once, inside or outside the window. */
+  function tick({ now = Date.now(), env, sweepNow = false } = {}) {
     if (off(env || deps.env)) return { off: true };
     const summary = { epoch: 0, woke: 0, swept: 0, started: 0, refused: 0 };
     const leads = [];
@@ -155,9 +156,9 @@ function create(deps) {
         for (const l of newWakes) { D.append(file, l, { now }); summary.woke++; }
         state = readState(file);
         // The unblock sweep: deterministic, every 30 minutes inside the day-check window.
-        const due = !lastSweep.has(file) || now - lastSweep.get(file) >= D.SWEEP_EVERY_MS;
+        const due = sweepNow || !lastSweep.has(file) || now - lastSweep.get(file) >= D.SWEEP_EVERY_MS;
         let factsNow = null;
-        if (due && dayCheckOpen(settings, now, deps.inQuiet)) {
+        if (due && (sweepNow || dayCheckOpen(settings, now, deps.inQuiet))) {
           const g = gather(w, deps.ctx, { now, includeWork: w.id === home, runtimeDir: deps.runtimeDir, driverState: state });
           if (g.ok) {
             factsNow = g.facts;

package/workspace/lib/freshness.js

@@ -112,6 +112,8 @@ function create(o) {
   });
 
   function scheduleOf(skill) {
+    // data-refresh-settings: a skill source's schedule lives in Settings › Data refresh, which answers for it here.
+    if (skill && o.scheduleOf) { try { const r = o.scheduleOf(skill); if (r !== undefined) return r; } catch { /* fall back to schedules.json */ } }
     if (!skill || !o.schedules) return null;
     let list = [];
     try { list = o.schedules() || []; } catch { return null; }

package/workspace/lib/refresh-run.js

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