create-pmos 0.52.0 → 0.53.1

package/workspace/public/pm/cycle-review.js

@@ -0,0 +1,125 @@
+/* pm/cycle-review.js — the Cycle review card of Today, kind 7 (pm-os-absorb Run 2, slice 2D; PRD R12, R26, R27).
+ *
+ * ONE renderer for two row kinds. The server's initiative provider makes `cycle-review` (day one, or a new cycle: what
+ * reads Now and is unconfirmed, the agents' proposals, the check-by dates that passed). The reports provider makes
+ * `cycle-kill-check` (the monthly kill-condition check). Both rows open the same sheet, so the PM reviews the cycle in one
+ * place. The kill-check row adds its own line: its cause and the file the check reads.
+ *
+ * The sheet has three lists:
+ *   - Now, unconfirmed:  Confirm (a placed line into Now, written by the PM's press) or Move back (to Later). One initiative
+ *     for each press: Move to Now is never bulk (R17), so there is no "Confirm all";
+ *   - Agent proposals:   Keep (adopt: written as the PM's line) or Drop;
+ *   - Check-by dates passed:  Set check-by, or Move to Next.
+ * Each press is one write through initiatives-api.js; the sheet reads the Roadmap again and redraws.
+ */
+
+import { el } from './dom.js';
+import { button, card, row, sheet, toast, ensureComponentsCss } from './primitives.js';
+import { registerTodayCard } from './registry.js';
+import { COPY, shortDate } from './initiatives-copy.js';
+import { getRoadmap, place, placed, leaveNow, adopt, drop } from './initiatives-api.js';
+import { say, checkBySheet } from './initiatives-ui.js';
+import { changed } from './initiative-sheet.js';
+
+const refreshToday = (ws) => { try { window.dispatchEvent(new CustomEvent('pmos:ledgers', { detail: { changed: [ws] } })); } catch { /* no window */ } };
+
+/** What the sheet lists, from one Roadmap answer. */
+export function cycleItems(data) {
+  const today = String((data && data.now) || '').slice(0, 10) || new Date().toISOString().slice(0, 10);
+  const now = (data && data.horizons && data.horizons.now) || [];
+  return {
+    unconfirmed: now.filter((r) => !r.confirmed),
+    proposals: (data && data.proposals) || [],
+    passed: now.filter((r) => r.check_by && r.check_by < today),
+  };
+}
+
+export function openCycleReview({ row: needsRow, ws, repo }) {
+  ensureComponentsCss();
+  const list = el('div', { class: 'in-cycle', 'data-in-cycle': '' }, el('p', { class: 'in-note' }, COPY.cycle.reading));
+  const head = [];
+  if (needsRow && needsRow.kind === 'cycle-kill-check') {
+    const t = needsRow.today || {};
+    head.push(el('p', { class: 'in-note', 'data-in-kill': '' }, [needsRow.question, t.evidence ? ' · ' + t.evidence : ''].join('')));
+  } else if (needsRow && needsRow.today && needsRow.today.cause) head.push(el('p', { class: 'in-note' }, needsRow.today.cause));
+  const s = sheet({ mode: 'auto', title: COPY.cycle.sheetTitle, body: [...head, list], attrs: { 'data-in-sheet': 'cycle-review' }, actions: [button({ label: COPY.sheet.close, variant: 'outline', onClick: () => s.close(), attrs: { 'data-in-close': '' } })] });
+
+  let data = null;
+  const after = async (pending, text) => { const out = await pending; if (say(out, text)) { changed(); refreshToday(ws); } await load(); };
+
+  const sectionTitle = (text, hint) => [el('h3', { class: 'in-cycle__title' }, text), el('p', { class: 'in-note' }, hint)];
+
+  function draw() {
+    const { unconfirmed, proposals, passed } = cycleItems(data);
+    const kids = [];
+    if (!unconfirmed.length && !proposals.length && !passed.length) kids.push(el('p', { class: 'in-note', 'data-in-nothing': '' }, COPY.cycle.nothing));
+    if (unconfirmed.length) {
+      kids.push(...sectionTitle(COPY.cycle.confirmNow, COPY.cycle.confirmNowHint));
+      for (const r of unconfirmed) {
+        const idx = ((data.horizons.now || []).findIndex((x) => x.id === r.id));
+        const prev = idx > 0 ? data.horizons.now[idx - 1].id : null;
+        kids.push(row({
+          title: r.title, meta: [r.display && r.display.word, r.anchor], attrs: { 'data-in-cycle-row': r.id, 'data-kind': 'unconfirmed' },
+          trail: [
+            button({ label: COPY.cycle.confirm, variant: 'primary', size: 'sm', attrs: { 'data-in-confirm-one': r.id }, onClick: () => after(place(ws, [placed(r.id, 'now', prev)]), COPY.cycle.confirmed(r.title)) }),
+            button({ label: COPY.cycle.moveBack, variant: 'outline', size: 'sm', attrs: { 'data-in-moveback': r.id }, onClick: () => after(place(ws, [placed(r.id, 'later', null, leaveNow(r, 'later'))]), COPY.cycle.movedBack(r.title)) }),
+          ],
+        }));
+      }
+    }
+    if (proposals.length) {
+      kids.push(...sectionTitle(COPY.cycle.proposals, COPY.cycle.proposalsHint));
+      for (const p of proposals) {
+        kids.push(row({
+          title: p.title || p.initiative, meta: [COPY.cycle.proposalLine(COPY.horizons[p.horizon] || p.horizon, p.by)], proposed: true,
+          attrs: { 'data-in-cycle-row': p.initiative, 'data-kind': 'proposal', 'data-eid': p.eid },
+          trail: [
+            button({ label: COPY.cycle.keep, variant: 'primary', size: 'sm', attrs: { 'data-in-keep': p.eid }, onClick: () => after(adopt(ws, p.eid), COPY.cycle.kept) }),
+            button({ label: COPY.cycle.drop, variant: 'outline', size: 'sm', attrs: { 'data-in-drop': p.eid }, onClick: () => after(drop(ws, p.eid), COPY.cycle.dropped) }),
+          ],
+        }));
+      }
+    }
+    if (passed.length) {
+      kids.push(...sectionTitle(COPY.cycle.checkBys, COPY.cycle.checkBysHint));
+      for (const r of passed) {
+        const idx = (data.horizons.now || []).findIndex((x) => x.id === r.id);
+        const prev = idx > 0 ? data.horizons.now[idx - 1].id : null;
+        kids.push(row({
+          title: r.title, meta: [COPY.checkBy(shortDate(r.check_by))], attrs: { 'data-in-cycle-row': r.id, 'data-kind': 'check-by' },
+          trail: [
+            button({
+              label: COPY.cycle.setCheckBy, variant: 'outline', size: 'sm', attrs: { 'data-in-set-check-by': r.id },
+              onClick: () => checkBySheet({ title: COPY.sheet.checkByTitle, value: r.check_by, onSave: async (d) => { const out = await place(ws, [placed(r.id, 'now', prev, { check_by: d })]); if (out && out.ok) { toast({ text: COPY.moved.checkBy(r.title, d ? shortDate(d) : ''), timeout: 4000 }); changed(); refreshToday(ws); load(); } return out; } }),
+            }),
+            button({ label: COPY.cycle.moveNext, variant: 'outline', size: 'sm', attrs: { 'data-in-move-next': r.id }, onClick: () => after(place(ws, [placed(r.id, 'next', null, leaveNow(r, 'next'))]), COPY.moved.next(r.title)) }),
+          ],
+        }));
+      }
+    }
+    list.replaceChildren(...kids);
+  }
+
+  async function load() {
+    const a = await getRoadmap(ws);
+    if (a && a.ok) { data = a; draw(); } else list.replaceChildren(el('p', { class: 'in-error', role: 'alert' }, COPY.readFailed((a && a.error) || 'the server did not answer')));
+  }
+  load();
+  return s;
+}
+
+/** The one renderer, for both row kinds. */
+export function renderCycleCard(row_, ctx) {
+  ensureComponentsCss();
+  const t = row_.today || {};
+  const open = () => openCycleReview({ row: row_, ws: ctx.ws, repo: ctx.repo });
+  return card({
+    title: row_.question || COPY.cycle.cardKind, meta: [COPY.cycle.cardKind, t.cause, t.evidence],
+    trail: [button({ label: (t.act && t.act.label) || COPY.cycle.review, variant: 'primary', attrs: { 'data-in-cycle-open': row_.kind }, onClick: open })],
+    onOpen: open, openLabel: COPY.cycle.review + ': ' + (row_.question || ''),
+    attrs: { class: 'in-today-card', 'data-today-row': row_.kind, 'data-provider': row_.provider || null },
+  });
+}
+
+registerTodayCard('cycle-review', renderCycleCard);
+registerTodayCard('cycle-kill-check', renderCycleCard);

package/workspace/public/pm/data.js

@@ -25,16 +25,16 @@
  *     never a plausible-looking guess. `— not tracked` is the surface's job, not this file's.
  *
  * ── What is derived here, and by what rule ──────────────────────────────────────────────────
- * PMOS has no task entity, so a phase's tasks are DERIVED (PRD, "Tasks"):
+ * PMOS has no task entity. The phases below are folded from the workflow ladder; the tasks they once carried (derived
+ * from the rungs) are cut with the Task tab (R29), and the work an initiative holds is the Breakdown's:
  *   · the phase SET comes from the initiative's lane;
  *   · each phase folds a fixed set of the workflow engine's twelve rungs, so every rung's evidence
  *     lands in exactly one phase and none is dropped;
- *   · a task's status comes from that phase's rungs — `done` where they passed, `blocked` where
- *     one is blocking, `doing` where one is current, else `todo`. A phase whose rungs carry no
- *     evidence at all reads `todo`, NEVER `done`;
- *   · an `## Tasks` section authored in the initiative record overrides the derivation entirely.
- * Nothing is invented per initiative: every task's instruction, expectation and evaluation is the
- * engine's own text for the rung it belongs to.
+ *   · a phase's status comes from its rungs — `done` where they passed, `blocked` where one is
+ *     blocking, `current` where one is current, else `pending`. A phase whose rungs carry no
+ *     evidence at all reads `pending`, NEVER `done`.
+ * Nothing is invented per initiative: every phase's text is the engine's own text for the rung it
+ * belongs to.
  *
  * ── The one thing this file refuses to do ───────────────────────────────────────────────────
  * Linking an artifact records a DECLARATION (`{artifact_path, kind, target}` appended to
@@ -53,6 +53,7 @@
 
 import { state, setState, subscribe, FIXTURE } from './state.js';
 import { C } from './fixture.js';
+import { pressFetch } from './http.js';
 
 /* ── transport ──────────────────────────────────────────────────────────────────────────────
  * Relative URLs only. The server's origin/host allowlist 403s a page served from anywhere else,
@@ -81,8 +82,8 @@ async function getJson(path, params) {
 async function postJson(path, body) {
   let res;
   try {
-    res = await fetch(path, {
-      method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body),
+    res = await pressFetch(path, {
+      method: 'POST', body: JSON.stringify(body),   // pm/http.js: carries the per-launch nonce, and renews a stale one
     });
   } catch (e) { return { ok: false, error: 'could not reach the workspace server — ' + msg(e) }; }
   try { return await res.json(); }
@@ -192,62 +193,7 @@ function decidingRung(rungs) {
     || rungs[rungs.length - 1] || null;
 }
 
-/** Task statuses per phase status — the PRD's rule, spread over the three derived tasks. */
-const TASK_STATUS = {
-  done: ['done', 'done', 'done'],
-  current: ['done', 'doing', 'todo'],
-  blocked: ['blocked', 'todo', 'todo'],
-  pending: ['todo', 'todo', 'todo'],
-};
-
-/**
- * The three derived tasks for one phase. Each field is the engine's own text for the rungs this
- * phase folds — the instruction is what the engine says to DO, the expectation is what it says it
- * LOOKED FOR, the evaluation names the rule that decides. A field with no source is null and the
- * task pane renders it empty; it is never filled with a sentence that sounds like evidence.
- */
-function derivedTasks(phase, rungs, ctx) {
-  const s = phaseRungStatus(rungs);
-  const lead = decidingRung(rungs) || {};
-  const titles = s === 'blocked'
-    ? ['resolve the ' + phase + ' blocker', 'produce the ' + phase + ' output', 'record the result']
-    : ['read the inputs for ' + phase, 'produce the ' + phase + ' output', 'record the result'];
-  const evidence = rungs.filter((r) => r.evidence).map((r) => r.key + ': ' + r.evidence).join(' · ') || null;
-  const inputs = [ctx.record, ctx.brief, ctx.doc, ctx.prd, ctx.rubric].filter(Boolean)
-    .filter((v, i, a) => a.indexOf(v) === i).join(' · ') || null;
-  // D77 — what each rung read and the sentence that decides it, from the engine's own basis.
-  const basis = rungs.map((r) => ({ key: r.key, b: r.basis || null })).filter((x) => x.b);
-  const sentences = basis.map((x) => x.b.rule).filter((v, i, a) => v && a.indexOf(v) === i);
-  const readLine = basis.filter((x) => x.b.file)
-    .map((x) => x.b.file + (x.b.first_seen ? ' (first seen ' + x.b.first_seen + ')' : '')).filter((v, i, a) => a.indexOf(v) === i);
-  const rules = rungs.map((r) => r.rule).filter(Boolean);
-  // The produced artifact: a file a rung of this phase read, never guessed. A document or record is
-  // preferred over a ledger for the second task; the third task shows the ledger the result lands in.
-  const files = basis.filter((x) => x.b.file && x.b.source === 'file').map((x) => x.b.file);
-  const ledgers = basis.filter((x) => x.b.file && x.b.source === 'ledger').map((x) => x.b.file);
-  const produced = files[files.length - 1] || pathIn(lead.evidence) || pathIn(lead.next) || null;
-  const recorded = ledgers[ledgers.length - 1] || null;
-  const def = ctx.laneDef || null;
-  return titles.map((title, i) => ({
-    title,
-    status: (TASK_STATUS[s] || TASK_STATUS.pending)[i],
-    // The engine's own action for the phase — except on the first task, whose job IS the reading,
-    // so it names the files rather than repeating the action. Neither is authored prose: one is the
-    // engine's sentence, the other is a list of paths the record declares.
-    instruction: (i === 0 && inputs ? 'Read ' + inputs : null) || lead.next || lead.evidence || null,
-    input: inputs,
-    // What the lane says finishing means, then what the engine found. Both are data, not prose written here.
-    expect: [def ? def.done : null, evidence ? 'Found: ' + evidence : null].filter(Boolean).join(' — ') || null,
-    evalNote: sentences.length
-      ? sentences.join(' ') + (readLine.length ? ' Decided from: ' + readLine.join(', ') + '.' : '')
-      : rules.length
-        ? 'workflow rule ' + rules.join(', ') + ' decides this phase'
-        : 'the workflow engine derives this phase from ' + rungs.map((r) => r.key).join(', '),
-    output: i === 1 ? produced : (i === 2 ? recorded : null),
-  }));
-}
-
-/** The first repo-relative path inside an engine message, or null. Used only for a task's `output`. */
+/** The first repo-relative path inside an engine message, or null. Used for a step's `cmd`. */
 function pathIn(text) {
   const m = String(text || '').match(/\b(?:planning|prototype|workspace|okf|skills|build-skills)\/[\w./-]+\.\w+/);
   return m ? m[0] : null;
@@ -492,21 +438,6 @@ function recordFrom(payload) {
   const lane = fm.lane || (row && row.lane) || null;
   const steps = row ? phaseSteps(lane, row.steps, row.profile) : [];
   const laneDef = (payload.lanes && payload.lanes.defs && lane && payload.lanes.defs[lane]) || null;
-  const ctx = {
-    record: payload.record, prd: fm.prd_path || null, rubric: fm.rubric_path || null,
-    brief: fm.brief_path || null, doc: fm.doc_path || null, laneDef,
-  };
-  // Authored tasks win over derivation, per phase (PRD, "Tasks"). Their absence is not a defect.
-  const authored = payload.tasks || {};
-  const tasks = {};
-  const byKey = {};
-  for (const s of (row && row.steps) || []) byKey[s.key] = s;
-  for (const st of steps) {
-    const rungs = (RUNGS[laneOf(lane, row && row.profile)][st.k] || []).map((k) => byKey[k]).filter(Boolean);
-    tasks[st.k] = Array.isArray(authored[st.k]) && authored[st.k].length
-      ? authored[st.k]
-      : derivedTasks(st.k, rungs, ctx);
-  }
   const rec = {
     tag: fm.title || (row && row.title) || '',
     // the lane this record declares, and the lanes this repository allows — what the header's lane picker offers
@@ -522,7 +453,6 @@ function recordFrom(payload) {
     branch: scope ? scope.branch : null,
     answer: answerFor(row),
     steps,
-    tasks,
     sessions: (payload.sessions || []).map(sessionRow),
     links: linksFor(payload),
     arts: artsFor(payload),
@@ -905,101 +835,6 @@ function currentProductName() {
   return productOrder[0] || null;
 }
 
-/* ── the Focus queue ─────────────────────────────────────────────────────────────────────────
- * `/api/console?name=focus` is cross-product (the server accepts and ignores `ws`) and it runs the
- * board and ladder derivations for every registered workspace — a cold derive the boot path
- * deliberately avoids (see `lightRecord`). So it is fetched LAZILY, on entry to focus mode, never
- * at load.
- *
- * The server's view (lib/focus.js buildFocus) is `{queue, handoffs, delegated, upkeep, badge, …}`;
- * modes.js renders the fixture rows' shape `{first, waiting, syn, saw}`. The reshape happens here
- * — one adapter, not a second renderer — and a failed read is published as `{readError}`, which
- * the mode renders as a failed read, never as "a successful read of nothing".
- */
-
-/** One focus row in the shape the mode's queue renderer reads. The `read:` label is the caller's
- * to add (lib/focus.js R4) — the server's string is the content after it. */
-function focusRow(r) {
-  return {
-    n: r.rank == null ? '' : String(r.rank),
-    slug: r.subject || '',
-    // `productName` is the board's own key (the repo name data.js registered), which is what
-    // `jump` needs; `product` is the server's repo-key path and matches no board.
-    prod2: r.productName || '',
-    why: r.why || '',
-    read: r.read ? 'read: ' + r.read : '',
-  };
-}
-
-/** The server's focus view, reshaped to what focusList renders. Every row is the payload's — no
- * fixture constant is reachable from here. */
-function focusFrom(view) {
-  const h = view.handoffs || {};
-  const d = view.delegated || {};
-  const u = view.upkeep || {};
-
-  const syn = [];
-  for (const s of d.running || []) {
-    syn.push({
-      t: (s.name || s.id) + ' · ' + (s.word || s.shown) + (s.productName ? ' — ' + s.productName : ''),
-      hasBtn: false,
-    });
-  }
-  /* `starts` are the engine's own delegate OFFERS. They render as rows, not buttons: this surface
-   * has no runner that can feed `initialInput` into a spawn, and a ▶ button PMOS cannot honour is
-   * worse than no button (the server's own starts_note rule). */
-  for (const s of d.starts || []) {
-    syn.push({ t: (s.initiative || '') + ' — ' + (s.action || s.skill || ''), hasBtn: false });
-  }
-
-  const saw = [];
-  if (u.memory && u.memory.heading) {
-    saw.push({ t: u.memory.heading + ' — ' + (u.memory.body || u.memory.state || '') });
-  }
-  const bud = u.budgets || {};
-  if (bud.state === 'error') {
-    saw.push({ t: 'health budgets — read failed: ' + (bud.error || 'no reason given') });
-  }
-  for (const r of bud.rows || []) {
-    saw.push({
-      t: r.id + ' — cap ' + (r.cap || 'not declared') + ' · ' + (r.total || 0)
-        + ' anchored initiative' + (r.total === 1 ? '' : 's'),
-    });
-  }
-  // The server's caveat travels with the counts it qualifies: without it the totals above read as
-  // the cap test, which is exactly the claim the view refuses to make.
-  if ((bud.rows || []).length && bud.caveat) saw.push({ t: bud.caveat });
-
-  return {
-    first: (view.queue || []).map(focusRow),
-    waiting: (h.items || []).map(focusRow),
-    // The handoffs body for a tracker that is NOT CONNECTED — a different sentence from an empty
-    // list, rendered by the mode in place of the calm empty line.
-    waitingNote: (h.items || []).length ? null : (h.body || null),
-    syn,
-    saw,
-  };
-}
-
-let focusInFlight = false;
-
-async function loadFocus() {
-  if (FIXTURE || focusInFlight) return;
-  focusInFlight = true;
-  // The in-flight read is STATED. With nothing published yet, the mode would otherwise render its
-  // calm empty line — a claim of a successful read of nothing while the read is still out. A
-  // usable earlier payload stays on screen for the refresh instead.
-  if (!state.focus || state.focus.readError) setState({ focus: { reading: true } });
-  try {
-    const view = await getJson('/api/console', { name: 'focus' });
-    setState({
-      focus: view && view.ok !== false
-        ? focusFrom(view)
-        : { readError: (view && view.error) || 'the focus queue could not be read' },
-    });
-  } finally { focusInFlight = false; }
-}
-
 /* ── sessions ───────────────────────────────────────────────────────────────────────────────
  * Polled rather than pushed. The WebSocket that carries `sessions` frames belongs to panel 4's
  * terminal module, which owns the attach/input protocol; opening a SECOND socket here to read a
@@ -1010,6 +845,22 @@ async function loadFocus() {
 let pollTimer = null;
 let sessionDigest = null;
 
+/* pm-os-absorb Run 1 — the plan-items signatures. An open Breakdown watches its workspace; the poll then asks for that
+ * workspace's `evidence` signature too, and `pmos:ledgers` tells every listener which workspaces' signatures moved. */
+const ledgerWatch = new Map();   // ws id -> how many open Breakdowns watch it
+let lastLedgers = null;          // null until the first poll: its signatures are the baseline, not a change
+export function watchLedgers(wsId) {
+  if (!wsId) return () => {};
+  ledgerWatch.set(wsId, (ledgerWatch.get(wsId) || 0) + 1);
+  let done = false;
+  return () => {
+    if (done) return;
+    done = true;
+    const n = (ledgerWatch.get(wsId) || 1) - 1;
+    if (n > 0) ledgerWatch.set(wsId, n); else ledgerWatch.delete(wsId);
+  };
+}
+
 /**
  * WHAT THE SURFACE ACTUALLY RENDERS from a session row, as one string.
  *
@@ -1040,7 +891,8 @@ function sessionProjection(rows) {
 
 async function pollSessions() {
   if (FIXTURE) return;
-  const out = await getJson('/api/sessions');
+  const watched = [...ledgerWatch.keys()].slice(0, 4);
+  const out = await getJson('/api/sessions' + (watched.length ? '?ledgers=' + watched.map(encodeURIComponent).join(',') : ''));
   if (out && Array.isArray(out.sessions)) {
     const digest = sessionProjection(out.sessions);
     const count = liveCount(out.sessions);
@@ -1051,6 +903,12 @@ async function pollSessions() {
       setState({ sessions: out.sessions, runningCount: count });
     }
   }
+  if (out && out.ledgers && typeof out.ledgers === 'object' && typeof window !== 'undefined') {
+    const prev = lastLedgers;
+    const changed = Object.keys(out.ledgers).filter((ws) => prev && JSON.stringify(out.ledgers[ws]) !== JSON.stringify(prev[ws]));
+    lastLedgers = out.ledgers;
+    if (changed.length) window.dispatchEvent(new CustomEvent('pmos:ledgers', { detail: { changed, ledgers: out.ledgers } }));
+  }
   schedulePoll();
 }
 
@@ -1102,6 +960,9 @@ export async function loadRepos() {
   const rows = foldWorkspaces(out && out.workspaces);
   productOrder = rows.map((r) => r.name);
   for (const r of rows) products.set(r.name, Object.assign(products.get(r.name) || {}, r));
+  // The session poll does not read a board, so it does not wait for one. Behind the board loads it first answered only
+  // after the (now larger) initiatives surface had been fetched, and a live agent's marker was missing until then.
+  pollSessions();
   await Promise.all(rows.map((r) => loadBoard(products.get(r.name))));
   publishBoards();
   const first = currentProductName();
@@ -1121,8 +982,6 @@ export async function loadRepos() {
     sel,
   });
   if (sel) hydrate(sel);
-  schedulePoll();
-  pollSessions();
   return productOrder.map((name) => {
     const prod = products.get(name);
     return {
@@ -1545,7 +1404,7 @@ export async function searchFiles(query, limit, all) {
 export async function saveDoc({ ws, path, base, text }) {
   if (FIXTURE) return { ok: true };
   const p = products.get(currentProductName());
-  return postJson('/api/doc/save', { ws: ws || state.wsId || (p ? p.ws : ''), path, base, text, pm: true });
+  return postJson('/api/doc/save', { ws: ws || state.wsId || (p ? p.ws : ''), path, base, text });
 }
 
 /**
@@ -1636,7 +1495,7 @@ export function runningCount(s) {
  * newly selected initiative, and a repaint when it lands.
  */
 if (!FIXTURE) {
-  let lastSel = null, lastProduct = null, lastMode = null;
+  let lastSel = null, lastProduct = null;
   subscribe(() => {
     if (state.product !== lastProduct) {
       lastProduct = state.product;
@@ -1644,12 +1503,6 @@ if (!FIXTURE) {
       if (p && p.ws && state.wsId !== p.ws) setState({ wsId: p.ws });
       if (p && !p.board) loadInitiatives(state.product);
     }
-    // The focus view is fetched on ENTRY to focus mode, and re-fetched on every re-entry — the
-    // queue is a statement about now, and the mode switch is the moment the PM asks for it.
-    if (state.mode !== lastMode) {
-      lastMode = state.mode;
-      if (state.mode === 'focus') loadFocus();
-    }
     const sel = state.sel;
     if (sel && sel !== lastSel) {
       lastSel = sel;