create-pmos 0.522.0 → 0.524.0

package/workspace/lib/project-onboard.js

@@ -11,6 +11,8 @@
  *   folderFacts(root, { git })                  → what is in a folder: git root, PMOS, README, commits (no model call)
  *   proposeFolder(parent, name)                 → a destination that does not overwrite anything
  *   draftContext({ project, folder, search })   → the editable context; a field is filled only with provenance
+ *   readContext(text)                           → project-context.md read back: { name, fields, jira }. Setup's fundamentals and
+ *                                                 later readers take About, the Jira key, the weekly and the goal draft from it
  *   initialize({ plan, journalFile, kit, git }) → resumable, idempotent initialization of the chosen folder
  *
  * THE READ-ONLY BOUNDARY (requirement 7). The search run gets no built-in tools (`--tools ""`), user hooks off, slash
@@ -24,28 +26,15 @@ const os = require('os');
 const crypto = require('crypto');
 const cp = require('child_process');
 
-const READ_VERBS = new Set(['search', 'get', 'list', 'read', 'fetch', 'find', 'query', 'lookup', 'view', 'describe', 'retrieve', 'browse', 'resolve']);
-const WRITE_VERBS = new Set(['create', 'update', 'delete', 'add', 'post', 'send', 'write', 'edit', 'move', 'transition', 'comment', 'assign', 'upload',
-  'remove', 'set', 'merge', 'close', 'archive', 'share', 'copy', 'trash', 'label', 'mark', 'apply', 'schedule', 'reply', 'forward', 'draft', 'respond',
-  'invite', 'publish', 'run', 'execute', 'trigger', 'link', 'unlink', 'approve', 'submit', 'save', 'log', 'record', 'register', 'insert', 'append',
-  'clear', 'fork', 'enable', 'disable', 'untrash', 'unmark', 'unlabel', 'cancel', 'install', 'import', 'export', 'generate', 'use', 'push', 'request', 'rename']);
+const { readTool } = require('./connector-read.js');
 const HOOKS_OFF = JSON.stringify({ disableAllHooks: true });
 const MAX_FINDINGS = 40;
-const FIELDS = ['purpose', 'team', 'owner', 'timeline', 'goals'];
+const FIELDS = ['purpose', 'team', 'owner', 'timeline', 'weekly', 'goals'];
 
 const clean = (v, n = 300) => String(v == null ? '' : v).replace(/[\u0000-\u001f\u007f]+/g, ' ').trim().slice(0, n);
 const httpsOnly = (u) => { try { const x = new URL(String(u)); return x.protocol === 'https:' ? x.href.slice(0, 500) : null; } catch { return null; } };
 /** Claude Code's tool prefix for a server name: `mcp__<name with every other character as _>__`. */
 const prefixOf = (name) => 'mcp__' + String(name).replace(/[^A-Za-z0-9_-]/g, '_') + '__';
-const words = (s) => String(s).replace(/([a-z0-9])([A-Z])/g, '$1 $2').split(/[^A-Za-z0-9]+/).filter(Boolean).map((w) => w.toLowerCase());
-
-/** A tool may be granted only when its own name (after the server prefix) leads with a read verb and holds no write verb. */
-function readTool(toolName, prefix) {
-  const own = prefix && toolName.startsWith(prefix) ? toolName.slice(prefix.length) : toolName.replace(/^mcp__[^_]+(?:_[^_]+)*?__/, '');
-  const w = words(own);
-  if (!w.length || w.some((x) => WRITE_VERBS.has(x))) return false;
-  return w.slice(0, 3).some((x) => READ_VERBS.has(x));
-}
 
 function parseMcpList(stdout) {
   const out = [];
@@ -134,8 +123,16 @@ function promptFor(project, sources) {
     'Answer with ONE JSON object and nothing else:',
     '{"findings":[{"id":"f1","source":"<source name>","kind":"jira_project|issue|page|document|channel|other","title":"...","url":"https://...","summary":"one sentence"}],',
     ' "jira_projects":[{"key":"ABC","name":"...","url":"https://...","finding":"f1"}],',
-    ' "fields":{"purpose":{"value":"...","finding":"f2"},"team":null,"owner":null,"timeline":null,"goals":null}}',
+    ' "fields":{"purpose":{"value":"...","finding":"f2"},"team":null,"owner":null,"timeline":null,"weekly":null,"goals":null},',
+    ' "highlights":[{"finding":"f2","headline":"...","detail":"..."}],',
+    ' "goal_draft":{"objective":"...","kr":"...","finding":"f2"},',
+    ' "facts":{"jira":{"key":"ABC","open":42,"mine":6,"due_week":2,"finding":"f1"},"weekly":{"title":"...","weekday":"Tue","time":"10:00","next":"YYYY-MM-DD","finding":"f3"},',
+    '  "goal":{"metric":"...","now":"61%","target":"68%","finding":"f2"},"timeline":{"start":"YYYY-MM-DD","end":"YYYY-MM-DD","finding":"f2"}}}',
     'Rules: report only what a tool returned. A field must cite the id of the finding it came from, else null. Never guess purpose, audience, goals, metrics, owners or dates. At most 40 findings.',
+    '"weekly" is a recurring meeting about the project found in a calendar: its name, day and time, for example "Checkout weekly · Tuesdays 10:00".',
+    '"highlights": at most 3, at most one per source, the most useful thing each source said about the project. headline: at most 8 words; detail: one short sentence (a quote of the purpose, a count of open issues and how many are assigned to the user, or the next date of a recurring meeting).',
+    '"goal_draft": ONE key result a PM could keep for this project, drafted from the purpose finding it cites: an objective in a few words and a key result that names what to measure. It is a draft for the PM to judge. Use null when no finding states a purpose.',
+    '"facts": counts and dates exactly as a tool returned them (open = unresolved issues of the Jira project, mine = of those assigned to the current user, due_week = of mine due in the next 7 days; weekly = a recurring meeting about the project), each citing its finding. Leave out any fact you did not read.',
   ].join('\n');
 }
 function jsonIn(text) {
@@ -183,8 +180,20 @@ async function search({ bound, project, sources, tools, spawnLines: sl = spawnLi
     const v = body && body.fields && body.fields[k];
     if (v && typeof v === 'object' && byId.has(v.finding) && clean(v.value)) fields[k] = { value: clean(v.value, 400), finding: v.finding };
   }
+  const facts = factsOf(body && body.facts, byId);
+  // the source tiles: at most one per source, each citing a finding of a source that answered
+  const highlights = [], tiled = new Set();
+  for (const h of (body && Array.isArray(body.highlights) ? body.highlights : [])) {
+    const f = h && byId.get(h.finding);
+    if (!f || tiled.has(f.source) || !clean(h.headline)) continue;
+    tiled.add(f.source);
+    highlights.push({ finding: f.id, source: f.source, source_label: f.source_label, headline: clean(h.headline, 80), detail: clean(h.detail, 200), url: f.url });
+    if (highlights.length === 3) break;
+  }
+  const g = body && body.goal_draft;
+  const goal = g && typeof g === 'object' && byId.has(g.finding) && clean(g.kr) ? { objective: clean(g.objective, 120), kr: clean(g.kr, 200), finding: g.finding } : null;
   return {
-    ok: true, findings, jira, fields,
+    ok: true, findings, jira, fields, highlights, goal, facts,
     sources: sources.map((s) => {
       const p = per[s.id];
       if (!(tools[s.id] || []).length) return { id: s.id, label: s.label, state: 'failed', error: 'This login has no read access to search it.' };
@@ -195,6 +204,33 @@ async function search({ bound, project, sources, tools, spawnLines: sl = spawnLi
   };
 }
 
+/** The numbers and dates the search read (onboarding B2: the portrait, lib/first-reveal.js). A fact is kept only when it cites a finding
+ *  this run kept, with every value cut to its shape: a count is a whole number, a date is YYYY-MM-DD, text is one short line. */
+const FACT_SHAPES = {
+  jira: { key: 'key', open: 'count', mine: 'count', due_week: 'count' },
+  weekly: { title: 'text', weekday: 'text', time: 'text', next: 'day' },
+  goal: { metric: 'text', now: 'text', target: 'text' },
+  timeline: { start: 'day', end: 'day' },
+};
+function factsOf(raw, byId) {
+  const out = {};
+  if (!raw || typeof raw !== 'object') return out;
+  for (const [k, shape] of Object.entries(FACT_SHAPES)) {
+    const v = raw[k];
+    if (!v || typeof v !== 'object' || !byId.has(v.finding)) continue;
+    const x = { finding: v.finding };
+    for (const [f, t] of Object.entries(shape)) {
+      const y = v[f];
+      if (t === 'count' && Number.isInteger(Number(y)) && Number(y) >= 0 && Number(y) < 1e6 && y !== '' && y !== null) x[f] = Number(y);
+      else if (t === 'day' && /^\d{4}-\d{2}-\d{2}$/.test(String(y || '')) && Number.isFinite(Date.parse(y + 'T00:00:00Z'))) x[f] = String(y);
+      else if (t === 'key' && /^[A-Z][A-Z0-9_]{1,19}$/.test(String(y || ''))) x[f] = String(y);
+      else if (t === 'text' && clean(y)) x[f] = clean(y, 120);
+    }
+    if (Object.keys(x).length > 1) out[k] = x;
+  }
+  return out;
+}
+
 function gitRun(git, args, cwd) {
   try { return cp.execFileSync(git, args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 15000, windowsHide: true }).trim(); }
   catch { return null; }
@@ -253,7 +289,7 @@ function draftContext({ project, folder, found }) {
   }
   if (!f.purpose && folder && folder.readme) f.purpose = { value: folder.readme.slice(0, 300), source: 'folder', title: folder.readme_file };
   if (!f.purpose && clean(project.description) && clean(project.description) !== clean(project.name)) f.purpose = you(project.description);
-  for (const k of ['purpose', 'team', 'owner', 'timeline', 'goals']) if (!f[k]) f[k] = null;
+  for (const k of FIELDS) if (!f[k]) f[k] = null;
   return f;
 }
 
@@ -262,12 +298,43 @@ function contextMarkdown(ctx) {
   const f = ctx.fields || {};
   return ['---', 'type: Reference', `title: "Project context: ${String(ctx.name).replace(/"/g, "'")}"`, `timestamp: ${new Date().toISOString().slice(0, 10)}`, '---', '',
     `# ${ctx.name}`, '', 'Reviewed by the PM during PMOS setup. Facts without a source were left blank on purpose.', '',
-    line('Purpose', f.purpose), line('Team', f.team), line('Owner', f.owner), line('Timeline', f.timeline), line('Goals and metrics', f.goals), line('Link', f.link), line('Code', f.code),
+    line('Purpose', f.purpose), line('Team', f.team), line('Owner', f.owner), line('Timeline', f.timeline), line('Weekly', f.weekly), line('Goals and metrics', f.goals), line('Link', f.link), line('Code', f.code),
     ctx.jira ? `- **Jira:** ${ctx.jira.key}${ctx.jira.name ? ' · ' + ctx.jira.name : ''}${ctx.jira.url ? ' (' + ctx.jira.url + ')' : ''}. Linked as a source; PMOS changed nothing in Jira.` : '- **Jira:** Not linked.',
+    ...(ctx.goal ? [`- **Goal draft:** ${ctx.goal.objective ? ctx.goal.objective.replace(/\n/g, ' ') + ' — ' : ''}${ctx.goal.kr.replace(/\n/g, ' ')} (draft${ctx.goal.source_label ? ', from ' + ctx.goal.source_label : ''})`] : []),
     '', ...(ctx.sources && ctx.sources.length ? ['## Sources read during setup', '', ...ctx.sources.map((s) => `- ${s.title}${s.url ? ' — ' + s.url : ''} (${s.source_label})`), ''] : []),
   ].join('\n') + '\n';
 }
 
+const LABEL_KEY = { purpose: 'purpose', team: 'team', owner: 'owner', timeline: 'timeline', weekly: 'weekly', 'goals and metrics': 'goals', link: 'link', code: 'code' };
+/** project-context.md read back (the file contextMarkdown writes, or the PM's edit of it). → { name, fields: { k: { value, source, source_label } }, jira, goal }.
+ *  A line that says "Not known yet." is no field. PURE. */
+function readContext(text) {
+  const s = String(text || '');
+  const out = { name: clean((/^#\s+(.+)$/m.exec(s) || [])[1] || '', 120), fields: {}, jira: null, goal: null };
+  for (const m of s.matchAll(/^- \*\*([^*:]+):\*\*\s*(.*)$/gm)) {
+    const label = m[1].trim().toLowerCase(), rest = m[2].trim();
+    if (label === 'jira') {
+      const j = /^([A-Z][A-Z0-9_]{1,19})\b(?:\s·\s([^(.]+?))?(?:\s\((https:[^)\s]+)\))?\./.exec(rest);
+      if (j) out.jira = { key: j[1], name: clean(j[2] || '', 120) || null, url: j[3] || null };
+      continue;
+    }
+    if (label === 'goal draft') {
+      const g = /^(?:(.+?) — )?(.+?) \(draft(?:, from ([^)]+))?\)$/.exec(rest);
+      if (g) out.goal = { objective: clean(g[1] || '', 120), kr: clean(g[2], 200), source_label: g[3] ? clean(g[3], 80) : null };
+      continue;
+    }
+    const k = LABEL_KEY[label];
+    if (!k || /^Not known yet\.?$/.test(rest)) continue;
+    const src = /^(.*?) \(source: (.+)\)$/.exec(rest);
+    const value = clean(src ? src[1] : rest, 400);
+    if (!value) continue;
+    const said = src ? src[2] : '';
+    out.fields[k] = said === 'the PM' ? { value, source: 'you' } : said === 'the folder' ? { value, source: 'folder' }
+      : said ? { value, source: 'finding', source_label: clean(said.split(',')[0], 80) } : { value, source: 'you' };
+  }
+  return out;
+}
+
 function writeJson(file, v) {
   fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
   const tmp = file + '.' + crypto.randomBytes(6).toString('hex') + '.tmp';
@@ -282,7 +349,9 @@ function installKit(root, kit) {
   if (fs.existsSync(dest)) throw new Error('A pmos folder is already there. PMOS will not replace it.');
   if (kit.payload) { fs.cpSync(kit.payload, dest, { recursive: true }); }
   else if (kit.buildScript) { cp.execFileSync('bash', [kit.buildScript, root], { stdio: 'ignore', timeout: 300000 }); }
-  else throw new Error('This PMOS install has no kit to add.');
+  // No npm fallback here: only lib/kit-update.js reaches the registry (no-network.test.js). An app installed before the kit shipped with
+  // it gets the kit with its next update.
+  else throw new Error('This PMOS install has no kit to add. Update PMOS in Settings › Updates, then try again.');
   if (!fs.existsSync(path.join(dest, 'AGENTS.md'))) throw new Error('The kit did not install completely.');
   const profile = path.join(root, '.pmos-profile');
   if (!fs.existsSync(profile)) fs.writeFileSync(profile, 'pm-artifacts\n# PMOS repository profile (D68): pm-artifacts | product-code\n');
@@ -290,8 +359,10 @@ function installKit(root, kit) {
   const cur = fs.existsSync(ga) ? fs.readFileSync(ga, 'utf8') : '';
   if (!cur.split('\n').some((l) => l.trim() === '*.jsonl merge=union')) fs.writeFileSync(ga, `${cur}${cur && !cur.endsWith('\n') ? '\n' : ''}*.jsonl merge=union\n`);
 }
+/** Where the kit comes from: the installed app's own payload/ (create-pmos copies it there), the npx bundle's, a PMOS checkout's
+ *  build script. */
 function kitSource(here = __dirname, env = process.env) {
-  const candidates = [env.PMOS_KIT_PAYLOAD, path.join(here, '..', '..', 'payload'), path.join(here, '..', '..', 'npm-pkg', 'payload')].filter(Boolean);
+  const candidates = [env.PMOS_KIT_PAYLOAD, path.join(here, '..', 'payload'), path.join(here, '..', '..', 'payload'), path.join(here, '..', '..', 'npm-pkg', 'payload')].filter(Boolean);
   const payload = candidates.find((p) => fs.existsSync(path.join(p, 'AGENTS.md')));
   if (payload) return { payload };
   const buildScript = path.join(here, '..', '..', 'kit', 'build-kit.sh');
@@ -360,4 +431,4 @@ function initialize({ plan, journalFile, kit = kitSource(), git = 'git', now = (
   return { ok: true, root, journal: j };
 }
 
-module.exports = { discover, inventory, search, readTool, parseMcpList, prefixOf, folderFacts, proposeFolder, draftContext, contextMarkdown, initialize, kitSource, pmosIn, slug, spawnLines, LOCKED };
+module.exports = { discover, inventory, search, factsOf, readTool, parseMcpList, prefixOf, folderFacts, proposeFolder, draftContext, contextMarkdown, readContext, initialize, kitSource, pmosIn, slug, spawnLines, LOCKED };

package/workspace/lib/proposals.js

@@ -21,6 +21,8 @@
  *   description the record's own description (initiative-description-field; filed by lib/description-props.js): type new (none yet) or
  *           enrich (the PRD says more). data { text, from? }; one item { id: 'description', title: the text cut }. Always section 'check'.
  *           ✓ writes the record's description line (lib/initiative-writer.js setDescription)
+ *   prototyped · improved · scanned   what the idle lab made while the PM was away (lib/idle-lab.js result): a first round of 2–3 specimens,
+ *           a new round of one, a scan finding to attach as evidence. No items; always section 'check'. ✓ keeps it as a document
  *   grill   what Claude found when it grilled the initiative by itself (lib/grill.js): type = the angle, no items, a next step in data.next;
  *           always section 'check' (its own ✓, never Keep all). 3 show, best rank first; the group's `more` counts the rest
  *
@@ -30,7 +32,7 @@
  *   end      { ini, run, ok, stopped? }                           the run ended (stopped: the PM pressed ■)
  *   propose  { ini, board, run, id, group, type, section, title, why, sources: [{ label, ref }], items: [item], data }
  *            an agent filed it (`pmos propose …`); the last line for an id wins, so a newer run replaces what it files again
- *   drop     { ini, sig, facts? }   ✕ on a proposal or on one item of it: gone until its evidence changes (a new signature) or the date
+ *   drop     { ini, sig, facts?, why? }   why: the PM's reason, when given (the idle lab learns from it). ✕ on a proposal or on one item of it: gone until its evidence changes (a new signature) or the date
  *            passes again. `facts` (batch 24 item 6) are what the ✕ rests on, not where the work sits: a date proposal's facts are its tasks
  *            and the due dates they missed, a grill finding's are its angle and its sources. A ✕ holds while they hold, so a workflow switch
  *            (new section keys, so new ids and signatures), a reworded reason or a new day (new computed dates) does not bring it back
@@ -64,6 +66,7 @@ const TYPES = { found: ['stage', 'docs', 'tasks', 'link', 'maybe', 'unplaced'],
 const SOURCES = ['drive', 'docs', 'sheets', 'slides', 'jira', 'calendar', 'notes', 'mail', 'slack', 'confluence', 'chat', 'repo'];
 const SOURCE_NAMES = { drive: 'Drive and Slides', docs: 'Docs', sheets: 'Sheets', slides: 'Slides', jira: 'Jira', calendar: 'Calendar and meeting notes', notes: 'Meeting notes',
   mail: 'Gmail', slack: 'Slack', confluence: 'Confluence', chat: 'Chat', repo: 'This repository' };
+const LAB = ['prototyped', 'improved', 'scanned'];   // the idle lab's results (lib/idle-lab.js result): no items, always section 'check'
 const CLOSED = new Set(['Done', "Won't do", 'Archived']);
 const RISK_DAYS = 3;
 const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
@@ -201,6 +204,7 @@ function tidyName(from, to) {
 function fold(lines) {
   const props = new Map();    // id → the newest propose line
   const drops = new Set();    // signatures
+  const dropWhy = new Map();  // signature → the PM's reason for the ✕, when one was given (the idle lab learns from it)
   const kept = [];            // keep lines, oldest first
   const undone = new Set();
   const looks = new Map();    // ini → { run, why, at, ended, ok, stopped, sources: Map source → { state, n, what } }
@@ -214,11 +218,11 @@ function fold(lines) {
     else if (l.kind === 'src' && ini) { const L = looks.get(ini); if (L && L.run === l.run && str(l.source)) L.sources.set(l.source, { state: l.state === 'done' ? 'done' : 'reading', n: Number(l.n) || 0, what: str(l.what) }); }
     else if (l.kind === 'end' && ini) { const L = looks.get(ini); if (L && L.run === l.run) { L.ended = true; L.ok = !!l.ok; L.stopped = !!l.stopped; L.endAt = l.at || ''; } }
     else if (l.kind === 'propose' && ini && str(l.id)) props.set(l.id, { id: l.id, ini, board: str(l.board), run: str(l.run), group: l.group, type: l.type, section: str(l.section) || 'sure', title: str(l.title), why: str(l.why), sources: Array.isArray(l.sources) ? l.sources : [], items: Array.isArray(l.items) ? l.items.filter(isObj) : [], data: isObj(l.data) ? l.data : {}, at: l.at || '', by: l.by || null });
-    else if (l.kind === 'drop' && str(l.sig)) { drops.add(l.sig); for (const f of Array.isArray(l.facts) ? l.facts : []) if (/^f:[0-9a-f]{10}$/.test(String(f))) drops.add(f); }
+    else if (l.kind === 'drop' && str(l.sig)) { drops.add(l.sig); if (str(l.why)) dropWhy.set(l.sig, one(l.why, 300)); for (const f of Array.isArray(l.facts) ? l.facts : []) if (/^f:[0-9a-f]{10}$/.test(String(f))) drops.add(f); }
     else if (l.kind === 'keep' && str(l.batch)) kept.push({ batch: l.batch, ini, board: str(l.board), ids: Array.isArray(l.ids) ? l.ids : [], wrote: Array.isArray(l.wrote) ? l.wrote.filter(isObj) : [], at: l.at || '', by: l.by || null });
     else if (l.kind === 'undo' && str(l.batch)) undone.add(l.batch);
   }
-  return { props, drops, kept, undone, looks, epoch, t };
+  return { props, drops, dropWhy, kept, undone, looks, epoch, t };
 }
 /** The kept proposal ids (a batch undone gives its proposals back). */
 const keptIds = (F) => { const s = new Set(); for (const k of F.kept) if (!F.undone.has(k.batch)) for (const id of k.ids) s.add(id); return s; };
@@ -332,7 +336,7 @@ function datesOf(ini, T, o = {}) {
 }
 
 /* ── what r.props carries ── */
-const ORDER = { description: -2, outcome: -1, found: 0, dates: 1, status: 2, names: 3, links: 4, grill: 5 };
+const ORDER = { description: -2, outcome: -1, prototyped: -0.6, improved: -0.5, scanned: -0.4, found: 0, dates: 1, status: 2, names: 3, links: 4, grill: 5 };
 const GRILL_SHOWN = 3;
 /**
  * One initiative's proposals, as the ✦ and the Viewer draw them, or null when there is nothing to show.
@@ -351,7 +355,7 @@ function viewOf(F, ini, o = {}) {
     p.items = p.items.filter((x) => !F.drops.has(itemSig(p, x)) && (!x.task || (T.has(x.task) && !(p.group !== 'found' && T.get(x.task).closed && p.group !== 'status'))));
     if (p.group === 'status') p.items = p.items.filter((x) => T.has(x.task) && !T.get(x.task).closed);
     if (p.group === 'names') p.items = p.items.filter((x) => T.has(x.task) && T.get(x.task).title !== x.to).map((x) => ({ ...x, from: T.get(x.task).title, ...(T.get(x.task).jira ? { jira: true } : {}) }));
-    if (!p.items.length && p.type !== 'stage' && p.group !== 'grill') continue;
+    if (!p.items.length && p.type !== 'stage' && p.group !== 'grill' && !LAB.includes(p.group)) continue;
     if (p.group === 'grill' && factsOf(p).some((f) => F.drops.has(f))) continue;
     props.push(p);
   }

package/workspace/lib/refresh-run.js

@@ -236,7 +236,8 @@ function create(host) {
       }
       start(src, ws, { trigger: d.trigger, slot: d.slot, note: d.note });
     }
-    try { healTick(t, set); } catch (e) { warn('source repair', e); }
+    // PMOS_SOURCE_HEAL=off stops the repairs (a suite about pressed and scheduled runs sets it, so no repair run races them)
+    if (process.env.PMOS_SOURCE_HEAL !== 'off') { try { healTick(t, set); } catch (e) { warn('source repair', e); } }
     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); }

package/workspace/lib/route-modules.js

@@ -33,6 +33,7 @@ const path = require('path');
 const MODULES = Object.freeze([
   'routes-setup', // Claude-ready onboarding, explicit profile checks and real first work
   'routes-onboard', // project-first onboarding in the Cozy Home (claude-onboarding-build), bound to no workspace
+  'routes-reveal',  // onboarding B2: Home right after setup (the ticks, the product portrait, the drafted first initiative)
   'routes-initiatives',   // Run 2 (2C): Roadmap, List, placements, new initiative, measurements
   'routes-today',         // Run 3 (3B): GET /api/today
   'routes-capture',       // Run 3 (3C): ⌘K capture
@@ -56,6 +57,7 @@ const MODULES = Object.freeze([
   'routes-board-grill',   // premium-uncovered-features (Board): a new initiative's Why, material and first questions (page press; file mode)
   'routes-insights-premium', // briefing-premium-insights: the premium Insights page's model from the KR metric records and report files (read-only)
   'routes-forecast',      // build brief Grill and Forecast F-A: a goal forecast's kept baseline, and the forecasts that turned
+  'routes-morning-goals', // build brief Good morning GM1: the quarter strip, the PM's line, the morning snapshot, goal tags, what Yes does
   'routes-grill',         // Grill and Forecast screens: Claude's checks for the pages (mode, cap, spend, each initiative's last run, Home's one line; read-only)
   'routes-home-desk',     // premium-agreed-design (Home): seen marks, queued messages, the weekly update's recipients and sends, stakeholders (page press; file mode)
   'routes-live',          // batch 6 item 2: the Live pill's sessions and the titles of their initiatives (read-only)
@@ -82,6 +84,7 @@ const MODULES = Object.freeze([
   'routes-task-plans',    // batch 11 item 8: drafts of an initiative's tasks, saved plans, Make live (task-plans.jsonl; page-press POST)
   'routes-task-links',    // batch 11 item 15: links between tasks, Claude's proposals, the quiet moves (task-links.jsonl; page-press POST)
   'routes-proposals',     // batch 12 items 2, 3 and 4: everything Claude proposes on an initiative, under its one ✦ (proposals.jsonl; page-press POST)
+  'routes-lab',           // idle lab (build U): Intelligence › Lab, the compare view, the specimen files and the Lab's own ✦ (idle-lab.jsonl; page-press POST)
   'routes-loose',         // batch 13 item 3: Claude's clean-up of Home's "Not in an initiative" under the group's ✦ (loose-props/; page-press POST)
   'routes-workflows',     // workflows-per-initiative (D99): the workflow library, save, copy, archive and the chat's draft (workflows.jsonl; page-press POST)
   'routes-settings',      // console3 Settings: the settings store for settings with no home of their own (GET; page-press POST)
@@ -116,6 +119,7 @@ const MODULES = Object.freeze([
   'routes-impact-views',  // batch 16 item 7 (Your impact, Phase 4): the chapter card's read, a stage that closed this week (boards.jsonl; read-only)
   'routes-next-prompt',   // batch 26 item 2: the chat's suggested next prompt and Sharper card (lib/next-prompt.js, through lib/ai-guard.js)
   'routes-drift',         // weekly-drift-check: What would I have missed, Home's weekly ✦ and its ⋯ drop and Undo (runtime drift/drift.jsonl; page-press POST)
+  'routes-moments',       // onboarding B3 gradual exposure: the day's ✦ in Home's chat, the menu dots, a quiet place's one line (onboarding-progress record; page-press POST)
 ]);
 const PM_DIR = path.join(__dirname, '..', 'public', 'pm');
 const MODULE_NAME = /^[a-z0-9][a-z0-9-]*\.js$/;

package/workspace/lib/routes-lab.js

@@ -0,0 +1,137 @@
+'use strict';
+/* routes-lab.js — what the pages show of the idle lab (build U, idle-lab B+C 2026-11-04; canvas main, In development I1 IlBC, I3 IlCompare).
+ * The fold and the shapes are lib/idle-lab.js; a result on an initiative is a ✦ under its one blue ✦ (lib/routes-proposals.js keeps, drops
+ * and undoes it). This module answers Intelligence › Lab, the compare view and the specimen files, and the Lab's own ✦.
+ *
+ *   GET  /api/lab?ws&board                → { ok, lab }   lab: lib/idle-lab.js labOf (null: nothing ran this week and nothing waits)
+ *   GET  /api/lab/compare?ws&board&id[&key] → { ok, compare }   lib/idle-lab.js compareOf (404 when the prototype is gone)
+ *   GET  /api/lab/specimen?file           → text/html, a specimen from <runtime>/idle-lab/specimens/, served sandboxed (no scripts that can
+ *                                          reach PMOS: CSP sandbox without allow-same-origin, no network but the fonts)
+ *   POST /api/lab/keep  { ws, id }        → { ok, batch, said }   ✓ on a Lab ✦: start keeps it and starts the initiative on its board
+ *   POST /api/lab/drop  { ws, id, why? }  → { ok, batch }         ✕, with the PM's reason when given
+ *   POST /api/lab/undo  { ws, batch }     → { ok }                Undo of a keep or a drop (a started initiative stays: close it on the Board)
+ *
+ * The week's record lists every background job: the idle lab, the grill runs (lib/grill.js), the AI jobs through lib/ai-guard.js, and
+ * whatever the shared queue reports (ctx.bgQueue.record({ ws, since }) → [{ job, title, meta?, at, ini?, board? }], when it is there).
+ * Every POST passes pm-guard requirePagePress. */
+const fs = require('fs');
+const guard = require('./pm-guard.js');
+const LAB = require('./idle-lab.js');
+const PR = require('./proposals.js');
+
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const fail = (ctx, res, status, error) => { ctx.json(res, { ok: false, error }, status); return true; };
+const WEEK = 7 * 864e5;
+const ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/;
+const JOB_NAMES = { 'past-repeat': 'You decided this before', 'decision-memory': 'Earlier decisions', outcomes: 'Expected outcomes', descriptions: 'Descriptions',
+  drift: 'What you might have missed', rehearse: 'Rehearse a plan', 'next-prompt': 'Next prompt', 'sharpen-prompt': 'Sharper prompt' };
+const CSP = "sandbox allow-scripts; default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline' https://fonts.googleapis.com; font-src https://fonts.gstatic.com data:; img-src data: blob:";
+
+function wsOf(ctx, id) { let w = null; try { w = ctx.getWs(id || null); } catch { w = null; } return w && (!id || w.id === id) ? w : null; }
+const dirOf = (ctx, w) => { try { return ctx.stateDirFor ? ctx.stateDirFor(w) : null; } catch { return null; } };
+/** The initiatives' names, from the rows the Board already read (none while they are still being read). */
+function titles(w) {
+  const m = new Map();
+  try { const b = require('./routes-boards.js').baseRows(w); if (b && b.ok) for (const r of b.rows || []) if (r && r.id) m.set(r.id, { title: r.title || r.id, board: r.board || '' }); } catch { /* none */ }
+  return m;
+}
+/** What the other background jobs did this week, as record rows. Each source that cannot be read is left out. */
+function others(ctx, w, dir, T, now) {
+  const out = [], since = now - WEEK, name = (ini) => (T.get(ini) || {}).title || ini;
+  try {
+    const G = require('./grill.js'), F = ctx.runtimeDir ? G.read(ctx.runtimeDir) : null;
+    for (const r of F ? F.runs.values() : []) if (r.ended && r.ok !== false && r.ws === w.id && (Date.parse(r.endAt || r.at) || 0) >= since) out.push({ job: 'grill', title: 'Grill · ' + name(r.ini), meta: 'why: ' + r.why, at: r.endAt || r.at, ini: r.ini, board: r.board || '' });
+  } catch { /* no grill log */ }
+  try {
+    // the AI jobs' audit (lib/ai-guard.js AUDIT), read as a file: this page files nothing through the guard
+    const audit = dir ? fs.readFileSync(require('path').join(dir, 'ai-audit.jsonl'), 'utf8').split('\n').slice(-400).map((s) => { try { return JSON.parse(s); } catch { return null; } }).filter(isObj) : [];
+    for (const l of audit) if (l.event === 'end' && (Date.parse(l.at) || 0) >= since) out.push({ job: l.job, title: (JOB_NAMES[l.job] || l.job), meta: l.filed != null ? l.filed + ' filed' : '', at: l.at });
+  } catch { /* no audit */ }
+  try { if (ctx.bgQueue && typeof ctx.bgQueue.record === 'function') for (const x of ctx.bgQueue.record({ ws: w.id, since }) || []) if (isObj(x) && x.job !== 'grill') out.push(x); /* grill runs are read above, from their own log */ } catch { /* the queue says nothing */ }
+  return out;
+}
+
+const READS = {
+  '/api/lab': (ctx, res, url) => {
+    const w = wsOf(ctx, url.searchParams.get('ws')); if (!w) return fail(ctx, res, 404, 'no such workspace');
+    const dir = dirOf(ctx, w); if (!dir) { ctx.json(res, { ok: true, lab: null }); return true; }
+    const now = Date.now(), T = titles(w);
+    const lab = LAB.labOf({ P: PR.read(dir), L: LAB.read(dir), extra: others(ctx, w, dir, T, now), now, titleOf: (ini) => (T.get(ini) || {}).title || '' });
+    ctx.json(res, { ok: true, lab });
+    return true;
+  },
+  '/api/lab/compare': (ctx, res, url) => {
+    const w = wsOf(ctx, url.searchParams.get('ws')); if (!w) return fail(ctx, res, 404, 'no such workspace');
+    const dir = dirOf(ctx, w), id = url.searchParams.get('id') || '';
+    if (!dir || !ID_RE.test(id)) return fail(ctx, res, 400, 'id names a prototype');
+    const T = titles(w);
+    const c = LAB.compareOf(PR.read(dir), id, { key: url.searchParams.get('key') || '', titleOf: (ini) => (T.get(ini) || {}).title || '' });
+    if (!c) return fail(ctx, res, 404, 'That prototype is no longer here');
+    for (const col of c.columns) if (col.file) col.url = LAB.specimenUrl(col.file);
+    ctx.json(res, { ok: true, compare: c });
+    return true;
+  },
+  '/api/lab/specimen': (ctx, res, url) => {
+    const f = LAB.specimenPath(ctx.runtimeDir, url.searchParams.get('file') || '');
+    let html = null;
+    try { html = f ? fs.readFileSync(f) : null; } catch { html = null; }
+    if (!html) return fail(ctx, res, 404, 'That specimen is not in the idle lab folder');
+    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Content-Security-Policy': CSP, 'X-Content-Type-Options': 'nosniff', 'Cache-Control': 'private, no-cache', 'Referrer-Policy': 'no-referrer' });
+    res.end(html);
+    return true;
+  },
+};
+
+const WRITES = {
+  '/api/lab/keep': (ctx, res, body, g, w, dir) => {
+    const F = LAB.read(dir), p = LAB.looseOpen(F).find((x) => x.id === body.id);
+    if (!p) return fail(ctx, res, 409, 'That is no longer waiting');
+    const wrote = [];
+    let said = 'Kept it.';
+    if (p.type === 'start') {
+      const r = require('./routes-loose.js').createIni(ctx, g, { ws: w.id, board: p.data.board }, p.data.title, p.data.anchor, p.why);
+      if (r.error) return fail(ctx, res, 409, r.error);
+      wrote.push(r.write); said = 'Started ' + p.data.title + '.';
+    }
+    const batch = PR.newBatch();
+    LAB.append(dir, g.actor, { kind: 'keep', id: p.id, batch, wrote });
+    ctx.json(res, { ok: true, batch, said });
+    return true;
+  },
+  '/api/lab/drop': (ctx, res, body, g, w, dir) => {
+    const p = LAB.looseOpen(LAB.read(dir)).find((x) => x.id === body.id);
+    if (!p) return fail(ctx, res, 409, 'That is no longer waiting');
+    const why = typeof body.why === 'string' ? body.why.replace(/\s+/g, ' ').trim().slice(0, 300) : '';
+    const batch = PR.newBatch();
+    LAB.append(dir, g.actor, { kind: 'drop', id: p.id, batch, ...(why ? { why } : {}) });
+    ctx.json(res, { ok: true, batch });
+    return true;
+  },
+  '/api/lab/undo': (ctx, res, body, g, w, dir) => {
+    const F = LAB.read(dir), b = String(body.batch || '');
+    const known = F.kept.some((k) => k.batch === b) || readsDrop(dir, b);
+    if (!known || F.undone.has(b)) return fail(ctx, res, 409, 'Nothing to undo');
+    LAB.append(dir, g.actor, { kind: 'undo', batch: b });
+    ctx.json(res, { ok: true });
+    return true;
+  },
+};
+const readsDrop = (dir, b) => LAB.readLines(LAB.ledgerFile(dir)).some((l) => l.kind === 'drop' && l.batch === b);
+
+module.exports = {
+  prefixes: ['/api/lab'],
+  handle: async (req, res, url, ctx) => {
+    const p0 = url.pathname;
+    if (req.method === 'GET') { const fn = READS[p0]; if (!fn) return fail(ctx, res, 404, 'not found'); return fn(ctx, res, url); }
+    if (req.method !== 'POST') return fail(ctx, res, 405, 'GET or POST only');
+    const fn = WRITES[p0];
+    if (!fn) return fail(ctx, res, 404, 'not found');
+    const got = await ctx.readJson(req);
+    if (!got.ok || !isObj(got.body)) return fail(ctx, res, 400, 'the body must be a JSON object');
+    const g = guard.requirePagePress(req, got.body);
+    if (!g.ok) return fail(ctx, res, g.status, g.error);
+    const w = wsOf(ctx, typeof got.body.ws === 'string' ? got.body.ws : null); if (!w) return fail(ctx, res, 404, 'no such workspace');
+    const dir = dirOf(ctx, w); if (!dir) return fail(ctx, res, 409, 'This repository has no PMOS state folder. Nothing is saved until the folder exists.');
+    return fn(ctx, res, got.body, g, w, dir);
+  },
+};

package/workspace/lib/routes-loose.js

@@ -187,6 +187,7 @@ function dropLine(ctx, res, body, g, dir, kind) {
 
 module.exports = {
   prefixes: ['/api/loose-props'],
+  createIni,   // the idle lab's Lab ✦ "start an initiative" uses the same Add an ask and Accept (lib/routes-lab.js)
   handle: async (req, res, url, ctx) => {
     const p = url.pathname;
     const dir = LP.dirOf(ctx.runtimeDir);

package/workspace/lib/routes-moments.js

@@ -0,0 +1,42 @@
+'use strict';
+/* routes-moments.js — a feature appears when its moment comes, over HTTP (onboarding build B3; lib/moments.js holds the rules).
+ *
+ *   GET  /api/moments                         → { ok, moment: { id, ws, product, text, sub, href, guide, guideLabel, go, shown } | null,
+ *                                                places: { board|insights|reports: { quiet, dot, line } } }
+ *                                               the day's ✦ for Home's chat, the menu dots, and the quiet line of a place not open yet
+ *   POST /api/moments/shown { ws, id }        → { ok }   the ✦ was drawn: it is that day's moment
+ *   POST /api/moments/keep  { ws, id }        → { ok }   ✓: the page opens the place; its dot clears
+ *   POST /api/moments/drop  { ws, id }        → { ok }   ✕: that moment never comes back
+ *   POST /api/moments/visit { place }         → { ok }   the PM opened Board, Intelligence or reports: its dot clears
+ *
+ * Reads files only (no model, no connector). A GET records a place that just opened in the workspace's onboarding-progress record, so its
+ * dot shows once. WHO WRITES: every POST is a page press (pm-guard requirePagePress); an agent session header is refused (403). */
+const guard = require('./pm-guard.js');
+const MO = require('./moments.js');
+
+const text = (v) => (typeof v === 'string' ? v : '');
+const bad = (status, error) => ({ status, body: { ok: false, error } });
+const nowMs = (ctx) => { const t = Date.parse((ctx.env || process.env).PMOS_MOMENTS_NOW || ''); return Number.isFinite(t) ? t : Date.now(); };
+
+async function handle(req, res, url, ctx) {
+  const send = (r) => { ctx.json(res, r.body, r.status); return true; };
+  const what = url.pathname.replace(/^\/api\/moments\/?/, '');
+  if (!ctx.runtimeDir) return send(bad(409, 'There is no runtime folder.'));
+  if (what === '') {
+    if (req.method !== 'GET') return send(bad(405, 'GET only'));
+    try { return send({ status: 200, body: { ok: true, ...MO.current(ctx, nowMs(ctx)) } }); }
+    catch { return send(bad(500, 'The moments could not be read.')); }
+  }
+  if (!['shown', 'keep', 'drop', 'visit'].includes(what)) return send(bad(404, 'no such moments route'));
+  if (req.method !== 'POST') return send(bad(405, 'POST only'));
+  if (req.headers && req.headers['x-pmos-session']) return send(bad(403, 'Only you answer a moment, from the page.'));
+  const rd = await ctx.readJson(req);
+  if (!rd.ok) return send(bad(400, 'the body is not JSON'));
+  const body = rd.body || {};
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) return send(bad(g.status, g.error));
+  const r = what === 'visit' ? MO.visit(ctx, text(body.place), nowMs(ctx)) : MO.answer(ctx, what, text(body.ws), text(body.id), nowMs(ctx));
+  return send(r.ok ? { status: 200, body: { ok: true } } : bad(r.status, r.error));
+}
+
+module.exports = { prefixes: ['/api/moments'], handle };

package/workspace/lib/routes-morning-goals.js

@@ -0,0 +1,109 @@
+'use strict';
+/* routes-morning-goals.js — the quarter under Good morning (build brief Good morning, GM1). lib/morning-goals.js holds the rules.
+ *
+ *   GET  /api/morning-goals[?ws=a,b]     → { ok, today, quarter, weeksLeft, strip, line, proposal, since, tags, goals, missing }
+ *        ws: the products to read; with none, the products Home reads (GET /api/briefing-premium/products, the ticked ones).
+ *        Each product's goals come from its Intelligence model (GET /api/insights-premium?ws=), so a goal says the same thing on both pages.
+ *        line: { line, at } the PM kept for this quarter, or null. proposal: Claude's ✦ { line, of, why } when there is no line and the
+ *        ✦ was not put off. since: the move since the day's first read (null on the first read). A product that cannot be read is named
+ *        in missing and is not counted. The first read of the day writes <runtime>/goal-morning.jsonl once.
+ *   POST /api/morning-goals/line         { line, quarter? }   the PM keeps the line (✓, the number may be changed). A page press
+ *   POST /api/morning-goals/line-off     { quarter? }         the ✦ is put off for the quarter (✕). A page press
+ *   POST /api/morning-goals/yes-effect   { ws, goal, date } | { ws, initiative, date, from }   → { ok, effect | null }
+ *        the forecast run again with the proposed date (lib/forecast.js). Reads and writes nothing else. null when it cannot run. */
+const guard = require('./pm-guard.js');
+const MG = require('./morning-goals.js');
+
+const localDay = (ms = Date.now()) => { const d = new Date(ms); return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0'); };
+const text = (v) => (typeof v === 'string' ? v : '');
+
+async function via(mod, pathAndQuery, req, ctx) {
+  let out = { status: 500, body: null };
+  const c = Object.assign({}, ctx, { json: (res, obj, code) => { out = { status: code || 200, body: obj }; } });
+  const handled = await mod.handle({ method: 'GET', headers: (req && req.headers) || {} }, {}, new URL('http://local' + pathAndQuery), c);
+  return handled === false ? { status: 404, body: null } : out;
+}
+
+async function productsOf(ctx, req, want) {
+  if (want.length) return want.map((ws) => ({ ws, name: ws }));
+  const r = await via(require('./routes-briefing-premium.js'), '/api/briefing-premium/products', req, ctx).catch(() => ({ status: 500, body: null }));
+  const P = (r.body && Array.isArray(r.body.products) && r.body.products) || [];
+  return P.filter((p) => p && p.on).map((p) => ({ ws: p.ws, name: p.name || p.ws }));
+}
+
+/** One product's Intelligence model goals, or null when it cannot be read. */
+async function modelOf(ctx, req, ws) {
+  const r = await via(require('./routes-insights-premium.js'), '/api/insights-premium?ws=' + encodeURIComponent(ws), req, ctx).catch(() => ({ status: 500, body: null }));
+  const m = r.status === 200 && r.body && r.body.ok && r.body.model;
+  return m && m.board && m.board.ws === ws ? m : null;
+}
+
+async function read(ctx, req, want) {
+  const today = localDay(), quarter = MG.quarterOf(today);
+  const products = [], missing = [];
+  for (const p of await productsOf(ctx, req, want)) {
+    const m = await modelOf(ctx, req, p.ws);
+    if (!m) { missing.push(p.name); continue; }
+    products.push({ ws: p.ws, name: (m.board && m.board.name && m.board.name !== 'Intelligence' ? m.board.name : p.name), goals: m.goals || [], model: m });
+  }
+  const list = MG.collect(products);
+  const dir = ctx.runtimeDir || null;
+  const kept = dir ? MG.lineFor(dir, quarter) : null;
+  const line = kept && kept.line ? kept : null;
+  const strip = MG.stripOf(list, line ? line.line : null);
+  const proposal = !line && !(kept && kept.off) ? MG.proposeLine(strip) : null;
+  let since = null;
+  if (dir && list.length) {
+    try {
+      const had = MG.snapshotFor(dir, today);
+      if (had) since = MG.deltaOf(had, list);
+      else if (!missing.length) MG.takeSnapshot(dir, today, list);   // a part read is no morning: the snapshot waits for every product
+    } catch { since = null; }
+  }
+  return { ok: true, today, quarter, weeksLeft: MG.weeksLeft(today), strip, line, proposal, since, tags: MG.tagsOf(list),
+    goals: list.map(({ moves, ...g }) => g), missing, products };
+}
+
+module.exports = {
+  prefixes: ['/api/morning-goals'],
+  handle: async (req, res, url, ctx) => {
+    const send = (status, body) => { ctx.json(res, body, status); return true; };
+    const what = url.pathname.replace(/^\/api\/morning-goals\/?/, '');
+    if (!['', 'line', 'line-off', 'yes-effect'].includes(what)) return send(404, { ok: false, error: 'no such morning-goals route' });
+    if (what === '') {
+      if (req.method !== 'GET') return send(405, { ok: false, error: 'GET only' });
+      const want = text(url.searchParams.get('ws')).split(',').map((s) => s.trim()).filter(Boolean);
+      try { const out = await read(ctx, req, want); delete out.products; return send(200, out); } catch (e) { return send(500, { ok: false, error: String((e && e.message) || e) }); }
+    }
+    if (req.method !== 'POST') return send(405, { ok: false, error: 'POST only' });
+    const got = await ctx.readJson(req);
+    if (!got.ok) return send(400, { ok: false, error: 'the body is not JSON' });
+    const body = got.body || {};
+    if (what === 'yes-effect') {
+      const date = text(body.date), today = localDay();
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) return send(400, { ok: false, error: 'date is required, as YYYY-MM-DD' });
+      const FC = require('./forecast.js');
+      let effect = null;
+      try {
+        if (body.goal) {
+          const m = await modelOf(ctx, req, text(body.ws));
+          const g = m && (m.goals || []).find((x) => String(x.id) === String(body.goal));
+          if (g) effect = MG.yesEffect({ goal: g, date }, FC, today);
+        } else if (body.initiative) {
+          const w = ctx.getWs(text(body.ws) || null), sn = w ? require('./jira-status.js').readSnapshot(w.root, String(body.initiative)) : null;
+          const jira = sn ? { at: sn.fetchedAt, tickets: [...sn.tickets.values()].map((t) => ({ category: t.category, resolved: t.resolved || null })) } : null;
+          effect = MG.yesEffect({ initiative: { id: String(body.initiative), title: text(body.title) }, jira, date, from: text(body.from) }, FC, today);
+        }
+      } catch { effect = null; }
+      return send(200, { ok: true, effect });
+    }
+    const g = guard.requirePagePress(req, body);
+    if (!g.ok) return send(g.status, { ok: false, error: g.error });
+    if (!ctx.runtimeDir) return send(409, { ok: false, error: 'PMOS has no runtime folder, so the line cannot be kept' });
+    const quarter = text(body.quarter) || MG.quarterOf(localDay());
+    const r = what === 'line' ? MG.setLine(ctx.runtimeDir, g.actor, { quarter, line: body.line }) : MG.putOff(ctx.runtimeDir, g.actor, quarter);
+    if (r.error) return send(400, { ok: false, error: r.error });
+    return send(200, { ok: true, line: r.line });
+  },
+  _read: read,
+};