create-pmos 0.522.0 → 0.524.0

package/workspace/lib/morning-goals.js

@@ -0,0 +1,191 @@
+'use strict';
+/* morning-goals.js — the data under Good morning's quarter strip (build brief Good morning, GM1; frames NyG1Morning to NyG4Phone).
+ *
+ * ONE COUNT. stateOf(g) is the one place a goal's quarter state is decided; the strip, the goal tags and the morning snapshot all read it.
+ * g is a goal of the Intelligence model (lib/insights-premium.js goalsOf, decorated by lib/forecast.js), so a goal says the same thing on
+ * Good morning and in Intelligence.
+ *
+ *   stateOf(g)                 → 'reached' | 'on-track' | 'reading' | 'at-risk' | 'will-miss' | null (a watched metric: not a goal)
+ *                                On track only from a read (W2 "Status says what it knows"): a forecast on track, or a fresh reading on its
+ *                                line when the goal has no forecast. Too early, held, a stale reading and no reading are "still reading".
+ *   collect(products)          → [{ key, ws, product, id, title, state, moves }]     products: [{ ws, name, goals }]
+ *   stripOf(list, line)        → { order, counts, total, good, line, gap, verdict, why, byProduct }
+ *   proposeLine(strip)         → { line, why } | null       Claude's ✦: the goals reached, on track or still in reach. None without a read
+ *   tagsOf(list)               → { "<ws>:<initiative>": { goal, title, state } }    the goal an initiative moves (the worst state wins)
+ *   yesEffect(o)               → { scope, id, title, from, to, clause } | null       a forecast run again with the proposed date
+ *   quarterOf(day) · weeksLeft(day)
+ *
+ * TWO LEDGERS in the runtime folder, append-only:
+ *   quarter-line.jsonl   { at, by, kind: 'line' | 'off', quarter, line? }   the PM's line (✓) or the ✦ put off for the quarter (✕)
+ *   goal-morning.jsonl   { at, day, states: { key: state } }                the day's first read, once a day
+ *   lineFor(dir, quarter) → { line, at } | { off: true } | null · setLine(dir, actor, i) · putOff(dir, actor, quarter)
+ *   snapshotFor(dir, day) → line | null · takeSnapshot(dir, day, list, at) → line (the existing one when the day has one)
+ *   deltaOf(snapshot, list) → { at, from, to, moved: [{ key, title, product, from, to }] } | null
+ *
+ * NOTHING HERE MAKES A NUMBER UP: a state comes from a forecast or a reading the model holds, the line from the PM's press. */
+const fs = require('fs');
+const path = require('path');
+
+const ORDER = Object.freeze(['reached', 'on-track', 'reading', 'at-risk', 'will-miss']);
+const WORDS = Object.freeze({ reached: 'reached', 'on-track': 'on track', reading: 'still reading', 'at-risk': 'at risk', 'will-miss': 'will miss' });
+const GOOD = new Set(['reached', 'on-track']);
+const LINE_FILE = 'quarter-line.jsonl', SNAP_FILE = 'goal-morning.jsonl';
+const DAY = 864e5;
+const fin = (v) => typeof v === 'number' && Number.isFinite(v);
+const str = (v) => (typeof v === 'string' ? v : '');
+const dayMs = (v) => { const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(String(v || '')); return m ? Date.UTC(+m[1], +m[2] - 1, +m[3]) : null; };
+const NUM = ['No', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten'];
+const say = (n) => (n >= 0 && n < NUM.length ? NUM[n] : String(n));
+const noun = (n, one, many) => n + ' ' + (n === 1 ? one : many);
+
+const FORECAST = { 'on-track': 'on-track', 'at-risk': 'at-risk', 'will-miss': 'will-miss', 'too-early': 'reading', held: 'reading' };
+function stateOf(g) {
+  if (!g || g.role === 'watch') return null;
+  const r = g.reading || null, head = g.pace && g.pace.head;
+  if (head === 'Reached' || head === 'Done' || (r && r.line === 'target reached')) return 'reached';
+  const fresh = !!(r && r.dot && r.dot !== 'none' && !r.stale);
+  if (g.type === 'Stay within') {
+    if (!fresh) return 'reading';
+    return r.dot === 'broken' ? 'will-miss' : r.dot === 'close' ? 'at-risk' : 'on-track';
+  }
+  if (g.type === 'Done or not') {
+    if (g.pace && g.pace.tone === 'late') return 'will-miss';
+    return fresh ? 'on-track' : 'reading';
+  }
+  const F = g.forecast && FORECAST[g.forecast.state];
+  if (F) return F === 'on-track' && !fresh && r ? 'reading' : F;
+  if (!fresh) return 'reading';
+  return r.dot === 'behind' ? 'at-risk' : 'on-track';
+}
+
+function collect(products) {
+  const out = [];
+  for (const p of products || []) for (const g of (p && p.goals) || []) {
+    const state = stateOf(g);
+    if (!state || !g.id) continue;
+    out.push({ key: p.ws + ':' + g.id, ws: p.ws, product: p.name || p.ws, id: String(g.id), title: str(g.title) || String(g.id), state,
+      moves: (g.moves || []).map((m) => m && m.id).filter(Boolean).map(String) });
+  }
+  return out;
+}
+
+function stripOf(list, line) {
+  const counts = Object.fromEntries(ORDER.map((s) => [s, 0]));
+  for (const g of list || []) if (counts[g.state] !== undefined) counts[g.state]++;
+  const total = (list || []).length, good = counts.reached + counts['on-track'];
+  const L = fin(line) && line > 0 ? Math.min(Math.round(line), total || Math.round(line)) : null;
+  const byP = new Map();
+  for (const g of list || []) {
+    const b = byP.get(g.ws) || { ws: g.ws, product: g.product, total: 0, good: 0, risk: 0, miss: 0, reading: 0 };
+    b.total++; if (GOOD.has(g.state)) b.good++; if (g.state === 'at-risk') b.risk++; if (g.state === 'will-miss') b.miss++; if (g.state === 'reading') b.reading++;
+    byP.set(g.ws, b);
+  }
+  const byProduct = [...byP.values()];
+  if (!total) return { order: ORDER, words: WORDS, counts, total, good, line: L, gap: null, verdict: '', why: '', byProduct };
+  const verdict = noun(good, 'goal', 'goals') + ' on track or better.' + (L ? ' You set the line at ' + L + '.' : '');
+  const gap = L ? L - good : null;
+  let why = '';
+  const worst = byProduct.filter((b) => b.miss + b.risk > 0).sort((a, b) => (b.miss - a.miss) || (b.miss + b.risk - a.miss - a.risk) || a.product.localeCompare(b.product))[0];
+  if (gap !== null && gap <= 0) why = gap === 0 ? 'On your line.' : say(-gap) + ' above your line.';
+  if (worst && (gap === null || gap > 0)) {
+    const lead = gap ? say(gap) + ' short. ' : '';
+    const of = (k) => (worst.total === 1 ? 'its one goal' : k + ' of its ' + worst.total + ' goals');
+    const part = worst.miss ? of(worst.miss) + ' will miss at today\'s pace'
+      : of(worst.risk) + (worst.risk === 1 ? ' is at risk' : ' are at risk');
+    why = lead + worst.product + (gap ? ' is most of the gap: ' : ' holds the most at stake: ') + part + '.';
+  } else if (gap > 0) why = say(gap) + ' short. ' + noun(counts.reading, 'goal is', 'goals are') + ' still reading.';
+  return { order: ORDER, words: WORDS, counts, total, good, line: L, gap, verdict, why, byProduct };
+}
+
+/** Claude's ✦ for the quarter line: every goal reached, on track or at risk can still make it; a goal that will miss or is unread is left out. */
+function proposeLine(strip) {
+  if (!strip || !strip.total) return null;
+  const read = strip.total - strip.counts.reading;
+  if (!read) return null;
+  const line = strip.counts.reached + strip.counts['on-track'] + strip.counts['at-risk'];
+  if (!line) return null;
+  const parts = [strip.counts.reached && strip.counts.reached + ' reached', strip.counts['on-track'] && strip.counts['on-track'] + ' on track', strip.counts['at-risk'] && strip.counts['at-risk'] + ' at risk that can still make it'].filter(Boolean);
+  return { line, of: strip.total, why: 'Of ' + noun(strip.total, 'goal', 'goals') + ': ' + parts.join(', ') + '. The ones that will miss or are not read yet are left out.' };
+}
+
+/** The goal an initiative moves, for the goal tag on its Your move row. Two goals: the one in the worse state. */
+const RANK = { 'will-miss': 0, 'at-risk': 1, reading: 2, 'on-track': 3, reached: 4 };
+function tagsOf(list) {
+  const out = {};
+  for (const g of list || []) for (const id of g.moves || []) {
+    const k = g.ws + ':' + id, had = out[k];
+    if (!had || RANK[g.state] < RANK[had.state]) out[k] = { goal: g.id, title: g.title, state: g.state, words: WORDS[g.state] };
+  }
+  return out;
+}
+
+/** What Yes does: the forecast run again with the proposed date. o: { goal: model goal, date } or { initiative: { id, title }, jira, date, from }.
+ *  FC is lib/forecast.js. A clause only when both states are known and differ. */
+function yesEffect(o, FC, today) {
+  if (!o || !/^\d{4}-\d{2}-\d{2}$/.test(str(o.date))) return null;
+  const word = (s) => WORDS[FORECAST[s] || s] || null;
+  if (o.goal) {
+    const g = o.goal, was = stateOf(g);
+    const re = FC.goalForecast(Object.assign({}, g, { byAt: o.date }), { today });
+    const to = re ? FORECAST[re.state] : null;
+    if (!was || !to || to === 'reading' || was === 'reading' || to === was) return null;
+    return { scope: 'goal', id: g.id, title: g.title, from: was, to, clause: (g.title || 'The goal') + ' moves from ' + WORDS[was] + ' to ' + WORDS[to] + '.' };
+  }
+  if (o.initiative && o.jira && /^\d{4}-\d{2}-\d{2}$/.test(str(o.from))) {
+    const a = FC.deliveryForecast({ end: o.from }, o.jira, { today }), b = FC.deliveryForecast({ end: o.date }, o.jira, { today });
+    const from = a && a.state, to = b && b.state;
+    if (!from || !to || from === to || from === 'held' || to === 'held' || from === 'too-early' || to === 'too-early') return null;
+    return { scope: 'initiative', id: o.initiative.id, title: o.initiative.title || o.initiative.id, from, to, clause: 'Its delivery moves from ' + word(from) + ' to ' + word(to) + '.' };
+  }
+  return null;
+}
+
+const quarterOf = (day) => { const m = /^(\d{4})-(\d{2})/.exec(str(day)); return m ? m[1] + '-Q' + (Math.floor((+m[2] - 1) / 3) + 1) : null; };
+function weeksLeft(day) {
+  const t = dayMs(day); if (t === null) return null;
+  const d = new Date(t), qEnd = Date.UTC(d.getUTCFullYear(), Math.floor(d.getUTCMonth() / 3) * 3 + 3, 1);
+  return Math.max(0, Math.floor((qEnd - t) / (7 * DAY)));
+}
+
+/* ── the ledgers ── */
+function readLines(dir, file) {
+  if (!dir) return [];
+  let text = '';
+  try { text = fs.readFileSync(path.join(dir, file), 'utf8'); } catch { return []; }
+  const out = [];
+  for (const raw of text.split('\n')) { if (!raw.trim()) continue; try { const l = JSON.parse(raw); if (l && typeof l === 'object') out.push(l); } catch { /* a torn line is skipped */ } }
+  return out;
+}
+function append(dir, file, line) { fs.mkdirSync(dir, { recursive: true }); fs.appendFileSync(path.join(dir, file), JSON.stringify(line) + '\n'); return line; }
+
+function lineFor(dir, quarter) {
+  let out = null;
+  for (const l of readLines(dir, LINE_FILE)) if (l.quarter === quarter) out = l.kind === 'off' ? { off: true, at: l.at } : l.kind === 'line' && fin(l.line) ? { line: l.line, at: l.at } : out;
+  return out;
+}
+function setLine(dir, actor, i) {
+  const quarter = str(i && i.quarter), line = Number(i && i.line);
+  if (!/^\d{4}-Q[1-4]$/.test(quarter)) return { error: 'quarter is required, as YYYY-Qn' };
+  if (!Number.isInteger(line) || line < 1 || line > 500) return { error: 'line is a whole number of goals, 1 or more' };
+  return { ok: true, line: append(dir, LINE_FILE, { at: new Date().toISOString(), by: (actor && actor.by) || null, kind: 'line', quarter, line }) };
+}
+function putOff(dir, actor, quarter) {
+  if (!/^\d{4}-Q[1-4]$/.test(str(quarter))) return { error: 'quarter is required, as YYYY-Qn' };
+  return { ok: true, line: append(dir, LINE_FILE, { at: new Date().toISOString(), by: (actor && actor.by) || null, kind: 'off', quarter }) };
+}
+
+function snapshotFor(dir, day) { return readLines(dir, SNAP_FILE).find((l) => l.day === day && l.states && typeof l.states === 'object') || null; }
+function takeSnapshot(dir, day, list, at) {
+  const had = snapshotFor(dir, day);
+  if (had || !dir || !(list || []).length) return had;
+  return append(dir, SNAP_FILE, { at: at || new Date().toISOString(), day, states: Object.fromEntries(list.map((g) => [g.key, g.state])) });
+}
+function deltaOf(snap, list) {
+  if (!snap || !snap.states) return null;
+  const S = snap.states, keys = Object.keys(S);
+  const from = keys.filter((k) => GOOD.has(S[k])).length, to = (list || []).filter((g) => GOOD.has(g.state)).length;
+  const moved = (list || []).filter((g) => S[g.key] && S[g.key] !== g.state).map((g) => ({ key: g.key, title: g.title, product: g.product, from: S[g.key], to: g.state }));
+  return { at: snap.at, from, to, moved };
+}
+
+module.exports = { ORDER, WORDS, LINE_FILE, SNAP_FILE, stateOf, collect, stripOf, proposeLine, tagsOf, yesEffect, quarterOf, weeksLeft, lineFor, setLine, putOff, snapshotFor, takeSnapshot, deltaOf };

package/workspace/lib/onboard-fundamentals.js

@@ -0,0 +1,205 @@
+'use strict';
+/* onboard-fundamentals.js — the fundamentals PMOS settles for a new product right after setup (onboarding build B1, frame ObA3Fundamentals).
+ *
+ *   settle({ root, ws, sources, fresh, refresh, launcher, now }) → { at, lines: [line] }   reads project-context.md, writes what each line says
+ *   change(state, key, { root, ws, refresh, launcher }) → { ok, state }            the one-press change of one line
+ *   workflowHint(purpose)                       → { word } | null             a purpose that names work Product feature does not fit. PURE
+ *   goalFile(name, goal, purpose, today)        → the draft OKR document text. PURE
+ *
+ * A LINE. { key, text, source, change: { label, to } | null, done: bool }. Nothing on the card is a question: each line says what PMOS did and
+ * where the fact came from, and its change undoes or flips it with one press. A line with nothing behind it is left out (zero is silence).
+ *
+ * WHERE THE FACTS COME FROM. Only project-context.md, read back with readContext (the file the PM reviewed): About is its Purpose, the Jira
+ * key its Jira line, the weekly its Weekly line, the goal its Goal draft. A source is called linked only when the setup search reached it
+ * (`sources`: the search's per-source states), so a Jira key the PM typed but no Jira read proved is said as typed, not as linked.
+ *
+ *   profile   D68: pm-artifacts unless the folder holds code (lib/profile-default.js looksLikeCode). Change: flips it.
+ *   workflow  Product feature (D99 wf-default). A purpose that names a tender, vendor onboarding, a campaign … gets a chat link that drafts a
+ *             copy of Product feature for it, as New workflow does. Nothing is written for this line.
+ *   jira      the key is the product's Jira source: Work assigned to you and the Jira status read are turned on for this product, every
+ *             weekday morning (lib/refresh-run.js setSource). Change: turns them off again, only if this setup turned them on.
+ *   calendar  a weekly found in a calendar is the proof the calendar answers: the calendar read is turned on. Change: off again.
+ *   about     the Purpose, as the product's description, with its source. Nothing is written beyond project-context.md.
+ *   goal      ONE key result drafted from the purpose, written as PROPOSED to pmos/planning/okrs/okrs-draft.md. It reads nothing and claims no
+ *             number. Change: removes the file, only while it is the text setup wrote.
+ *   launcher  `pmos launcher on` (an app and a login item), when none is installed. Change: `pmos launcher off`. Only on a real server
+ *             (lib/profile-default.js enabledFor): a scratch server writes no launcher.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const P = require('./project-onboard.js');
+const profileDefault = require('./profile-default.js');
+
+const PROFILE = '.pmos-profile';
+const GOAL_FILE = ['planning', 'okrs', 'okrs-draft.md'];
+const MORNING = { kind: 'weekdays', times: ['07:30'] };
+const HINTS = [
+  [/\btender(s|ing)?\b|\bprocurement\b|\bRFP\b|\brequest for proposal/i, 'tender'],
+  [/\bvendor onboarding\b|\bsupplier onboarding\b|\bonboard(ing)? (new )?vendors?\b/i, 'vendor onboarding'],
+  [/\bcampaigns?\b/i, 'campaign'],
+  [/\bhiring\b|\brecruit(ing|ment)\b/i, 'hiring'],
+  [/\bevents?\b.*\b(launch|conference|summit)\b|\bconference\b/i, 'event'],
+];
+const clip = (s, n) => { s = String(s || '').replace(/\s+/g, ' ').trim(); return s.length > n ? s.slice(0, n - 1).replace(/\s+\S*$/, '') + '…' : s; };
+const sha = (t) => crypto.createHash('sha256').update(String(t)).digest('hex');
+
+function workflowHint(purpose) {
+  const t = String(purpose || '');
+  for (const [re, word] of HINTS) if (re.test(t)) return { word };
+  return null;
+}
+
+function goalFile(name, goal, purpose, today) {
+  const objective = (goal && goal.objective) || clip(purpose, 110) || name;
+  const kr = goal && goal.kr ? goal.kr : `Choose one number that shows ${name} does what its purpose says`;
+  const from = goal && goal.source_label ? `the purpose, as ${goal.source_label} states it` : 'the purpose in project-context.md';
+  return ['---', 'type: OKR', `title: "Goals: ${String(name).replace(/"/g, "'")} (draft)"`, `timestamp: ${today}`, '---', '',
+    `# Goals: ${name} (draft)`, '',
+    `PMOS drafted this during setup from ${from}. It is a draft: nothing reads it, and no number is claimed. Keep it, change it or remove it in Intelligence.`, '',
+    `## O1 — ${clip(objective, 110)}`, '',
+    `- **KR1** PROPOSED: ${clip(kr, 200)}. Measure: not chosen yet. Source: project-context.md (Purpose).`, ''].join('\n');
+}
+
+function contextOf(root) {
+  const pm = P.pmosIn(root);
+  if (!pm) return { pm: null, file: null, ctx: null };
+  const file = path.join(pm.planning, 'project-context.md');
+  let text = null; try { text = fs.readFileSync(file, 'utf8'); } catch {}
+  return { pm, file, ctx: text == null ? null : P.readContext(text) };
+}
+const answered = (sources, re) => (sources || []).some((s) => re.test(String(s.label || s.id || '')) && (s.state === 'found' || s.state === 'empty'));
+function readProfile(root) { try { return (fs.readFileSync(path.join(root, PROFILE), 'utf8').split('\n')[0] || '').trim(); } catch { return null; } }
+function writeProfile(root, value) {
+  const f = path.join(root, PROFILE);
+  let rest = ''; try { rest = fs.readFileSync(f, 'utf8').split('\n').slice(1).join('\n'); } catch {}
+  fs.writeFileSync(f, value + '\n' + (rest || '# PMOS repository profile (D68): pm-artifacts | product-code\n'));
+}
+/** Turn a refresh source on for this product with a morning read, unless the PM already has it on. → true when this call turned it on. */
+function turnOn(refresh, id, ws, schedule) {
+  if (!refresh) return false;
+  let cur = null; try { const set = refresh.settings(); cur = set && set.sources && set.sources[id]; } catch {}
+  if (cur && cur.on) return false;
+  const r = refresh.setSource(id, schedule ? { on: true, schedule } : { on: true });
+  if (r && r.ok && refresh.ensureOn) refresh.ensureOn(id, ws);   // ensureOn names the product as the source's workspace when none is set
+  return !!(r && r.ok);
+}
+
+/** The refresh settings in the runtime folder (lib/refresh.js, the same file lib/refresh-run.js ticks on), as settle() and change() use them. */
+function refreshAt(dir) {
+  if (!dir) return null;
+  const R = require('./refresh.js');
+  return {
+    settings: () => R.readSettings(dir),
+    setSource: (id, patch) => {
+      const src = R.BY_ID.get(id); if (!src) return { ok: false };
+      const set = R.readSettings(dir); const cur = set.sources[id]; if (!cur) return { ok: false };
+      if (patch.schedule) { const n = R.normalize(src, patch.schedule); if (!n.ok) return n; cur.s = n.s; }
+      if (typeof patch.on === 'boolean') cur.on = patch.on;
+      set.migrated = true; R.writeSettings(dir, set);
+      return { ok: true };
+    },
+    ensureOn: (id, ws) => { const set = R.readSettings(dir); const cur = set.sources[id]; if (cur && ws && !cur.ws) { cur.ws = ws; R.writeSettings(dir, set); } },
+  };
+}
+
+function launcherOps(env = process.env) {
+  if (!profileDefault.enabledFor(env) || String(env.PMOS_AUTO_LAUNCHER || '') === '0') return null;
+  const L = require('./launcher-cli.js');
+  const quiet = () => {};
+  return {
+    installed: () => { try { return L.run(['launcher', 'status'], { say: quiet }) === 0; } catch { return false; } },
+    on: (root) => { try { return L.run(['launcher', 'on', root], { say: quiet, cwd: root }) === 0; } catch { return false; } },
+    off: () => { try { return L.run(['launcher', 'off'], { say: quiet }) === 0; } catch { return false; } },
+  };
+}
+
+function settle({ root, ws, sources = [], fresh = true, refresh = null, launcher = launcherOps(), now = () => new Date() }) {
+  const { pm, ctx } = contextOf(root);
+  const f = (ctx && ctx.fields) || {};
+  const name = (ctx && ctx.name) || path.basename(root);
+  const lines = [];
+  const did = {};
+  // profile (D68)
+  const code = profileDefault.looksLikeCode(root);
+  let prof = readProfile(root);
+  if (code.code && prof !== 'product-code' && (fresh || !prof)) {   // a profile the PM already had is theirs (fresh: setup installed the kit now)
+     writeProfile(root, 'product-code'); prof = 'product-code'; did.profile = 'code'; }
+  else if (!prof) { writeProfile(root, 'pm-artifacts'); prof = 'pm-artifacts'; }
+  lines.push(prof === 'product-code'
+    ? { key: 'profile', text: 'A product with code: records are saved on the default branch, and each initiative gets its own branch.', source: code.code ? code.why : PROFILE, change: { label: 'it is documents only', to: 'docs' } }
+    : { key: 'profile', text: 'A document product: PMOS saves its records for you.', source: 'no code in the folder', change: { label: 'it has code', to: 'code' } });
+  // workflow (D99)
+  const hint = workflowHint(f.purpose && f.purpose.value);
+  lines.push({ key: 'workflow', text: 'Workflow: Product feature, for every new initiative.', source: 'the default workflow',
+    hint: hint ? { word: hint.word, say: `Draft a workflow for ${hint.word} work, as a copy of Product feature, from the purpose of ${name}` } : null,
+    change: { label: 'another workflow', to: 'settings' } });
+  // jira
+  if (ctx && ctx.jira) {
+    const proven = answered(sources, /atlassian|jira/i);
+    if (proven) { did.mywork = turnOn(refresh, 'mywork', ws, MORNING); did.jira = turnOn(refresh, 'jira', ws, MORNING); }
+    lines.push(proven
+      ? { key: 'jira', text: `Jira ${ctx.jira.key} linked: read-only, every weekday morning. Your tickets show in My work.`, source: ctx.jira.url || 'the setup search', change: did.mywork || did.jira ? { label: 'turn off', to: 'off' } : null }
+      : { key: 'jira', text: `Jira ${ctx.jira.key} is noted in the project context. It is not read until Jira answers a search.`, source: 'you', change: null });
+  }
+  // calendar
+  if (f.weekly && f.weekly.source === 'finding' && /calendar/i.test(f.weekly.source_label || '') && answered(sources, /calendar/i)) {
+    did.calendar = turnOn(refresh, 'calendar', ws, null);
+    lines.push({ key: 'calendar', text: `Calendar read: ${f.weekly.value} is your weekly.`, source: f.weekly.source_label, change: did.calendar ? { label: 'turn off', to: 'off' } : null });
+  }
+  // about
+  if (f.purpose && f.purpose.value) lines.push({ key: 'about', text: `About: “${clip(f.purpose.value, 200)}”`, source: f.purpose.source === 'finding' ? f.purpose.source_label : f.purpose.source === 'folder' ? 'the folder README' : 'you', change: { label: 'edit', to: 'context' } });
+  // goal
+  if (pm && (f.purpose || (ctx && ctx.goal))) {
+    const file = path.join(pm.planning, 'okrs', 'okrs-draft.md');
+    // a product that already declares a key result keeps it: no draft beside it (B2 writes the kept outcome as okrs-<quarter>.md)
+    const has = require('./okr-goals.js').read(root);
+    if (!fs.existsSync(file) && !(has.ok && has.objectives.length)) {
+      const text = goalFile(name, ctx && ctx.goal, f.purpose && f.purpose.value, now().toISOString().slice(0, 10));
+      fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, text);
+      did.goal = { file: path.relative(root, file), sha: sha(text) };
+    }
+    if (did.goal) lines.push({ key: 'goal', text: 'Goal file: one key result drafted from the purpose, marked draft. It counts only once you keep it in Intelligence.', source: did.goal.file, change: { label: 'remove', to: 'drop' } });
+  }
+  // launcher
+  if (launcher) {
+    const had = launcher.installed();
+    if (!had) did.launcher = launcher.on(root);
+    if (had || did.launcher) lines.push({ key: 'launcher', text: 'PMOS opens from Applications and starts at login.', source: had ? 'already set up' : 'pmos launcher on', change: { label: 'turn off', to: 'off' } });
+  }
+  return { at: now().toISOString(), root, ws, lines, did };
+}
+
+/** One press on a line's change. Undo only what setup itself did; anything else is a link the page follows (settings, context). */
+function change(state, key, { refresh = null, launcher = launcherOps() } = {}) {
+  if (!state || !Array.isArray(state.lines)) return { ok: false, error: 'Nothing was set up yet.' };
+  const line = state.lines.find((l) => l.key === key);
+  if (!line || !line.change) return { ok: false, error: 'That line has nothing to change.' };
+  const root = state.root, did = { ...(state.did || {}) };
+  let next = { ...line };
+  if (key === 'profile') {
+    const to = line.change.to === 'code' ? 'product-code' : 'pm-artifacts';
+    writeProfile(root, to);
+    next = to === 'product-code'
+      ? { key, text: 'A product with code: records are saved on the default branch, and each initiative gets its own branch.', source: 'you', change: { label: 'it is documents only', to: 'docs' } }
+      : { key, text: 'A document product: PMOS saves its records for you.', source: 'you', change: { label: 'it has code', to: 'code' } };
+  } else if (key === 'jira' || key === 'calendar') {
+    const ids = key === 'jira' ? ['mywork', 'jira'] : ['calendar'];
+    for (const id of ids) if (did[id] && refresh) { refresh.setSource(id, { on: false }); did[id] = false; }
+    next = { key, text: key === 'jira' ? `Jira is not read for this product. Turn it on any time in Settings, Sources.` : 'The calendar is not read. Turn it on any time in Settings, Sources.', source: 'you', change: null };
+  } else if (key === 'goal') {
+    const f = did.goal && path.join(root, did.goal.file);
+    let text = null; try { text = fs.readFileSync(f, 'utf8'); } catch {}
+    if (text != null && sha(text) !== did.goal.sha) return { ok: false, error: 'The goal file was changed after setup, so PMOS leaves it. Remove it yourself if you want.' };
+    if (text != null) fs.unlinkSync(f);
+    did.goal = null;
+    next = { key, text: 'No goal file. Say a goal in the chat any time, and I draft it again.', source: 'you', change: null };
+  } else if (key === 'launcher') {
+    if (launcher) launcher.off();
+    did.launcher = false;
+    next = { key, text: 'PMOS does not start at login. Run `pmos launcher on` to add it again.', source: 'you', change: null };
+  } else return { ok: true, state, follow: line.change.to };
+  return { ok: true, state: { ...state, did, lines: state.lines.map((l) => (l.key === key ? next : l)) } };
+}
+
+module.exports = { settle, change, workflowHint, goalFile, launcherOps, refreshAt, GOAL_FILE, MORNING };

package/workspace/lib/onboarding-progress.js

@@ -15,6 +15,18 @@ function save(root, id, patch) {
   finally { try { fs.unlinkSync(tmp); } catch {} }
   return next;
 }
+/** The moments of gradual exposure (lib/moments.js): { moments?, places? } replace those two fields. It keeps `started` as it was, so a record
+ *  written only for moments never reads as a setup that ran. */
+function saveMoments(root, id, patch) {
+  const f = file(root, id); fs.mkdirSync(path.dirname(f), { recursive: true });
+  const cur = read(root, id), next = { ...cur, updated_at: new Date().toISOString() };
+  if (patch.moments) next.moments = patch.moments;
+  if (patch.places) next.places = patch.places;
+  const tmp = f + '.' + crypto.randomBytes(6).toString('hex') + '.tmp';
+  try { fs.writeFileSync(tmp, JSON.stringify(next) + '\n', { mode: 0o600, flag: 'wx' }); fs.renameSync(tmp, f); }
+  finally { try { fs.unlinkSync(tmp); } catch {} }
+  return next;
+}
 function hasWork(ctx, w) {
   const dirs = [path.join(w.root, 'planning', 'initiatives')];
   try { const state = ctx.stateDirFor && ctx.stateDirFor(w); if (state) dirs.push(path.join(state, 'initiatives')); } catch {}
@@ -33,4 +45,4 @@ function task(ctx, w, body) {
   pmItems.appendEvent(path.join(ctx.runtimeDir, 'pm-items', 'items.jsonl'), ev, new Date());
   return { ...r.body.item, id, title: body.title.trim(), due, flagged: !due };
 }
-module.exports = { read, save, hasWork, task, STEPS };
+module.exports = { read, save, saveMoments, hasWork, task, STEPS };

package/workspace/lib/orchestrator-spawn.js

@@ -11,8 +11,10 @@
  * A run that started is counted toward the day's cap (gate.granted). The count of running runs adds the Driver's runs to the runs
  * started here that have not ended, so the cap covers all orchestrator work together. It also adds `pmWorking`: the PM's chat-panel
  * sessions (a /goal included) that are working now. Those are never held or counted toward the daily cap, but they use the same
- * machine and the same usage, so background work yields to them. `own()` is the runs started here alone, for the Driver's own ask. */
-function wrap({ gate, spawn, driverRunning = () => 0, pmWorking = () => 0 }) {
+ * machine and the same usage, so background work yields to them. `own()` is the runs started here alone, for the Driver's own ask.
+ * `holder(initiative)` (lib/bg-queue.js, one background run per initiative): a start for an initiative that another live background
+ * run holds is held the same way, and tried again on the next tick. */
+function wrap({ gate, spawn, driverRunning = () => 0, pmWorking = () => 0, holder = null }) {
   const live = new Set();
   const prune = () => { for (const s of [...live]) if (!s || s.state === 'exited') live.delete(s); };
   const n = (f) => { try { return Number(f()) || 0; } catch { return 0; } };
@@ -25,6 +27,11 @@ function wrap({ gate, spawn, driverRunning = () => 0, pmWorking = () => 0 }) {
       let g = { allowed: true };
       try { g = gate.mayStart({ running: running() }) || g; } catch { /* a broken gate must not stop the PM's schedules */ }
       if (!g.allowed) return held(g.reason || 'it is not time to start more runs');
+      if (holder && spec && spec.initiative) {
+        let h = null;
+        try { h = holder(spec.initiative); } catch { h = null; }
+        if (h) return held(`another background run (${h.name || h.origin}) is working on ${spec.initiative}`);
+      }
       const s = spawn(spec);
       if (s && s.state !== 'exited') { live.add(s); try { gate.granted(); } catch { /* a counter */ } }
       return s;