create-pmos 0.511.0 → 0.512.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.511.0",
+  "version": "0.512.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": {
@@ -32,6 +32,19 @@
     "audit"
   ],
   "pmosChanges": [
+    {
+      "v": "0.512.0",
+      "at": "2026-11-03T15:33:10.629Z",
+      "f": 4,
+      "prs": [
+        {
+          "n": 1204,
+          "t": "Suggest the next prompt and sharpen a rough one in the chat",
+          "s": "Suggest the next prompt and sharpen a rough one in the chat",
+          "k": "new"
+        }
+      ]
+    },
     {
       "v": "0.511.0",
       "at": "2026-11-03T15:10:29.930Z",
@@ -551,21 +564,6 @@
           "d": "The roadmap split work into Now, Next and Later. Now it is one ranked list, and each initiative's stage says where it is."
         }
       ]
-    },
-    {
-      "v": "0.492.0",
-      "at": "2026-11-02T10:50:33.055Z",
-      "f": 4,
-      "prs": [
-        {
-          "n": 1155,
-          "t": "A new user's empty PMOS folder no longer skips the setup conversation",
-          "s": "A new user's empty PMOS folder no longer skips the setup conversation",
-          "k": "fix",
-          "h": "New users get the setup conversation",
-          "d": "A new user with an empty PMOS folder landed on a bare Home. Now the setup conversation starts as it should."
-        }
-      ]
     }
   ]
 }

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@f8d9c6e4
+kernel-source: pmos@55dc3bc3
 assembled: 2026-11-03
 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-11-03T15:10:26Z"}
+generated: {by: process:create-pmos, at: "2026-11-03T15:33:07Z"}
 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-11-03T15:10:26Z"}
+generated: {by: process:create-pmos, at: "2026-11-03T15:33:07Z"}
 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-11-03T15:10:26Z"}
+generated: {by: process:create-pmos, at: "2026-11-03T15:33:07Z"}
 status: stable
 ---
 

package/workspace/changelog.json

@@ -1,4 +1,17 @@
 [
+ {
+  "v": "0.512.0",
+  "at": "2026-11-03T15:33:10.629Z",
+  "f": 4,
+  "prs": [
+   {
+    "n": 1204,
+    "t": "Suggest the next prompt and sharpen a rough one in the chat",
+    "s": "Suggest the next prompt and sharpen a rough one in the chat",
+    "k": "new"
+   }
+  ]
+ },
  {
   "v": "0.511.0",
   "at": "2026-11-03T15:10:29.930Z",

package/workspace/fixtures/next-prompt-replay.json

@@ -0,0 +1,40 @@
+{
+  "about": "Recorded answers for the next-prompt and sharpen-prompt replay gates (lib/routes-next-prompt.js). Each answer was given by claude-sonnet-5-5 on a real reply from the PMOS project threads on 2026-11-03, except the cases named as made up, which test a drop. The replay never calls a model.",
+  "next": [
+    { "name": "a reply that asks a question gets the answer as a follow card, citing the line it answers",
+      "reply": "#1198 (no initiative without an expected outcome) is merged, and kit-publish is publishing it.\nAll five approved features are now merged except the hindsight engine, which stays unbuilt because there are only 1 of the 10 needed prediction-and-outcome pairs. Do you want to swap it for another idea, such as a period-end KR debrief, or stay at four?",
+      "answer": { "cards": [{ "move": "follow", "text": "Yes, swap the hindsight engine for the period-end KR debrief.", "from": "Do you want to swap it for another idea, such as a period-end KR debrief, or stay at four?" }] },
+      "expect": { "filed": 1 } },
+    { "name": "a retired thing in an initiative chat gets an ask-the-past card, citing the verb that answers it",
+      "place": { "initiative": "Fix OOH Digital missing from Board" },
+      "reply": "Found the cause: the Board hid initiatives on the Later horizon. Retiring Now/Next/Later everywhere is a bigger change, so I asked for a separate thread for it.",
+      "answer": { "cards": [{ "move": "past", "text": "Did we ever decide to retire the Now/Next/Later stage? Answer from the records with file:line sources, or say No record found." }] },
+      "expect": { "filed": 1, "cites": ["lib/pmos-verbs.js"] } },
+    { "name": "a reply that needs nothing gets no card",
+      "reply": "First I'll find why OOH Digital is ticked in the product filter but has no rows on the Board.",
+      "answer": { "cards": [] },
+      "expect": { "none": true } },
+    { "name": "made up: a move PMOS does not have is dropped",
+      "reply": "PR #1171 is merged.",
+      "answer": { "cards": [{ "move": "deploy", "text": "Deploy PR #1171 to production now." }] },
+      "expect": { "none": true } },
+    { "name": "made up: a follow card that quotes a line the reply never said is dropped",
+      "reply": "PR #1171 is merged. Tell me if any task still sits under \"Not in a stage\".",
+      "answer": { "cards": [{ "move": "follow", "text": "Yes, merge it.", "from": "Should I merge PR #1171 now or wait?" }] },
+      "expect": { "none": true } },
+    { "name": "made up: ask the past outside an initiative chat is dropped",
+      "reply": "Retiring Now/Next/Later everywhere is a bigger change.",
+      "answer": { "cards": [{ "move": "past", "text": "Why did we retire Now/Next/Later?" }] },
+      "expect": { "none": true } }
+  ],
+  "sharpen": [
+    { "name": "a rough date move becomes a rehearsal, citing what the PM typed",
+      "text": "move the legal review 3 days later",
+      "answer": { "text": "Rehearse moving the legal review task in Ooh-digital 3 days later: show what it pushes back and which dates or tasks shift, then wait for my yes before changing anything." },
+      "expect": { "filed": 1 } },
+    { "name": "a sharper prompt that says the same is not shown",
+      "text": "Hotfix, why OOH digital product isn't shown here",
+      "answer": { "text": "Hotfix: why isn't the OOH digital product shown here?" },
+      "expect": { "none": true } }
+  ]
+}

package/workspace/guide/index.md

@@ -81,6 +81,7 @@ On a desktop the workspace is one frame. [Layout](layout.md) explains each part.
 - [Initiatives › Timeline](initiatives-timeline.md): when each initiative runs, one row per initiative, and how to reorder rows by their grip.
 - [Workflows](workflows.md): Settings › Workflows, the stages each kind of initiative goes through, New workflow in the chat, and `pmos workflow`.
 - [Expected outcomes](outcomes.md): every initiative says what should change once it ships and when to check it. Claude drafts each one from the PRD or the KR, you keep it with ✓, and `pmos outcomes`.
+- [The next prompt, suggested and sharpened](next-prompt.md): after a reply, up to two prompts to send next; while you type a rough prompt, a sharper version in your style (Polish, Prompt engineer, Your own).
 - [Rehearse a plan](rehearse.md): before you approve a date change or a cut, Claude shows what it breaks or helps in other initiatives, goals and program milestones, with the record each effect comes from, and `pmos rehearse`.
 - [Forecasts](forecast.md): how a goal, a delivery, a program and a health budget are forecast, the states, the kept baseline, and `pmos forecast`.
 - [Programs on the Board](programs.md): All products, programs first then products, By product, the program panel and its milestones, and the 60 % side panels.

package/workspace/guide/next-prompt.md

@@ -0,0 +1,62 @@
+---
+type: Guide
+title: "The next prompt, suggested and sharpened"
+description: "After a reply, the chat suggests what to say next. While you type a rough prompt, Claude offers a sharper version. What each card means, the styles, the settings, and the guardrails."
+timestamp: 2026-11-03
+---
+
+# The next prompt, suggested and sharpened
+
+You do not have to remember phrases such as "grill this". The chat suggests them when they fit.
+
+## After a reply
+
+When Claude finishes a reply, up to two cards can show above the box. Usually there is one.
+
+- The card Claude recommends is white, with a blue ring and a blue ✦. Another card is grey.
+- Tap a card to put its text in the box. Nothing is sent. Change the text if you want to, then send it with ↑.
+- The cards go away when you type, or when Claude starts a new reply. They do not time out.
+- When there is no clear next step, no card shows.
+
+A card suggests only something that works in PMOS today:
+
+- an answer to the question or the offer at the end of the reply;
+- "Grill this …" in an initiative's chat ([Claude proposes](claude-proposes.md));
+- "Why did we …?" in an initiative's chat ([Ask about the past](ask-the-past.md));
+- "Rehearse moving …" before a date change or a cut ([Rehearse a plan](rehearse.md));
+- "Run the drift replay" when the weekly check waits for it ([What you might have missed](what-you-missed.md)).
+
+Each card names only the initiatives, tasks and PRs that the reply or your message names.
+
+## While you type
+
+When you stop typing for about 1.5 seconds on a rough prompt of three or more words, a small spinner card shows while Claude sharpens it. Then one lit **Sharper** card shows. Tap it to put the sharper text in the box. ↶ in the box puts back what you wrote. When the sharper version says the same as yours, no card shows.
+
+The sliders icon on the Sharper card sets how Claude sharpens:
+
+- **Polish**: clearer and shorter. Your meaning is kept.
+- **Prompt engineer** (the default): the best prompt for the job. It names the real initiative or task and says what a good answer holds. A date move or a cut becomes a rehearsal that waits for your yes.
+- **Your own**: your own wording rules. You write them once in Settings.
+
+The same menu has the **Sharpen as I type** switch. Off means no spinner and no Sharper card.
+
+## Settings › Claude › Sharpen prompts
+
+| Row | What it does |
+|---|---|
+| Suggest the next prompt | On by default. Off: no cards after a reply. |
+| Sharpen as I type | On when Claude's runs use your API key (Settings › Claude › API key), because a sharper version then shows in about 2 seconds. Without a key, each one is a background Claude run that takes 10 seconds or more, so it starts off. You can turn it on anyway. |
+| Sharpen as | Polish, Prompt engineer or Your own. |
+| Your own rules | The rules for Your own, up to 1000 characters. |
+
+## The guardrails
+
+The suggestions and the sharper prompt go through the same guardrail as every AI job in PMOS:
+
+- **Propose only.** A card is text you can put in the box. Nothing is sent, and nothing is written to a record, a session or a repository.
+- **Proven only.** Each suggested move points to the line of PMOS code that makes it work, and PMOS checks that line before the card shows. An answer to the reply points to the line of the reply it answers. A card that PMOS cannot check is not shown.
+- **Replay-tested.** A new version shows nothing until its recorded cases pass, and those include cases that must be dropped.
+- **Audited.** Each run writes a line to the AI audit, with no text of your conversation in it.
+- **Off switch.** `pmos ai off next-prompt` stops the suggestions after a reply. `pmos ai off sharpen-prompt` stops the Sharper card. `pmos ai off` stops every AI job.
+
+The reply and the words a card refers to are kept in your PMOS state folder (`next-prompt/`, the newest 30 files), outside every repository. Your choices for these rows are kept there too, in `next-prompt/prefs.json`.

package/workspace/guide/settings.md

@@ -35,7 +35,7 @@ Settings is not a tab. While it is open, no tab is selected. Press a tab to go b
 | Claude sessions | What a new session starts with: the CLI, the model, the Claude profile and the launch flags for sessions you start, and the flags for automatic sessions. The session limits. Validate consent for this workspace. |
 | Privacy and data | A list of what leaves this computer and when. Whether a TypeSafe key is saved, the local model that answers when there is no key (Off, Winnow or Laya), and the data folder. |
 | Appearance | The theme (Same as system, Light or Dark) and the page that opens first. |
-| Claude | The Claude profile that new Claude sessions start with, and the Anthropic API key for Claude's own runs on the API (see below). |
+| Claude | The Claude profile that new Claude sessions start with, the Anthropic API key for Claude's own runs on the API, and Sharpen prompts (see below). |
 | Claude's checks | When Claude grills an initiative by itself (Full, Only at stage exits, or Off) and the monthly credit for its checks ($5, $10, $20 or $50), with what this month used. See below. |
 | Updates | The version of the app and of each workspace's kit, the check for updates, and what changed in each week's kits (what's new). See below. |
 
@@ -85,6 +85,8 @@ Under the update card, **Updates** shows what changed in the published kits. **T
 
 **API key.** Some runs of Claude, for example Grill, can use the Claude API and not a Claude session. Paste an Anthropic API key and press **Save** to turn this on. The key stays on this computer, in a file only you can read, outside every repository. PMOS never shows the key again: the row only says that a key is set. Press **Remove** to delete it. A key saved here is used before `ANTHROPIC_API_KEY`. A command that a run starts does not get the key. Only the computer that runs the workspace can change it. Set `PMOS_GRILL_API=off` to stop runs on the API.
 
+**Sharpen prompts.** Suggest the next prompt (on by default) shows up to two prompts above the chat box after a reply. Sharpen as I type offers a sharper version of a rough prompt. It is on when an API key is set, and off without one, because a background run is too slow to follow your typing. Sharpen as picks Polish, Prompt engineer (the default) or Your own, and Your own rules holds the rules for Your own. The same style and switch are in the menu on the chat's Sharper card. See [The next prompt, suggested and sharpened](next-prompt.md).
+
 ## Claude's checks: when Claude grills, and what it may spend
 
 Claude grills an initiative by itself and files what it finds under the initiative's ✦ (see the Claude proposes guide). There is no button to start it. This section is the only control.

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/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/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.511.0",
+  "version": "0.512.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.511.0",
+      "version": "0.512.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.512.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/public/pm/cozy-ev.css

@@ -379,3 +379,5 @@
 .ev-st [data-claude-setup] .cs-actions { display: flex; flex-wrap: wrap; gap: 8px; }
 .ev-st [data-claude-setup] .cs-term { width: 100%; min-height: 280px; border-radius: 14px; overflow: hidden; }
 @media (max-width: 760px) { .ev-st [data-claude-setup] .wl-btn, .ev-st [data-claude-setup] select { min-height: 44px; } .ev-st [data-claude-setup] .cs-label { flex-wrap: wrap; } }
+/* Settings › Claude › Your own rules (batch 26 item 2) */
+.ev-st textarea.ev-rules { display: block; width: 100%; box-sizing: border-box; margin-top: 8px; min-height: 72px; padding: 10px 12px; border: 0; border-radius: 14px; background: var(--cz-well); color: var(--cz-ink); font: inherit; font-size: var(--fs-3); line-height: 1.45; resize: vertical; }

package/workspace/public/pm/cozy-home.css

@@ -20,7 +20,8 @@ body.cz-home { min-height: 100vh; overflow: hidden; }
  * ground, 16px apart, the list 360px wide (cozy-today.css) */
 @media (min-width: 761px) {
   body.cz-home .hm-desk { inset: 0; padding: 16px; gap: 16px; background: none; box-shadow: none; border-radius: 0; }
-  body.cz-home .hm-chat { background: var(--cz-card); border-radius: 24px; padding: 16px 24px 20px; box-shadow: 0 10px 30px -24px var(--cz-c-9da3ac); }
+  /* batch 26 item 2 (NpBw): the chat sits on the same soft gradient as on a phone */
+  body.cz-home .hm-chat { background: var(--cz-ground); border-radius: 24px; padding: 16px 24px 20px; box-shadow: 0 10px 30px -24px var(--cz-c-9da3ac); }
   body.cz-home .hm-vw .cz-vw { flex-basis: min(500px, max(380px, calc(100vw - 852px))); width: min(500px, max(380px, calc(100vw - 852px))); }
   body.cz-home.hm-folded:not(.cz-vw-rail) .hm-desk { padding-left: 56px; }
   body.cz-home .hm-reopen { top: 12px; right: 12px; }
@@ -791,3 +792,46 @@ form.hm-box textarea { min-height: 48px; border: 0; background: none; resize: no
 .hm-chat .ctxmore[open] > summary { display: none; }
 .hm-chat .ctxmore > .ctxc { display: contents; }
 .hm-chat .ctxmore:not([open]) > .ctxc { display: none; }
+
+/* ── the suggested next prompt and the Sharper card (batch 26 item 2, canvas NpB, NpBw; pm/next-prompt-ui.js) ──
+ * Above the box: up to two cards, the recommended one lit (card white, blue ring, blue ✦), the other grey. A tap fills the box. */
+.np { display: flex; flex-direction: column; gap: 8px; padding-top: 8px; }
+.np[hidden] { display: none; }
+.np-list { display: flex; flex-direction: column; gap: 8px; }
+.np-card { position: relative; display: flex; align-items: flex-start; gap: 10px; width: 100%; box-sizing: border-box; min-height: 44px; padding: 11px 14px; border-radius: 16px;
+  border: 1px solid transparent; background: var(--cz-well); color: var(--cz-ink); font: inherit; font-size: var(--fs-3); line-height: 1.5; text-align: left; cursor: pointer; }
+.np-card .np-star { flex: none; margin-top: 3px; fill: currentColor; stroke: currentColor; color: var(--cz-ink3); }
+.np-card.rec { background: var(--cz-card); border-color: var(--cz-blue); box-shadow: 0 0 0 3px var(--cz-bluebg); }
+.np-card.rec .np-star { color: var(--cz-blue); }
+.np-card:hover { border-color: var(--cz-blue); }
+.np-card:focus-visible, .np-use:focus-visible, .np-ib:focus-visible, .np-mi:focus-visible { outline: 2px solid var(--cz-blue); outline-offset: 2px; }
+.np-t { flex: 1; min-width: 0; }
+.np-sh { padding: 0 6px 0 0; cursor: default; align-items: center; }
+.np-use { display: flex; align-items: flex-start; gap: 10px; flex: 1; min-width: 0; padding: 11px 0 11px 14px; border: 0; background: none; color: inherit; font: inherit; text-align: left; cursor: pointer; }
+.np-ib { flex: none; width: 36px; height: 36px; display: inline-grid; place-items: center; border: 0; border-radius: 999px; background: none; color: var(--cz-ink2); cursor: pointer; }
+.np-ib:hover, .np-ib[aria-expanded="true"] { background: var(--cz-well); }
+.np-spin { display: flex; align-items: center; gap: 12px; padding: 14px 16px; border-radius: 16px; background: var(--cz-bluebg); color: var(--cz-blue); }
+.np-sp { display: inline-flex; animation: np-rot 1.1s linear infinite; }
+@keyframes np-rot { to { transform: rotate(360deg); } }
+@media (prefers-reduced-motion: reduce) { .np-sp { animation: none; } }
+.np-sk { flex: 1; display: flex; flex-direction: column; gap: 8px; }
+.np-sk i { display: block; height: 12px; border-radius: 6px; background: var(--cz-bluebg); }
+.np-sk i:first-child { width: 88%; } .np-sk i:last-child { width: 60%; }
+.np-menu { position: absolute; right: 0; bottom: calc(100% + 8px); z-index: 20; width: 310px; max-width: calc(100vw - 32px); box-sizing: border-box; padding: 8px; border-radius: 20px;
+  background: var(--cz-card); box-shadow: 0 24px 60px -24px rgba(42,46,53,.45), 0 0 0 1px var(--cz-hair); display: flex; flex-direction: column; gap: 2px; }
+.np-mh { margin: 0; padding: 8px 12px 4px; font-size: var(--fs-1); font-weight: 800; color: var(--cz-ink2); }
+.np-mi { display: flex; align-items: flex-start; gap: 10px; min-height: 44px; padding: 8px 12px; border: 0; border-radius: 12px; background: none; color: var(--cz-ink); font: inherit; text-align: left; cursor: pointer; }
+.np-mi:hover, .np-mi[aria-checked="true"]:not(.np-swr) { background: var(--cz-well); }
+.np-mi b { display: block; font-size: var(--fs-3); font-weight: 600; }
+.np-mi[aria-checked="true"] b { font-weight: 700; }
+.np-mi em { display: block; font-style: normal; font-size: var(--fs-1); color: var(--cz-ink2); }
+.np-ck { flex: none; width: 18px; margin-top: 2px; color: var(--cz-blue); display: inline-flex; }
+.np-sep { height: 1px; margin: 6px 8px; background: var(--cz-hair); }
+.np-swr { align-items: center; }
+.np-swr b { flex: 1; }
+.np-sw { flex: none; width: 40px; height: 24px; border-radius: 12px; background: var(--cz-well2); display: inline-flex; align-items: center; padding: 0 3px; box-sizing: border-box; }
+.np-sw i { width: 18px; height: 18px; border-radius: 50%; background: var(--cz-card); box-shadow: 0 1px 2px rgba(0,0,0,.2); }
+.np-sw.on { background: var(--cz-solid); justify-content: flex-end; }
+@media (max-width: 760px) {
+  .np-t { display: -webkit-box; -webkit-line-clamp: 3; -webkit-box-orient: vertical; overflow: hidden; }   /* a phone shows 3 lines; a tap still fills the whole text */
+}

package/workspace/public/pm/cozy-settings.js

@@ -3,6 +3,8 @@
  *               (this device), Product (which products Home reads: the Products card), Your day (when the end-of-day card shows:
  *               time.workEnd, POST /api/settings), Your impact (impact.on, POST /api/settings; canvas GmP1Switch, batch 16 item 7: the one switch
  *               for Adler's leaf, the impact log and the weekly check; the page hears `pmos:impact`), Agents write to Jira (fixed: only after Commit)
+ *   Claude      the Claude profile, the API key, and Sharpen prompts: suggestions after a reply, Sharpen as I type, the style and Your own rules
+ *               (GET/POST /api/next-prompt/prefs; batch 26 item 2)
  *   Claude’s checks  Grill by itself (Full, Only at stage exits, Off) and the monthly credit for checks with what this month used (grill.mode,
  *               grill.cap, POST /api/settings; GET /api/grill; canvas GrillEntry). At the cap Claude pauses and says so once here.
  *   Jev and Laya  the TypeSafe key, Laya on this computer and the per-repository switches (pm/cozy-jl.js; canvas JlA1Empty–JlA4Phone)
@@ -262,7 +264,35 @@ function claudeSec() {
   const keyRight = `<span class="ev-dr-pl"><label class="ev-vh" for="evKey">Anthropic API key</label><input id="evKey" class="ev-inp" type="password" autocomplete="off" spellcheck="false" placeholder="${k.present ? 'Replace the key' : 'sk-ant-\u2026'}" data-ev-key><button type="button" class="ev-btn sm pri" data-ev-keysave>Save</button>${k.source === 'settings' ? '<button type="button" class="ev-btn sm" data-ev-keyclear>Remove</button>' : ''}</span>`;
   return '<h4>Claude login and profile</h4><div data-claude-setup></div>'
     + trow('API key', keySub, keyRight)
-    + (k.present && C.off ? trow('Runs on the API', 'Off: PMOS_GRILL_API is off in the environment.', '<span class="ev-pill">Off</span>') : '');
+    + (k.present && C.off ? trow('Runs on the API', 'Off: PMOS_GRILL_API is off in the environment.', '<span class="ev-pill">Off</span>') : '')
+    + sharpenRows(k.present);
+}
+/* Settings › Claude › Sharpen prompts (batch 26 item 2; pm/next-prompt-ui.js, lib/routes-next-prompt.js): the suggestions after a reply, Sharpen as I
+ * type ('auto' is on when Claude runs on the API key, where a sharpen takes about 2 s), the style, and the PM's own rules for Your own.
+ * The same style and switch are in the chat's Sharper card menu; a save here tells the chat (the event pmos:prompt-prefs). */
+const NPK = { 'prompt.next': ['nextSet', 'next'], 'prompt.sharpen': ['sharpenSet', 'sharpen'], 'prompt.style': ['style', 'style'], 'prompt.rules': ['rulesText', 'rules'] };   // row key → [GET field, POST key]
+const setVal = (k, d) => { const v = T.np ? T.np[NPK[k][0]] : undefined; return v !== undefined && v !== null ? v : d; };
+function sharpenRows(api) {
+  const next = setVal('prompt.next', true) !== false, sh = setVal('prompt.sharpen', 'auto'), style = setVal('prompt.style', 'engineer'), rules = String(setVal('prompt.rules', '') || '');
+  const on = sh === 'on' || (sh === 'auto' && api);
+  const shSub = sh === 'auto' ? (api ? 'On, because Claude runs on your API key: the sharper version shows in about 2 seconds.' : 'Off for now: without an API key each one takes 10 seconds or more. Turn it on to use it anyway.')
+    : on ? 'When you pause on a rough prompt, a sharper version shows above the box.' : 'Off. No spinner and no Sharper card.';
+  const styleSub = style === 'polish' ? 'Clearer and shorter, your meaning kept.' : style === 'own' ? (rules.trim() ? 'Your rules below.' : 'Write your rules below first.') : 'Builds the best prompt for the job.';
+  return '<h4>Sharpen prompts</h4>'
+    + trow('Suggest the next prompt', 'After a reply, up to two prompts above the box. A tap puts one in the box. Nothing sends.', sw(next, 'data-ev-np="prompt.next"', 'Suggest the next prompt'))
+    + trow('Sharpen as I type', shSub, sw(on, 'data-ev-np="prompt.sharpen"', 'Sharpen as I type'))
+    + trow('Sharpen as', styleSub, seg('Sharpen as', 'prompt.style', style, [['polish', 'Polish'], ['engineer', 'Prompt engineer'], ['own', 'Your own']]))
+    + `<div class="ev-trow"><div class="ev-tx"><label for="evRules"><b>Your own rules</b></label><p class="ev-small ev-mut">For Your own. For example: short, always name the initiative, ask for sources.</p>`
+    + `<textarea id="evRules" class="ev-inp ev-rules" rows="3" maxlength="1000" spellcheck="true">${esc(rules)}</textarea></div><button type="button" class="ev-btn sm pri" data-ev-rulesave>Save</button></div>`;
+}
+async function savePrompt(key, value, said) {
+  const r = await pmPost('/api/next-prompt/prefs', { key: NPK[key][1], value });
+  if (r && r.ok) {
+    T.np = { ...(T.np || {}), [NPK[key][0]]: value };
+    document.dispatchEvent(new CustomEvent('pmos:prompt-prefs', { detail: { key, value } }));
+  }
+  T.msg = r && r.ok ? said : (r && r.error) || 'Not saved.';
+  draw();
 }
 /* Settings > Claude's checks (GrillEntry): Claude grills by itself, so this is the only control: when, and how much it may spend a month */
 const CAPS = [5, 10, 20, 50];
@@ -343,6 +373,10 @@ async function press(e) {
     T.msg = r && r.ok ? (key === 'grill.mode' ? (value === 'off' ? 'Saved. Claude no longer grills by itself.' : value === 'exits' ? 'Saved. Claude grills only before a stage ends.' : 'Saved. Claude grills by itself when it matters.') : 'Saved. Claude’s checks spend at most ' + usd(value) + ' a month.') : (r && r.error) || 'Not saved.';
     draw(); return;
   }
+  if (t.dataset.evSeg === 'prompt.style') { await savePrompt('prompt.style', t.dataset.v, 'Saved. Sharper prompts follow this style.'); return; }
+  if (t.dataset.evNp === 'prompt.next') { const on = setVal('prompt.next', true) === false; await savePrompt('prompt.next', on, on ? 'Saved. Claude suggests the next prompt after a reply.' : 'Saved. No suggestions after a reply.'); return; }
+  if (t.dataset.evNp === 'prompt.sharpen') { const api = !!(T.cl && T.cl.key && T.cl.key.present), sh = setVal('prompt.sharpen', 'auto'), was = sh === 'on' || (sh === 'auto' && api); await savePrompt('prompt.sharpen', was ? 'off' : 'on', was ? 'Saved. Sharpen as I type is off.' : 'Saved. Sharpen as I type is on.'); return; }
+  if ('evRulesave' in t.dataset) { const ta = T.el.querySelector('#evRules'); await savePrompt('prompt.rules', ta ? ta.value.slice(0, 1000) : '', 'Saved. Your own rules are used when Sharpen as is Your own.'); return; }
   if (t.dataset.evSeg && t.dataset.evSeg.startsWith('adler.')) { const r = await AD.savePref(pmPost, t.dataset.evSeg, t.dataset.v); T.msg = r && r.ok ? 'Saved.' : (r && r.error) || 'Not saved.'; draw(); return; }
   if (t.dataset.evDress) {
     const a = t.dataset.evDress;
@@ -459,6 +493,7 @@ async function readAgain(id) {
 async function load() {
   readFresh();
   pmGet('/api/grill').then((g) => { T.gr = g && g.ok ? g : { ok: false, error: (g && g.error) || '' }; draw(); }).catch(() => { T.gr = { ok: false }; draw(); });
+  pmGet('/api/next-prompt/prefs').then((n) => { T.np = n && n.ok ? n : null; draw(); }).catch(() => { T.np = null; });
   pmGet('/api/profiles').then(async (pr) => { const k = await pmGet('/api/anthropic'); T.cl = { profiles: pr && Array.isArray(pr.profiles) ? pr.profiles : [], prefs: (pr && pr.prefs) || {}, perr: pr && pr.ok === false ? (pr.error || 'the server did not answer') : '', key: k && k.ok ? k.key : { present: false, source: null }, off: !!(k && k.off) }; draw(); }).catch(() => { T.cl = { profiles: [], prefs: {}, perr: 'the server did not answer', key: { present: false, source: null } }; draw(); });
   const [w, p, s, b] = await Promise.all([pmGet('/api/workspaces'), pmGet('/api/proactive/settings'), pmGet('/api/settings'), pmGet('/api/briefing-premium')]);
   T.ws = w && Array.isArray(w.workspaces) ? w.workspaces : [];
@@ -477,7 +512,7 @@ async function load() {
 export function openSettings(section) {
   const el = mount();
   if (section === 'dress') { T.sec = 'adler'; T.dress = true; } else if (section && BODY[section]) { T.sec = section; T.dress = false; }
-  if (el.hidden) { const ae = document.activeElement; T.back = ae && ae !== document.body ? ae : null; T.ws = null; T.src = null; T.msg = ''; T.phase = ''; T.auto = false; T.wkOpen = new Set(); T.wkMore = new Set(); T.arc = false; T.fresh = null; T.note = {}; T.dset = {}; T.cl = null; T.gr = null; JL.reset(); }
+  if (el.hidden) { const ae = document.activeElement; T.back = ae && ae !== document.body ? ae : null; T.ws = null; T.src = null; T.msg = ''; T.phase = ''; T.auto = false; T.wkOpen = new Set(); T.wkMore = new Set(); T.arc = false; T.fresh = null; T.note = {}; T.dset = {}; T.cl = null; T.gr = null; T.np = null; JL.reset(); }
   el.hidden = false; document.getElementById('evStScrim').hidden = false; el.setAttribute('data-esc-layer', '');
   draw();
   const f = el.querySelector('[aria-current="page"]'); if (f) f.focus();

package/workspace/public/pm/home-chat.js

@@ -34,6 +34,7 @@ import * as VWC from './cozy-viewer.js';
 import { canDictate, dictate } from './home-dictate.js';
 import { adler } from './cozy-adler.js';
 import { snapOf, turnEnded } from './chat-turn-end.js';   // a finished turn re-reads what the Viewer shows (batch 25 item 3)
+import { nextPromptUi } from './next-prompt-ui.js';   // the suggested next prompt and the Sharper card above the box (batch 26 item 2)
 /* The views a chat opens go in the Viewer: on a page with no dialog the old viewer's views draw in the cozy card (premium-viewer.js). */
 const views = {
   ctx: () => import('./premium-vw-ctx.js'), file: () => import('./premium-vw-file.js'), attach: () => import('./premium-attach.js'),
@@ -78,6 +79,18 @@ export function mountChat(el, host) {
   const role = () => (C.t && C.t.role) || roleOf(C.sess || null, host.roles(), firstUser());
   const firstUser = () => { const m = ((C.conv && C.conv.messages) || []).find((x) => x.role === 'user'); return m ? m.text : ''; };
   const running = () => !!C.conv && (C.conv.turn === 'agent' || C.conv.turn === 'tool') && C.conv.state !== 'ended';
+  // the suggested next prompt (batch 26 item 2): cards above the box after a reply, a Sharper card while the PM types a rough prompt
+  const NPU = nextPromptUi({ el, host, box: () => foot.querySelector('textarea'), redrawFoot: () => { if (C.t) drawFoot({ role: role() }); } });
+  el.addEventListener('np-grow', (e) => grow(e.target), true);
+  const plain = (s) => String(s || '').replace(/```pmos-[\s\S]*?```/g, '').trim();
+  function npCtx() {
+    const t = C.t, ms = (C.conv && C.conv.messages) || [];
+    let ai = -1; for (let i = ms.length - 1; i >= 0; i--) if (ms[i] && ms[i].role !== 'user' && plain(ms[i].text)) { ai = i; break; }
+    let pi = -1; for (let i = ai - 1; i >= 0; i--) if (ms[i] && ms[i].role === 'user') { pi = i; break; }
+    const ini = /^init:/.test(String(t.key || ''));
+    return { key: t.key || t.sid || '', reply: ai >= 0 ? plain(ms[ai].text).slice(0, 6000) : '', asked: pi >= 0 ? shownUser(String(ms[pi].text || '')).slice(0, 2000) : '',
+      initiative: ini ? String(t.title || '') : '', stage: ini ? String(t.sub || '') : '', title: String(t.title || '') };
+  }
 
   /* ── reading ── */
   async function read() {
@@ -98,6 +111,8 @@ export function mountChat(el, host) {
     const ended = turnEnded(C.turn, snap); C.turn = snap;
     draw();
     if (ended && host.turnEnded) host.turnEnded(t);
+    NPU.read(snap.busy);
+    if (ended && !(C.conv && C.conv.ask)) NPU.turnEnded(npCtx());
     clearTimeout(C.timer);
     const live = (C.th && (C.th.session || C.th.working)) || (t.sid && C.conv && C.conv.state !== 'ended');
     C.timer = setTimeout(() => { if (!document.hidden) read(); else C.timer = setTimeout(read, IDLE_POLL); }, live ? POLL : IDLE_POLL);
@@ -429,7 +444,7 @@ export function mountChat(el, host) {
     const html = `${also}<form class="hm-box${on ? ' ut-on' : ''}" id="hmForm">${dot}<textarea id="hmIn" rows="1" aria-label="A message for ${esc(R.role.name)}" placeholder="${esc(ph)}"></textarea>`
       + `<div class="hm-tb">${add}`
       + to + wait + scope + `<span class="sp"></span>${host.viewerClosed() ? '<span class="hm-key">Enter sends · Shift+Enter for a new line</span>' : ''}`
-      + `${mic}<button type="submit" class="hm-send" aria-label="Send" title="Send">${SVG(UP, 18)}</button></div>`
+      + `${NPU.undoHtml()}${mic}<button type="submit" class="hm-send" aria-label="Send" title="Send">${SVG(UP, 18)}</button></div>`
       + filesRow()
       + '</form>';
     if (foot.__h !== html) {
@@ -511,6 +526,7 @@ export function mountChat(el, host) {
       return;
     }
     const b = e.target.closest('button, [data-file], [data-att], [data-ctx]'); if (!b || !el.contains(b)) return;
+    if (NPU.click(b)) return;
     // ✓ types /compact (and hides the ✦ until the pie moves); ✕ hides it until the session is 10 points fuller
     if (b.dataset.hmCpt && C.cpt) { if (b.dataset.hmCpt === 'ok') host.compact(sid()); else host.dismissCompact(sid(), C.cpt.pct); C.cpt = null; sug.hidden = true; put(sug, ''); return; }
     if (b.dataset.hmSug && C.sug) { const g = C.sug; if (b.dataset.hmSug === 'link') host.linkTo(C.t.sid, g.id); else { host.dismissLink(C.t.sid); drawSug(); } return; }
@@ -572,7 +588,7 @@ export function mountChat(el, host) {
   el.addEventListener('submit', (e) => { e.preventDefault(); const ta = foot.querySelector('textarea'); const v = ta.value; if (GU.submit(v)) { ta.value = ''; grow(ta); return; }
     // the box empties at once and the bubble shows (batch 24 item 2); a send that fails puts the words back, unless the PM typed again
     if (!v.trim() && !C.files.length) return;
-    ta.value = ''; grow(ta);
+    ta.value = ''; grow(ta); NPU.sent();
     send(v).then((ok) => { const box = foot.querySelector('textarea'); if (!ok && box && !box.value) { box.value = v; grow(box); } }); });
   const shutAdd = (focus) => { if (!C.addOpen) return; C.addOpen = false; drawFoot({ role: role() }); if (focus) { const a = foot.querySelector('#hmAdd'); if (a) a.focus(); } };
   document.addEventListener('click', (e) => { if (C.addOpen && e.target.isConnected && !e.target.closest('.hm-addw')) shutAdd(false); }, true);
@@ -580,6 +596,7 @@ export function mountChat(el, host) {
   document.addEventListener('keydown', (e) => { if (e.key === 'Escape' && !e.defaultPrevented && el.isConnected && !el.contains(e.target) && !document.querySelector('[data-esc-layer]') && GU.escape()) e.preventDefault(); });
   el.addEventListener('keydown', (e) => {
     if (e.key === 'Escape' && C.addOpen) { e.preventDefault(); e.stopPropagation(); shutAdd(true); return; }
+    if (e.key === 'Escape' && NPU.escape()) { e.preventDefault(); e.stopPropagation(); return; }
     if (e.key === 'Escape' && GU.escape()) { e.preventDefault(); e.stopPropagation(); return; }
     if (e.target.id !== 'hmIn') { if (e.key === 'Escape' && running() && !document.querySelector('[data-esc-layer]') && !(window.czViewer && window.czViewer.isOpen())) press('esc'); return; }
     if (e.isComposing || e.keyCode === 229) return;
@@ -592,7 +609,7 @@ export function mountChat(el, host) {
   el.addEventListener('input', (e) => {
     const card = C.t && C.t.intro && C.t.intro.card;
     if (card && card.input && e.target.closest('.hm-icard')) { card.input(e.target, e.target.closest('.hm-icard')); return; }
-    if (e.target.id === 'hmIn') { grow(e.target); C.slashAt = 0; drawSlash(); }
+    if (e.target.id === 'hmIn') { grow(e.target); C.slashAt = 0; drawSlash(); NPU.input(e.target.value); }
   });
   /* ── the mic ── dictation into the box only (HmMic). A desk shows the blue dot in the box; a phone shows the Speak to Claude sheet. */
   const box = () => foot.querySelector('textarea');
@@ -671,7 +688,7 @@ export function mountChat(el, host) {
       if (notesM) notesM.then((M) => setTimeout(() => M.syncNotes(), 0));   // the Notes open in the Viewer belonged to the conversation before
       const same = C.t && t && C.t.key === t.key && C.t.sid === t.sid;
       C.t = t;
-      if (!same) { C.addOpen = false; C.th = null; C.conv = null; C.show = 12; C.open = new Set(); C.files = []; C.marked = null; C.touched = null; C.picked = {}; C.pend = []; C.plOpen = false; C.plAll = false; C.seenAt = t.key ? host.seen(t.key) : null; put(log, introHtml(t.intro)); put(pl, ''); pl.hidden = true; C.jump = true; peek(null); }
+      if (!same) { NPU.open(); C.addOpen = false; C.th = null; C.conv = null; C.show = 12; C.open = new Set(); C.files = []; C.marked = null; C.touched = null; C.picked = {}; C.pend = []; C.plOpen = false; C.plAll = false; C.seenAt = t.key ? host.seen(t.key) : null; put(log, introHtml(t.intro)); put(pl, ''); pl.hidden = true; C.jump = true; peek(null); }
       draw(); read();
     },
     refresh() { if (C.t) draw(); },

package/workspace/public/pm/next-prompt-ui.js

@@ -0,0 +1,117 @@
+/* pm/next-prompt-ui.js — the chat's suggested next prompt and its Sharper card (batch 26 item 2, design B: canvas NpB, NpBw).
+ *
+ * After a reply ends: up to two cards above the box, the one Claude recommends lit (white, blue ring, blue ✦), the other grey. A tap puts its
+ * text in the box; nothing sends, and the PM sends with the box's own ↑. No ↵, edit or dismiss icon. No card when there is no clear next step.
+ * The cards hide when the PM types or a new reply starts; they have no timeout.
+ * While the PM types a rough prompt (3 or more words), after a 1.5 s pause: a spinner card while Claude sharpens it, then one lit Sharper card.
+ * Its sliders icon opens the style menu: Sharpen as Polish, Prompt engineer (the default) or Your own, and the Sharpen as I type switch.
+ * After a tap on the Sharper card, ↶ in the box puts back what the PM wrote (NpB 5).
+ * Server: GET /api/next-prompt/prefs, POST /api/next-prompt/next and /sharpen (lib/routes-next-prompt.js, through lib/ai-guard.js); the style
+ * and the switch are saved with POST /api/next-prompt/prefs (style, sharpen). Settings › Claude › Sharpen prompts holds the same.
+ *
+ *   nextPromptUi({ el, host, box, redrawFoot }) → { turnEnded(ctx), read(busy), input(value), sent(), open(), undoHtml(), click(target) → bool }
+ *     ctx: { key, asked, reply, initiative?, stage?, title? }   box() → the textarea   redrawFoot() draws the box again (for ↶) */
+const STAR = '<svg aria-hidden="true" width="15" height="15" viewBox="0 0 24 24" class="np-star"><path d="M12 3l1.8 5.2L19 10l-5.2 1.8L12 17l-1.8-5.2L5 10l5.2-1.8z"/></svg>';
+const SLIDERS = 'M4 7h9M17 7h3M4 17h3M11 17h9M13 4v6M7 14v6', CHECK = 'M5 12l5 5L20 7', UNDO = 'M9 14L4 9l5-5M4 9h11a5 5 0 0 1 0 10h-3', SPIN = 'M12 3a9 9 0 1 1-9 9';
+const ic = (d, w = 16) => `<svg aria-hidden="true" width="${w}" height="${w}" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round"><path d="${d}"/></svg>`;
+const STYLES = [['polish', 'Polish', 'Clearer and shorter, your meaning kept'], ['engineer', 'Prompt engineer', 'Builds the best prompt for the job'], ['own', 'Your own', 'Your wording rules, written once in Settings']];
+const PAUSE = 1500;
+export const roughText = (t) => { const s = String(t || '').trim(); return !s.startsWith('/') && s.length >= 12 && s.split(/\s+/).filter(Boolean).length >= 3; };
+
+export function nextPromptUi({ el, host, box, redrawFoot }) {
+  const esc = host.esc;
+  const N = { mode: null, cards: [], sharp: null, menu: false, prefs: null, seq: 0, timer: null, ctx: null, orig: null, filled: null, sent: null };
+  const wrap = document.createElement('div');
+  wrap.className = 'np'; wrap.id = 'hmNp'; wrap.hidden = true;
+  const foot = el.querySelector('#hmFoot');
+  foot.parentNode.insertBefore(wrap, foot);
+
+  const loadPrefs = () => host.pmGet('/api/next-prompt/prefs').then((r) => { if (r && r.ok) { N.prefs = r; if (!r.sharpen && N.mode !== 'cards') clear(); else draw(); } }).catch(() => {});
+  loadPrefs();
+  document.addEventListener('pmos:prompt-prefs', loadPrefs);   // Settings › Claude changed them
+
+  function clear() { N.seq++; clearTimeout(N.timer); N.mode = null; N.cards = []; N.sharp = null; N.menu = false; draw(); }
+  function draw() {
+    let html = '';
+    if (N.mode === 'cards' && N.cards.length) {
+      html = `<div class="np-list" role="group" aria-label="Suggested next prompts">${N.cards.map((c, i) => `<button type="button" class="np-card${c.rec ? ' rec' : ''}" data-np-use="${i}" aria-label="Use this prompt: ${esc(c.text)}"${c.rec ? ' title="Claude recommends this one"' : ''}>${STAR}<span class="np-t">${esc(c.text)}</span></button>`).join('')}</div>`;
+    } else if (N.mode === 'spin') {
+      html = `<div class="np-spin" role="status" aria-label="Claude is sharpening your prompt"><span class="np-sp">${ic(SPIN, 20)}</span><span class="np-sk"><i></i><i></i></span></div>`;
+    } else if (N.mode === 'sharp' && N.sharp) {
+      const P = N.prefs || {}, st = P.style || 'engineer';
+      const menu = N.menu ? `<div class="np-menu" role="menu" aria-label="Style of sharper prompts" data-esc-layer><p class="np-mh">Sharpen as</p>${STYLES.map(([k, l, d]) => `<button type="button" role="menuitemradio" aria-checked="${st === k}" class="np-mi" data-np-voice="${k}"><span class="np-ck">${st === k ? ic(CHECK) : ''}</span><span><b>${esc(l)}</b><em>${esc(k === 'own' && !P.rules ? 'Write your rules in Settings first' : d)}</em></span></button>`).join('')}`
+        + `<span class="np-sep" role="separator"></span><button type="button" role="menuitemcheckbox" class="np-mi np-swr" aria-checked="${!!P.sharpen}" data-np-sw><b>Sharpen as I type</b><span class="np-sw${P.sharpen ? ' on' : ''}" aria-hidden="true"><i></i></span></button></div>` : '';
+      html = `<div class="np-card rec np-sh"><button type="button" class="np-use" data-np-sharp aria-label="Use the sharper prompt: ${esc(N.sharp)}" title="Claude sharpened your prompt">${STAR}<span class="np-t">${esc(N.sharp)}</span></button>`
+        + `<button type="button" class="np-ib" data-np-menu aria-haspopup="menu" aria-expanded="${N.menu}" aria-label="Style of sharper prompts" title="Style of sharper prompts">${ic(SLIDERS)}</button>${menu}</div>`;
+    }
+    if (wrap.__h !== html) { wrap.__h = html; wrap.innerHTML = html; }
+    wrap.hidden = !html;
+  }
+  function fill(text, keepOrig) {
+    const ta = box(); if (!ta) return;
+    N.orig = keepOrig && ta.value.trim() && ta.value !== text ? ta.value : null;
+    N.filled = text; ta.value = text;
+    clear(); redrawFoot();
+    const t2 = box(); if (t2) { t2.dispatchEvent(new Event('np-grow')); t2.focus(); t2.setSelectionRange(t2.value.length, t2.value.length); }
+  }
+  async function sharpen(value) {
+    const my = ++N.seq;
+    N.mode = 'spin'; N.sharp = null; draw();
+    const c = N.ctx || {};
+    const r = await host.pmPost('/api/next-prompt/sharpen', { key: c.key || '', text: value, reply: c.reply || '', initiative: c.initiative || '', title: c.title || '' }).catch(() => null);
+    const ta = box();
+    if (my !== N.seq || !ta || ta.value !== value) return;   // the PM typed on, or sent: this answer is for words no longer in the box
+    if (r && r.ok && r.text) { N.mode = 'sharp'; N.sharp = r.text; } else { N.mode = null; }
+    draw();
+  }
+  async function save(key, value) {
+    const r = await host.pmPost('/api/next-prompt/prefs', { key, value }).catch(() => null);
+    if (!(r && r.ok)) { host.toast((r && r.error) || 'Not saved.'); return; }
+    await loadPrefs();
+    document.dispatchEvent(new CustomEvent('pmos:prompt-prefs-saved', { detail: { key, value } }));
+  }
+
+  return {
+    /** A reply ended: ask for the next prompts, unless the PM is already typing. */
+    async turnEnded(ctx) {
+      N.ctx = ctx;
+      const ta = box();
+      if (!N.prefs || !N.prefs.next || !ctx || !ctx.reply || (ta && ta.value.trim())) return;
+      const my = ++N.seq; clearTimeout(N.timer);
+      const r = await host.pmPost('/api/next-prompt/next', ctx).catch(() => null);
+      const t2 = box();
+      if (my !== N.seq || (t2 && t2.value.trim())) return;
+      N.cards = r && r.ok && Array.isArray(r.cards) ? r.cards.slice(0, 2) : [];
+      N.mode = N.cards.length ? 'cards' : null; N.menu = false; draw();
+    },
+    /** Each read of the conversation: a new turn at work hides the cards. */
+    read(busy, ctx) { if (ctx) N.ctx = { ...(N.ctx || {}), ...ctx }; if (busy && N.mode) clear(); },
+    input(value) {
+      if (N.orig != null && !value.trim()) { N.orig = null; redrawFoot(); }
+      if (N.mode === 'cards' || N.mode === 'sharp' || N.mode === 'spin') { N.seq++; N.mode = null; N.menu = false; draw(); }
+      clearTimeout(N.timer);
+      if (!N.prefs || !N.prefs.sharpen || value === N.filled || !roughText(value)) return;
+      N.timer = setTimeout(() => { const ta = box(); if (ta && ta.value === value) sharpen(value); }, PAUSE);
+    },
+    sent() { N.orig = null; N.filled = null; clear(); },
+    open() { N.ctx = null; N.orig = null; N.filled = null; clear(); },
+    undoHtml: () => (N.orig != null ? `<button type="button" class="hm-tool np-undo" data-np-undo aria-label="Back to what I wrote" title="Back to what I wrote">${ic(UNDO)}</button>` : ''),
+    /** A click inside the chat: true when it was one of ours. */
+    click(b) {
+      if (!b) return false;
+      if ('npUse' in b.dataset) { const c = N.cards[Number(b.dataset.npUse)]; if (c) fill(c.text, false); return true; }
+      if ('npSharp' in b.dataset) { if (N.sharp) fill(N.sharp, true); return true; }
+      if ('npUndo' in b.dataset) { const ta = box(); if (ta && N.orig != null) { const o = N.orig; N.orig = null; N.filled = null; ta.value = o; redrawFoot(); const t2 = box(); if (t2) { t2.dispatchEvent(new Event('np-grow')); t2.focus(); } } return true; }
+      if ('npMenu' in b.dataset) { N.menu = !N.menu; draw(); if (N.menu) { const f = wrap.querySelector('.np-mi'); if (f) f.focus(); } return true; }
+      if (b.dataset.npVoice) {
+        const k = b.dataset.npVoice;
+        if (k === 'own' && !(N.prefs && N.prefs.rules)) { N.menu = false; draw(); import('./cozy-settings.js').then((M) => M.openSettings('claude')).catch(() => {}); return true; }
+        N.menu = false; save('style', k).then(() => { const ta = box(); if (ta && roughText(ta.value)) sharpen(ta.value); });
+        return true;
+      }
+      if ('npSw' in b.dataset) { const on = !(N.prefs && N.prefs.sharpen); save('sharpen', on ? 'on' : 'off').then(() => { if (!on) clear(); else draw(); }); return true; }
+      return false;
+    },
+    escape() { if (!N.menu) return false; N.menu = false; draw(); const m = wrap.querySelector('[data-np-menu]'); if (m) m.focus(); return true; },
+  };
+}

package/workspace/test-lists/next-prompt.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "The chat's suggested next prompt and Sharper card (batch 26 item 2): the engine, the route with a recorded answer in place of Claude, the shared guard's replay, citation check and kill switch, and the Settings keys.",
+  "modules": ["next-prompt.test.js"],
+  "seconds": { "next-prompt.test.js": 2 }
+}