diff --git a/plugins/planning/.claude-plugin/plugin.json b/plugins/planning/.claude-plugin/plugin.json
index bfe365b93d..9714e1624a 100644
--- a/plugins/planning/.claude-plugin/plugin.json
+++ b/plugins/planning/.claude-plugin/plugin.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "planning",
-  "version": "0.53.0",
+  "version": "0.54.0",
   "userConfig": {
     "surface": {
       "type": "string",
diff --git a/plugins/planning/CHANGELOG.md b/plugins/planning/CHANGELOG.md
index b736ba3564..58df740105 100644
--- a/plugins/planning/CHANGELOG.md
+++ b/plugins/planning/CHANGELOG.md
@@ -3,6 +3,21 @@
 All notable changes to the `planning` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.54.0] - 2026-09-30
+
+### Added
+
+- **The interview page has Research this and Cancel research buttons.** They post generic `research` and `cancel-research` events that name no skill or plugin; the interviewing session decides how to fulfill them. The `wait` op stamps `waitingSince`, and a held card reads "Research in progress, started <time>". While Claude holds a question, Accept, the alternatives and Own answer stay enabled (Answer anyway, as before); disabling them is not done and is left to the owner ([#5569](https://github.com/melodic-software/claude-code-plugins/issues/5569)).
+- **A question waiting for Claude's reply shows a chip, and Accept asks first.** An ask or rephrase with no later reply from Claude marks the question "Waiting for Claude's reply", and Accept then asks "Accept current recommendation anyway?" ([#5569](https://github.com/melodic-software/claude-code-plugins/issues/5569)).
+- **A bare `#N` in question text links to the issue in the new `meta.repo` key.** `round.py` warns, without blocking, when text carries one and `meta.repo` is unset ([#5569](https://github.com/melodic-software/claude-code-plugins/issues/5569)).
+
+### Fixed
+
+- **The revising chip reads "Answer not handled yet" and shows on a question only while Claude has not handled that question's own decision.** It no longer names an upstream question; a changed prerequisite stays in the Stale and Waiting-on chips ([#5569](https://github.com/melodic-software/claude-code-plugins/issues/5569)).
+- **The summary's Confirm and Something's off buttons sit in one row below the What-is-off box**, clear of it ([#5569](https://github.com/melodic-software/claude-code-plugins/issues/5569)).
+- **The decide area caps at 40% of the viewport height on short screens, and the phone layout wraps the status line and no longer scrolls the question rail inside itself** ([#5569](https://github.com/melodic-software/claude-code-plugins/issues/5569)).
+- **The wake contract says to re-read the events and restate after a stale-read refusal instead of forcing** ([#5569](https://github.com/melodic-software/claude-code-plugins/issues/5569)).
+
 ## [0.53.0] - 2026-09-30
 
 ### Added
diff --git a/plugins/planning/skills/interview/context/surface.md b/plugins/planning/skills/interview/context/surface.md
index b5ec11587f..33be37fcc9 100644
--- a/plugins/planning/skills/interview/context/surface.md
+++ b/plugins/planning/skills/interview/context/surface.md
@@ -25,7 +25,7 @@ The page is the input surface SKILL.md "Question surface: the page" selects. The
 - **Start** with the command in SKILL.md (it carries the configured emoji setting). It prints the page URL; give that URL to the user. A missing prerequisite exits non-zero with its name: take the degrade below.
 - **Ids.** Page question ids are `Q<N>` on the session's one continuous counter, so the register rows written at ask-time match what `export-ledger` emits (it renumbers any other id set). When the register already has rows as the page starts (earlier terminal rounds, or a resumed topic whose data dir was discarded), seed the still-empty data dir with `round.sh import-ledger --ledger '<memory_dir>/<topic-slug>/interview-checklist.md'` before the first `add-round`; it keeps each row's `Q<N>` and decision. `export-ledger` writes each row's resolution as escaped named fields in a fixed order (`hold`, `proposal`, `was`, `answer`, `note`, `aside`, `commitments`; the grammar is in `surface/exporters.py`), and import restores them: the hold, a superseded-by-plan row's proposal and displaced answer, the decision on any status (an accept or a defer on a superseded-by-plan row too), the note, a decision a user hold set aside (restored still set aside), and every commitment with its confirmed or unconfirmed mark. An unknown field or a contradictory pair is refused, naming the field. Every older grammar still imports, read as it always was: `waits on::`, `awaiting user::`, `confirmed::`, `plan proposes::` and `answer::` rows, a settled row's `; confirmed::` tail, and the unescaped `waits on:`, `confirmed:` and `; confirmed:` forms. A hand-written resolution imports as the row's own text.
 - **A round.** Write the frontier to `'<data_dir>/round-<n>.json'` (`{"meta": {...}, "groups": [...], "questions": [...], "visuals": [...]}`), run `round.sh add-round --file '<data_dir>/round-<n>.json' --round <n>`, and write the register's `open` rows in the same step. Each question carries `recommendation` (one line), `basis` (2-3 sentences, shown behind Why), at least two `alternatives` (`{key, text}`), `commits` (what accepting commits the user to, or `[]`), and `dependsOn` for its prerequisites. Send the round's closing constraint probe with a `note-reply` op (no `seq`) so it lands in Notes to Claude, or as a Claude thread line on the round's first question. `add` and `add-round` refuse a question without `commits` or with fewer than two alternatives.
-- **Meta.** `meta` takes `title`, `eyebrow`, `stages` and `next`. `stages` is an object mapping each stage key to its label, for example `"stages": {"frame": "Frame", "decide": "Decide"}`; a list is refused (`$.meta.stages: expected object, got list`). Set with `add-round`'s `meta` object or the `meta` op; any other key is refused. `meta.next` is what Claude does after wrap-up, shown on the finished screen. Keep round numbers out of `meta.eyebrow`: the page derives the round label (`<stage> round N`) from the questions and shows it beside the eyebrow, so a number in the eyebrow goes stale at the next round.
+- **Meta.** `meta` takes `title`, `eyebrow`, `stages`, `next` and `repo`. `stages` is an object mapping each stage key to its label, for example `"stages": {"frame": "Frame", "decide": "Decide"}`; a list is refused (`$.meta.stages: expected object, got list`). Set with `add-round`'s `meta` object or the `meta` op; any other key is refused. `meta.next` is what Claude does after wrap-up, shown on the finished screen. `meta.repo` (`owner/repo`) makes the page link a bare `#N` in any markdown field to that repo's issue; `owner/repo#N` always links to its own repo, and `[text](url)` links, `Qn` refs and code spans are left as written. A bare `#N` with `meta.repo` unset stays plain text and `add`, `add-round` and `apply` warn (non-blocking). Keep round numbers out of `meta.eyebrow`: the page derives the round label (`<stage> round N`) from the questions and shows it beside the eyebrow, so a number in the eyebrow goes stale at the next round.
 - **Visuals** are declared by format (`svg`, `mermaid`, `image`, `markdown`, `html`, `chart`) with a `scope` (`question:<id>`, `group:<id>`, `round:<stage>:<n>`, `all`) and inline `content` or a data-dir-relative `file`. `label` is its tab name (short; the page falls back to `title`, then `id`). `group`, `order` and `primary` arrange visuals: those sharing a `group` are versions or alternatives of one another, `order` sorts them, and at most one live `primary` is allowed per `group` within a `scope`. Change a visual with `replace-visual` (a full object with the same id) or retire it with `archive-visual`; an archived visual stays in `questions.json` and the page and report never show it. `add-round` refuses an id that already exists. Describe what a visual shows; leave out the tool or skill that made it. An `html` visual runs its scripts on the page, in an opaque-origin sandbox that cannot reach the page, so an interactive prototype or an inlined chart library works; the page CSP still blocks remote content. The exported report runs no scripts: when the decision rests on what a scripted visual shows, attach an `image` of it as well. Two or more `image` visuals on a question also get a Gallery tab (one more per group holding a smaller set) with a thumbnail strip, arrow-key flip and a side-by-side compare, in full screen too. Any visual opens in a new tab from the panel or full screen, still sandboxed.
 - **Arm** the watcher as a background Bash task (`run_in_background`): `bash '<surface_dir>/watch.sh' '<data_dir>'`.
 - **One watcher.** One session watches an interview at a time: the first watcher holds the server's lease, and `watch.sh` exits 3 naming the holder, since when and its last poll when another session holds it. Do not re-arm. When the holder is another Claude session, coordinate with it through the cross-session messaging tooling this session provides (discover what is available; assume no particular tool) and agree which session runs the interview, or ask it to hand over with `round.sh lease --release`. When it cannot be reached, tell the user which session holds the lease and since when; the lease frees itself once the holder stops polling for `leaseTimeout` seconds (default 600). `round.sh lease` prints the current holder. `watch.sh` also exits 3 when this session's lease was released while it waited: run `round.sh lease`, and re-arm only when this session should still watch. When it exits 2 with "no watcher id" (no session id is exported and the parent pid is 1), export `WATCH_ID` with a name for this session and re-arm.
@@ -41,7 +41,7 @@ The watcher exits with one JSON line: `{"seq", "timedOut", "events": [...], "not
 
 1. For an `ask`, `own` or `rephrase`, open the turn with a one-line status (which question, what you are doing) before the reply (R10).
 2. Answer every `ask`. For decisions on one question, the latest live event wins; mark the earlier ones handled with it (R7).
-3. Write `'<data_dir>/ops.json'` fresh with the Write tool on every wake; a stale file re-applies old replies.
+3. Write `'<data_dir>/ops.json'` fresh with the Write tool on every wake; a stale file re-applies old replies. When `apply` refuses a `rec` because the question has a newer live user event (the stale-read refusal, R2), re-read the events, restate the reply or revision against what the user just did, and apply again instead of passing `"force": true`.
 4. Run exactly one background Bash call that records and re-arms (R8):
 
 <!-- wake-command: surface/watch.test.sh runs the fenced command below -->
@@ -67,7 +67,7 @@ When the first wake prompts for permission, offer the user one allow rule, `Bash
 | `revise` | `id`, `title`, `short`, `facts`, `basis`, `rec`, `why`, `text`, `alternatives`, `commits`, `seq`, `affects`, `force` | Reword a question; `commits` replaces the list and resets its confirmations |
 | `note-reply` | `text`, `seq` | Answer a note in Notes to Claude; with no `seq`, post a closing probe there |
 | `add`, `add-round`, `group` | `question`; `round`, `meta`, `groups`, `questions`, `visuals`; `id`, `title`, `summary`, `dependsOn` | New questions and groups; writing a `summary` records the group's current question ids as `summaryOf`, and the page marks the summary Stale once the members differ, so rewrite the summary after adding questions |
-| `meta` | `set` (`title`, `eyebrow`, `stages`, `next`) | Merge into `meta`; other meta keys stay |
+| `meta` | `set` (`title`, `eyebrow`, `stages`, `next`, `repo`) | Merge into `meta`; other meta keys stay |
 | `archive` | `ids`, `why` | Take off-path questions out of the open count |
 | `replace-visual` | `visual` | Swap in a full visual object for the top-level visual with the same id; an unknown id is refused |
 | `archive-visual` | `ids`, `why` | Hide top-level visuals from the page and report; they stay in `questions.json` |
@@ -93,7 +93,7 @@ The page header shows a Claude line: the `set-status` text with its age while on
 
 A `wait` holds a question in one of two ways. The page labels them as follows:
 
-- **Pending research** (`by: claude`, the default): Claude is working something out. The question shows `Pending research: <waitsOn>`, counts in the header's pending-research count, and is listed under Show: Pending. The user can still answer it (Answer anyway).
+- **Pending research** (`by: claude`, the default): Claude is working something out. The question shows `Pending research: <waitsOn>`, counts in the header's pending-research count, and is listed under Show: Pending. The card reads `Research in progress, started <time>` (the time the `wait` landed). The user can still answer it (Answer anyway) and can post `cancel-research` (Cancel research) to release it; a question with no hold offers `research` (Research this) instead, and one waiting on the user offers neither.
 - **Needs your answer** (`by: user`): the question needs the user again, even though a decision is recorded. The question shows `Needs your answer: <waitsOn>` and counts as open and in the needs-you navigation. The `wait` also stamps `setAsideAt` and `setAsideSeq`: a page or terminal decision recorded before it no longer counts as an answer anywhere, even after the hold clears; the user's next decision counts. A recommendation revision (`reply --rec`, `revise --rec`) stamps the same fields on a counted `own` answer without a hold: the question returns to open until a new decision counts.
 
 Both count as not answered in the page meter, `round.sh status` and `export-ledger`.
@@ -127,6 +127,8 @@ When the work returns, clear both (`wait` with `"clear": true`, `set-status` wit
 | `reopen` | question | clears it, keeps the note | `handle` |
 | `ask` | question | no | `reply` with its `seq` |
 | `rephrase` | question | no | `reply` with `"kind": "rephrase"` and its `seq` |
+| `research` | question, optional `text` | no | `wait` (`by: claude`) plus `set-status`, then `reply` or `revise` when the lookup returns. Run `/discovery:research` when that skill resolves in this session, else look it up inline. See [Status, activity and holds](#status-activity-and-holds) |
+| `cancel-research` | question | no | `wait` with `clear` and `set-status` with `clear`; ignore the pending result, and `handle` both seqs |
 | `note` | none | no | `note-reply` with its `seq`, or `reply` on a question |
 | `undo` | question, `undoSeq` | withdraws `undoSeq` | Drop that decision from the ledger; `handle` both seqs |
 | `wrapup` | none | no | Run [Wrap-up](#wrap-up), then `handle` |
diff --git a/plugins/planning/surface/README.md b/plugins/planning/surface/README.md
index 93590a0b5c..0ef4e38c50 100644
--- a/plugins/planning/surface/README.md
+++ b/plugins/planning/surface/README.md
@@ -44,8 +44,8 @@ Every command needs `--dir '<data_dir>'`; there is no default. Every write valid
 |---|---|
 | `ensure-running`, `stop` | Server lifecycle, as above |
 | `add` | One question from `--file` or flags. Refuses a question without `commits` (`--commit none` is an explicit empty list) or with fewer than two alternatives |
-| `add-round --file F [--round N]` | Meta, groups, questions and visuals in one write; any error writes nothing. The file's `meta` object takes `title`, `eyebrow`, `stages` and `next` (what Claude does after wrap-up, shown on the finished screen) and refuses other keys |
-| `meta` op | `{"op": "meta", "set": {...}}` merges the same four keys into `meta`; other meta keys, such as `emojiMarkers`, stay |
+| `add-round --file F [--round N]` | Meta, groups, questions and visuals in one write; any error writes nothing. The file's `meta` object takes `title`, `eyebrow`, `stages`, `next` (what Claude does after wrap-up, shown on the finished screen) and `repo` (`owner/repo`, links a bare `#N` on the page) and refuses other keys |
+| `meta` op | `{"op": "meta", "set": {...}}` merges the same five keys into `meta`; other meta keys, such as `emojiMarkers`, stay |
 | `group <id>` | Add or update a group; `--depends` names prerequisite groups |
 | `reply` op | A Claude line on the question's thread; `seq` marks that event handled; `rec` revises the recommendation and needs `affects` |
 | `revise <id>` | Change wording, recommendation (`--rec` needs `--affects`), alternatives (at least two) or commitments (`--commit`, repeatable; `none` clears). New commitments replace the list and reset its confirmations |
@@ -70,7 +70,7 @@ Every command needs `--dir '<data_dir>'`; there is no default. Every write valid
 
 ## Data contract
 
-`schema/` is the contract; other tools write these formats or read the exports, and the surface reads no other files except a file a visual names inside the data dir. Both documents carry `"schemaVersion": "1.0"`; a file without one reads as version 0 and loads unchanged. `responses.json` is an append-only event log with a global `seq`; undo marks an event `withdrawn` and nothing is deleted. Event kinds: `accept`, `alt`, `own`, `defer`, `reopen`, `ask`, `rephrase`, `note`, `undo`, `wrapup`, `confirm`, `confirm-understanding`, `accept-audit`. `accept-audit` has no id; its `alt` is the round id and `items` is a non-empty list of `{id, contentRev}` (anything else is 400). The server accepts each item that is open, has a recommendation, is not held, and has every prerequisite decided, and skips one whose `contentRev` no longer matches (`changed`) or that is not eligible (`ineligible`). It writes the `accept-audit` event, then one `accept` per accepted item carrying `auditSeq`, and answers `{"ok": true, "seq": <accept-audit seq>, "accepted": [ids], "skipped": [{"id", "reason"}]}`; when nothing is accepted it writes nothing and answers 409 `{"error": "nothing accepted", "skipped": [...]}`. An accept with `auditSeq` exports with the note `pending agent validation`. `confirm-understanding` has no id; its `alt` is `confirm` or `off` (`off` needs `text`), and its `contentRev` must equal `restatement.rev`: a missing restatement or `contentRev` is 400, an older rev is 409 `{"error": "stale", "contentRev": <current>}`. A `confirm` may carry `contentRev`, which must equal the question's current `contentRev` (an older one is 409 `stale`, so a page holding a replaced commitments list cannot confirm the new one by index). A repeated Confirm (a `confirm` of the same commitment, or a `confirm-understanding` Confirm of the same rev) records nothing and returns the first event's seq. Question `state` (`open`, `stale`, `upstream-pending`, `archived`) is computed by the server from `dependsOn` and `archived`, never written; it is dependency staleness, not an answered flag. `answered` (server-computed, never written) is true when a page or terminal decision counts, so a question with a terminal decision reads `state` `open` and `answered` true. A visual is declared by `format` (`svg`, `mermaid`, `image`, `markdown`, `html`, `chart`; `kind` is read as an alias) and describes only its content.
+`schema/` is the contract; other tools write these formats or read the exports, and the surface reads no other files except a file a visual names inside the data dir. Both documents carry `"schemaVersion": "1.0"`; a file without one reads as version 0 and loads unchanged. `responses.json` is an append-only event log with a global `seq`; undo marks an event `withdrawn` and nothing is deleted. Event kinds: `accept`, `alt`, `own`, `defer`, `reopen`, `ask`, `rephrase`, `research`, `cancel-research`, `note`, `undo`, `wrapup`, `confirm`, `confirm-understanding`, `accept-audit`. `accept-audit` has no id; its `alt` is the round id and `items` is a non-empty list of `{id, contentRev}` (anything else is 400). The server accepts each item that is open, has a recommendation, is not held, and has every prerequisite decided, and skips one whose `contentRev` no longer matches (`changed`) or that is not eligible (`ineligible`). It writes the `accept-audit` event, then one `accept` per accepted item carrying `auditSeq`, and answers `{"ok": true, "seq": <accept-audit seq>, "accepted": [ids], "skipped": [{"id", "reason"}]}`; when nothing is accepted it writes nothing and answers 409 `{"error": "nothing accepted", "skipped": [...]}`. An accept with `auditSeq` exports with the note `pending agent validation`. `confirm-understanding` has no id; its `alt` is `confirm` or `off` (`off` needs `text`), and its `contentRev` must equal `restatement.rev`: a missing restatement or `contentRev` is 400, an older rev is 409 `{"error": "stale", "contentRev": <current>}`. A `confirm` may carry `contentRev`, which must equal the question's current `contentRev` (an older one is 409 `stale`, so a page holding a replaced commitments list cannot confirm the new one by index). A repeated Confirm (a `confirm` of the same commitment, or a `confirm-understanding` Confirm of the same rev) records nothing and returns the first event's seq. Question `state` (`open`, `stale`, `upstream-pending`, `archived`) is computed by the server from `dependsOn` and `archived`, never written; it is dependency staleness, not an answered flag. `answered` (server-computed, never written) is true when a page or terminal decision counts, so a question with a terminal decision reads `state` `open` and `answered` true. A visual is declared by `format` (`svg`, `mermaid`, `image`, `markdown`, `html`, `chart`; `kind` is read as an alias) and describes only its content.
 
 ## Security model
 
diff --git a/plugins/planning/surface/index.html b/plugins/planning/surface/index.html
index 14ef6b5715..d427f7bfed 100644
--- a/plugins/planning/surface/index.html
+++ b/plugins/planning/surface/index.html
@@ -152,7 +152,7 @@
 .act-list li{display:grid;gap:2px;font-size:13.5px;border-left:2px solid var(--line);padding-left:10px}
 .act-list li.unseen{border-color:var(--chg)}
 .nudge-q{font-size:13px;color:var(--chg);display:flex;gap:8px;align-items:center;flex-wrap:wrap}
-.ustate textarea{min-height:56px}
+.ustate textarea{display:block;width:100%;margin-top:8px;min-height:56px}
 .chip.plain{color:var(--muted);background:transparent;border:1px solid var(--line-strong)}
 .chip.plain::before{display:none}
 .chip.hot{color:var(--chg);background:transparent;border:1px solid var(--chg)}
@@ -333,10 +333,15 @@
   .app{height:auto;min-height:100vh}
   .layout,.layout.pinned,.layout.norail,.layout.norail.pinned{grid-template-columns:minmax(0,1fr)}
   .strip{flex-direction:row;order:-1}
-  nav.rail{max-height:45vh}
+  nav.rail{max-height:none}
+  .rail-list{overflow:visible}
+  h1{font-size:20px;margin-top:2px}
+  header.top{gap:4px;padding-bottom:4px}
+  .cline{white-space:normal;overflow-wrap:anywhere;overflow:visible;text-overflow:clip}
   .notice{max-width:100%}
   aside.fly.open{position:fixed;inset:0;width:auto;border-radius:0}
 }
+@media (max-height:800px){ .choices{max-height:calc(40vh - 90px)} fieldset.decide{max-height:40vh;overflow-y:auto} }
 @media (prefers-reduced-motion: reduce){*,*::before{animation:none!important;transition:none!important}}
 </style>
 <style id="themeOverride"></style>
@@ -477,6 +482,10 @@ <h1 id="title">Interview</h1>
       if (i % 2) return "<code>" + esc(part.slice(1, -1)) + "</code>";
       const keep = [];
       let e = esc(part).replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g, (m, t, u) => { keep.push('<a href="' + u + '" target="_blank" rel="noopener noreferrer">' + t + '</a>'); return "\u0000" + (keep.length - 1) + "\u0000"; });
+      const link = (t, repo, n) => { keep.push('<a href="https://github.com/' + repo + '/issues/' + n + '" target="_blank" rel="noopener noreferrer">' + t + '</a>'); return "\u0000" + (keep.length - 1) + "\u0000"; };
+      e = e.replace(/(^|[^\w/.&#-])([\w.-]+\/[\w.-]+)#(\d+)\b/g, (m, pre, repo, n) => pre + link(repo + "#" + n, repo, n));
+      const base = /^[\w.-]+\/[\w.-]+$/.test(S.doc.meta.repo || "") ? S.doc.meta.repo : "";
+      if (base) e = e.replace(/(^|[^\w/&#-])#(\d+)\b/g, (m, pre, n) => pre + link("#" + n, base, n));
       e = e.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>").replace(/(^|[^*\w])\*([^*\s][^*]*?)\*(?!\w)/g, "$1<em>$2</em>");
       e = e.replace(/\b([A-Z]{1,3}\d{1,4})\b/g, (m, id) => Q[id] ? refHtml(id) : m);
       return e.replace(/\u0000(\d+)\u0000/g, (m, n) => keep[+n]);
@@ -545,10 +554,6 @@ <h1 id="title">Interview</h1>
   function pending(){ return events().filter(e => !isHandled(e.seq) && !e.withdrawn); }
   function lastEventSeq(id){ let s = 0; for (const e of events()) if (e.id === id && e.seq > s) s = e.seq; return s; }
   const answered = (q, seq) => isHandled(seq) || (q.history || []).some(h => h.by === "claude" && h.replyTo >= seq); // a later reply or revise to this event (or a newer one) answers it
-  function upstreamChanged(q){ // the prerequisites behind a delivered, unhandled decision; the server marks their direct dependents `revising`
-    return (q.dependsOn || []).filter(p => Q[p] && events().some(e => e.id === p && DEC.has(e.kind) && e.deliveredAt && !e.withdrawn && !isHandled(e.seq)));
-  }
-  const upstreamText = q => { const u = upstreamChanged(q); return u.length ? "Upstream " + u.join(", ") + " changed" : "Upstream changed"; };
   function lastDecisionSeq(id){ let s = 0; for (const e of events()) if (e.id === id && DEC.has(e.kind) && !e.withdrawn && e.seq > s) s = e.seq; return s; }
   function staleBy(q){ // the prerequisites decided after this question was
     const ps = (q.dependsOn || []).filter(p => Q[p]), mine = lastDecisionSeq(q.id), c = ps.filter(p => lastDecisionSeq(p) > mine);
@@ -579,6 +584,7 @@ <h1 id="title">Interview</h1>
     const h = d && historyOf(q).find(x => talks(x) && !recorded(x));
     return h && String(h.at) > String(d.updatedAt) ? h : null;
   }
+  const waitingReply = q => events().some(e => e.id === q.id && (e.kind === "ask" || e.kind === "rephrase") && !e.withdrawn && !answered(q, e.seq)); // your ask or rephrase has no later reply from Claude
   const afterText = h => h.kind === "revise" ? "Revised after your answer - review" : "Replied after your answer " + fmtT(h.at);
   const answerLine = q => { const d = counted(q); return d ? "You answered " + LABEL[d.decision] + (d.decision === "alt" ? " (" + d.alt + ")" : "") + " at " + fmtT(d.updatedAt) : ""; };
   const needsYou = q => isOpen(stateOf(q)) || isStale(q) || (live(q) && (unansweredReply(q) || !!afterAnswer(q)));
@@ -674,11 +680,12 @@ <h1 id="title">Interview</h1>
     else chips.push('<span class="chip s-' + st + '">' + LABEL[st] + (st === "alt" && d ? " (" + esc(d.alt) + ")" : "") + "</span>");
     if (isStale(q)) chips.push('<span class="chip hot">Stale</span>');
     if (up) chips.push('<span class="chip plain">Waiting on ' + esc(upOf(q).join(", ")) + "</span>");
-    if (q.revising && st !== "arch") chips.push('<span class="chip hot" title="Claude has not handled that answer yet, so this question may be revised.">' + esc(upstreamText(q)) + "</span>");
+    if (q.revising && st !== "arch") chips.push('<span class="chip hot" title="Claude has not handled your answer to this question yet.">Answer not handled yet</span>');
     if (carry[q.id]) chips.push('<span class="chip hot" title="' + esc("Asked " + carry[q.id] + (carry[q.id] > 1 ? " rounds" : " round") + " before this stage's latest round and still unanswered.") + '">carried ' + carry[q.id] + (carry[q.id] > 1 ? " rounds" : " round") + "</span>");
     if (q.revised && st === "open") chips.push('<span class="chip plain">Revised</span>');
     const aa = live(q) && afterAnswer(q);
     if (aa) chips.push('<span class="chip hot">' + esc(afterText(aa)) + "</span>");
+    if (waitingReply(q)) chips.push('<span class="chip hot">Waiting for Claude\'s reply</span>');
     if (lastEventSeq(q.id) && !answered(q, lastEventSeq(q.id))) chips.push('<span class="chip plain">Sent to Claude</span>');
     if (sec && sec.pin && q.group) chips.push('<span class="chip plain">' + esc(groupTitle(q.group)) + "</span>");
     const needs = upOf(q).map(p => '<span class="needs' + (isAnswered(stateOf(Q[p])) ? "" : " unmet") + '">needs ' + esc(p) + "</span>").join("");
@@ -817,7 +824,7 @@ <h1 id="title">Interview</h1>
   const actTarget = e => e.notes ? "notes" : (e.ids || []).find(id => Q[id]) || (isRestate(e) ? SUMMARY : null);
 
   // ---------- history thread ----------
-  const VERB = {accept: "accepted", hedged: "accepted with a condition", own: "answered", defer: "deferred", reopen: "reopened", ask: "asked Claude", rephrase: "asked for a rephrase", undo: "undid a save", note: "wrote", wrapup: "asked to wrap up"};
+  const VERB = {accept: "accepted", hedged: "accepted with a condition", own: "answered", defer: "deferred", reopen: "reopened", ask: "asked Claude", rephrase: "asked for a rephrase", research: "asked Claude to research", "cancel-research": "cancelled the research", undo: "undid a save", note: "wrote", wrapup: "asked to wrap up"};
   function whoLabel(h){
     if (h.by === "claude") {
       if (h.kind === "rephrase") return "Claude rephrased";
@@ -944,7 +951,7 @@ <h1 id="title">Interview</h1>
     h += '<div class="dhead"><div class="dids"><b>' + esc(q.id) + "</b><span>" + esc(roundLabel(q)) + "</span>" + (g ? "<span>" + esc(g.title) + "</span>" : "") +
       '<span class="chip s-' + st + '">' + LABEL[st] + '</span><span class="grow"></span>' +
       (vis.length ? '<button class="tbtn small" data-panel="visuals">Visuals (' + vis.length + ")</button>" : "") + '</div><h3 id="qhead">' + (marks ? "❓ " : "") + inline(q.title) + "</h3>" +
-      (counted(q) ? '<p class="youans">' + esc(answerLine(q)) + (aa ? ' <span class="chip hot">' + esc(afterText(aa)) + "</span>" : "") + "</p>" : "") + "</div>";
+      (counted(q) ? '<p class="youans">' + esc(answerLine(q)) + (aa ? ' <span class="chip hot">' + esc(afterText(aa)) + "</span>" : "") + "</p>" : "") + (waitingReply(q) ? '<p class="youans"><span class="chip hot">Waiting for Claude\'s reply</span></p>' : "") + "</div>";
     const kids = S.doc.questions.filter(x => x.followUpOf === q.id).map(x => x.id);
     const unblocks = S.doc.questions.filter(x => (x.dependsOn || []).includes(q.id)).map(x => x.id);
     const link = (label, ids) => ids.length ? "<span>" + label + " " + ids.map(refHtml).join(" ") + "</span>" : "";
@@ -954,9 +961,9 @@ <h1 id="title">Interview</h1>
     if (st === "arch") h += '<div class="sup-banner"><b>Archived:</b> ' + inline((q.archived || {}).why || "off the current path") + "</div>";
     if (isStale(q)) h += '<div class="banner"><b>Stale:</b> ' + staleBy(q).map(refHtml).join(" ") + " changed. " + (reconfirmOf(q) ? "Your decision is kept: Reconfirm it (a, choice 1) or pick again." : "Pick an answer.") + "</div>";
     else if (q.state === "upstream-pending" && st !== "arch") h += '<div class="lockban"><b>Waiting on ' + upOf(q).map(refHtml).join(" ") + ":</b> an earlier answer on this path changed. You can still answer.</div>";
-    if (st === "wait") h += '<div class="waitban"><b>Pending research:</b> ' + inline(q.waitsOn) + ". You can answer anyway; it counts once the research returns.</div>";
+    if (st === "wait") h += '<div class="waitban"><b>Pending research:</b> ' + inline(q.waitsOn) + ". Research in progress" + (fmtT(q.waitingSince) ? ", started " + esc(fmtT(q.waitingSince)) : "") + ". You can answer anyway; it counts once the research returns.</div>";
     if (st === "need") h += '<div class="waitban need"><b>Needs your answer:</b> ' + inline(q.waitsOn) + ".</div>";
-    if (q.revising && st !== "arch") h += '<div class="banner"><b>' + esc(upstreamText(q)) + ".</b> Claude has not handled that answer yet, so this question may be revised. You can still answer.</div>";
+    if (q.revising && st !== "arch") h += '<div class="banner"><b>Answer not handled yet.</b> Claude has not handled your answer to this question yet, so it may be revised. You can still answer.</div>';
     if (lock.length) h += '<div class="lockban"><b>Locked:</b> opens after ' + lock.map(x => esc(groupTitle(x))).join(", ") + ". You can still answer.</div>";
     if (q.supersededBy) h += '<div class="sup-banner"><b>Superseded by</b> ' + refHtml(q.supersededBy) + ". Answer that one instead.</div>";
     if (q.revised) h += '<div class="banner"><b>Recommendation revised.</b> ' + inline(q.revised === true ? "" : q.revised) +
@@ -1025,6 +1032,10 @@ <h1 id="title">Interview</h1>
       (d && d.decision && !d.aside ? '<span style="flex:1"></span><button class="act" data-act="reopen" data-submit="1" aria-keyshortcuts="r"' + (can && !frozen ? "" : " disabled") + ' title="Keeps your note (r)">Reopen</button>' : "");
     $("talkRow").innerHTML = '<button class="act soft" data-act="ask" data-submit="1" aria-keyshortcuts="Control+Shift+Enter Meta+Shift+Enter"' + (can && text ? "" : " disabled") + ' title="Sends your note as a question (Ctrl+Shift+Enter)">Ask Claude</button>' +
       '<button class="act soft" data-act="rephrase" data-submit="1"' + (can ? "" : " disabled") + ' title="Asks Claude to restate this plainly">Rephrase</button>' +
+      (st === "wait"
+        ? '<button class="act soft" data-research="cancel-research" data-submit="1"' + (can ? "" : " disabled") + ' title="Releases the hold; Claude ignores the pending result">Cancel research</button>'
+        : st === "need" ? ""
+        : '<button class="act soft" data-research="research" data-submit="1"' + (can ? "" : " disabled") + ' title="Asks Claude to look this question up">Research this</button>') +
       '<button class="act soft" data-clear="1"' + (text ? "" : " disabled") + ' title="Empties the note">Clear</button>';
     renderConflict();
     renderToast();
@@ -1109,9 +1120,9 @@ <h1 id="title">Interview</h1>
     const u = uState(), body = USECT.filter(([k]) => String((r.sections || {})[k] || "").trim()).map(([k, t]) => "<h5>" + t + "</h5>" + md(r.sections[k])).join("");
     const foot = u && u.alt === "confirm" ? '<p id="uDone"><b>Confirmed</b> ' + esc(fmt(u.at)) + "</p>"
       : u ? '<div class="banner" id="uDone"><b>You flagged:</b> ' + inline(u.text) + " (" + esc(fmt(u.at)) + "). Claude fixes the understanding and restates it.</div>"
-      : '<div class="ustate"><div class="arow"><button class="act primary" data-understand="confirm" data-submit="1">Confirm</button><span class="kbd">Or say what is off, then flag it.</span></div>' +
-        '<textarea id="offText" rows="2" aria-label="What is off" placeholder="What is off? Required to flag it."></textarea>' +
-        '<div class="arow"><button class="act" data-understand="off" data-submit="1">Something\'s off</button>' + (S.uMsg ? '<span class="toast bad">' + esc(S.uMsg) + "</span>" : "") + "</div></div>";
+      : '<div class="ustate"><textarea id="offText" rows="2" aria-label="What is off" placeholder="What is off? Required to flag it."></textarea>' +
+        '<div class="arow"><button class="act primary" data-understand="confirm" data-submit="1">Confirm</button><button class="act" data-understand="off" data-submit="1">Something\'s off</button>' +
+        '<span class="kbd">Or say what is off, then flag it.</span>' + (S.uMsg ? '<span class="toast bad">' + esc(S.uMsg) + "</span>" : "") + "</div></div>";
     return '<section class="blk" id="restate"><h4>Shared understanding, restated ' + esc(fmt(r.at)) + "</h4>" + body + foot + "</section>";
   }
   function cBoxHtml(){ // only what is still to confirm; Claude's confirmations are listed with their reasons below it
@@ -1454,11 +1465,24 @@ <h1 id="title">Interview</h1>
     if (!c && S.armed) { S.armed = null; toast("Pick a choice again: the choices changed.", true); renderAnswer(); return; }
     if (!c) { toast("Pick a choice first (1 to " + choicesOf(q).length + ").", true); const el = $("choices"); el.classList.remove("nudge"); void el.offsetWidth; el.classList.add("nudge"); return; }
     const keep = keptText(c);
+    if (c.kind === "accept" && waitingReply(q) && !await confirmAccept()) return;
     const note = keep !== undefined ? keep : $("note").value.trim();
     if (noteKind(c.kind) && !note) { toast(c.kind === "hedged" ? "Hedged needs a condition in the note." : "Own answer needs a note.", true); $("note").focus(); return; }
     if (c.kind === "hedged" && note.length > LINE_CAP) { toast("The condition is too long: at most " + LINE_CAP + " characters.", true); $("note").focus(); return; }
     await send(c.kind, c.alt, undefined, keep, withNote(q, c));
   }
+  function confirmAccept(){ // Claude has not answered your ask yet, so the recommendation may still change
+    const dlg = $("dlg");
+    $("dlgTitle").textContent = "Accept current recommendation anyway?";
+    $("dlgBody").innerHTML = "<p>Claude has not replied to your question yet. Its reply may change the recommendation.</p>";
+    $("dlgOk").textContent = "Accept anyway"; $("dlgOk").disabled = false;
+    return new Promise(res => {
+      dlg.onclose = () => res(dlg.returnValue === "ok");
+      $("dlgOk").onclick = () => dlg.close("ok");
+      $("dlgCancel").onclick = () => dlg.close("cancel");
+      dlg.showModal(); $("dlgCancel").focus();
+    });
+  }
   async function send(kind, alt, force, keep, noted){
     const q = Q[S.sel]; if (!q || S.busy) return;
     const typing = document.activeElement === $("note"), held = stateOf(q) === "wait";
@@ -1525,6 +1549,10 @@ <h1 id="title">Interview</h1>
       await refresh(); return true;
     } catch (e) { S.busy = false; if (!e.quiet) toast("Not sent (" + e.message + ").", true); return false; }
   }
+  async function researchNow(kind){ // one event either way: Claude holds or releases the question
+    const id = S.sel;
+    if (await sendFree(kind, "", {id})) { toast(kind === "research" ? "Sent. Claude researches " + id + " and replies in its thread." : "Sent. Claude releases " + id + " and ignores the pending result."); renderAll(); }
+  }
   async function confirmCommit(id, i){ // records only this commitment; idempotent
     const q = Q[id]; if (!q || S.busy || !accepted(q) || confirmed(q).has(String(i))) return false;
     if (await sendFree("confirm", "", {id: q.id, alt: String(i), contentRev: q.contentRev || 0})) { toast("Confirmed on " + q.id + "."); renderAll(); return true; }
@@ -1582,8 +1610,8 @@ <h1 id="title">Interview</h1>
       (held.length ? '<p class="left-out">Left out, ' + (audit ? "they carry a note, which this button does not send. Accept them one at a time: " : "their note challenges a commitment: ") + held.map(q => esc(q.id)).join(", ") + ".</p>" : "") +
       (unopened ? '<p class="left-out">Left out: ' + unopened + " open " + (unopened === 1 ? "question" : "questions") + " you have not opened.</p>" : "") +
       "<p>This set cannot be undone as one step: Reopen each question to change it.</p>";
-    $("dlgOk").disabled = !items.length;
-    const dlg = $("dlg");
+    $("dlgOk").disabled = !items.length; $("dlgOk").textContent = "Accept these";
+    const dlg = $("dlg"); dlg.onclose = null;
     $("dlgOk").onclick = async () => {
       dlg.close(); if (S.busy) return;
       if (wrapFreeze() > 0) { toast("Wrapping up. Saves resume once Claude handles the wrap-up.", true); return; }
@@ -1720,6 +1748,7 @@ <h1 id="title">Interview</h1>
     const v = t.closest(".seg button"); if (v) { S.view = v.dataset.view; lsSet("view", S.view); renderRail(); return; }
     if (t.closest("[data-save]")) { submitArmed(); return; }
     const a = t.closest("button[data-act]"); if (a && !a.disabled) { send(a.dataset.act); return; }
+    const rb = t.closest("button[data-research]"); if (rb && !rb.disabled) { researchNow(rb.dataset.research); return; }
     const cl = t.closest("button[data-clear]"); if (cl && !cl.disabled) { clearNote(); return; }
     if (t.closest("[data-undo]")) { doUndo(); return; }
     const cf = t.closest("[data-conflict]");
diff --git a/plugins/planning/surface/round.py b/plugins/planning/surface/round.py
index 541476df2d..447234d16d 100644
--- a/plugins/planning/surface/round.py
+++ b/plugins/planning/surface/round.py
@@ -113,6 +113,9 @@
 ID_TOKEN = re.compile(r"\b[A-Z]+[0-9]+\b")
 VERSION_LABEL = re.compile(r"V[0-9]+")
 SENTENCE_BREAK = re.compile(r"[.!?](\s|$)")
+BARE_ISSUE_REF = re.compile(r"(?<![\w/&#-])#\d+\b")
+CODE_SPAN = re.compile(r"`[^`\n]+`")
+REPO_SLUG = re.compile(r"[\w.-]+/[\w.-]+", re.ASCII)
 
 if os.name == "nt":
     import msvcrt
@@ -316,10 +319,34 @@ def add_question(doc, q):
     return touched
 
 
+def strings(v):
+    """Every string inside a JSON value."""
+    if isinstance(v, str):
+        yield v
+    elif isinstance(v, dict):
+        for x in v.values():
+            yield from strings(x)
+    elif isinstance(v, list):
+        for x in v:
+            yield from strings(x)
+
+
+def warn_bare_issue_refs(doc, label, value):
+    """Warn once when any text in value carries a bare #N (outside code spans) and meta.repo is not an owner/repo slug, so the page cannot link it."""
+    if not REPO_SLUG.fullmatch(str(doc["meta"].get("repo") or "")) and any(
+        BARE_ISSUE_REF.search(CODE_SPAN.sub("", s)) for s in strings(value)
+    ):
+        warn(
+            f"{label} has a bare #N; the page links it only when meta.repo is set "
+            "(owner/repo), so set it or write owner/repo#N"
+        )
+
+
 def lint_questions(doc, qs):
-    """Warnings, never refusals: R12 length budget and bare ids (not version labels like V1) that name no question here."""
+    """Warnings, never refusals: R12 length budget, bare ids (not version labels like V1) that name no question here, and bare #N with no meta.repo."""
     ids = {x.get("id") for x in doc["questions"]}
     for q in qs:
+        warn_bare_issue_refs(doc, q["id"], q)
         rec = q.get("recommendation") or ""
         m = SENTENCE_BREAK.search(rec)
         first = m.start() + 1 if m else len(rec)
@@ -394,11 +421,11 @@ def put_group(doc, g):
 # The CLI commands and `apply` share them; only the caller loads, locks and saves.
 
 
-META_KEYS = ("title", "eyebrow", "stages", "next")
+META_KEYS = ("title", "eyebrow", "stages", "next", "repo")
 
 
 def set_meta(doc, m):
-    """Merge title, eyebrow, stages and next into questions.json meta; any other key is refused."""
+    """Merge title, eyebrow, stages, next and repo into questions.json meta; any other key is refused."""
     if not isinstance(m, dict):
         sys.exit("refused: meta is an object")
     extra = sorted(set(m) - set(META_KEYS))
@@ -728,12 +755,12 @@ def op_wait(d, doc, a):
         sys.exit(f"refused: wait on {a.id} takes no by with clear")
     if a.clear:
         label = HOLD_LABELS[q.get("waitingBy") or "claude"]
-        for key in ("waiting", "waitsOn", "waitingBy"):
+        for key in ("waiting", "waitsOn", "waitingBy", "waitingSince"):
             q.pop(key, None)
         line, msg = f"No longer {label}.", f"{a.id} no longer {label}"
     else:
         by = a.by or "claude"
-        q.update(waiting=True, waitsOn=waits)
+        q.update(waiting=True, waitsOn=waits, waitingSince=now())
         q.pop("waitingBy", None)
         if by == "user":
             seq = load_json(d / "responses.json", EMPTY_RESPONSES).get("seq", 0)
@@ -1041,6 +1068,9 @@ def cmd_apply(d, a):
                 logged.append((op["op"], msg, t))
         summarize(doc, logged)
         lint_questions(doc, added)
+        for op in spec["ops"]:
+            if op["op"] not in ("add", "add-round", "meta"):
+                warn_bare_issue_refs(doc, f"{op['op']} op", op)
         save(d, doc, touched)
     for line in lines:
         print(line)
diff --git a/plugins/planning/surface/schema/event.schema.json b/plugins/planning/surface/schema/event.schema.json
index 2aee39cc13..c324640779 100644
--- a/plugins/planning/surface/schema/event.schema.json
+++ b/plugins/planning/surface/schema/event.schema.json
@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://melodic-software.github.io/claude-code-plugins/planning/surface/event",
   "title": "Interview surface page event",
-  "description": "One entry of responses.json events, the append-only log of everything the user did. `hedged` is an accept whose `text` is its required condition (one line). `confirm` ticks one commitment (`alt` is its index as a string) and records no decision. `confirm-understanding` answers the restatement (no id; `alt` is `confirm` or `off`, `text` says what is off, `contentRev` is the restatement rev it answers). `accept-audit` is the user accepting a round's recommendations and asking for agent validation (no id; `alt` is the round id, `items` the accepted questions as id and the contentRev the user held). The server writes it followed by one ordinary `accept` per item, each carrying `auditSeq` set to the accept-audit's seq. An accept with `auditSeq` is accepted pending agent validation, never a plain hand accept: exporters write that row with the note `pending agent validation`. Commitments stay unconfirmed.",
+  "description": "One entry of responses.json events, the append-only log of everything the user did. `hedged` is an accept whose `text` is its required condition (one line). `research` asks Claude to look the question up and `cancel-research` withdraws that request; neither records a decision and `text` is optional. `confirm` ticks one commitment (`alt` is its index as a string) and records no decision. `confirm-understanding` answers the restatement (no id; `alt` is `confirm` or `off`, `text` says what is off, `contentRev` is the restatement rev it answers). `accept-audit` is the user accepting a round's recommendations and asking for agent validation (no id; `alt` is the round id, `items` the accepted questions as id and the contentRev the user held). The server writes it followed by one ordinary `accept` per item, each carrying `auditSeq` set to the accept-audit's seq. An accept with `auditSeq` is accepted pending agent validation, never a plain hand accept: exporters write that row with the note `pending agent validation`. Commitments stay unconfirmed.",
   "type": "object",
   "required": ["seq", "kind", "at"],
   "additionalProperties": false,
@@ -10,7 +10,7 @@
     "seq": {"type": "integer"},
     "id": {"type": ["string", "null"]},
     "kind": {
-      "enum": ["accept", "alt", "own", "defer", "hedged", "reopen", "ask", "rephrase", "note", "undo", "wrapup", "confirm", "confirm-understanding", "accept-audit"]
+      "enum": ["accept", "alt", "own", "defer", "hedged", "reopen", "ask", "rephrase", "research", "cancel-research", "note", "undo", "wrapup", "confirm", "confirm-understanding", "accept-audit"]
     },
     "alt": {"type": ["string", "null"]},
     "text": {"type": "string"},
diff --git a/plugins/planning/surface/schema/ops.schema.json b/plugins/planning/surface/schema/ops.schema.json
index 14665022c8..f8189f92c3 100644
--- a/plugins/planning/surface/schema/ops.schema.json
+++ b/plugins/planning/surface/schema/ops.schema.json
@@ -133,7 +133,8 @@
         "title": {"type": "string"},
         "eyebrow": {"type": "string"},
         "stages": {"type": "object", "additionalProperties": {"type": "string"}},
-        "next": {"type": "string"}
+        "next": {"type": "string"},
+        "repo": {"type": "string"}
       }
     },
     "meta": {
diff --git a/plugins/planning/surface/schema/questions.schema.json b/plugins/planning/surface/schema/questions.schema.json
index c1ec32a9d8..88e537e196 100644
--- a/plugins/planning/surface/schema/questions.schema.json
+++ b/plugins/planning/surface/schema/questions.schema.json
@@ -81,6 +81,7 @@
         "eyebrow": {"type": "string"},
         "stages": {"type": "object", "additionalProperties": {"type": "string"}},
         "next": {"type": "string"},
+        "repo": {"type": "string"},
         "emojiMarkers": {"type": "boolean"},
         "displayName": {"type": "string"},
         "seededFrom": {"$ref": "#/$defs/seededFrom"}
@@ -220,6 +221,10 @@
         "supersededBy": {"type": "string"},
         "waiting": {"type": "boolean"},
         "waitsOn": {"type": "string"},
+        "waitingSince": {
+          "type": "string",
+          "description": "When the current hold landed; the page shows it as the time research started. Written by the wait op, removed when the hold clears."
+        },
         "waitingBy": {
           "enum": ["claude", "user"],
           "description": "Who a hold waits on; absent means claude (pending research). Written by the wait op, removed when the hold clears."
diff --git a/plugins/planning/surface/server.py b/plugins/planning/surface/server.py
index bb6a3c6414..4fc174c9b0 100644
--- a/plugins/planning/surface/server.py
+++ b/plugins/planning/surface/server.py
@@ -42,7 +42,8 @@
 # One-line free-text cap; a hedged decision's condition is one.
 LINE_CAP = 500
 DECISIONS = {"accept", "alt", "own", "defer", "hedged", "reopen"}
-REQUESTS = {"ask", "rephrase"}
+# Requests to Claude that record no decision. `research` and `cancel-research` name no skill or plugin.
+REQUESTS = {"ask", "rephrase", "research", "cancel-research"}
 # Events not tied to a question; `confirm-understanding` answers the restatement, and
 # `accept-audit` lists the questions one click accepted (each also gets its own `accept`).
 FREE = {"note", "wrapup", "confirm-understanding", "accept-audit"}
@@ -275,8 +276,8 @@ def question_states(doc, r):
     its direct dependents that hold a live decision stale; a decision on a stale question clears
     it without re-staling its own dependents (that cascade is deferred). A withdrawn event never
     happened, so an undo clears what it caused. A question with a stale ancestor further up is
-    upstream-pending; `archived` wins over both. `revising` marks the direct dependents of a
-    question with a delivered, unhandled decision event.
+    upstream-pending; `archived` wins over both. `revising` marks a question with its own
+    delivered, unhandled decision event; upstream effects stay in stale and upstream-pending.
     """
     qs = [q for q in doc.get("questions") or [] if isinstance(q, dict) and q.get("id")]
     deps = {q["id"]: list(q.get("dependsOn") or []) for q in qs}
@@ -333,12 +334,11 @@ def upstream(qid):
             todo += deps.get(p, [])
         return False
 
-    sources = {
+    revising = {
         e["id"]
         for e in events
         if e.get("deliveredAt") and not is_handled(doc, e.get("seq", 0))
     }
-    revising = {c for s in sources for c in children.get(s, [])}
     out = {}
     for qid in deps:
         if qid in archived:
diff --git a/plugins/planning/surface/test_round.py b/plugins/planning/surface/test_round.py
index 78fb77a3f6..7ad2b53465 100644
--- a/plugins/planning/surface/test_round.py
+++ b/plugins/planning/surface/test_round.py
@@ -272,6 +272,41 @@ def test_short_recommendation_does_not_warn(self):
         self.assertEqual(rc, 0)
         self.assertNotIn("warning", err)
 
+    def test_bare_issue_ref_warns_without_meta_repo(self):
+        q = question("Q4", title="Does #123 block the release?")
+        rc, _, err = self.rp("add", "--file", self.file("q.json", q))
+        self.assertEqual(rc, 0)
+        self.assertIn("Q4 has a bare #N", err)
+        self.assertIn("Q4", {x["id"] for x in self.doc()["questions"]})
+
+    def test_bare_issue_ref_is_quiet_with_repo_code_span_or_owner_repo(self):
+        titles = ("Close `#123` first?", "Does o/r#4 block it?", "Does #123 block it?")
+        for n, title in enumerate(titles, start=4):
+            if n == 6:
+                doc = self.doc()
+                doc["meta"]["repo"] = "o/r"
+                self.write_doc(doc)
+            q = question(f"Q{n}", title=title)
+            rc, _, err = self.rp("add", "--file", self.file("q.json", q))
+            self.assertEqual(rc, 0)
+            self.assertNotIn("bare #N", err, title)
+
+    def test_bare_issue_ref_warns_when_meta_repo_is_not_an_owner_repo_slug(self):
+        for n, repo in enumerate(("https://github.com/o/r", "o/r/"), start=4):
+            doc = self.doc()
+            doc["meta"]["repo"] = repo
+            self.write_doc(doc)
+            q = question(f"Q{n}", title="Does #123 block the release?")
+            rc, _, err = self.rp("add", "--file", self.file("q.json", q))
+            self.assertEqual(rc, 0)
+            self.assertIn("bare #N", err, repo)
+
+    def test_bare_issue_ref_in_a_reply_op_warns(self):
+        ops = {"ops": [{"op": "note-reply", "text": "See #77 for the thread."}]}
+        rc, _, err = self.rp("apply", "--file", self.file("ops.json", ops))
+        self.assertEqual(rc, 0)
+        self.assertIn("note-reply op has a bare #N", err)
+
     def test_basis_over_three_sentences_warns(self):
         q = question("Q4", basis="One. Two. Three. Four.")
         rc, _, err = self.rp("add", "--file", self.file("q.json", q))
@@ -855,6 +890,12 @@ def test_set_status_then_clear(self):
         self.assertNotIn("status", self.doc())
         self.assertEqual(self.entries(), [])
 
+    def test_a_hold_records_when_it_started_and_clearing_it_removes_the_time(self):
+        self.apply({"op": "wait", "id": "Q3", "waitsOn": "research"})
+        self.assertTrue(self.q("Q3")["waitingSince"])
+        self.apply({"op": "wait", "id": "Q3", "clear": True})
+        self.assertNotIn("waitingSince", self.q("Q3"))
+
     def test_a_non_ascii_summary_prints_on_a_legacy_console(self):
         waits = "the \u6771\u4eac benchmark \u2192 done"
         ops = self.file(
@@ -1769,7 +1810,7 @@ def test_add_round_with_summary_and_questions_records_them_without_warning(self)
 
 
 class TestMeta(DirCase):
-    """`add-round` meta and the `meta` op: title, eyebrow, stages, next; nothing else."""
+    """`add-round` meta and the `meta` op: title, eyebrow, stages, next, repo; nothing else."""
 
     def setUp(self):
         super().setUp()
@@ -1807,6 +1848,12 @@ def test_apply_meta_op_merges_and_keeps_emoji_markers(self):
         self.assertIs(meta["emojiMarkers"], True)
         self.assertIn("meta:", out)
 
+    def test_apply_meta_op_sets_repo(self):
+        ops = {"ops": [{"op": "meta", "set": {"repo": "o/r"}}]}
+        rc, out, err = self.rp("apply", "--file", self.file("ops.json", ops))
+        self.assertEqual(rc, 0, out + err)
+        self.assertEqual(self.doc()["meta"]["repo"], "o/r")
+
     def test_apply_meta_op_unknown_key_is_refused(self):
         ops = {"ops": [{"op": "meta", "set": {"displayName": "Kyle"}}]}
         self.assert_refused("apply", "--file", self.file("ops.json", ops))
diff --git a/plugins/planning/surface/test_schema.py b/plugins/planning/surface/test_schema.py
index 21b5be9e7b..bdad76e6aa 100644
--- a/plugins/planning/surface/test_schema.py
+++ b/plugins/planning/surface/test_schema.py
@@ -123,6 +123,18 @@ def test_seeded_row_status_accepts_superseded_by_plan(self):
         rows["Q1"]["status"] = "pending"
         self.assertIsNotNone(schema.first_error(doc, schema.load("questions")))
 
+    def test_meta_repo_is_a_string_in_the_file_and_in_the_meta_op(self):
+        doc = json.loads((FIXTURES / "questions.json").read_text(encoding="utf-8"))
+        doc["meta"]["repo"] = "o/r"
+        self.assertIsNone(schema.first_error(doc, schema.load("questions")))
+        doc["meta"]["repo"] = 5
+        self.assertIn("$.meta.repo", schema.first_error(doc, schema.load("questions")))
+        ops = schema.load("ops")
+        op = {"op": "meta", "set": {"repo": "o/r"}}
+        self.assertIsNone(schema.first_error(op, ops["$defs"]["meta"], "$", ops))
+        op["set"]["repo"] = 5
+        self.assertIsNotNone(schema.first_error(op, ops["$defs"]["meta"], "$", ops))
+
     def test_activity_is_capped_at_200_entries(self):
         doc = json.loads((FIXTURES / "questions.json").read_text(encoding="utf-8"))
         doc["status"] = {"text": "Researching", "at": "t"}
@@ -135,6 +147,14 @@ def test_event_kinds_include_confirm(self):
         e = {"seq": 1, "id": "Q1", "kind": "confirm", "alt": "0", "at": "t"}
         self.assertIsNone(schema.first_error(e, schema.load("event")))
 
+    def test_event_kinds_include_research_and_cancel_research_but_not_others(self):
+        s = schema.load("event")
+        for kind in ("research", "cancel-research"):
+            e = {"seq": 1, "id": "Q1", "kind": kind, "at": "t"}
+            self.assertIsNone(schema.first_error(e, s), kind)
+        e = {"seq": 1, "id": "Q1", "kind": "research-now", "at": "t"}
+        self.assertIsNotNone(schema.first_error(e, s))
+
     def test_event_kinds_include_confirm_understanding(self):
         e = {
             "seq": 1,
diff --git a/plugins/planning/surface/test_server.py b/plugins/planning/surface/test_server.py
index 0a35ca95f8..8ce1206167 100644
--- a/plugins/planning/surface/test_server.py
+++ b/plugins/planning/surface/test_server.py
@@ -190,6 +190,26 @@ def test_06_wait_keeps_shape_for_watch_sh(self):
     def test_07_delivered_at_stamped(self):
         self.assertIn("deliveredAt", self.state()["responses"]["events"][-1])
 
+    def test_08a_research_and_cancel_research_are_accepted_without_a_decision(self):
+        seqs_ = []
+        before = self.state()["responses"]["responses"].get("Q5")
+        for body in (
+            {"id": "Q5", "kind": "research"},
+            {"id": "Q5", "kind": "research", "text": "check the vendor docs"},
+            {"id": "Q5", "kind": "cancel-research"},
+        ):
+            code, data = self.post(body)
+            self.assertEqual(code, 200, data)
+            seqs_.append(data["seq"])
+        evs = {e["seq"]: e for e in self.state()["responses"]["events"]}
+        self.assertEqual(
+            [evs[s]["kind"] for s in seqs_], ["research", "research", "cancel-research"]
+        )
+        self.assertEqual(evs[seqs_[1]]["text"], "check the vendor docs")
+        self.assertEqual(self.state()["responses"]["responses"].get("Q5"), before)
+        self.assertEqual(self.post({"id": "nope", "kind": "research"})[0], 400)
+        self.assertEqual(self.post({"id": "Q5", "kind": "researchh"})[0], 400)
+
     def test_08_empty_note_is_400(self):
         code, _ = self.post({"kind": "note", "text": "  "})
         self.assertEqual(code, 400)
@@ -399,6 +419,30 @@ def test_28_ac31_both_files_validate_after_the_suite(self):
         self.assertEqual(rc, 0, out)
 
 
+class TestLongText(ServerCase):
+    """A long own answer and a long ask are stored whole, not cut at any length limit."""
+
+    fixtures = True
+
+    def test_long_own_answer_and_ask_reach_responses_json_whole(self):
+        filler = "Sentence of filler text that keeps going. " * 145
+        long_text = (
+            filler
+            + "There are more questions here, but the rest is for round two and then it ends"
+        )
+        self.assertGreaterEqual(len(long_text), 6000)
+        for qid, kind in (("Q5", "own"), ("Q6", "ask")):
+            code, _ = self.post({"id": qid, "kind": kind, "text": long_text})
+            self.assertEqual(code, 200)
+        saved = json.loads((self.dir / "responses.json").read_text(encoding="utf-8"))
+        texts = {
+            e["kind"]: e["text"] for e in saved["events"] if e["id"] in ("Q5", "Q6")
+        }
+        self.assertEqual(texts["own"], long_text)
+        self.assertEqual(texts["ask"], long_text)
+        self.assertEqual(saved["responses"]["Q5"]["text"], long_text)
+
+
 class TestEnsureRunning(ServerCase):
     """AC2: a fresh data dir gets a server and its URL within 3 s; a second call reuses it."""
 
@@ -1330,7 +1374,7 @@ def test_6_state_is_never_written_to_questions_json(self):
         doc = json.loads((self.dir / "questions.json").read_text(encoding="utf-8"))
         self.assertFalse(any("state" in q for q in doc["questions"]))
 
-    def test_7_revising_marks_direct_dependents_of_a_delivered_unhandled_decision(
+    def test_7_revising_marks_the_question_with_its_own_delivered_unhandled_decision(
         self,
     ):
         self.handle_all()
@@ -1338,18 +1382,18 @@ def test_7_revising_marks_direct_dependents_of_a_delivered_unhandled_decision(
         before = {
             q["id"]: q.get("revising") for q in self.state()["questions"]["questions"]
         }
-        self.assertFalse(before["B"], "revising before delivery")
+        self.assertFalse(before["A"], "revising before delivery")
         code, body, _ = self.wait("after=handled&replayed=0&timeout=5")
         self.assertFalse(body["timedOut"])
         rev = {
             q["id"]: q.get("revising") for q in self.state()["questions"]["questions"]
         }
-        self.assertEqual(rev, {"A": False, "B": True, "C": False, "D": False})
+        self.assertEqual(rev, {"A": True, "B": False, "C": False, "D": False})
         self.handle_all()
         rev = {
             q["id"]: q.get("revising") for q in self.state()["questions"]["questions"]
         }
-        self.assertFalse(rev["B"])
+        self.assertFalse(rev["A"])
 
     def test_8_archived(self):
         rc, out = self.rp("archive", "D", "--why", "Off the chosen path.")
diff --git a/plugins/planning/surface/tests/round-d3.json b/plugins/planning/surface/tests/round-d3.json
index 0b38589efc..468d792a98 100644
--- a/plugins/planning/surface/tests/round-d3.json
+++ b/plugins/planning/surface/tests/round-d3.json
@@ -1,10 +1,11 @@
 {
+  "meta": {"repo": "o/r"},
   "groups": [
     {"id": "g9", "title": "New group", "summary": "Two new questions.", "dependsOn": ["judged"]},
     {"id": "g10", "title": "Later group", "summary": "Opens after New group.", "dependsOn": ["g9"]}
   ],
   "questions": [
-    {"id": "N1", "group": "g9", "short": "First new", "title": "Should the first new thing happen?", "recommendation": "Yes. It keeps the flow simple.", "commits": [], "alternatives": [{"key": "a", "text": "No, skip it"}, {"key": "b", "text": "Only on request"}]},
+    {"id": "N1", "group": "g9", "short": "First new", "title": "Should the first new thing (#123, x/y#4) happen?", "facts": "Tracked in #123 and x/y#4; `#9` stays code.", "recommendation": "Yes. It keeps the flow simple.", "commits": [], "alternatives": [{"key": "a", "text": "No, skip it"}, {"key": "b", "text": "Only on request"}]},
     {"id": "N2", "group": "g9", "short": "Second new", "title": "Should the second new thing happen?", "dependsOn": ["N1"], "recommendation": "Yes, after the first.", "commits": [], "alternatives": [{"key": "a", "text": "No"}, {"key": "b", "text": "Only when the first is skipped"}]},
     {"id": "N3", "group": "g10", "short": "Third new", "title": "Should the third new thing happen?", "recommendation": "Yes, once the group opens.", "commits": [], "alternatives": [{"key": "a", "text": "No"}, {"key": "b", "text": "Later, in its own round"}]}
   ]
diff --git a/plugins/planning/surface/tests/ui_a.js b/plugins/planning/surface/tests/ui_a.js
index ea05f1a934..cc674b2570 100644
--- a/plugins/planning/surface/tests/ui_a.js
+++ b/plugins/planning/surface/tests/ui_a.js
@@ -43,6 +43,8 @@ async page => {
 
   // dictation: plain Enter, digits while typing, Ctrl+Enter unarmed
   await page.click('.qbtn[data-q="N1"]'); await page.waitForTimeout(200);
+  const refs = await page.evaluate(() => [...document.querySelectorAll("#qhead a, .blk a")].map(a => a.textContent + " " + a.getAttribute("href")));
+  ok("bare #N and owner/repo#N in a title and in facts render as issue links", ["#123 https://github.com/o/r/issues/123", "x/y#4 https://github.com/x/y/issues/4"].every(r => refs.filter(x => x === r).length === 2) && !refs.some(r => /#9\b/.test(r)), refs.join(" | "));
   const n0 = (await events()).length;
   await page.click("#note"); await page.keyboard.type("hello"); await page.keyboard.press("Enter"); await page.keyboard.type("world 1");
   await page.waitForTimeout(300);
diff --git a/plugins/planning/surface/tests/ui_b.js b/plugins/planning/surface/tests/ui_b.js
index 2d59695c40..283c2aa173 100644
--- a/plugins/planning/surface/tests/ui_b.js
+++ b/plugins/planning/surface/tests/ui_b.js
@@ -25,6 +25,13 @@ async page => {
   await page.request.get(base + "api/wait?after=" + (ev[ev.length - 1].seq - 1) + "&timeout=2", {headers: {"X-Interview-Token": token}});
   await page.waitForTimeout(900);
   ok("Claude line reads 'Claude is working on ...'", /^Claude is working on /.test(await page.textContent("#claudeLine")), await page.textContent("#claudeLine"));
+  await page.setViewportSize({width: 1280, height: 720}); await page.waitForTimeout(200);
+  const dh = await page.evaluate(() => ({h: document.querySelector("fieldset.decide").getBoundingClientRect().height, vh: innerHeight}));
+  ok("at 1280x720 the decide fieldset is at most 40% of the viewport", dh.h <= dh.vh * 0.4 + 1, JSON.stringify(dh));
+  await page.setViewportSize({width: 390, height: 844}); await page.waitForTimeout(200);
+  const ph = await page.evaluate(() => { const c = document.getElementById("claudeLine"); return {hs: document.documentElement.scrollWidth - innerWidth, cut: c.scrollWidth > c.clientWidth + 1 || c.scrollHeight > c.clientHeight + 1, shown: !c.hidden}; });
+  ok("at 390x844 there is no horizontal page scroll and the status line is not truncated", ph.hs <= 0 && ph.shown && !ph.cut, JSON.stringify(ph));
+  await page.setViewportSize({width: 1400, height: 860}); await page.waitForTimeout(200);
   if (await page.$eval('.qbtn[data-q="N2"]', el => !el.offsetParent)) await page.click('.sec[data-key="g:g9"] .sec-h');
   await page.click('.qbtn[data-q="N2"]'); await page.waitForTimeout(200);
   ok("receipt shows Saved and Delivered with times", /Saved \d.*Delivered \d/.test(await page.textContent("#cur")), await page.textContent("#cur"));
diff --git a/plugins/planning/surface/tests/ui_c.js b/plugins/planning/surface/tests/ui_c.js
index a6411edf52..afd0db56c1 100644
--- a/plugins/planning/surface/tests/ui_c.js
+++ b/plugins/planning/surface/tests/ui_c.js
@@ -224,8 +224,7 @@ async page => {
     const r5 = await (await post({id: "P1", kind: "accept", alt: null, text: ""})).json();
     await page.request.get(base + "api/wait?after=" + (r5.seq - 1) + "&timeout=2", {headers: {"X-Interview-Token": await token()}});
     await page.waitForTimeout(900);
-    ok("revising chip on the dependent", /Upstream P1 changed/.test(await page.textContent('.qbtn[data-q="P2"]')));
-    ok("revising banner in the detail", /Upstream P1 changed/.test(await page.textContent("#dscroll")));
+    ok("revising chip on the answered question, not its dependent", /Answer not handled yet/.test(await page.textContent('.qbtn[data-q="P1"]')) && !/Answer not handled yet/.test(await page.textContent('.qbtn[data-q="P2"]')));
 
     // shortcuts off: no single key acts
     await page.keyboard.press(","); await page.waitForTimeout(200);
diff --git a/plugins/planning/surface/tests/ui_journey.js b/plugins/planning/surface/tests/ui_journey.js
index 1ca73890c6..a9976ecd0c 100644
--- a/plugins/planning/surface/tests/ui_journey.js
+++ b/plugins/planning/surface/tests/ui_journey.js
@@ -76,6 +76,12 @@ async page => { // the user journey in order on one page, no reload after phase
     ok("Clear empties the note and disables itself", (await page.inputValue("#note")) === "" && await page.$eval("[data-clear]", b => b.disabled));
     await page.request.get(base + "api/wait?after=0&timeout=2", {headers: {"X-Interview-Token": await token()}}); await page.waitForTimeout(900);
     ok("the Claude line reads Claude is working on", /^Claude is working on Q\d/.test(await text("#claudeLine")), await text("#claudeLine"));
+    ok("an unanswered ask shows the Waiting for Claude's reply chip on Q4", /Waiting for Claude's reply/.test(await text('.qbtn[data-q="Q4"]')), await text('.qbtn[data-q="Q4"]'));
+    await pick("Q4"); await arm("a"); await tap("[data-save]", 300);
+    const nb = (await events()).length;
+    ok("Accept on a question still waiting for Claude asks first", /Accept current recommendation anyway\?/.test(await text("#dlgTitle")), await text("#dlgTitle"));
+    await tap("#dlgCancel", 300);
+    ok("cancelling the prompt sends nothing", (await events()).length === nb, String(nb));
 
     // own answer that is a question
     const askToast = await text("#toast");
@@ -128,6 +134,16 @@ async page => { // the user journey in order on one page, no reload after phase
     await tap("[data-save]", 700);
     const aw = await last();
     ok("Answer anyway saves, stays on Q3 and says it counts once the research returns", aw.id === "Q3" && aw.kind === "alt" && await sel() === "Q3" && /Counts once Claude's research on Q3 returns/.test(await text("#toast")) && (await text("#meterText")) === "2 of 5 answered", JSON.stringify(aw) + " " + await text("#toast"));
+    ok("the held card says research is in progress with its start time and keeps the answer controls enabled", /Research in progress, started \d/.test(await text("#dscroll .waitban")) && !(await page.$("#choices input:disabled")) && !(await page.$("#note:disabled")), await text("#dscroll .waitban"));
+    ok("a held question offers Cancel research and no Research this", !!(await page.$('[data-research="cancel-research"]')) && !(await page.$('[data-research="research"]')), await text("#talkRow"));
+    await tap('[data-research="cancel-research"]', 600);
+    const cr = await last();
+    ok("Cancel research posts kind cancel-research for Q3 and the hold stays until Claude releases it", cr.kind === "cancel-research" && cr.id === "Q3" && !!(await page.$('#dscroll .waitban')), JSON.stringify(cr));
+    await pick("Q4");
+    ok("a question with no hold offers Research this and no Cancel research", !!(await page.$('[data-research="research"]')) && !(await page.$('[data-research="cancel-research"]')), await text("#talkRow"));
+    await tap('[data-research="research"]', 600);
+    const rr = await last();
+    ok("Research this posts kind research for Q4", rr.kind === "research" && rr.id === "Q4", JSON.stringify(rr));
     await page.selectOption("#filter", "pending"); await page.waitForTimeout(200);
     const listed = (await page.$$eval(".rail-list .qbtn", els => els.map(e => e.dataset.q))).join(",");
     ok("Show: Pending lists only Q3", listed === "Q3", listed);
@@ -137,6 +153,7 @@ async page => { // the user journey in order on one page, no reload after phase
     ok("Q5 reads Needs your answer and its group counts it open", /Needs your answer: whether the version must be pinned/.test(await text('.qbtn[data-q="Q5"] .chip.s-need')) && (await text('.sec[data-key="g:g2"] .cnt')) === "3 open / 3", await text('.sec[data-key="g:g2"] .cnt'));
     await pick("Q1"); await page.click("#qhead"); await page.keyboard.press("n"); const n1 = await sel(); await page.keyboard.press("n"); const n2 = await sel();
     ok("n visits Q4 then Q5 and skips Q3, pending research", n1 === "Q4" && n2 === "Q5", n1 + " " + n2);
+    ok("a question waiting on the user offers neither Research this nor Cancel research", !(await page.$('[data-research]')), await text("#talkRow"));
     ok("a long hold text wraps inside the rail: it never scrolls sideways", await page.$eval("#railList", el => el.scrollWidth <= el.clientWidth), await page.$eval("#railList", el => el.scrollWidth + " > " + el.clientWidth));
     ok("Q5 offers one action, Answer again, with a one-line reason and no Reopen", /set your earlier answer \(Own answer: .*\) aside because it needs your decision\./.test(await text("#cur")) && (await page.$$("#cur [data-again]")).length === 1 && !(await page.$('[data-act="reopen"]')) && !/Set aside/.test(await text("#cur")), await text("#cur"));
     const aside = await page.$eval('.qbtn[data-q="Q5"] .chip.aside', el => { const s = getComputedStyle(el); return {t: el.textContent, b: s.borderTopWidth, bg: s.backgroundColor, c: s.cursor}; }).catch(() => null);
@@ -227,6 +244,12 @@ async page => { // the user journey in order on one page, no reload after phase
     // confirm understanding
     ok("the summary shows the restatement with Confirm and Something's off", /Ship green builds to staging/.test(await text("#restate")) && /Left to the plan stage/.test(await text("#restate")) && !!(await page.$('[data-understand="confirm"]')) && !!(await page.$('[data-understand="off"]')), (await text("#restate")).slice(0, 160));
     ok("Wrap up warns Understanding not confirmed yet", /Understanding not confirmed yet/.test(await text("#unconfWarn")));
+    for (const [w, h] of [[1440, 900], [390, 844]]) {
+      await page.setViewportSize({width: w, height: h}); await page.waitForTimeout(200);
+      const hit = await page.evaluate(() => { const a = document.querySelector('[data-understand="confirm"]').getBoundingClientRect(), b = document.getElementById("offText").getBoundingClientRect(); return !(a.right <= b.left || b.right <= a.left || a.bottom <= b.top || b.bottom <= a.top); });
+      ok("at " + w + "x" + h + " Confirm does not overlap the What-is-off box", !hit);
+    }
+    await page.setViewportSize({width: 1400, height: 860}); await page.waitForTimeout(200);
     const n2 = (await events()).length;
     await tap('[data-understand="off"]', 400);
     ok("Something's off needs text: nothing posts without it", (await events()).length === n2 && /Say what is off first/.test(await text("#restate")), await text("#restate"));