create-pmos 0.511.0 → 0.513.0

package/workspace/lib/next-prompt.js

@@ -0,0 +1,199 @@
+'use strict';
+/* next-prompt.js — Claude suggests the PM's next prompt, already sharpened (batch 26 item 2, design B on the main canvas: NpB, NpBw).
+ *
+ * Two jobs, both short Claude calls whose answer is a suggestion and never an act:
+ *   next     after a reply ends: up to two prompts the PM could send next, the first one recommended. A tap puts the text in the box; nothing sends.
+ *   sharpen  while the PM types a rough prompt: one sharper version in the PM's chosen style (Polish, Prompt engineer, Your own).
+ *
+ * PROVEN ONLY. A `next` card is one of MOVES, and a move is offered only while the code that makes it work is on disk: each move names the file
+ * and the text that prove it (lib/pmos-verbs.js for rehearse, ask the past and the drift replay; lib/routes-briefing-premium.js for "grill
+ * this"). movesOf(root) finds that line, and the card cites it, so lib/ai-guard.js check() verifies the quote at its line before the card shows.
+ * A `follow` card answers the question or the offer the reply ends with; it cites the line of the reply it answers (state:next-prompt/…).
+ * A sharpened prompt cites the PM's own words. A card with no verified source is dropped and never shown.
+ *
+ *   MOVES · STYLES · JOB_NEXT · JOB_SHARPEN
+ *   movesOf(root) → [{ id, where, use, ref, quote }]           the moves whose proving line is on disk
+ *   nextPrompt({ pm, reply, place, style, rules, moves }) → string     the prompt for the `next` call
+ *   sharpenPrompt({ text, reply, place, style, rules }) → string       the prompt for the `sharpen` call
+ *   parseNext(text, { moves, place }) → [{ move, text, from? }]        the cards the answer holds, unknown moves and bad shapes left out (≤ 2)
+ *   parseSharpen(text, rough) → string | null                          the sharper prompt, or null (no answer, or it says the same)
+ *   same(a, b) → bool                                                  two prompts that say the same thing (≥ 90% the same words)
+ *   proposalsOfNext(cards, { moves, replyRef }) → [ai-guard proposal]  replyRef(from) → { ref, quote } | null
+ *   proposalOfSharpen(text, roughRef) → ai-guard proposal
+ *   rough(text) → bool                                                 3 or more words and 12 or more characters, not a slash command
+ *
+ * Pure: no I/O apart from movesOf reading the proving files. lib/routes-next-prompt.js makes the call and files the cards through the guard. */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const JOB_NEXT = 'next-prompt';
+const JOB_SHARPEN = 'sharpen-prompt';
+const MAX_CARDS = 2;
+const MAX_TEXT = 400;
+const REPLY_MAX = 3000;
+const GRILL_RE = /^\s*(please\s+)?(grill|re-?grill)\b/i;   // the same test lib/routes-briefing-premium.js grillAsk makes
+
+/* where: 'any' chat, or only an initiative's chat (its key starts init:). `find` is the text that proves the move works today. */
+const MOVES = Object.freeze([
+  { id: 'follow', where: 'any', file: null,
+    use: 'Answer the question the reply asks, or take up the offer it makes, in the PM\'s words (for example "Yes, swap it for the period-end KR debrief."). Only when the reply asks or offers something. Put the exact line of the reply you answer in "from".' },
+  { id: 'grill', where: 'initiative', file: 'lib/routes-briefing-premium.js', find: 'const GRILL_RE = ',
+    use: 'Ask Claude to grill this initiative\'s plan. The text MUST start with "Grill this" and then say what to test it against (earlier decisions, scope, dates). Only when the reply is about this initiative\'s plan, scope, dates or a decision on it.' },
+  { id: 'past', where: 'initiative', file: 'lib/pmos-verbs.js', find: "past: Object.freeze({ module: 'past-cli.js'",
+    use: 'Ask why something was decided or dropped: "Why did we …?" or "Did we ever decide …?", answered from the records with file:line sources or "No record found". Only when the reply names an earlier decision, or something dropped, retired or replaced.' },
+  { id: 'rehearse', where: 'any', file: 'lib/pmos-verbs.js', find: "rehearse: Object.freeze({ module: 'rehearse-cli.js'",
+    use: 'Ask Claude to rehearse a change before making it: moving a task, changing an initiative\'s end date, or cutting a task or an initiative. It shows what breaks, helps and moves, then waits for the PM\'s yes. Only when the reply or the PM\'s message talks about such a change, naming the real task or initiative.' },
+  { id: 'drift', where: 'any', file: 'lib/pmos-verbs.js', find: "drift: Object.freeze({ module: 'drift-cli.js'",
+    use: 'Ask Claude to run the weekly drift check\'s replay on the PM\'s records ("Run the drift replay"). Only when the reply says the weekly "what you might have missed" check waits for its replay.' },
+]);
+
+const STYLES = Object.freeze({
+  polish: 'Polish: make it clearer and shorter. Keep the PM\'s meaning, words and order where they work. Add nothing the PM did not ask for.',
+  engineer: 'Prompt engineer: build the best prompt for the job. Say the goal in the first words, name the real things (initiative, task, product, PR) from the context, and say what a good answer holds. Add no new request, step or condition the PM did not ask for. One or two short sentences, plain words, no role-play preamble, no markdown, no lists.',
+  own: 'The PM\'s own rules, below. Follow them; where they say nothing, keep the PM\'s meaning and make it clear.',
+});
+
+const one = (s, n) => String(s == null ? '' : s).replace(/\s+/g, ' ').trim().slice(0, n);
+const norm = (s) => String(s == null ? '' : s).toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, ' ').replace(/\s+/g, ' ').trim();
+const words = (s) => norm(s).split(' ').filter(Boolean);
+const rough = (t) => { const s = String(t || '').trim(); return !s.startsWith('/') && s.length >= 12 && words(s).length >= 3; };
+
+/** The moves whose proving line is on disk now, each with its ref (path:line under root) and the line as its quote. */
+function movesOf(root) {
+  const out = [], cache = new Map();
+  for (const m of MOVES) {
+    if (!m.file) { out.push({ id: m.id, where: m.where, use: m.use, ref: null, quote: null }); continue; }
+    if (!cache.has(m.file)) { let L = null; try { L = fs.readFileSync(path.join(root, m.file), 'utf8').split('\n'); } catch { L = null; } cache.set(m.file, L); }
+    const L = cache.get(m.file); if (!L) continue;
+    const i = L.findIndex((l) => l.includes(m.find)); if (i < 0) continue;
+    out.push({ id: m.id, where: m.where, use: m.use, ref: `${m.file}:${i + 1}`, quote: one(L[i], 200) });
+  }
+  return out;
+}
+const inInitiative = (place) => !!(place && place.initiative);
+const usable = (moves, place) => (moves || []).filter((m) => m.where === 'any' || inInitiative(place));
+
+function placeLines(place) {
+  if (!place) return 'The chat: Home (not tied to one initiative).';
+  const bits = [];
+  if (place.initiative) bits.push(`The chat: the initiative "${one(place.initiative, 120)}"${place.stage ? `, stage ${one(place.stage, 40)}` : ''}${place.product ? `, product ${one(place.product, 80)}` : ''}.`);
+  else bits.push(`The chat: ${one(place.title || 'Home', 120)} (not tied to one initiative).`);
+  return bits.join('\n');
+}
+const styleLines = (style, rules) => (STYLES[style] || STYLES.engineer) + (style === 'own' && rules ? '\nThe PM\'s rules:\n' + one(rules, 1000) : '');
+const clip = (s, n) => { const t = String(s == null ? '' : s).trim(); return t.length > n ? t.slice(0, n) + ' …' : t; };
+
+function nextPrompt({ pm, reply, place, style = 'engineer', rules = '', moves = [] } = {}) {
+  const ok = usable(moves, place);
+  return [
+    'You suggest the next message a product manager (the PM) could send in a PMOS chat with Claude. You write it in the PM\'s voice, ready to send. You do not answer the PM, and you run nothing.',
+    '',
+    placeLines(place),
+    '',
+    'The PM\'s last message:', '<pm>', clip(pm, 1200) || '(none)', '</pm>',
+    '',
+    'Claude\'s reply:', '<reply>', clip(reply, REPLY_MAX), '</reply>',
+    '',
+    'You may suggest only these moves. Each one works in PMOS today:',
+    ...ok.map((m) => `- ${m.id}: ${m.use}`),
+    '',
+    'How to write each suggestion:',
+    styleLines(style, rules),
+    '',
+    'Rules:',
+    '- At most 2 suggestions, the best first. Usually 1. Return none when the reply needs nothing from the PM or no move clearly fits: an empty list is a good answer.',
+    '- Use only names, numbers and dates that appear above. Never invent them.',
+    '- Never suggest something the reply says is already done, or that only repeats the reply.',
+    `- Each text is at most ${MAX_TEXT} characters.`,
+    '',
+    'Answer with JSON only, no other text: {"cards":[{"move":"<id>","text":"<the prompt>","from":"<follow only: the exact line of the reply it answers>"}]}',
+  ].join('\n');
+}
+
+function sharpenPrompt({ text, reply, place, style = 'engineer', rules = '' } = {}) {
+  return [
+    'A product manager (the PM) is typing a message to Claude in a PMOS chat. Rewrite it into a sharper prompt, ready to send. You do not answer it, and you run nothing.',
+    '',
+    placeLines(place),
+    '',
+    reply ? 'Claude\'s last reply, for context:\n<reply>\n' + clip(reply, 1500) + '\n</reply>\n' : '',
+    'What the PM typed:', '<draft>', clip(text, 1500), '</draft>',
+    '',
+    'Style:',
+    styleLines(style, rules),
+    '',
+    'Rules:',
+    '- Keep what the PM asks for. Do not add a new request or step, and do not answer it. Say nothing about how Claude should read or check data.',
+    '- When the draft asks to move a task, change an end date or cut work, ask Claude to rehearse it first ("Rehearse moving …") and wait for the PM\'s yes: PMOS does that today.',
+    '- Use only names, numbers and dates from the draft and the context above. Never invent them.',
+    '- Write in the PM\'s voice, as the message the PM sends. Do not guess what "here" or "this" points at when the context does not say.',
+    `- At most ${MAX_TEXT} characters.`,
+    '- If the draft is already as sharp as it can be in this style, say so.',
+    '',
+    'Answer with JSON only, no other text: {"text":"<the sharper prompt>"} or {"same":true}',
+  ].join('\n');
+}
+
+/** The first JSON object in a model's answer (it may wrap it in a code fence or a sentence). */
+function jsonOf(text) {
+  const s = String(text == null ? '' : text);
+  const a = s.indexOf('{'), b = s.lastIndexOf('}');
+  if (a < 0 || b <= a) return null;
+  try { return JSON.parse(s.slice(a, b + 1)); } catch { return null; }
+}
+
+function parseNext(text, { moves = [], place = null } = {}) {
+  const o = jsonOf(text); if (!o || !Array.isArray(o.cards)) return [];
+  const ok = new Map(usable(moves, place).map((m) => [m.id, m]));
+  const out = [];
+  for (const c of o.cards) {
+    if (out.length >= MAX_CARDS) break;
+    if (!c || typeof c !== 'object') continue;
+    const move = String(c.move || ''), t = one(c.text, MAX_TEXT + 1);
+    if (!ok.has(move) || !t || t.length > MAX_TEXT) continue;
+    if (move === 'grill' && !GRILL_RE.test(t)) continue;   // the chat starts a grill run only on a message that starts with grill
+    if (move === 'follow' && !one(c.from, 400)) continue;
+    if (out.some((x) => same(x.text, t))) continue;
+    out.push({ move, text: t, ...(move === 'follow' ? { from: one(c.from, 400) } : {}) });
+  }
+  return out;
+}
+
+/** Two prompts that say the same: the same words, or at least 90% of the words of both shared. */
+function same(a, b) {
+  const x = words(a), y = words(b);
+  if (!x.length || !y.length) return x.length === y.length;
+  if (x.join(' ') === y.join(' ')) return true;
+  const X = new Set(x), Y = new Set(y);
+  let both = 0; for (const w of X) if (Y.has(w)) both++;
+  return both / Math.max(X.size, Y.size) >= 0.9;
+}
+
+function parseSharpen(text, roughText) {
+  const o = jsonOf(text); if (!o || o.same === true) return null;
+  const t = one(o.text, MAX_TEXT + 1);
+  if (!t || t.length > MAX_TEXT || same(t, roughText)) return null;
+  return t;
+}
+
+const idOf = (prefix, s) => prefix + ':' + crypto.createHash('sha1').update(String(s)).digest('hex').slice(0, 12);
+
+function proposalsOfNext(cards, { moves = [], replyRef = () => null } = {}) {
+  const by = new Map(moves.map((m) => [m.id, m]));
+  return (cards || []).map((c, i) => {
+    const m = by.get(c.move) || {};
+    const src = c.move === 'follow' ? replyRef(c.from) : (m.ref ? { ref: m.ref, quote: m.quote } : null);
+    return {
+      id: idOf('np', c.move + '\n' + c.text), title: c.move, say: c.text, confidence: 'medium',
+      claims: [{ text: c.move === 'follow' ? 'It answers the reply' : 'This move works in PMOS today', sources: src ? [{ label: c.move === 'follow' ? 'the reply' : m.file || c.move, ref: src.ref, quote: src.quote }] : [] }],
+      data: { move: c.move, rec: i === 0 },
+    };
+  });
+}
+function proposalOfSharpen(text, src) {
+  return { id: idOf('sh', text), title: 'sharper', say: text, confidence: 'medium',
+    claims: [{ text: 'It keeps what the PM typed', sources: src ? [{ label: 'what you typed', ref: src.ref, quote: src.quote }] : [] }], data: { kind: 'sharper' } };
+}
+
+module.exports = { JOB_NEXT, JOB_SHARPEN, MAX_CARDS, MAX_TEXT, MOVES, STYLES, GRILL_RE, movesOf, nextPrompt, sharpenPrompt, parseNext, parseSharpen, same, rough, jsonOf, proposalsOfNext, proposalOfSharpen };

package/workspace/lib/premium-console-type.js

@@ -3,25 +3,25 @@
  * The premium stylesheets were cut from the approved mockup, which set its own type: Geist and Geist Mono, a 15 px body and sizes from 10 to
  * 44 px written as plain pixels, and weights from 550 to 700. The console (pm/console3.css + pm/tokens.css) sets Space Grotesk and IBM Plex
  * Mono, a 14 px / 1.5 body, a six-step scale (--fs-1 to --fs-6: 11, 12, 14, 16, 20, 28 px) and three weights (400, 500, 600).
+ * Since feedback batch 26 item 6 (2026-11-03) the steps are the typography roles (cozy.css): sizes go to a role token (13, 15, 18 or 26 px)
+ * and weights to the two weight tokens (400, 600).
  * transform(css) maps a premium stylesheet onto the console's type and changes nothing else: every font size goes to the nearest console
  * step, every heavy weight to 600 (550 to 500), the two font families to the console's, and the body line height to 1.5. It is idempotent,
  * so a stylesheet already on console type comes back unchanged (premium-console-type.test.js holds the committed stylesheets to that).
  * The browser suites also run it over the mockup before they compare computed styles, so the mockup stays the reference for the look and
  * the console is the reference for the type. */
 
-const FS = '--fs-1:11px;--fs-2:12px;--fs-3:14px;--fs-4:16px;--fs-5:20px;--fs-6:28px';
+const FS = '--fw-regular:400;--fw-strong:600;--fs-field:16px;--fs-display:26px;--fs-page:26px;--fs-panel:18px;--fs-section:15px;--fs-row:15px;--fs-body:15px;--fs-meta:13px;--fs-label:13px;--fs-badge:13px;--lh-display:1.2;--lh-page:1.2;--lh-panel:1.3;--lh-section:1.35;--lh-row:1.4;--lh-body:1.6;--lh-meta:1.5;--lh-label:1.35;--lh-badge:1.2';
 
-/* a pixel size to the console step it reads as */
+/* a pixel size to the role size it reads as: 13 meta, 15 body, 18 panel, 26 display */
 function step(px) {
   const n = parseFloat(px);
-  if (n <= 11.5) return 'var(--fs-1)';
-  if (n <= 13) return 'var(--fs-2)';
-  if (n <= 15) return 'var(--fs-3)';
-  if (n <= 20) return 'var(--fs-4)';
-  if (n <= 30) return 'var(--fs-5)';
-  return 'var(--fs-6)';
+  if (n < 13.5) return 'var(--fs-meta)';
+  if (n < 17.5) return 'var(--fs-body)';
+  if (n < 23) return 'var(--fs-panel)';
+  return 'var(--fs-display)';
 }
-const weight = (w) => (w === '550' ? '500' : (+w > 600 ? '600' : w));
+const weight = (w) => (+w >= 600 ? 'var(--fw-strong)' : 'var(--fw-regular)');
 
 /* the console's font files; base is where /vendor/ is served ('/vendor/' on the server, a file:// path for the mockup) */
 function fontFaces(base = '/vendor/') {
@@ -32,7 +32,9 @@ function fontFaces(base = '/vendor/') {
 }
 
 function transform(css, { base = '/vendor/', faces = true } = {}) {
-  let out = String(css)
+  // an @font-face's weight is a descriptor of the file (400, 300 700), not a style: set aside, then put back unchanged
+  const kept = [];
+  let out = String(css).replace(/@font-face\s*\{[^}]*\}/g, (m) => (/Geist/.test(m) ? m : '\u0000' + (kept.push(m) - 1) + '\u0000'))
     .replace(/@font-face\s*\{[^}]*Geist[^}]*\}\s*/g, '')
     .replace(/--sans:[^;}]*/g, '--sans:"Space Grotesk",ui-sans-serif,system-ui,sans-serif')
     .replace(/--mono:[^;}]*/g, '--mono:"IBM Plex Mono",ui-monospace,SFMono-Regular,Menlo,Consolas,monospace')
@@ -49,8 +51,9 @@ function transform(css, { base = '/vendor/', faces = true } = {}) {
     .replace(/font:\s*((?:italic\s+)?)(\d{3})(\s)/g, (m, it, w, sp) => 'font:' + it + weight(w) + sp)
     // the body reads at the console's line height; the Briefing paragraph gets the width its smaller type needs
     .replace(/(\bbody\{[^}]*?)line-height:1\.45/g, '$1line-height:1.5')
-    .replace(/(\.brief\{[^}]*?)max-width:42ch/g, '$1max-width:64ch');
-  if (!/--fs-1:/.test(out)) out = ':root{' + FS + '}\n' + out;
+    .replace(/(\.brief\{[^}]*?)max-width:42ch/g, '$1max-width:64ch')
+    .replace(/\u0000(\d+)\u0000/g, (m, k) => kept[+k]);
+  if (!/--fs-body:/.test(out)) out = ':root{' + FS + '}\n' + out;
   if (faces && !/space-grotesk-var\.woff2/.test(out)) out = fontFaces(base) + out;
   return out;
 }

package/workspace/lib/route-modules.js

@@ -114,6 +114,7 @@ const MODULES = Object.freeze([
   'routes-goal-status',   // batch 16 item 6: the goals' one status from readings (product page), notify choice, recipe, Read now, test read, CSV readings
   'routes-refresh',       // data-refresh-settings: Settings › Data refresh: what refreshes, when, the refresh log, Refresh now
   '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)
 ]);
 const PM_DIR = path.join(__dirname, '..', 'public', 'pm');

package/workspace/lib/routes-next-prompt.js

@@ -0,0 +1,248 @@
+'use strict';
+/* routes-next-prompt.js — the chat's suggested next prompt and its Sharper card over HTTP (batch 26 item 2, design B; lib/next-prompt.js).
+ *
+ *   GET  /api/next-prompt/prefs                    → { ok, next, sharpen, sharpenSet, style, rules, api }
+ *        next: suggestions after a reply are on. sharpen: Sharpen as I type is on now ('auto' is on when Claude's runs go to the API, where a
+ *        call takes about 2 s; a background `claude -p` run takes 10 s or more, too slow to follow typing). sharpenSet: 'auto'|'on'|'off'.
+ *        style: 'polish'|'engineer'|'own'. rules: whether Your own rules are written. api: a key for the Claude API is set.
+ *   POST /api/next-prompt/prefs   { key: 'next'|'sharpen'|'style'|'rules', value }          → { ok } (saved in <runtime>/next-prompt/prefs.json)
+ *   POST /api/next-prompt/next    { key, asked, reply, initiative?, stage?, product?, title? }  → { ok, on, cards: [{ text, move, rec }] }
+ *   POST /api/next-prompt/sharpen { key, text, reply?, initiative?, title? }                  → { ok, on, text | null }
+ *
+ * Both POSTs are page presses (lib/pm-guard.js requirePagePress; an agent session header is refused) and run ONE short Claude call:
+ * on the API with the PM's key when one is set (lib/anthropic-key.js, model PMOS_NEXT_PROMPT_MODEL or claude-sonnet-5-5), else a headless
+ * read-only run (lib/headless.js kind 'ask', origin briefing-ask:next-prompt:…). The answer goes through the shared door, lib/ai-guard.js file():
+ * the kill switch (`pmos ai off next-prompt`, `pmos ai off sharpen-prompt`, PMOS_AI=off), the replay gate (fixtures/next-prompt-replay.json,
+ * recorded answers, never a model), the citation check and the audit (<runtime>/ai-audit.jsonl). A card with no verified source is never
+ * shown. The reply and the typed text a card cites are kept in <runtime>/next-prompt/ (the newest 30 files), outside every repository.
+ * Nothing here writes to a session, a record or a repository: a card is text the PM may put in the box.
+ *
+ * Tests inject ctx.askClaude(prompt, { job, key }) → Promise<string|null> instead of a real call. */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const guard = require('./pm-guard.js');
+const AG = require('./ai-guard.js');
+const NP = require('./next-prompt.js');
+
+const VERSION = '1';
+const ROOT = path.join(__dirname, '..');   // the workspace package: the files that prove a move works today
+const FIXTURE = path.join(ROOT, 'fixtures/next-prompt-replay.json');
+const KEEP = 30;
+const TIMEOUT_MS = 90000;
+const DEFAULT_MODEL = 'claude-sonnet-5-5';
+
+const text = (v, n) => (typeof v === 'string' ? v.slice(0, n) : '');
+const bad = (status, error) => ({ status, body: { ok: false, error } });
+const dirOf = (runtimeDir) => path.join(runtimeDir, 'next-prompt');
+
+/* The PM's choices live in <runtime>/next-prompt/prefs.json, owned by this route (Settings › Claude and the sliders menu write them here). */
+const PREFS = {
+  next: (v) => typeof v === 'boolean',
+  sharpen: (v) => v === 'auto' || v === 'on' || v === 'off',
+  style: (v) => Object.prototype.hasOwnProperty.call(NP.STYLES, v),
+  rules: (v) => typeof v === 'string' && v.length <= 1000,
+};
+const prefsFile = (runtimeDir) => path.join(dirOf(runtimeDir), 'prefs.json');
+function readPrefs(runtimeDir) {
+  try { const o = JSON.parse(fs.readFileSync(prefsFile(runtimeDir), 'utf8')); return o && typeof o === 'object' ? o : {}; } catch { return {}; }
+}
+/** Save one choice → { ok } or { ok:false, error }. */
+function setPref(runtimeDir, key, value) {
+  if (!Object.prototype.hasOwnProperty.call(PREFS, key)) return { ok: false, error: 'no such choice: ' + String(key).slice(0, 40) };
+  if (!PREFS[key](value)) return { ok: false, error: 'that value does not fit ' + key };
+  const o = readPrefs(runtimeDir); o[key] = value;
+  fs.mkdirSync(dirOf(runtimeDir), { recursive: true, mode: 0o700 });
+  const f = prefsFile(runtimeDir), tmp = f + '.' + process.pid + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(o, null, 2) + '\n', { mode: 0o600 });
+  fs.renameSync(tmp, f);
+  return { ok: true };
+}
+const get = (ctx, k) => { const v = readPrefs(ctx.runtimeDir)[k]; return PREFS[k](v) ? v : undefined; };
+const envOf = (ctx) => ctx.env || process.env;
+
+function apiKey(ctx) {
+  const env = envOf(ctx);
+  if (/^(off|0|false|no)$/i.test(String(env.PMOS_NEXT_PROMPT_API || ''))) return null;
+  try { return require('./anthropic-key.js').getKey(ctx.runtimeDir, env); } catch { return null; }
+}
+function prefs(ctx) {
+  const set = get(ctx, 'sharpen') || 'auto', api = !!apiKey(ctx), style = get(ctx, 'style') || 'engineer', rules = String(get(ctx, 'rules') || '');
+  return { next: get(ctx, 'next') !== false, sharpen: set === 'on' || (set === 'auto' && api), sharpenSet: set, style, rules: !!rules.trim(), rulesText: rules, api };
+}
+function offWhy(ctx, job) {
+  const why = AG.off(job, { env: envOf(ctx), settingsDir: ctx.runtimeDir });
+  if (why) return why;
+  const P = prefs(ctx);
+  if (job === NP.JOB_NEXT && !P.next) return 'Suggestions after a reply are off (Settings › Claude)';
+  if (job === NP.JOB_SHARPEN && !P.sharpen) return 'Sharpen as I type is off (Settings › Claude)';
+  return null;
+}
+
+/* ── the call ────────────────────────────────────────────────────────────────────────────── */
+
+async function viaApi(key, prompt, env) {
+  const Anthropic = require('@anthropic-ai/sdk');
+  const api = new Anthropic({ apiKey: key });
+  const res = await api.messages.create({ model: String(env.PMOS_NEXT_PROMPT_MODEL || '').trim() || DEFAULT_MODEL, max_tokens: 800, messages: [{ role: 'user', content: prompt }] });
+  return (res.content || []).filter((b) => b.type === 'text').map((b) => b.text).join('\n');
+}
+function viaHeadless(ctx, prompt, origin) {
+  const headless = require('./headless.js');
+  if (typeof ctx.spawnSession !== 'function' || headless.kindFor({ agent: 'claude', origin }) !== 'ask') return Promise.resolve(null);
+  return new Promise((resolve) => {
+    let settled = false; const done = (v) => { if (!settled) { settled = true; clearTimeout(t); resolve(v); } };
+    const t = setTimeout(() => done(null), TIMEOUT_MS);
+    let s = null;
+    try {
+      s = ctx.spawnSession({ name: 'chat: next prompt', agent: 'claude', origin, initialInput: prompt,
+        onDone: (d) => { const r = d && d.result; done(r && r.ok && !r.isError ? String(r.text || '') : null); } });
+    } catch { s = null; }
+    if (!s || s.state === 'exited') done(null);
+  });
+}
+async function ask(ctx, prompt, { job, key }) {
+  if (typeof ctx.askClaude === 'function') return ctx.askClaude(prompt, { job, key });
+  const k = apiKey(ctx);
+  if (k) { try { return await viaApi(k, prompt, envOf(ctx)); } catch { return null; } }
+  return viaHeadless(ctx, prompt, `briefing-ask:next-prompt:${job}:${crypto.createHash('sha1').update(String(key)).digest('hex').slice(0, 10)}`);
+}
+
+/* ── what a card cites ───────────────────────────────────────────────────────────────────── */
+
+function prune(dir) {
+  let fsx = []; try { fsx = fs.readdirSync(dir).filter((f) => f.endsWith('.txt')).map((f) => ({ f, t: fs.statSync(path.join(dir, f)).mtimeMs })); } catch { return; }
+  fsx.sort((a, b) => b.t - a.t);
+  for (const x of fsx.slice(KEEP)) { try { fs.unlinkSync(path.join(dir, x.f)); } catch { /* gone already */ } }
+}
+/** Keep a text where the guard can read it at its lines; → its name under the state folder. */
+function keep(runtimeDir, prefix, body) {
+  const dir = dirOf(runtimeDir);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const name = prefix + '-' + crypto.createHash('sha1').update(body).digest('hex').slice(0, 16) + '.txt';
+  fs.writeFileSync(path.join(dir, name), body, { mode: 0o600 });
+  prune(dir);
+  return 'next-prompt/' + name;
+}
+const flat = (s) => String(s == null ? '' : s).toLowerCase().replace(/\s+/g, ' ').trim();
+/** The line of the kept reply that holds `from` (spacing and case ignored) → { ref, quote } for the guard, or null. */
+function lineRef(rel, body, from) {
+  const want = flat(from); if (want.length < AG.QUOTE_MIN) return null;
+  const L = body.split('\n');
+  for (let i = 0; i < L.length; i++) if (flat(L.slice(Math.max(0, i - 2), i + 3).join(' ')).includes(want)) return { ref: `state:${rel}:${i + 1}`, quote: from };
+  return null;
+}
+
+/* ── the guard ───────────────────────────────────────────────────────────────────────────── */
+
+const MOVES = () => NP.movesOf(ROOT);
+function replayCases(runtimeDir, job = null) {
+  let F; try { F = JSON.parse(fs.readFileSync(FIXTURE, 'utf8')); } catch { return []; }
+  const moves = MOVES();
+  const N = job === NP.JOB_SHARPEN ? [] : F.next || [], H = job === NP.JOB_NEXT ? [] : F.sharpen || [];
+  return N.map((c) => ({ name: 'next: ' + c.name, expect: c.expect, run: async () => {
+    const reply = String(c.reply || ''), rel = keep(runtimeDir, 'replay', reply);
+    return NP.proposalsOfNext(NP.parseNext(JSON.stringify(c.answer), { moves, place: c.place || null }), { moves, replyRef: (from) => lineRef(rel, reply, from) });
+  } })).concat(H.map((c) => ({ name: 'sharpen: ' + c.name, expect: c.expect, run: async () => {
+    const out = NP.parseSharpen(JSON.stringify(c.answer), c.text);
+    if (!out) return [];
+    const rel = keep(runtimeDir, 'replay-typed', String(c.text));
+    return [NP.proposalOfSharpen(out, c.cite === false ? null : { ref: `state:${rel}:1`, quote: String(c.text).split('\n')[0] })];
+  } })));
+}
+async function gate(ctx, job) {
+  if (AG.ready(ctx.runtimeDir, job, VERSION)) return true;
+  const rp = await AG.replay(job, VERSION, replayCases(ctx.runtimeDir, job), { root: ROOT, stateDir: ctx.runtimeDir, max: NP.MAX_CARDS });
+  return rp.ok;
+}
+async function through(ctx, job, run, proposals) {
+  let shown = [];
+  const got = await AG.file({ job, version: VERSION, run, root: ROOT, stateDir: ctx.runtimeDir, settingsDir: ctx.runtimeDir, env: envOf(ctx), max: NP.MAX_CARDS }, proposals, async (filed) => { shown = filed; });
+  return got.off || got.held ? [] : shown;
+}
+
+/* ── the two calls ───────────────────────────────────────────────────────────────────────── */
+
+const placeOf = (b) => ({ initiative: text(b.initiative, 160) || null, stage: text(b.stage, 60) || null, product: text(b.product, 120) || null, title: text(b.title, 160) || null });
+const inflight = new Map();   // the same reply asked twice (two tabs, a re-read) shares one call
+function once(k, fn) {
+  if (inflight.has(k)) return inflight.get(k);
+  const p = fn().finally(() => setTimeout(() => inflight.delete(k), 60000));
+  inflight.set(k, p);
+  if (inflight.size > 100) inflight.delete(inflight.keys().next().value);
+  return p;
+}
+
+async function next(ctx, b) {
+  const reply = text(b.reply, 6000).trim(), key = text(b.key, 200);
+  if (!reply) return { ok: true, on: true, cards: [] };
+  const job = NP.JOB_NEXT, run = 'np-' + crypto.randomBytes(4).toString('hex');
+  const P = prefs(ctx), place = placeOf(b), moves = MOVES();
+  if (!(await gate(ctx, job))) return { ok: true, on: true, held: true, cards: [] };
+  const k = 'n:' + key + ':' + crypto.createHash('sha1').update(reply + '\n' + P.style + '\n' + P.rulesText).digest('hex');
+  return once(k, async () => {
+    AG.audit(ctx.runtimeDir, { job, version: VERSION, run, event: 'start' });
+    const answer = await ask(ctx, NP.nextPrompt({ pm: text(b.asked, 2000), reply, place, style: P.style, rules: P.rulesText, moves }), { job, key });
+    const cards = NP.parseNext(answer, { moves, place });
+    if (!cards.length) { AG.audit(ctx.runtimeDir, { job, version: VERSION, run, event: 'end', filed: 0, dropped: 0, ...(answer == null ? { error: 'no answer' } : {}) }); return { ok: true, on: true, cards: [] }; }
+    const rel = keep(ctx.runtimeDir, 'reply', reply);
+    const shown = await through(ctx, job, run, NP.proposalsOfNext(cards, { moves, replyRef: (from) => lineRef(rel, reply, from) }));
+    return { ok: true, on: true, cards: shown.map((p, i) => ({ text: p.say, move: p.data.move, rec: i === 0 })) };
+  });
+}
+
+async function sharpen(ctx, b) {
+  const typed = text(b.text, 2000).trim(), key = text(b.key, 200);
+  if (!NP.rough(typed)) return { ok: true, on: true, text: null };
+  const job = NP.JOB_SHARPEN, run = 'sh-' + crypto.randomBytes(4).toString('hex');
+  const P = prefs(ctx);
+  if (!(await gate(ctx, job))) return { ok: true, on: true, held: true, text: null };
+  const k = 's:' + key + ':' + crypto.createHash('sha1').update(typed + '\n' + P.style + '\n' + P.rulesText).digest('hex');
+  return once(k, async () => {
+    AG.audit(ctx.runtimeDir, { job, version: VERSION, run, event: 'start' });
+    const answer = await ask(ctx, NP.sharpenPrompt({ text: typed, reply: text(b.reply, 3000), place: placeOf(b), style: P.style, rules: P.rulesText }), { job, key });
+    const out = NP.parseSharpen(answer, typed);
+    if (!out) { AG.audit(ctx.runtimeDir, { job, version: VERSION, run, event: 'end', filed: 0, dropped: 0, ...(answer == null ? { error: 'no answer' } : { same: true }) }); return { ok: true, on: true, text: null }; }
+    const first = typed.split('\n')[0], rel = keep(ctx.runtimeDir, 'typed', typed);
+    const shown = await through(ctx, job, run, [NP.proposalOfSharpen(out, { ref: `state:${rel}:1`, quote: first })]);
+    return { ok: true, on: true, text: shown.length ? shown[0].say : null };
+  });
+}
+
+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\/next-prompt\/?/, '');
+  if (what === 'prefs' && req.method === 'POST') {
+    if (req.headers && req.headers['x-pmos-session']) return send(bad(403, 'Only the page changes these choices.'));
+    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));
+    if (!ctx.runtimeDir) return send(bad(409, 'There is no runtime folder.'));
+    const r = setPref(ctx.runtimeDir, body.key, body.value);
+    return send(r.ok ? { status: 200, body: { ok: true } } : bad(400, r.error));
+  }
+  if (what === 'prefs') {
+    if (req.method !== 'GET') return send(bad(405, 'GET or POST only'));
+    const P = prefs(ctx), env = envOf(ctx);
+    const next = P.next && !AG.off(NP.JOB_NEXT, { env, settingsDir: ctx.runtimeDir }), sh = P.sharpen && !AG.off(NP.JOB_SHARPEN, { env, settingsDir: ctx.runtimeDir });
+    return send({ status: 200, body: { ok: true, next, nextSet: P.next, sharpen: sh, sharpenSet: P.sharpenSet, style: P.style, rules: P.rules, rulesText: P.rulesText, api: P.api } });
+  }
+  if (what !== 'next' && what !== 'sharpen') return send(bad(404, 'no such next-prompt route'));
+  if (req.method !== 'POST') return send(bad(405, 'POST only'));
+  if (req.headers && req.headers['x-pmos-session']) return send(bad(403, 'Only the page asks for a suggestion.'));
+  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));
+  if (!ctx.runtimeDir) return send(bad(409, 'There is no runtime folder.'));
+  const job = what === 'next' ? NP.JOB_NEXT : NP.JOB_SHARPEN;
+  const why = offWhy(ctx, job);
+  if (why) return send({ status: 200, body: { ok: true, on: false, why, ...(what === 'next' ? { cards: [] } : { text: null }) } });
+  try { return send({ status: 200, body: what === 'next' ? await next(ctx, body) : await sharpen(ctx, body) }); }
+  catch (e) { return send(bad(500, 'The suggestion failed: ' + String((e && e.message) || e).slice(0, 200))); }
+}
+
+module.exports = { prefixes: ['/api/next-prompt'], handle, VERSION, FIXTURE, prefs, setPref, lineRef, replayCases, next, sharpen };

package/workspace/metric-drafts-ui-test.js

@@ -108,9 +108,9 @@ const INITIATIVE = () => ({
       why: c.querySelector('.md-why').textContent,
       presses: [...c.querySelectorAll('.md-ft .md-ib')].map((b) => ({ label: b.getAttribute('aria-label'), title: b.getAttribute('title'), text: b.textContent.trim(), svg: !!b.querySelector('svg[aria-hidden="true"]'), solid: b.classList.contains('solid'), href: b.getAttribute('href') || '' })) };
   });
-  // every font size the parts draw: the type scale only (11, 12, 14, 16, 20, 28 px)
+  // every font size the parts draw: the type roles only (13, 15, 18, 26 px)
   const sizes = (p, sel) => p.evaluate((s) => [...new Set([...document.querySelectorAll(s + ', ' + s + ' *')].filter((e) => e.childNodes.length && [...e.childNodes].some((n) => n.nodeType === 3 && n.textContent.trim())).map((e) => getComputedStyle(e).fontSize))], sel);
-  const SCALE = new Set(['11px', '12px', '14px', '16px', '20px', '28px']);
+  const SCALE = new Set(['13px', '15px', '18px', '26px']);   // the typography roles (batch 26 item 6)
 
   /* ── P: the program's proposed goal ── */
   const D = await open();

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.511.0",
+  "version": "0.513.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.511.0",
+      "version": "0.513.0",
       "license": "MIT",
       "dependencies": {
         "@anthropic-ai/sdk": "^1.3.0",

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.511.0",
+  "version": "0.513.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/premium-menu-rows-test.js

@@ -90,7 +90,7 @@ const ONE = { '.crmenu': 42, '.crmenu.tbmenu': 44, '.dsmn': 44 };
       await page.goto(ORIGIN + '/menu.html');
       const c1 = await page.evaluate(() => { const t = getComputedStyle(document.querySelector('.tag')), p = getComputedStyle(document.querySelector('.lsn-help')), c = getComputedStyle(document.querySelector('.c3'));
         return { tag: t.backgroundColor, fs: p.fontSize, muted: c.getPropertyValue('--muted').trim(), fg: c.getPropertyValue('--foreground').trim() }; });
-      ok(`C1 a console sheet at ${w} ${theme}: its tokens are set, a tag has a fill and the body is 14px text`, c1.muted && c1.fg && !/rgba\(0, 0, 0, 0\)|transparent/.test(c1.tag) && c1.fs === '14px', JSON.stringify(c1));
+      ok(`C1 a console sheet at ${w} ${theme}: its tokens are set, a tag has a fill and the body is 15px text (the body role)`, c1.muted && c1.fg && !/rgba\(0, 0, 0, 0\)|transparent/.test(c1.tag) && c1.fs === '15px', JSON.stringify(c1));
       // H1: a long highlight keeps its tag on one line
       ctx._html = page0(`<section class="rvsec" style="overflow-wrap:anywhere;max-width:${Math.min(w - 32, 560)}px"><ul class="rvhl"><li><time>0:00</time><span>${LONG.join(' ').repeat(3)}</span><em>decision</em></li></ul></section>`, theme);
       await page.goto(ORIGIN + '/menu.html');

package/workspace/premium-vw-doc-test.js

@@ -232,7 +232,7 @@ const prop = (o) => Object.assign({ id: 'prop-a', state: 'proposed', prompt: 'ad
       const fs = [...root.querySelectorAll('*')].map((e) => getComputedStyle(e).fontSize).filter((x, i, a) => a.indexOf(x) === i);
       return { sx: document.documentElement.scrollWidth - innerWidth, bad, out, fs };
     }, [V, w < 600]);
-    ok(`D8 at ${w} px ${theme}: no sideways scroll, no small target, nothing past the edge, console sizes only`, f.sx <= 0 && f.bad.length === 0 && f.out === 0 && f.fs.every((x) => ['11px', '12px', '14px', '16px', '20px', '28px'].includes(x)), JSON.stringify(f));
+    ok(`D8 at ${w} px ${theme}: no sideways scroll, no small target, nothing past the edge, role sizes only`, f.sx <= 0 && f.bad.length === 0 && f.out === 0 && f.fs.every((x) => ['13px', '15px', '16px', '18px', '26px'].includes(x)), JSON.stringify(f));
     const c = await R.page.evaluate((v) => { const e = document.querySelector(v + ' .cf'); return [getComputedStyle(document.querySelector('#czViewer')).backgroundColor, getComputedStyle(e).color]; }, V);   // the page sits on the Viewer's card
     ok(`D8 at ${w} px ${theme}: the page follows the theme`, theme === 'dark' ? c[0] === 'rgb(36, 38, 43)' && c[1] === 'rgb(236, 238, 241)' : c[0] === 'rgb(255, 255, 255)' && c[1] === 'rgb(42, 46, 53)', JSON.stringify(c));   // the initiative page is cozy (premium-agreed-design): the card is the cozy white or dark card
     await R.ctx.close();

package/workspace/public/pm/bd-pin-card.css

@@ -1,13 +1,13 @@
 /* pm/bd-pin-card.css — the ◇ card on the Board timeline (feedback batch 13 item 4, XcalmA5Milestones): the initiative's milestones with a pin each.
  * The card is a pm/bd-pop.js popover; the Filter's "Milestones on the timeline" group uses the Filter's own chips. */
 .bd-pp.bd-pc { padding: 12px 12px 6px; }
-.bd-pc-h { margin: 0; font: 800 var(--fs-3)/1.3 var(--cz-sans); color: var(--cz-ink); }
-.bd-pc-sub { margin: 2px 0 6px; font-size: var(--fs-2); font-weight: 600; }
+.bd-pc-h { margin: 0; font: var(--fw-strong) var(--fs-section)/1.3 var(--cz-sans); color: var(--cz-ink); }
+.bd-pc-sub { margin: 2px 0 6px; font-size: var(--fs-label); font-weight: var(--fw-strong); line-height: var(--lh-label); }
 .bd-pc-r { display: flex; align-items: center; gap: 10px; min-height: 44px; border-top: 1px solid var(--cz-hair); }
 .bd-pc-r .tg-tm-i { margin-left: 4px; }
-.bd-pc-n { flex: 1; min-width: 0; font: 700 var(--fs-2)/1.25 var(--cz-sans); color: var(--cz-ink2); overflow-wrap: anywhere; }
+.bd-pc-n { flex: 1; min-width: 0; font: var(--fw-strong) var(--fs-label)/1.25 var(--cz-sans); color: var(--cz-ink2); overflow-wrap: anywhere; }
 .bd-pc-r.on .bd-pc-n { color: var(--cz-ink); }
-.bd-pc-n small { display: block; font-size: var(--fs-1); font-weight: 600; color: var(--cz-ink3); }
+.bd-pc-n small { display: block; font-size: var(--fs-badge); font-weight: var(--fw-strong); color: var(--cz-ink3); line-height: var(--lh-badge); }
 .bd-pc-n small.late { color: var(--cz-late); }
 .bd-pc-pin { all: unset; flex: none; width: 32px; height: 32px; border-radius: 9px; display: inline-flex; align-items: center; justify-content: center; color: var(--cz-ink3); cursor: pointer; }
 .bd-pc-pin svg { width: 15px; height: 15px; fill: none; stroke: currentColor; stroke-width: 2; stroke-linecap: round; stroke-linejoin: round; }