create-pmos 0.132.0 → 0.133.0

package/package.json

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

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@b177828
+kernel-source: pmos@c3d0fb4
 assembled: 2026-10-11
 mode: vendor

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

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-11T04:03:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T04:26:11Z"}
 status: stable
 ---
 

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

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-10-11T04:03:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T04:26:11Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-11T04:03:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T04:26:11Z"}
 status: stable
 ---
 

package/workspace/bin/pmos.js

@@ -188,6 +188,7 @@ function ensureInstalled() {
 // Register the target directory and open the browser ON IT. The `focus` broadcast matters:
 // the OS may refocus an already-open tab instead of opening our URL, and without it the PM
 // would be looking at the previously-opened repo — the defect this replaces.
+let FORCE_WELCOME = false; // `pmos welcome [path]`
 async function openWorkspace(dir, port, { open = true } = {}) {
   const root = repoRootOf(dir);
   const reg = await api(port, 'POST', '/api/workspaces', { root, name: path.basename(root) });
@@ -199,7 +200,17 @@ async function openWorkspace(dir, port, { open = true } = {}) {
   const w = reg.workspace;
   say(`✓ workspace “${w.name}” — ${urlOf(port)}?ws=${w.id}`);
   say(`  ${root}`);
-  if (open) openBrowser(`${urlOf(port)}?ws=${w.id}`);
+  // First run (onboarding-scan-and-map): a plain folder PMOS has never imported opens on Welcome (the route's first_run);
+  // `pmos welcome` opens it on purpose. Any failure keeps the old URL.
+  let first = FORCE_WELCOME;
+  if (!first) {
+    try {
+      const st = await api(port, 'GET', `/api/onboarding/status?ws=${encodeURIComponent(w.id)}`);
+      first = !!(st && st.ok && st.first_run);
+    } catch { first = false; }
+  }
+  if (first) say(FORCE_WELCOME ? '✓ opening Welcome' : '✓ first run — opening Welcome');
+  if (open) openBrowser(first ? `${urlOf(port)}/welcome?ws=${w.id}` : `${urlOf(port)}?ws=${w.id}`);
   return 0;
 }
 
@@ -511,9 +522,10 @@ function doctor() {
     if (r.error) { say('✗ could not run ' + npx + ' — ' + r.error.message); code = 1; }
     else code = r.status === null ? 1 : r.status;
   } else if (cmd === 'help' || cmd === '--help' || cmd === '-h') {
-    say('usage: pmos [<path>|status|ls|stop|doctor|phone|upgrade|schedule|skill|proactive|kg|item|' + require('../lib/pmos-verbs.js').names().join('|') + ']');
+    say('usage: pmos [<path>|welcome|status|ls|stop|doctor|phone|upgrade|schedule|skill|proactive|kg|item|' + require('../lib/pmos-verbs.js').names().join('|') + ']');
     say('  pmos          open the current repo as a workspace (starts the server if needed)');
     say('  pmos <path>   open another repo as a workspace');
+    say('  pmos welcome [<path>]  scan a folder and bring its products and initiatives into PMOS (undoable)');
     say('  pmos phone    turn on phone access over Tailscale and show the QR code to scan');
     say('  pmos schedule …  create, edit and run scheduled tasks (pmos schedule --help)');
     say('  pmos skill …     list, read, create and edit skills');
@@ -523,6 +535,10 @@ function doctor() {
     for (const line of require('../lib/pmos-verbs.js').helpLines()) say(line);
     say('  pmos upgrade  reinstall the workspace app from the latest published create-pmos');
     code = 0;
+  } else if (cmd === 'welcome') {
+    // the first-run page on purpose: scan this folder, import it, or undo an import (onboarding-scan-and-map)
+    FORCE_WELCOME = true;
+    code = await up(process.argv[3] && !process.argv[3].startsWith('-') ? path.resolve(process.argv[3]) : process.cwd());
   } else if (cmd === 'up' || cmd === 'start' || cmd === 'open') {
     // `pmos open ../other-repo` — the path is the argument AFTER the verb
     code = await up(process.argv[3] && !process.argv[3].startsWith('-') ? path.resolve(process.argv[3]) : process.cwd());

package/workspace/guide/index.md

@@ -39,6 +39,7 @@ On a desktop the workspace is one frame. [Layout](layout.md) explains each part.
 
 ## Where to read next
 
+- [Welcome (first run)](welcome.md): scan a new folder, review the proposed portfolio, import it and undo it.
 - [The Briefing](briefing.md): the console's first page: Today's meetings, Needs you (Done, Not yet, Drop) and the Portfolio pulse.
 - [Start the workspace without a terminal](launcher.md): the PMOS app, the login item and `pmos launcher`.
 - [Jira tickets](jira.md): Jira tickets drafted from the PRD, pushed when you select them, and their status.

package/workspace/guide/welcome.md

@@ -0,0 +1,38 @@
+---
+type: Guide
+title: "Guide: Welcome (first run)"
+timestamp: 2026-10-11
+---
+
+# Welcome (first run)
+
+The Welcome page is the first screen of a new folder. It reads your folder, shows what it found, and sets up your portfolio from it. You do not need to answer questions first.
+
+## How you get there
+
+Run `pmos` in a plain folder that PMOS has not imported. The terminal says "first run — opening Welcome" and the browser opens `/welcome`. A folder that already has its own PMOS state folder opens the console as before. After an import, `pmos` opens the console.
+
+Run `pmos welcome` to open the page on purpose, for example to scan a folder again or to undo an import. `pmos welcome <path>` opens it for another folder.
+
+Choose **Not now** on the first screen to go to the console. Welcome then stops opening on its own for that folder. `pmos welcome` still opens it.
+
+## The promise
+
+The page says it before the scan: PMOS reads only, writes nothing in your folder, and nothing leaves this computer. The scan runs on your machine and uses no model. The import is stored in the PMOS state folder, never in your folder.
+
+## The steps
+
+1. **Welcome.** The page shows the folder name and path. Choose **Add another folder** to open the system folder chooser and add a second folder. Choose **Scan** to start. A spinner shows while the scan runs. A large folder can take a minute or two, and the rest of PMOS keeps working.
+2. **First look.** One sentence gives the counts: initiatives, documents, deadlines, stale documents, duplicates, people and risks. Up to ten findings follow. Each finding shows the file and line it comes from. Choose **Continue**.
+3. **Your portfolio.** PMOS proposes one board for each product folder (`products/<name>/`). If there is no product folder, it proposes one board for the whole folder. Each board lists its initiatives. Each row has a checkbox, a title you can edit, a lane, an anchor, a stage and a document count. Choose the document count to see the documents. Use the board list on a row to move it to another board. Each board shows how many documents PMOS could not place. High and medium confidence rows start checked. The button reads **Import N initiatives into M boards**. The numbers change as you check, uncheck and move rows.
+4. **Questions.** This step appears only when the scan could not decide something. There are three questions at most. Each question shows its default already chosen. Choose **Import** to accept what is chosen. Choose **Skip** to leave a question open: for the anchor question, the proposed anchors then stay marked for you to confirm later.
+5. **First Briefing.** After the import, the page lists up to five things that need you first. An item that belongs to an imported initiative names the initiative and its board. Choose **Continue**. Choose **Undo this import** to take the import back and return to your portfolio.
+6. **More sources.** This step is optional. It offers Calendar (your meetings today and for the next 14 days) and Jira (the issues assigned to you). PMOS reads nothing from them until you choose **Bring in**. Bring in starts the source's read-only skill as an agent session in the workspace, with your own connection. The skill writes nothing to the tool. Choose **Skip** to leave a source out. You can bring it in later from Settings. Inbox and Slack have no import yet. Choose **Open PMOS** to go to the console.
+
+## Undo
+
+**Undo this import** retracts the import. Nothing is deleted: the import and its undo stay in the record. You can then change the portfolio and import again. When you open Welcome after an import, the page shows the first Briefing with the Undo link.
+
+## What the page does not do
+
+The page does not change your folder. It does not open the files that the exclusion list names, such as `.git`, `node_modules` and files that look like secrets. It does not read Calendar or Jira until you choose **Bring in** on More sources, and the PMOS server itself calls nothing outside this computer. It does not import from Drive, Inbox, Slack or other tools.

package/workspace/lib/import-overlay.js

@@ -0,0 +1,32 @@
+'use strict';
+/* import-overlay.js: where a workspace's first-run import lives, and the fold of it (slice 2 of onboarding-scan-and-map).
+ *   overlayDir(stateRoot, wsId) = <stateRoot>/imports/<wsId>      overlayDirFor is the same function
+ *   importedFor(stateRoot, wsId) -> { boards, initiatives, imports } from scripts/onboarding/apply.js; empty shapes when nothing is there.
+ * Initiative rows carry import_id and source: 'import'; board rows too. Never throws on a missing folder or file. */
+const fs = require('fs');
+const path = require('path');
+
+/** Where scripts/onboarding/ is: the checkout's own, else the copy an installed package vendors under lib/vendor/
+ * (scripts/vendor-workspace-engine.js vendorTree). Null when neither is there. */
+function onboardingDir() {
+  for (const d of [path.join(__dirname, '..', '..', 'scripts', 'onboarding'), path.join(__dirname, 'vendor', 'scripts', 'onboarding')]) {
+    if (fs.existsSync(path.join(d, 'scan.js'))) return d;
+  }
+  return null;
+}
+
+const WS_ID = /^[A-Za-z0-9_-]{1,64}$/; // one safe path segment (server ids are 10 hex characters)
+const empty = () => ({ boards: [], initiatives: [], imports: [] });
+
+function overlayDir(stateRoot, wsId) {
+  if (!WS_ID.test(String(wsId))) throw new Error('bad workspace id');
+  return path.join(stateRoot, 'imports', String(wsId));
+}
+
+function importedFor(stateRoot, wsId) {
+  let apply;
+  try { apply = require(path.join(onboardingDir(), 'apply.js')); } catch { return empty(); }
+  try { return apply.importedFor(overlayDir(stateRoot, wsId)); } catch { return empty(); }
+}
+
+module.exports = { overlayDir, overlayDirFor: overlayDir, importedFor, onboardingDir };

package/workspace/lib/route-modules.js

@@ -60,6 +60,7 @@ const MODULES = Object.freeze([
   'routes-c3-life',       // console3 Lifecycle lens panels: newest evaluation per initiative, corrections per run, evidence sources (read-only)
   'routes-c3-strategy',   // console3 Calendar Quarter and Year panes: outcomes, north star, signals, synergy, bets (read-only)
   'routes-c3-reports',    // console3 Reports dashboards: library, per-scope data, page-press layouts (layouts are the only write)
+  'routes-onboarding',    // onboarding-scan-and-map slice 2: first run (scan read-only, structure, import into the overlay, undo, first Briefing)
   'routes-hooks',         // planning-flows run 7: CLI hook endpoints (session token, per-run JSONL)
   'routes-sources',       // workspace-data-freshness: how old each source is, Refresh now, the change detector switch
 ]);

package/workspace/lib/routes-onboarding.js

@@ -0,0 +1,215 @@
+'use strict';
+/* routes-onboarding.js — the first run: scan a folder read-only, show the proposed portfolio, import it into the overlay
+ * (onboarding-scan-and-map, slice 2). Every read takes ?ws. Every POST passes pm-guard requirePagePress.
+ *
+ *   GET  /api/onboarding/status?ws        → { ok, state: 'new'|'scanned'|'imported', first_run, dismissed, scanning, scan_id, imported: { boards, initiatives }, imports }
+ *   POST /api/onboarding/scan { ws, extra_roots? } → { ok, scan_id, first_look: { sentence, numbers, findings } }
+ *   GET  /api/onboarding/structure?ws     → { ok, ...structure }
+ *   POST /api/onboarding/apply { ws, include, revisions, answers } → { ok, import_id, boards, initiatives }
+ *   POST /api/onboarding/undo { ws, import_id }    → { ok, retracted }
+ *   GET  /api/onboarding/briefing?ws      → { ok, items }
+ *   POST /api/onboarding/dismiss { ws }   → { ok }   "Not now": status.first_run turns false for this folder
+ *
+ * STATE: <STATE>/imports/<wsId>/ (brief.json, scan.json, firstlook.json, proposals.jsonl, imports.jsonl), in the per-user
+ * state folder and never in the scanned folder. The scan reads ws.root (and the root of each extra_roots entry that is a
+ * registered workspace) and writes nothing there. Apply writes to the overlay only.
+ *
+ * WHO WRITES: the press gives the page's actor ({ by: 'pm:<slug>', via: 'ui' }). The onboarding ledger wants a human actor,
+ * so humanOf() maps 'pm:<slug>' to 'human:<slug>'; an actor that is not a PM press is refused. Modules under
+ * scripts/onboarding/ are required inside the handlers, so a module that is not built yet answers 500 for its route only.
+ *
+ * EXTRA ROOTS. scan() reads one root. An extra root must be a registered workspace (never an arbitrary path); it is scanned
+ * on its own into its own overlay, so its own Welcome page shows it. The answer lists them in `extra`.
+ */
+const fs = require('fs');
+const path = require('path');
+const guard = require('./pm-guard.js');
+
+// the checkout's scripts/onboarding/, or the copy an installed package vendors under lib/vendor/ (import-overlay onboardingDir)
+const obDir = () => { const d = require('./import-overlay.js').onboardingDir(); if (!d) throw new Error('the onboarding modules are not installed'); return d; };
+const ob = (name) => require(path.join(obDir(), name));
+const stateRootOf = (ctx) => (ctx && (ctx.runtimeDir || ctx.stateRoot)) || require('./state-root.js').defaultRoot();
+const overlayOf = (ctx, w) => require('./import-overlay.js').overlayDir(stateRootOf(ctx), w.id);
+const today = () => new Date().toISOString().slice(0, 10);
+const bad = (status, error) => ({ status, body: { ok: false, error } });
+const len = (v) => (Array.isArray(v) ? v.length : Number(v) || 0);
+
+/** pm:<slug> from the press becomes human:<slug> for the onboarding ledger. Null for anything else. */
+function humanOf(actor) {
+  const by = actor && typeof actor.by === 'string' ? actor.by : '';
+  return /^pm:[a-z0-9_-]{1,40}$/.test(by) ? { by: 'human:' + by.slice(3), via: actor.via || 'ui' } : null;
+}
+
+function wsOf(ctx, id) {
+  if (typeof id !== 'string' || !id) return null;
+  const w = ctx.getWs(id);
+  return w && w.id === id ? w : null;
+}
+const readJsonFile = (f) => { try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch { return null; } };
+
+function loadScan(dir) {
+  const scan = readJsonFile(path.join(dir, 'scan.json'));
+  return scan ? { scan, brief: readJsonFile(path.join(dir, 'brief.json')) } : null;
+}
+function imported(dir) {
+  const r = ob('apply.js').importedFor(dir) || {};
+  const imports = Array.isArray(r.imports) ? r.imports : [];
+  return { boards: len(r.boards), initiatives: len(r.initiatives), imports, live: imports.some((i) => !i.retracted) };
+}
+
+function status(ctx, w) {
+  const dir = overlayOf(ctx, w);
+  const have = loadScan(dir);
+  const imp = have ? imported(dir) : { boards: 0, initiatives: 0, imports: [], live: false };
+  const state = !have ? 'new' : imp.live ? 'imported' : 'scanned';
+  // first_run: `pmos` opens Welcome on its own only for a plain folder (no PMOS state folder of its own) that is not imported and
+  // where the PM did not choose "Not now". A PMOS repository, or a kit tenant, opens the console as before; `pmos welcome` still works.
+  let ownState = false; try { ownState = typeof ctx.stateDirFor === 'function' && !!ctx.stateDirFor(w); } catch { ownState = false; }
+  const dismissed = fs.existsSync(path.join(dir, 'dismissed.json'));
+  const first_run = state !== 'imported' && !dismissed && !ownState;
+  return { status: 200, body: { ok: true, state, first_run, dismissed, scanning: running.has(w.id), scan_id: have ? have.scan.scan_id : null, imported: { boards: imp.boards, initiatives: imp.initiatives }, imports: imp.imports } };
+}
+
+/* The scan runs in a child process (scripts/onboarding/scan-worker.js): a large folder takes a minute or more, and the server
+ * holds the PM's terminals, so it must never wait on it. A second press for the same workspace joins the running scan. */
+const running = new Map();
+function scanOne(ctx, w, now) {
+  if (running.has(w.id)) return running.get(w.id);
+  const dir = overlayOf(ctx, w);
+  const p = new Promise((resolve, reject) => {
+    const cp = require('child_process');
+    const child = cp.spawn(process.execPath, [path.join(obDir(), 'scan-worker.js'), w.root, dir, now], { stdio: ['ignore', 'pipe', 'pipe'] });
+    let out = ''; let err = '';
+    child.stdout.on('data', (d) => { out += d; });
+    child.stderr.on('data', (d) => { err += d; });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code !== 0) return reject(new Error(err.trim() || 'the scan stopped with code ' + code));
+      const look = readJsonFile(path.join(dir, 'firstlook.json'));
+      let id = null; try { id = JSON.parse(out.trim().split('\n').pop()).scan_id; } catch { /* read below */ }
+      resolve({ scan_id: id || (readJsonFile(path.join(dir, 'scan.json')) || {}).scan_id, first_look: look });
+    });
+  }).finally(() => running.delete(w.id));
+  running.set(w.id, p);
+  return p;
+}
+
+async function scanRoute(ctx, w, body) {
+  const extra = body.extra_roots == null ? [] : body.extra_roots;
+  if (!Array.isArray(extra) || extra.some((x) => typeof x !== 'string')) return bad(400, 'extra_roots must be a list of folder paths');
+  const known = typeof ctx.workspaceList === 'function' ? ctx.workspaceList() : [];
+  const extras = [];
+  for (const r of extra) {
+    const root = path.resolve(r);
+    const hit = known.find((k) => k && k.root && path.resolve(k.root) === root);
+    if (!hit) return bad(400, 'extra_roots may name registered workspaces only: ' + r);
+    if (hit.id !== w.id) extras.push(hit);
+  }
+  const now = today();
+  let out;
+  try { out = await scanOne(ctx, w, now); } catch (e) { return bad(500, 'the scan failed: ' + String((e && e.message) || e).slice(0, 200)); }
+  out.extra = [];
+  for (const x of extras) {
+    try { out.extra.push({ ws: x.id, scan_id: (await scanOne(ctx, x, now)).scan_id }); } catch (e) { out.extra.push({ ws: x.id, error: String((e && e.message) || e).slice(0, 120) }); }
+  }
+  return { status: 200, body: { ok: true, ...out } };
+}
+
+function structureOf(dir) {
+  const have = loadScan(dir);
+  if (!have) return null;
+  return ob('structure.js').structure(have.scan, { brief: have.brief });
+}
+
+function structureRoute(ctx, w) {
+  const dir = overlayOf(ctx, w);
+  let s;
+  try { s = structureOf(dir); } catch (e) { return bad(500, 'the structure could not be built: ' + String((e && e.message) || e).slice(0, 200)); }
+  if (!s) return bad(409, 'scan first: there is no scan for this folder yet');
+  return { status: 200, body: { ok: true, ...s } };
+}
+
+function applyRoute(ctx, w, body, actor) {
+  const dir = overlayOf(ctx, w);
+  let s;
+  try { s = structureOf(dir); } catch (e) { return bad(500, 'the structure could not be built: ' + String((e && e.message) || e).slice(0, 200)); }
+  if (!s) return bad(409, 'scan first: there is no scan for this folder yet');
+  const isObj = (v) => v && typeof v === 'object' && !Array.isArray(v);
+  if (body.include != null && (!Array.isArray(body.include) || body.include.some((x) => typeof x !== 'string'))) return bad(400, 'include must be a list of proposal ids');
+  if (body.revisions != null && !isObj(body.revisions)) return bad(400, 'revisions must be an object keyed by proposal id');
+  if (body.answers != null && !isObj(body.answers)) return bad(400, 'answers must be an object keyed by question id');
+  const ids = new Set(s.boards.flatMap((b) => b.initiatives.map((r) => r.proposal_id)));
+  const unknown = (body.include || []).find((x) => !ids.has(x));
+  if (unknown) return bad(400, 'include names an unknown proposal: ' + unknown);
+  const include = body.include == null ? s.boards.flatMap((b) => b.initiatives.filter((r) => r.checked).map((r) => r.proposal_id)) : body.include;
+  try {
+    const r = ob('apply.js').apply(dir, s, { include, revisions: body.revisions || {}, answers: body.answers || {}, actor, now: new Date().toISOString(), root: w.root });
+    return { status: 200, body: { ok: true, import_id: r.import_id, boards: len(r.boards), initiatives: len(r.initiatives) } };
+  } catch (e) { return bad(400, String((e && e.message) || e).slice(0, 240)); }
+}
+
+function undoRoute(ctx, w, body, actor) {
+  const dir = overlayOf(ctx, w);
+  if (typeof body.import_id !== 'string' || !body.import_id) return bad(400, 'import_id is required');
+  const hit = imported(dir).imports.find((i) => i.import_id === body.import_id);
+  if (!hit) return bad(404, 'no such import');
+  if (hit.retracted) return bad(409, 'this import is already undone');
+  try {
+    const r = ob('apply.js').undo(dir, body.import_id, { actor, now: new Date().toISOString() });
+    return { status: 200, body: { ok: true, retracted: len(r.retracted) } };
+  } catch (e) { return bad(400, String((e && e.message) || e).slice(0, 240)); }
+}
+
+function briefingRoute(ctx, w) {
+  const dir = overlayOf(ctx, w);
+  const have = loadScan(dir);
+  if (!have) return bad(409, 'scan first: there is no scan for this folder yet');
+  const imp = imported(dir);
+  if (!imp.live) return bad(409, 'nothing is imported yet');
+  try {
+    const r = ob('first-briefing.js').firstBriefing(have.scan, ob('apply.js').importedFor(dir), { today: today() });
+    return { status: 200, body: { ok: true, items: r.items || [] } };
+  } catch (e) { return bad(500, 'the briefing could not be built: ' + String((e && e.message) || e).slice(0, 200)); }
+}
+
+/** "Not now": Welcome stops opening on its own for this folder. One file in the overlay; `pmos welcome` still opens it. */
+function dismissRoute(ctx, w, body, actor) {
+  const dir = overlayOf(ctx, w);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'dismissed.json'), JSON.stringify({ at: new Date().toISOString(), by: actor.by }) + '\n');
+  return { status: 200, body: { ok: true } };
+}
+
+const GETS = { status: status, structure: structureRoute, briefing: briefingRoute };
+const POSTS = { scan: scanRoute, apply: applyRoute, undo: undoRoute, dismiss: dismissRoute };
+
+module.exports = {
+  prefixes: ['/api/onboarding'],
+  humanOf, status, dismissRoute, scanRoute, structureRoute, applyRoute, undoRoute, briefingRoute,
+  handle: async (req, res, url, ctx) => {
+    const m = url.pathname.match(/^\/api\/onboarding\/([a-z]+)$/);
+    if (!m) return false;
+    const verb = m[1];
+    const isGet = Object.prototype.hasOwnProperty.call(GETS, verb);
+    const isPost = Object.prototype.hasOwnProperty.call(POSTS, verb);
+    if (!isGet && !isPost) return false;
+    const send = (r) => { ctx.json(res, r.body, r.status); return true; };
+    if (isGet) {
+      if (req.method !== 'GET') return send(bad(405, 'GET only'));
+      const w = wsOf(ctx, url.searchParams.get('ws'));
+      if (!w) return send(bad(404, 'no such workspace'));
+      return send(GETS[verb](ctx, w));
+    }
+    if (req.method !== 'POST') return send(bad(405, 'POST only'));
+    const got = await ctx.readJson(req);
+    if (!got.ok) return send(bad(400, 'invalid JSON body'));
+    const body = got.body || {};
+    const g = guard.requirePagePress(req, body);
+    if (!g.ok) return send(bad(g.status, g.error));
+    const w = wsOf(ctx, body.ws);
+    if (!w) return send(bad(404, 'no such workspace'));
+    const actor = humanOf(g.actor);
+    if (!actor) return send(bad(403, 'only the PM can do this, from the page'));
+    return send(await POSTS[verb](ctx, w, body, actor));
+  },
+};