From 51159c97924b697e54de60c80f82003eccd77483 Mon Sep 17 00:00:00 2001
From: Luka Skugor <luka.skugor@dfinity.org>
Date: Wed, 4 Nov 2026 08:07:19 +0100
Subject: [PATCH 1/4] cockpit v3: steering end to end on the live node API

Milestone 2's web seams now read the server: every steering route
(preview, apply, Undo, Needs you, Find, last look) is on the live
source, and what did not match the S9/S10/S12/S13 server is fixed:

- Previews draw the server's own shapes: the moved or added node sits
  dashed in the column it lands in (the server lists it under ghosts),
  "Wait: ..." sentences read as labelled lines, a plan's code prefix
  is left out of warnings, one arrow between before and after, and
  Apply stays off when the server says the viewer may only look.
- Add child sends what it waits on as depends_on: [ref] with
  depends_why, lands in First unless it waits on a sibling, and says
  the column the server placed it in.
- An answer that applied a proposal (Apply C-16) has its Undo (the
  proposal's own) in the toast and beside the node's verbs.
- A verb's card in its node's thread offers its Undo by token, also
  after a reload; the server's undone card names the token it undid.
- The node chat reads the per-node threads (?nodes=1) for its
  children's news; on a phone a verb from the full-screen chat closes
  it and opens the preview in view.
- Team's first pick never sends a preview with no changes (400);
  team rows size by the panel's width, not the window's.
- Asks read as words (a person's Markdown), chips end in an ellipsis.
- Server: Start now no longer warns about met links it already had,
  the factory team says "all idle" instead of "0 running", and Name
  it says it files under a stored node of its own level.

The e2e seeds the base env and a held Google Ads integration, and
tests/e2e_ui/factory_v3/test_v3_steering.py drives each verb, Needs
you, Find, the factory tree, every lens and the phone against a real
server.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/FACTORY.md                               |   7 +-
 omnigent/server/factory/node_verbs.py         |  30 +-
 omnigent/server/factory/nodes.py              |   5 +-
 tests/e2e_ui/factory_v3/checks.py             |  74 +++
 tests/e2e_ui/factory_v3/seed.py               |  53 +-
 tests/e2e_ui/factory_v3/test_v3_live_api.py   |  39 +-
 tests/e2e_ui/factory_v3/test_v3_steering.py   | 519 ++++++++++++++++++
 tests/server/factory/test_node_verbs.py       |  56 ++
 tests/server/factory/test_nodes.py            |   8 +
 web/src/components/factory/cards/RoomCard.tsx |   3 +-
 .../factory/cards/RoomCardContext.tsx         |   4 +-
 .../factory/room/RoomThreadView.tsx           |   2 +-
 .../components/factory/room/roomQueries.ts    |  45 +-
 .../components/factory/team/teamQueries.ts    |   4 +-
 web/src/components/factory/v3/LinkChip.tsx    |  24 +-
 .../components/factory/v3/chat/ChatCards.tsx  |  41 ++
 .../factory/v3/chat/NodeChat.test.tsx         |  85 +++
 .../components/factory/v3/chat/NodeChat.tsx   |  80 ++-
 .../factory/v3/fixture/renderChat.tsx         |  15 +-
 .../factory/v3/fixture/renderNode.tsx         |  18 +-
 .../factory/v3/fixture/sampleNodeSource.ts    |   1 +
 .../factory/v3/fixture/sampleRoom.ts          |  11 +-
 .../factory/v3/fixture/sampleSteer.ts         |  50 +-
 web/src/components/factory/v3/nodeParts.tsx   |   6 +
 web/src/components/factory/v3/nodeSource.ts   |  44 +-
 .../components/factory/v3/nodeSteer.test.tsx  |  10 +-
 web/src/components/factory/v3/nodeSteer.ts    | 134 ++++-
 web/src/components/factory/v3/nodeTypes.ts    |  15 +-
 web/src/components/factory/v3/nodeWire.ts     |  78 ++-
 .../components/factory/v3/sheets/V3Sheets.tsx |  23 +-
 .../components/factory/v3/steerLive.test.tsx  | 315 +++++++++++
 .../factory/v3/verbs/PreviewPanel.tsx         |   8 +-
 .../factory/v3/verbs/TeamPanel.live.test.tsx  |   5 +
 .../components/factory/v3/verbs/TeamPanel.tsx |  12 +-
 .../factory/v3/verbs/VerbPreviews.test.tsx    |   2 +-
 .../factory/v3/verbs/VerbPreviews.tsx         |  32 +-
 web/src/lib/factoryRoomApi.ts                 |   4 +-
 web/src/pages/factory/NodeRoute.tsx           |  27 +-
 38 files changed, 1701 insertions(+), 188 deletions(-)
 create mode 100644 tests/e2e_ui/factory_v3/checks.py
 create mode 100644 tests/e2e_ui/factory_v3/test_v3_steering.py
 create mode 100644 web/src/components/factory/v3/steerLive.test.tsx

diff --git a/docs/FACTORY.md b/docs/FACTORY.md
index 45f9783be41..ceab02d8930 100644
--- a/docs/FACTORY.md
+++ b/docs/FACTORY.md
@@ -1189,7 +1189,10 @@ undone, and a `preview_id` that digests the plan and the facts it touches.
 only that plan (409 `stale`, with the new preview, when what it touches
 moved), then posts a `preview_applied` card and returns the node page with
 an Undo token; `POST …/undo/{token}` takes it back once within 10 minutes
-(the person who applied it, or an owner). The verbs run today's cores: `add`
+(the person who applied it, or an owner). The card carries the token
+(`meta.undo_token`, `undo_until`), so cockpit v3's chat offers the same Undo
+after a reload; the card an Undo posts (`meta.undone`) names the token it
+undid, and the applied card stops offering it. The verbs run today's cores: `add`
 under a feature files the person's projects proposal extending it and
 applies it at once ("Plan X now" goes to the feature's thread; a title that
 matches a held item pulls that item forward; `col: "later"` holds it in a
@@ -1305,7 +1308,7 @@ sentences, or (`rollup_delta`) as `{field: {before, after}}` or the S12
 server's `{nodes: [{ref, title, items: [{key, label, before, after}]}],
 text}` (one line per changed item, then the sentence; `null` when nothing in
 the roll-up changes). The arguments
-the web sends: add `{title, col, depends_on?, because?, held_for?}`, start,
+the web sends: add `{title, col, depends_on?: [ref], depends_why?: {ref: reason}, held_for?}`, start,
 pause and resume `{}`, auto `{auto_merge?, autonomy?, base?}` (what is left out
 stays as it is; `base` once the preview asks for it, `args.base`; the server
 also takes `repo`, and sends its effects as `{label, text}` lines), move `{to?}`, name
diff --git a/omnigent/server/factory/node_verbs.py b/omnigent/server/factory/node_verbs.py
index b064ed1bbb3..a26079cc734 100644
--- a/omnigent/server/factory/node_verbs.py
+++ b/omnigent/server/factory/node_verbs.py
@@ -146,6 +146,8 @@
 _SLUG_CHARS: Final = re.compile(r"[^a-z0-9]+")
 _TOKEN_RE: Final = re.compile(r"^[0-9a-f]{24}$")
 _PAUSE_HOLD: Final = "paused from the cockpit"
+_ENDED_DEP: Final = re.compile(r"^depends_on_(?:done|cancelled): \S+ waits on \w+ (\S+)$")
+"""A projects plan's warning that a dependency already finished (``proposals``' wording)."""
 
 
 class VerbIn(BaseModel):
@@ -479,6 +481,13 @@ async def run() -> Applied:
         )
 
     up = tree.level_name(tree.ladder[node.tree][max(0, tree.level_index(node) - 1)]).lower()
+    # Name it files an implicit node's work under a stored node of its own level.
+    same = tree.level_name(node.level).lower()
+    offered = (
+        f"only a stored {same} is offered"
+        if verb == "name"
+        else f"only a {up} one level up is offered"
+    )
     return Plan(
         verb,
         node.ref,
@@ -486,9 +495,9 @@ async def run() -> Applied:
         {},
         [f"parents:{_digest([p['ref'] for p in parents])}"],
         [
-            f"{what.capitalize()}: only a {up} one level up is offered."
+            f"{what.capitalize()}: {offered}."
             if parents
-            else f"No stored {up} to put it under yet."
+            else f"No stored {same if verb == 'name' else up} to put it under yet."
         ],
         run,
         ready=False,
@@ -1089,7 +1098,14 @@ async def _plan_start(env: Env, tree: nodes.Tree, node: Any, args: dict[str, Any
         if patch
         else None
     )
-    warnings = list(plan.warnings) if plan is not None else []
+    # A link it already had to a finished project is history (its chip says "met"):
+    # starting now neither adds it nor changes it, so it is no warning here.
+    kept = {d for d in new if d in current}
+    warnings = [
+        w
+        for w in (plan.warnings if plan is not None else [])
+        if not ((m := _ENDED_DEP.match(w)) and m.group(1) in kept)
+    ]
     if not swaps and unmet and explicit is None:
         warnings.append("Nothing it waits on can be relaxed to a merged change.")
 
@@ -2850,7 +2866,13 @@ async def undo(env: Env, token: str) -> dict[str, Any]:
         ref,
         "preview_applied",
         f"Undone by {env.by}: {event.summary}",
-        meta={"verb": str(data.get("verb") or ""), "by": env.by, "undone": True},
+        # The token it undid: the applied card in the thread stops offering its Undo.
+        meta={
+            "verb": str(data.get("verb") or ""),
+            "by": env.by,
+            "undone": True,
+            "undo_token": token,
+        },
         message_id=derived_id(env.fid, "undone", token),
     )
     fresh = await env.tree(fresh=True)
diff --git a/omnigent/server/factory/nodes.py b/omnigent/server/factory/nodes.py
index af6a9c3171e..78bad5e9274 100644
--- a/omnigent/server/factory/nodes.py
+++ b/omnigent/server/factory/nodes.py
@@ -1342,7 +1342,10 @@ def _team(self) -> None:
         everyone = self.facts.members
         if everyone:
             running = sum(1 for m in everyone if m.get("running"))
-            team.short = f"{len(everyone)} members · {running} running"
+            # Nothing renders as "0": idle members are counted, never drawn.
+            team.short = f"{len(everyone)} members · " + (
+                f"{running} running" if running else "all idle"
+            )
 
     def _areas(self) -> None:
         """Each area's one line on what it holds; an area with nothing to act on is done."""
diff --git a/tests/e2e_ui/factory_v3/checks.py b/tests/e2e_ui/factory_v3/checks.py
new file mode 100644
index 00000000000..5cfc7f4b220
--- /dev/null
+++ b/tests/e2e_ui/factory_v3/checks.py
@@ -0,0 +1,74 @@
+"""
+What every cockpit v3 screen must hold, checked in the browser. Not a test module.
+
+- :data:`BODY_CHECKS` sweeps a node page and v3's own parts of its chat
+  column: no line, path or polygon drawn between nodes (icons are glyphs, not
+  links between nodes, and are left out), no leaf that says only "none", "0"
+  or "—", and no sideways scroll of the page.
+- :func:`node` is a node page by ref; :func:`api` reads the factory's API as
+  the browser's user (single-user server: no header).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+from playwright.sync_api import Locator, Page
+
+BODY_CHECKS = """(node) => {
+  const chat = [...document.querySelectorAll(
+    '[data-testid="v3-chat"], [data-testid="v3-chat-pinned"], [data-testid="v3-chat-full"]',
+  )];
+  const roots = new Set(chat);
+  const room = '[data-testid^="decision-card-"], [data-testid^="proposal-card-"], '
+    + '[data-testid^="loop-card-"]';
+  const own = (el) => {
+    const part = el.closest('[data-testid^="v3-"]');
+    return part !== null && !roots.has(part) && el.closest(room) === null;
+  };
+  const icon = (el) => el.closest('svg.lucide') !== null;
+  const body = (el) => !chat.some((c) => c.contains(el)) || own(el);
+  const shown = (sel) => [...document.querySelectorAll(sel)]
+    .filter((el) => node.contains(el) || chat.some((c) => c.contains(el)))
+    .filter(body);
+  const lines = shown('svg line, svg path, svg polyline, svg polygon')
+    .filter((el) => !icon(el))
+    .map((el) => el.closest('[data-testid]')?.dataset.testid ?? el.tagName);
+  const empty = new Set(['none', 'None', '—', '-', '0']);
+  const cells = shown('*')
+    .filter((el) => el.children.length === 0)
+    .map((el) => (el.textContent ?? '').trim())
+    .filter((text) => empty.has(text) || /^0(\\s|$)/.test(text));
+  return {
+    lines,
+    cells,
+    chat: shown('*').filter((el) => chat.some((c) => c.contains(el))).length,
+    overflow: document.documentElement.scrollWidth - document.documentElement.clientWidth,
+  };
+}"""
+"""Run with ``node.evaluate(BODY_CHECKS)`` on a ``v3-node-page``."""
+
+
+def node(page: Page, ref: str) -> Locator:
+    """:returns: The node page of *ref*."""
+    return page.locator(f'[data-testid="v3-node-page"][data-ref="{ref}"]')
+
+
+def api(base_url: str, fid: str, path: str, **params: Any) -> Any:
+    """``GET /v1/factory/factories/{fid}{path}`` as the browser's user; the JSON body."""
+    resp = httpx.get(
+        f"{base_url}/v1/factory/factories/{fid}{path}", params=params or None, timeout=30.0
+    )
+    assert resp.status_code == 200, (path, resp.status_code, resp.text)
+    return resp.json()
+
+
+def assert_clean(found: dict[str, Any], *where: object) -> None:
+    """A :data:`BODY_CHECKS` result with no line, no empty cell and no sideways scroll."""
+    assert found["lines"] == [], (*where, "lines", found["lines"])
+    assert found["cells"] == [], (*where, "empty", found["cells"])
+    assert found["overflow"] <= 0, (*where, "overflow", found["overflow"])
+
+
+__all__ = ["BODY_CHECKS", "api", "assert_clean", "node"]
diff --git a/tests/e2e_ui/factory_v3/seed.py b/tests/e2e_ui/factory_v3/seed.py
index 9b7e2af9e2e..2d5dea9ee97 100644
--- a/tests/e2e_ui/factory_v3/seed.py
+++ b/tests/e2e_ui/factory_v3/seed.py
@@ -15,7 +15,10 @@
   a person to merge them into ``main``;
 - C-14 and C-15 ask things that block nothing; C-19 (D-49) proposes a follow-up
   under I-1; C-17 and C-18 are rule proposals for the factory tree;
-- the server closed three alarms today (D-46, D-47, D-48).
+- the server closed three alarms today (D-46, D-47, D-48);
+- the base env (the integration project ``base-env``) runs the base's head,
+  which holds every merge, and answers its smoke checks;
+- Agent assistant's later waves hold "Google Ads integration" and a sales skill.
 
 Rows are written with the server's own stores (the same SQL tables the server
 reads), and C-16 is filed through ``POST …/proposals`` so its decision (D-45)
@@ -42,6 +45,14 @@
 from omnigent.db.db_models import SqlFactoryDecision, SqlFactoryProject
 from omnigent.entities.factory import EventDraft
 from omnigent.server.auth import LEVEL_OWNER, RESERVED_USER_LOCAL
+from omnigent.server.factory.base import (
+    BaseHead,
+    DeployedHead,
+    deployed_label,
+    deployed_value,
+    head_label,
+    head_value,
+)
 from omnigent.stores.agent_store.sqlalchemy_store import SqlAlchemyAgentStore
 from omnigent.stores.conversation_store.sqlalchemy_store import SqlAlchemyConversationStore
 from omnigent.stores.factory_store.sqlalchemy_store import SqlAlchemyFactoryStore
@@ -59,6 +70,8 @@
     "discovery and sales too."
 )
 H: Final = 3600
+DEPLOYED_SHA: Final = "5a3c9e1" + "0" * 33
+"""The base head the base env runs (it holds every merge of the story)."""
 
 
 @dataclass(frozen=True)
@@ -338,7 +351,25 @@ def seed_factory_1340(
             }
             for slug in SHORTLIST
         },
-        "base-env": {"stage": "planning", "charter": {"kind": "integration"}},
+        "base-env": {
+            "stage": "planning",
+            "charter": {"kind": "integration"},
+            "env": {
+                "reported": {
+                    "state": "ready",
+                    "at": int(clock - 12 * 60),
+                    "urls": {"app": "https://app.example.com", "api": "https://api.example.com"},
+                    "deployed": {"sha": DEPLOYED_SHA[:7]},
+                    "note": "Sign in with a test account (sample).",
+                },
+                "probe": {
+                    "health": "ok",
+                    "app": {"code": 200},
+                    "api": {"code": 200},
+                    "at": int(clock - 60),
+                },
+            },
+        },
     }
     made: dict[str, float] = {}
     for slug, fields in work.items():
@@ -384,7 +415,11 @@ def seed_factory_1340(
                 {"wave": 1, "proposal": "C-11", "added": list(WAVE_1), "at": int(clock - 7 * H)}
             ],
             "waves": [
-                {"n": 2, "goal": "ads network and growth", "projects": ["ads-integration"]},
+                {
+                    "n": 2,
+                    "goal": "ads network and growth",
+                    "projects": ["google-ads-integration"],
+                },
                 {"n": 3, "goal": "sales and promotion", "projects": ["sales-skill"]},
             ],
             "asked_at": int(clock - 7 * H - 45 * 60),
@@ -620,6 +655,18 @@ def seed_factory_1340(
         )
         fs.update_proposal(proposal_row.id, decision_id=row.id)
 
+    # ── The base env: the base's head after the last merge, deployed and answering ──
+    moved = int(clock - 14 * 60)
+    conv.set_labels(
+        fid,
+        {
+            head_label(REPO, BASE): head_value(BaseHead(DEPLOYED_SHA, moved), REPO, BASE),
+            deployed_label(REPO, BASE): deployed_value(
+                DeployedHead(DEPLOYED_SHA, int(clock - 12 * 60), moved), REPO, BASE
+            ),
+        },
+    )
+
     # ── An hour of work on assistant-core (its burn) ──
     fs.insert_span(
         fid,
diff --git a/tests/e2e_ui/factory_v3/test_v3_live_api.py b/tests/e2e_ui/factory_v3/test_v3_live_api.py
index 063179bfc24..89e95437476 100644
--- a/tests/e2e_ui/factory_v3/test_v3_live_api.py
+++ b/tests/e2e_ui/factory_v3/test_v3_live_api.py
@@ -27,6 +27,8 @@
 import pytest
 from playwright.sync_api import Page, expect
 
+from tests.e2e_ui.factory_v3.checks import BODY_CHECKS as _BODY_CHECKS
+from tests.e2e_ui.factory_v3.checks import node as _node
 from tests.e2e_ui.factory_v3.conftest import LOAD_MS, Cockpit, Theme, V3Server
 from tests.e2e_ui.factory_v3.seed import Seeded
 
@@ -35,43 +37,6 @@
 LEVEL_PAGES = (("product", "project"), ("product", "task"), ("I-1", "task"))
 """Level views the strip links to (``/n/<ref>/<level>``)."""
 
-# What the node page shows: the page, and v3's own parts of its chat column (title,
-# quick verbs, any why/ask/alarm/offer card). The Room's answer cards and the chat's
-# icons stay as they are.
-_BODY_CHECKS = """(node) => {
-  const chat = [...document.querySelectorAll(
-    '[data-testid="v3-chat"], [data-testid="v3-chat-pinned"]',
-  )];
-  const roots = new Set(chat);
-  const room = '[data-testid^="decision-card-"], [data-testid^="proposal-card-"], '
-    + '[data-testid^="loop-card-"], svg.lucide';
-  const own = (el) => {
-    const part = el.closest('[data-testid^="v3-"]');
-    return part !== null && !roots.has(part) && el.closest(room) === null;
-  };
-  const body = (el) => !chat.some((c) => c.contains(el)) || own(el);
-  const shown = (sel) => [...document.querySelectorAll(sel)]
-    .filter((el) => node.contains(el) || chat.some((c) => c.contains(el)))
-    .filter(body);
-  const lines = shown('svg line, svg path, svg polyline, svg polygon')
-    .map((el) => el.closest('[data-testid]')?.dataset.testid ?? el.tagName);
-  const empty = new Set(['none', 'None', '—', '-', '0']);
-  const cells = shown('*')
-    .filter((el) => el.children.length === 0)
-    .map((el) => (el.textContent ?? '').trim())
-    .filter((text) => empty.has(text) || /^0(\\s|$)/.test(text));
-  return {
-    lines,
-    cells,
-    chat: shown('*').filter((el) => chat.some((c) => c.contains(el))).length,
-    overflow: document.documentElement.scrollWidth - document.documentElement.clientWidth,
-  };
-}"""
-
-
-def _node(page: Page, ref: str):
-    return page.locator(f'[data-testid="v3-node-page"][data-ref="{ref}"]')
-
 
 def _api_page(v3_server: V3Server, factory: Seeded, ref: str) -> dict:
     resp = httpx.get(
diff --git a/tests/e2e_ui/factory_v3/test_v3_steering.py b/tests/e2e_ui/factory_v3/test_v3_steering.py
new file mode 100644
index 00000000000..e1df14e1df5
--- /dev/null
+++ b/tests/e2e_ui/factory_v3/test_v3_steering.py
@@ -0,0 +1,519 @@
+"""
+Cockpit v3 steering on a real server: every verb previews, applies and undoes
+through the node API, in the browser.
+
+The server holds a factory shaped like a real one at 13:40 (``seed.py``). Each
+test seeds its own, so what one applies never leaks into another:
+
+- Apply on a decision answers it, and its Undo (the proposal's own) takes it back;
+- Start now on the waiting panel: the preview moves it to First in its
+  feature's columns, Apply relaxes its wait to the merged change, the status
+  line changes, Undo restores it;
+- Add child "Google Ads integration" under the feature pulls the held item
+  forward (no second copy) and asks Atlas to plan it in the feature's thread;
+- Autonomy & merge on the feature turns auto-merge on for its subtree: the
+  preview says what it covers and what it leaves to people, only an owner
+  applies it, and every node under it shows it inherited;
+- Team: swapping one member's model shows the team's cost per hour before and
+  after, applies as a definition version, and Undo re-pins the one before;
+- Needs you lists the asks ranked by what each holds; Find opens nodes by
+  T-16, #9876 and C-16; the factory tree shows the base env;
+- every lens renders with no line between nodes and no empty cell;
+- at 390 the chat opens full screen and every verb is reachable.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+
+import httpx
+from playwright.sync_api import Locator, Page, expect
+
+from tests.e2e_ui.factory_v3.checks import BODY_CHECKS, api, assert_clean, node
+from tests.e2e_ui.factory_v3.conftest import LOAD_MS, Cockpit, Theme, V3Server
+from tests.e2e_ui.factory_v3.seed import BASE, DEPLOYED_SHA, REPO, Seeded
+
+PANEL = "assistant-panel-ux"
+FEATURE_TITLE = "Agent assistant (sample)"
+GOOGLE_ADS = "Google Ads integration"
+
+
+def _verb(page: Page, ref: str, label: str) -> Locator:
+    """The verb button *label* in the toolbar of node *ref*."""
+    bar = node(page, ref).get_by_test_id("v3-verbs")
+    return bar.get_by_role("button", name=re.compile(rf"^{re.escape(label)}\b"))
+
+
+def _preview(page: Page) -> Locator:
+    """The open verb preview, once the server's dry run is in."""
+    preview = page.get_by_test_id("v3-preview")
+    expect(preview).to_be_visible(timeout=LOAD_MS)
+    expect(preview.get_by_test_id("v3-preview-lines")).to_be_visible(timeout=LOAD_MS)
+    expect(preview).not_to_have_attribute("aria-busy", "true", timeout=LOAD_MS)
+    return preview
+
+
+def _line(preview: Locator, label: str) -> Locator:
+    """The preview line whose label is *label* ("Who approves", "Cost" …)."""
+    return preview.get_by_test_id("v3-preview-line").filter(
+        has=preview.page.locator("dt", has_text=re.compile(rf"^{re.escape(label)}$"))
+    )
+
+
+def _apply(page: Page, preview: Locator, label: str | re.Pattern[str]) -> None:
+    """Press the preview's Apply (*label*) and wait for ``POST …/apply`` to succeed."""
+    button = preview.get_by_test_id("v3-preview-apply")
+    expect(button).to_have_text(label)
+    expect(button).to_be_enabled(timeout=LOAD_MS)
+    with page.expect_response(
+        lambda r: r.request.method == "POST" and r.url.endswith("/apply")
+    ) as applied:
+        button.click()
+    assert applied.value.status == 200, applied.value.text()
+    expect(preview).to_have_count(0, timeout=LOAD_MS)
+
+
+def _undo_latest(page: Page, ref: str, label: str) -> Locator:
+    """The "<label>: Undo (n min left)" button beside node *ref*'s verbs."""
+    undo = node(page, ref).get_by_test_id("v3-undo-latest")
+    expect(undo).to_contain_text(f"{label}: Undo (", timeout=LOAD_MS)
+    return undo
+
+
+def _status(page: Page, ref: str) -> Locator:
+    return node(page, ref).get_by_test_id("v3-status")
+
+
+def _chip(page: Page, ref: str, kind: str) -> Locator:
+    """Node *ref*'s header chip of *kind* ("auto-merge →", "depends on")."""
+    header = node(page, ref).get_by_test_id("v3-header")
+    return header.locator(f'[data-testid="v3-chip"][data-kind="{kind}"]')
+
+
+def _clean(page: Page, ref: str, *where: object) -> None:
+    assert_clean(node(page, ref).evaluate(BODY_CHECKS), ref, *where)
+
+
+def _thread(v3_server: V3Server, factory: Seeded, key: str) -> list[str]:
+    body = api(v3_server.base_url, factory.fid, "/chat", thread=key, limit=50)
+    return [m["body"] for m in body["data"]]
+
+
+# ── Answer, then Undo ──────────────────────────────────────────
+
+
+def test_apply_on_a_decision_then_undo_takes_it_back(
+    open_cockpit: Callable[[int, int, Theme], Cockpit],
+    v3_server: V3Server,
+    factory: Seeded,
+) -> None:
+    cockpit = open_cockpit(1440, 900, "light")
+    page = cockpit.page
+    cockpit.open(factory.project)
+    status = _status(page, factory.project)
+    expect(status).to_contain_text(
+        f"needs you: Apply {factory.proposal} ({factory.apply_decision})"
+    )
+
+    with page.expect_response(
+        lambda r: r.request.method == "POST" and r.url.endswith("/answer")
+    ) as answered:
+        status.get_by_role("button", name="Apply", exact=True).click()
+    assert answered.value.status == 200, answered.value.text()
+    expect(page.locator("[data-factory-toast]")).to_contain_text(
+        f"{factory.apply_decision}: Apply"
+    )
+    expect(status).not_to_contain_text(factory.apply_decision, timeout=LOAD_MS)
+    applied = api(v3_server.base_url, factory.fid, f"/proposals/{factory.proposal}")
+    assert applied["proposal"]["status"] == "applied", applied
+
+    # The answer applied C-16: its own Undo stays beside the verbs for 10 minutes.
+    undo = _undo_latest(page, factory.project, f"Apply {factory.proposal}")
+    with page.expect_response(
+        lambda r: (
+            r.request.method == "POST" and r.url.endswith(f"/proposals/{factory.proposal}/undo")
+        )
+    ) as undone:
+        undo.click()
+    assert undone.value.status == 200, undone.value.text()
+    expect(page.locator("[data-factory-toast]")).to_contain_text(
+        f"Undone: Apply {factory.proposal} ({factory.apply_decision})."
+    )
+    expect(node(page, factory.project).get_by_test_id("v3-undo-latest")).to_have_count(0)
+    after = api(v3_server.base_url, factory.fid, f"/proposals/{factory.proposal}")
+    assert after["proposal"]["status"] == "undone", after
+    _clean(page, factory.project, "after undo")
+    assert cockpit.errors == [], cockpit.errors
+
+
+# ── Start now ──────────────────────────────────────────────────
+
+
+def test_start_now_on_a_waiting_project_previews_applies_and_undoes(
+    open_cockpit: Callable[[int, int, Theme], Cockpit],
+    v3_server: V3Server,
+    factory: Seeded,
+) -> None:
+    cockpit = open_cockpit(1440, 900, "light")
+    page = cockpit.page
+    cockpit.open(PANEL)
+    status = _status(page, PANEL)
+    before = status.get_attribute("aria-label") or ""
+    assert before.startswith("Not started for 7 h: waits on assistant-core"), before
+
+    # `s` is Start now's key: its preview opens under the header.
+    page.keyboard.press("s")
+    preview = _preview(page)
+    expect(preview).to_have_attribute("data-label", "Start now")
+    columns = preview.get_by_test_id("v3-mini-columns")
+    # The panel moves to First (a dashed ghost) and its place in Then is struck.
+    expect(columns.locator(f'[data-testid="v3-mini-ghost"][data-ref="{PANEL}"]')).to_be_visible()
+    expect(columns.locator(f'[data-testid="v3-mini-gone"][data-ref="{PANEL}"]')).to_be_visible()
+    expect(_line(preview, "Wait")).to_contain_text("needs only PR-9876 · merged (met)")
+    expect(_line(preview, "Order")).to_contain_text("Then → First")
+    expect(_line(preview, "Who approves")).to_contain_text("You, as owner")
+    # Met links it already had are history, not warnings.
+    expect(preview).not_to_contain_text("waits on done")
+    _clean(page, PANEL, "start preview")
+
+    _apply(page, preview, "Start now")
+    expect(status).not_to_have_attribute("aria-label", before, timeout=LOAD_MS)
+    expect(status).not_to_contain_text("waits on assistant-core")
+    expect(_chip(page, PANEL, "depends on")).to_contain_text("PR-9876")
+    expect(_chip(page, PANEL, "depends on")).to_contain_text("met")
+    page_after = api(v3_server.base_url, factory.fid, f"/n/{PANEL}")
+    assert page_after["status"].get("decision") is None, page_after["status"]
+    assert _thread(v3_server, factory, f"project:{PANEL}"), "no card in the panel's thread"
+
+    # Undo puts the wait back: the line ends at the person again.
+    with page.expect_response(
+        lambda r: r.request.method == "POST" and "/undo/" in r.url
+    ) as undone:
+        _undo_latest(page, PANEL, "Start now").click()
+    assert undone.value.status == 200, undone.value.text()
+    expect(status).to_have_attribute("aria-label", before, timeout=LOAD_MS)
+    assert cockpit.errors == [], cockpit.errors
+
+
+# ── Add child: pull forward ────────────────────────────────────
+
+
+def test_add_child_pulls_the_held_google_ads_forward_and_asks_atlas_to_plan_it(
+    open_cockpit: Callable[[int, int, Theme], Cockpit],
+    v3_server: V3Server,
+    factory: Seeded,
+) -> None:
+    cockpit = open_cockpit(1440, 900, "light")
+    page = cockpit.page
+    held = "google-ads-integration"
+    later = api(v3_server.base_url, factory.fid, f"/n/{factory.feature}")["children"]["later"]
+    assert held in [k["ref"] for k in later], later
+    cockpit.open(factory.feature)
+
+    _verb(page, factory.feature, "Add child").click()
+    page.get_by_test_id("v3-preview").get_by_label("Title").fill(GOOGLE_ADS)
+    preview = _preview(page)
+    expect(preview.get_by_test_id("v3-preview-found")).to_contain_text(
+        f"{held} is already here, held for wave 2"
+    )
+    expect(preview.get_by_test_id("v3-preview-found")).to_contain_text(
+        "pulls it forward into First instead of making a second copy"
+    )
+    columns = preview.get_by_test_id("v3-mini-columns")
+    expect(columns.locator(f'[data-testid="v3-mini-ghost"][data-ref="{held}"]')).to_have_text(
+        GOOGLE_ADS
+    )
+    expect(columns.locator(f'[data-testid="v3-mini-gone"][data-ref="{held}"]')).to_be_visible()
+    expect(
+        preview.get_by_test_id("v3-preview-line").filter(has_text="Later (held)")
+    ).to_contain_text("2 → 1")
+    expect(preview).to_contain_text("Atlas plans it now")
+    # The banner says it once: the server's own sentence for it is not repeated.
+    expect(preview.get_by_text(re.compile(rf"^{held} is already here"))).to_have_count(1)
+    _clean(page, factory.feature, "add preview")
+
+    _apply(page, preview, "Pull forward and plan")
+    expect(page.locator("[data-factory-toast]")).to_contain_text(f"pulled forward {GOOGLE_ADS}")
+    feature = api(v3_server.base_url, factory.fid, f"/n/{factory.feature}")["children"]
+    assert held in [k["ref"] for k in feature["items"]], feature["items"]
+    assert held not in [k["ref"] for k in feature["later"]], feature["later"]
+    # Atlas is asked to plan it, in the feature's own thread (its chat column).
+    plan = f"Plan {GOOGLE_ADS} now"
+    assert any(
+        b.startswith(plan) for b in _thread(v3_server, factory, f"feature:{factory.feature}")
+    )
+    expect(page.get_by_test_id("v3-chat").get_by_text(plan)).to_be_visible(timeout=LOAD_MS)
+    _undo_latest(page, factory.feature, "Add child")
+    assert cockpit.errors == [], cockpit.errors
+
+
+# ── Autonomy & merge ───────────────────────────────────────────
+
+
+def test_autonomy_and_merge_on_the_feature_covers_its_subtree_for_an_owner(
+    open_cockpit: Callable[[int, int, Theme], Cockpit],
+    v3_server: V3Server,
+    factory: Seeded,
+) -> None:
+    # Only an owner applies it: the server says so in every preview.
+    dry = httpx.post(
+        f"{v3_server.base_url}/v1/factory/factories/{factory.fid}/n/{factory.feature}/preview",
+        json={"verb": "auto", "args": {"auto_merge": True}},
+        timeout=30.0,
+    )
+    assert dry.status_code == 200, dry.text
+    assert dry.json()["who_may"] == "an owner" and dry.json()["can_apply"] is True, dry.json()
+
+    cockpit = open_cockpit(1440, 900, "light")
+    page = cockpit.page
+    cockpit.open(factory.feature)
+    page.keyboard.press("u")
+    preview = _preview(page)
+    expect(preview.get_by_test_id("v3-auto-merge-switch")).to_have_attribute(
+        "aria-checked", "true"
+    )
+    expect(_line(preview, "Merges into")).to_contain_text(f"{REPO}#{BASE}")
+    expect(_line(preview, "Covers")).to_contain_text(
+        "2 projects now (assistant-core, assistant-panel-ux) and any added under it later"
+    )
+    expect(_line(preview, "Not affected")).to_contain_text(
+        "main stays merged by people (build-tier-drafts-3 is outside this subtree)"
+    )
+    expect(_line(preview, "Who approves")).to_contain_text("You, as owner")
+    delta = preview.get_by_test_id("v3-preview-line").filter(has_text="Auto-merge").first
+    expect(delta).to_contain_text(f"off → {BASE} (here)")
+    _clean(page, factory.feature, "autonomy preview")
+
+    _apply(page, preview, "Turn on for this subtree")
+    chip = _chip(page, factory.feature, "auto-merge →")
+    expect(chip).to_contain_text(BASE)
+    expect(chip).to_contain_text("this subtree")
+    # Inherited by everything under it: a project and its task.
+    for ref in (factory.project, factory.held_task):
+        cockpit.open(ref)
+        inherited = _chip(page, ref, "auto-merge →")
+        expect(inherited).to_contain_text(BASE)
+        expect(inherited).to_contain_text(f"from {FEATURE_TITLE}")
+    project = api(v3_server.base_url, factory.fid, f"/n/{factory.project}")
+    assert project["node"]["auto_merge"] is True, project["node"]
+    drafts = api(v3_server.base_url, factory.fid, "/n/build-tier-drafts-3")
+    assert not drafts["node"].get("auto_merge"), drafts["node"]
+    assert cockpit.errors == [], cockpit.errors
+
+
+# ── Team ───────────────────────────────────────────────────────
+
+
+def test_team_model_swap_shows_the_cost_line_and_undoes(
+    open_cockpit: Callable[[int, int, Theme], Cockpit],
+    factory: Seeded,
+) -> None:
+    cockpit = open_cockpit(1440, 900, "light")
+    page = cockpit.page
+    cockpit.open(factory.project)
+    _verb(page, factory.project, "Team").click()
+    panel = page.get_by_test_id("v3-preview")
+    expect(panel).to_have_attribute("data-label", "Team editor")
+    rows = panel.get_by_test_id("v3-team-row")
+    expect(rows.first).to_be_visible(timeout=LOAD_MS)
+    # Nothing is preselected: Apply waits for a pick.
+    expect(panel.get_by_test_id("v3-preview-apply")).to_be_disabled()
+    builder = rows.nth(1)
+    member = builder.get_attribute("data-member") or ""
+    vendor = builder.get_by_label(f"{member} vendor")
+    other = next(v for v in ("codex", "claude") if v != vendor.input_value())
+    vendor.select_option(other)
+    expect(builder).to_have_attribute("data-changed", "")
+    cost = _line(panel, "Cost")
+    expect(cost).to_contain_text(re.compile(r"\$[\d.]+/h → about \$[\d.]+/h while working"))
+    expect(_line(panel, "Who approves")).to_be_visible()
+    expect(_line(panel, "When")).to_contain_text("next task")
+
+    apply = panel.get_by_test_id("v3-preview-apply")
+    expect(apply).to_be_enabled(timeout=LOAD_MS)
+    with page.expect_response(
+        lambda r: r.request.method == "PUT" and r.url.endswith("/definition")
+    ) as put:
+        apply.click()
+    assert put.value.status == 200, put.value.text()
+    expect(page.locator("[data-factory-toast]")).to_contain_text("Applied as definition v")
+    with page.expect_response(
+        lambda r: r.request.method == "POST" and r.url.endswith("/definition/pin")
+    ) as pinned:
+        _undo_latest(page, factory.project, "Team").click()
+    assert pinned.value.status == 200, pinned.value.text()
+    expect(page.locator("[data-factory-toast]")).to_contain_text("Undone. The team is back")
+    assert cockpit.errors == [], cockpit.errors
+
+
+# ── Needs you, Find ────────────────────────────────────────────
+
+
+def test_needs_you_ranks_each_ask_by_what_it_holds(
+    open_cockpit: Callable[[int, int, Theme], Cockpit],
+    factory: Seeded,
+) -> None:
+    cockpit = open_cockpit(1440, 900, "light")
+    page = cockpit.page
+    cockpit.open("product")
+    page.get_by_test_id("cockpit-needs-you").click()
+    sheet = page.get_by_test_id("v3-needs-sheet")
+    expect(sheet).to_be_visible(timeout=LOAD_MS)
+    items = sheet.get_by_test_id("v3-needs-item")
+    expect(items).to_have_count(3, timeout=LOAD_MS)
+    # What holds the most first: C-16 (T-16 and the panel), the merges on main, then D-49.
+    expect(items.nth(0)).to_have_attribute("data-decision", factory.apply_decision)
+    expect(items.nth(0)).to_contain_text("Holds T-16, assistant-panel-ux.")
+    expect(items.nth(0)).not_to_contain_text("**")
+    expect(items.nth(1)).to_have_attribute("data-decision", re.compile(r"^merge:"))
+    expect(items.nth(1)).to_contain_text("Merge #9856 and #9857")
+    expect(items.nth(2)).to_contain_text("Start the live-search fix?")
+    quiet = sheet.get_by_test_id("v3-needs-quiet")
+    expect(quiet).to_contain_text("These block nothing")
+    expect(quiet.get_by_test_id("v3-needs-apply-all")).to_have_text("Apply all 2")
+    closed = sheet.get_by_test_id("v3-needs-closed")
+    expect(closed).to_contain_text("3 alarms closed by the server")
+    for alarm in ("D-46", "D-47", "D-48"):
+        expect(closed).to_contain_text(alarm)
+    # The factory tree's asks wait there.
+    sheet.get_by_test_id("v3-needs-other-tree").click()
+    expect(sheet.get_by_test_id("v3-needs-item")).to_have_count(2, timeout=LOAD_MS)
+    expect(sheet.get_by_test_id("v3-needs-item").first).to_contain_text("C-17")
+    assert cockpit.errors == [], cockpit.errors
+
+
+def test_find_opens_nodes_by_task_change_and_proposal_refs(
+    open_cockpit: Callable[[int, int, Theme], Cockpit],
+    factory: Seeded,
+) -> None:
+    cockpit = open_cockpit(1440, 900, "light")
+    page = cockpit.page
+    cockpit.open("product")
+    for query, ref in (
+        (factory.held_task, factory.held_task),
+        ("#9876", "PR-9876"),
+        (factory.proposal, factory.project),
+    ):
+        page.get_by_test_id("cockpit-search").click()
+        page.get_by_test_id("factory-palette-input").fill(query)
+        hit = page.get_by_test_id(f"factory-palette-node-{ref}")
+        expect(hit).to_be_visible(timeout=LOAD_MS)
+        hit.click()
+        cockpit.wait_for(ref)
+        expect(page).to_have_url(re.compile(rf"/n/{re.escape(ref)}(\?|$)"))
+        # The palette has closed (its exit animation too) before it opens again.
+        expect(page.get_by_test_id("factory-palette")).to_have_count(0)
+        expect(page.get_by_role("dialog")).to_have_count(0)
+    assert cockpit.errors == [], cockpit.errors
+
+
+# ── The factory tree, lenses ───────────────────────────────────
+
+
+def test_the_factory_tree_shows_the_base_env_and_the_closed_alarms(
+    open_cockpit: Callable[[int, int, Theme], Cockpit],
+    factory: Seeded,
+) -> None:
+    cockpit = open_cockpit(1440, 900, "dark")
+    page = cockpit.page
+    cockpit.open("product")
+    page.get_by_test_id("cockpit-tree-factory").click()
+    cockpit.wait_for("fx")
+    _clean(page, "fx", "factory root")
+    node(page, "fx").locator('[data-node-link="fx:environments"]').first.click()
+    cockpit.wait_for("fx:environments")
+    env = node(page, "fx:environments").get_by_test_id("v3-base-env")
+    expect(env).to_contain_text(f"Base env · {BASE}")
+    expect(env).to_contain_text(DEPLOYED_SHA[:7])
+    expect(env).to_contain_text("smoke OK")
+    expect(env).to_contain_text("Sign in with a test account (sample).")
+    expect(env).to_contain_text("7 merged changes")
+    _clean(page, "fx:environments", "environments")
+    cockpit.open("fx:health")
+    alarms = node(page, "fx:health").get_by_test_id("v3-closed-alarms")
+    for alarm in ("D-46", "D-47", "D-48"):
+        expect(alarms).to_contain_text(alarm)
+    _clean(page, "fx:health", "health")
+    # The root's roll-up says where the product's changes are: all in the base env.
+    cockpit.open("product")
+    expect(node(page, "product").get_by_test_id("v3-results")).to_contain_text("all in base env")
+    assert cockpit.errors == [], cockpit.errors
+
+
+def test_every_lens_renders_without_lines_or_empty_cells(
+    open_cockpit: Callable[[int, int, Theme], Cockpit],
+    factory: Seeded,
+) -> None:
+    cockpit = open_cockpit(1440, 900, "light")
+    page = cockpit.page
+    content = {
+        "map": "v3-tile",
+        "list": "v3-row",
+        "lineage": "v3-lineage",
+        "timeline": "v3-timeline",
+        "money": "v3-money",
+    }
+    for ref, wanted in (
+        (factory.feature, ("map", "list", "lineage", "timeline", "money")),
+        (factory.project, ("list", "lineage", "timeline")),
+        ("fx", ("map", "list")),
+    ):
+        cockpit.open(ref)
+        bar = node(page, ref).get_by_test_id("v3-lens-bar")
+        offered = [t.get_attribute("data-lens") for t in bar.get_by_role("tab").all()]
+        for lens in wanted:
+            assert lens in offered, (ref, lens, offered)
+        for lens in offered:
+            bar.locator(f'[data-lens="{lens}"]').click()
+            expect(bar.locator(f'[data-lens="{lens}"]')).to_have_attribute("aria-selected", "true")
+            if lens in content:
+                expect(node(page, ref).get_by_test_id(content[lens]).first).to_be_visible(
+                    timeout=LOAD_MS
+                )
+            _clean(page, ref, lens)
+    # A task's lineage reads from the product down.
+    page.goto(f"/factory/{factory.fid}/n/{factory.held_task}?lens=lineage")
+    cockpit.wait_for(factory.held_task)
+    _clean(page, factory.held_task, "lineage")
+    assert cockpit.errors == [], cockpit.errors
+
+
+# ── Phone ──────────────────────────────────────────────────────
+
+
+def test_phone_chat_opens_full_screen_and_every_verb_is_reachable(
+    open_cockpit: Callable[[int, int, Theme], Cockpit],
+    factory: Seeded,
+) -> None:
+    cockpit = open_cockpit(390, 844, "dark")
+    page = cockpit.page
+    cockpit.open(PANEL)
+    _clean(page, PANEL, "phone")
+    # The verbs scroll sideways inside their row; the page never does.
+    bar = node(page, PANEL).get_by_test_id("v3-verbs")
+    for button in bar.get_by_role("button").all():
+        button.scroll_into_view_if_needed()
+        expect(button).to_be_in_viewport()
+    _verb(page, PANEL, "Start now").click()
+    preview = _preview(page)
+    expect(preview).to_be_in_viewport()
+    preview.get_by_test_id("v3-preview-cancel").click()
+    expect(preview).to_have_count(0)
+
+    # The pinned box opens the node's thread full screen.
+    page.get_by_test_id("v3-chat-open").click()
+    full = page.get_by_test_id("v3-chat-full")
+    expect(full).to_be_visible(timeout=LOAD_MS)
+    box = full.bounding_box()
+    assert box is not None and box["x"] <= 0 and box["y"] <= 0, box
+    assert box["width"] >= 390 and box["height"] >= 844, box
+    assert_clean(full.evaluate(BODY_CHECKS), "full chat")
+    expect(full.get_by_test_id("v3-chat-quick-answer")).to_have_text(f"Apply {factory.proposal}")
+    # A verb from the chat closes it and opens its preview on the page, in view.
+    full.get_by_test_id("v3-chat-quick-start").click()
+    expect(full).to_have_count(0, timeout=LOAD_MS)
+    preview = _preview(page)
+    expect(preview).to_have_attribute("data-label", "Start now")
+    expect(preview).to_be_in_viewport()
+    assert cockpit.errors == [], cockpit.errors
diff --git a/tests/server/factory/test_node_verbs.py b/tests/server/factory/test_node_verbs.py
index 5848444f46f..ecff07bd0a9 100644
--- a/tests/server/factory/test_node_verbs.py
+++ b/tests/server/factory/test_node_verbs.py
@@ -936,6 +936,8 @@ async def test_move_and_name_first_read_lists_the_parents(cockpit: Cockpit) -> N
     assert {p["ref"] for p in move["parents"]} == {"I-1", other.ref}
     assert move["can_apply"] is False and "one level up" in move["effects"][0]
     assert {p["ref"] for p in name["parents"]} == {"I-1", other.ref}
+    # Name it files the work under a stored node of its own level, and says so.
+    assert "only a stored feature is offered" in name["effects"][0], name["effects"]
     assert (applied.status_code, error_code(applied)) == (400, "invalid_args")
     assert picked["can_apply"] is True and picked["parents"] == move["parents"]
 
@@ -966,3 +968,57 @@ async def test_apply_answers_in_one_line_with_an_undo_until_a_time(cockpit: Cock
     assert applied["message"] == applied["line"] and "Docs" in applied["message"]
     assert re.fullmatch(r"\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ", applied["undo"]["expires_at"])
     assert undone.json()["message"].startswith("Undone: ")
+
+
+async def test_start_now_keeps_links_to_finished_work_without_warning(cockpit: Cockpit) -> None:
+    # The panel also waited on a spike that is done: a met link it already had.
+    spike = cockpit.store.upsert_project(cockpit.fid, "spike", title="spike", repo=REPO)
+    cockpit.store.update_project(spike.id, stage="merged", status="done")
+    row = cockpit.store.get_project(cockpit.fid, "panel")
+    assert row is not None
+    charter = {**normalize_charter(row.charter), "depends_on": ["core", "spike"]}
+    cockpit.store.update_project(row.id, charter=charter)
+
+    preview = await _preview(cockpit, "panel", "start")
+
+    assert preview["args"]["depends_on"] == ["PR-9001", "spike"]
+    assert not any("spike" in w for w in preview["warnings"]), preview["warnings"]
+    added = await _preview(cockpit, "I-1", "add", title="Late", depends_on=["spike"])
+    assert any("spike" in w for w in added["warnings"]), "a new link to done work still warns"
+
+
+async def test_the_undone_card_names_the_token_it_undid(cockpit: Cockpit) -> None:
+    applied = await _apply(cockpit, "I-1", await _preview(cockpit, "I-1", "add", title="Usage"))
+    token = applied["undo"]["token"]
+
+    undone = await _undo(cockpit, token)
+
+    assert undone.status_code == 200, undone.text
+    cards = [
+        (m.card or {}).get("meta") or {}
+        for m in cockpit.store.list_chat(cockpit.fid, "feature:I-1", limit=20)
+        if (m.card or {}).get("type") == "preview_applied"
+    ]
+    assert [c.get("undo_token") for c in cards] == [token, token]
+    assert [bool(c.get("undone")) for c in cards] == [False, True]
+
+
+async def test_add_takes_what_it_waits_on_as_a_list_with_reasons(cockpit: Cockpit) -> None:
+    preview = await _preview(
+        cockpit,
+        "I-1",
+        "add",
+        title="Usage",
+        depends_on=["core"],
+        depends_why={"core": "reads the core's API"},
+    )
+
+    assert preview["args"]["depends_on"] == ["core"]
+    assert preview["args"]["depends_why"] == {"core": "reads the core's API"}
+    ghost = preview["columns_after"]["ghosts"][-1]
+    assert (ghost["ref"], ghost["col"]) == ("usage", 1)
+    one = await cockpit.post(
+        _url(cockpit, "I-1", "preview"),
+        {"verb": "add", "args": {"title": "Usage", "depends_on": "core"}},
+    )
+    assert (one.status_code, error_code(one)) == (400, "invalid_args")
diff --git a/tests/server/factory/test_nodes.py b/tests/server/factory/test_nodes.py
index 415f277f74a..af08e31f8fa 100644
--- a/tests/server/factory/test_nodes.py
+++ b/tests/server/factory/test_nodes.py
@@ -450,6 +450,14 @@ def test_the_factory_tree(tree: Tree) -> None:
         assert _page(tree, area["ref"])["node"]["why_html"], area["ref"]
 
 
+def test_a_team_with_nobody_running_says_so_without_a_zero() -> None:
+    facts = factory_1340()
+    facts.members = [{**m, "running": False} for m in facts.members]
+    tree = assert_levels(Tree(facts))
+
+    assert _page(tree, "fx:team")["node"]["short"] == f"{len(facts.members)} members · all idle"
+
+
 def test_the_team_draws_working_agents_and_counts_idle_ones(tree: Tree) -> None:
     team = _page(tree, "fx:team")
 
diff --git a/web/src/components/factory/cards/RoomCard.tsx b/web/src/components/factory/cards/RoomCard.tsx
index 0e82c678078..53660462f5a 100644
--- a/web/src/components/factory/cards/RoomCard.tsx
+++ b/web/src/components/factory/cards/RoomCard.tsx
@@ -101,7 +101,8 @@ export function RoomCard({
     }
     case "why":
     case "closed_alarm":
-    case "offer": {
+    case "offer":
+    case "preview_applied": {
       // The cockpit's card shows the line itself when it cannot draw.
       const fallback = attached ? null : line;
       return data.nodeCard ? data.nodeCard(message, attached, fallback) : fallback;
diff --git a/web/src/components/factory/cards/RoomCardContext.tsx b/web/src/components/factory/cards/RoomCardContext.tsx
index 35c4e6eb6ed..c16ba59f255 100644
--- a/web/src/components/factory/cards/RoomCardContext.tsx
+++ b/web/src/components/factory/cards/RoomCardContext.tsx
@@ -27,8 +27,8 @@ export interface RoomCardData {
   /** The dock's narrow column: cards fold their long parts. */
   compact: boolean;
   /**
-   * Cards the Room does not draw (cockpit v3's `why`, `closed_alarm` and
-   * `offer`). A card it cannot draw renders `fallback` (the message's own
+   * Cards the Room does not draw (cockpit v3's `why`, `closed_alarm`, `offer`
+   * and `preview_applied`). A card it cannot draw renders `fallback` (the message's own
    * line, null under a message), so it never renders empty. Absent elsewhere.
    */
   nodeCard?:
diff --git a/web/src/components/factory/room/RoomThreadView.tsx b/web/src/components/factory/room/RoomThreadView.tsx
index 2c04e5cad89..df4e28d80f6 100644
--- a/web/src/components/factory/room/RoomThreadView.tsx
+++ b/web/src/components/factory/room/RoomThreadView.tsx
@@ -160,7 +160,7 @@ export interface RoomThreadNodeOptions {
   bottomCount?: number;
   /** What an empty thread says instead of "Nothing in #x yet". */
   empty?: ReactNode;
-  /** Cards the Room does not draw (`why`, `closed_alarm`, `offer`); `fallback` when it cannot draw one. */
+  /** Cards the Room does not draw (`why`, `closed_alarm`, `offer`, `preview_applied`); `fallback` when it cannot draw one. */
   card?: (message: ChatMessageView, attached: boolean, fallback: ReactNode) => ReactNode;
   composer?: RoomComposerNodeOptions;
 }
diff --git a/web/src/components/factory/room/roomQueries.ts b/web/src/components/factory/room/roomQueries.ts
index b3cddf2113b..4c60ba5c6cd 100644
--- a/web/src/components/factory/room/roomQueries.ts
+++ b/web/src/components/factory/room/roomQueries.ts
@@ -35,6 +35,9 @@ import {
 export const roomQueryKey = (factoryId: string) => ["factory-room", factoryId] as const;
 export const threadsQueryKey = (factoryId: string) =>
   [...roomQueryKey(factoryId), "threads"] as const;
+/** The threads with cockpit v3's per-node ones (`?nodes=1`); under `threadsQueryKey`, so it reads again with it. */
+export const nodeThreadsQueryKey = (factoryId: string) =>
+  [...threadsQueryKey(factoryId), "nodes"] as const;
 export const messagesQueryKey = (factoryId: string, thread: string) =>
   [...roomQueryKey(factoryId), "chat", thread] as const;
 export const proposalsQueryKey = (factoryId: string) =>
@@ -61,12 +64,19 @@ function useFallbackInterval(): number | false {
   return useSessionUpdatesConnected() ? false : FACTORY_FALLBACK_POLL_MS;
 }
 
-/** The Room's threads with the viewer's unread counts. */
-export function useRoomThreads(factoryId: string | null | undefined) {
+/**
+ * The Room's threads with the viewer's unread counts. `nodes`: also the
+ * per-node threads (`need:`, `feature:`, `task:` …) that have messages, for
+ * cockpit v3's chat; the Room's own list and badge never count them.
+ */
+export function useRoomThreads(
+  factoryId: string | null | undefined,
+  { nodes = false }: { nodes?: boolean } = {},
+) {
   const refetchInterval = useFallbackInterval();
   return useQuery<ThreadsResponse>({
-    queryKey: threadsQueryKey(factoryId ?? ""),
-    queryFn: ({ signal }) => fetchRoomThreads(factoryId as string, signal),
+    queryKey: nodes ? nodeThreadsQueryKey(factoryId ?? "") : threadsQueryKey(factoryId ?? ""),
+    queryFn: ({ signal }) => fetchRoomThreads(factoryId as string, signal, { nodes }),
     enabled: Boolean(factoryId),
     refetchInterval,
     retry: retryTransient,
@@ -223,14 +233,17 @@ function newChannel(): ReadChannel | null {
 
 /** Zero a thread's unread count in this client's cache (and anything read up to `lastSeq`). */
 export function applyReadMark(queryClient: QueryClient, mark: ReadMark): void {
-  queryClient.setQueryData<ThreadsResponse>(threadsQueryKey(mark.factoryId), (prev) =>
-    prev
-      ? {
-          data: prev.data.map((t) =>
-            t.key === mark.thread && t.last_seq <= mark.lastSeq ? { ...t, unread: 0 } : t,
-          ),
-        }
-      : prev,
+  // Both lists: the Room's, and cockpit v3's with the per-node threads.
+  queryClient.setQueriesData<ThreadsResponse>(
+    { queryKey: threadsQueryKey(mark.factoryId) },
+    (prev) =>
+      prev
+        ? {
+            data: prev.data.map((t) =>
+              t.key === mark.thread && t.last_seq <= mark.lastSeq ? { ...t, unread: 0 } : t,
+            ),
+          }
+        : prev,
   );
 }
 
@@ -294,8 +307,12 @@ export function useMarkThreadRead(
   channel: ReadChannel | null,
 ): void {
   const queryClient = useQueryClient();
-  const threads = queryClient.getQueryData<ThreadsResponse>(threadsQueryKey(factoryId));
-  const unread = threads?.data.find((t) => t.key === thread)?.unread ?? 0;
+  const unread = queryClient
+    .getQueriesData<ThreadsResponse>({ queryKey: threadsQueryKey(factoryId) })
+    .reduce((most, [, threads]) => {
+      const found = threads?.data.find((t) => t.key === thread)?.unread ?? 0;
+      return Math.max(most, found);
+    }, 0);
   useEffect(() => {
     if (!active || !thread || newestSeq <= 0) return;
     if (typeof document !== "undefined" && document.visibilityState === "hidden") return;
diff --git a/web/src/components/factory/team/teamQueries.ts b/web/src/components/factory/team/teamQueries.ts
index 929451257c9..b4c444e305d 100644
--- a/web/src/components/factory/team/teamQueries.ts
+++ b/web/src/components/factory/team/teamQueries.ts
@@ -89,10 +89,12 @@ export function useTeamPreview(
   );
   const settled =
     body === JSON.stringify({ changes, when, base_version: baseVersion ?? undefined });
+  // What is sent is the settled body: the first pick waits for it, never sending no changes.
+  const sends = (JSON.parse(body) as { changes: unknown[] }).changes.length > 0;
   const query = useQuery<DefinitionPreviewResponse>({
     queryKey: teamKey(factoryId, "preview", body),
     queryFn: () => previewFactoryDefinition(factoryId, JSON.parse(body)),
-    enabled: Boolean(factoryId) && changes.length > 0,
+    enabled: Boolean(factoryId) && changes.length > 0 && sends,
     placeholderData: keepPreviousData,
     staleTime: 30_000,
     retry: retryTransient,
diff --git a/web/src/components/factory/v3/LinkChip.tsx b/web/src/components/factory/v3/LinkChip.tsx
index ec11cc13d09..da777ba0801 100644
--- a/web/src/components/factory/v3/LinkChip.tsx
+++ b/web/src/components/factory/v3/LinkChip.tsx
@@ -28,11 +28,12 @@ function toneClass(tone: Chip["tone"]): string {
 
 function ChipBody({ chip }: { chip: Chip }) {
   const quiet = chip.tone ? "opacity-80" : "text-foreground-tertiary";
+  // A chip wider than its row ends in "…" (its parts shrink; the kind stays).
   return (
     <>
-      {chip.kind && <span className={quiet}>{chip.kind}</span>}
-      <span>{chip.title}</span>
-      {chip.state && <span className={quiet}>· {chip.state}</span>}
+      {chip.kind && <span className={cn(quiet, "shrink-0")}>{chip.kind}</span>}
+      <span className="min-w-0 truncate">{chip.title}</span>
+      {chip.state && <span className={cn(quiet, "min-w-0 truncate")}>· {chip.state}</span>}
     </>
   );
 }
@@ -49,7 +50,13 @@ export function LinkChip({
 }) {
   if (chip.ref && !chip.list) {
     return (
-      <NodeLink nodeRef={chip.ref} title={chip.reason} className={cn(CHIP, toneClass(chip.tone))}>
+      <NodeLink
+        nodeRef={chip.ref}
+        title={chip.reason}
+        data-testid="v3-chip"
+        data-kind={chip.kind}
+        className={cn(CHIP, toneClass(chip.tone))}
+      >
         <ChipBody chip={chip} />
       </NodeLink>
     );
@@ -61,6 +68,8 @@ export function LinkChip({
         aria-expanded={open}
         onClick={onToggle}
         title={chip.reason}
+        data-testid="v3-chip"
+        data-kind={chip.kind}
         className={cn(CHIP, "cursor-pointer", toneClass(chip.tone))}
       >
         <ChipBody chip={chip} />
@@ -68,7 +77,12 @@ export function LinkChip({
     );
   }
   return (
-    <span title={chip.reason} className={cn(CHIP, toneClass(chip.tone))}>
+    <span
+      title={chip.reason}
+      data-testid="v3-chip"
+      data-kind={chip.kind}
+      className={cn(CHIP, toneClass(chip.tone))}
+    >
       <ChipBody chip={chip} />
     </span>
   );
diff --git a/web/src/components/factory/v3/chat/ChatCards.tsx b/web/src/components/factory/v3/chat/ChatCards.tsx
index 1b5354381bf..cdbc019a377 100644
--- a/web/src/components/factory/v3/chat/ChatCards.tsx
+++ b/web/src/components/factory/v3/chat/ChatCards.tsx
@@ -5,6 +5,7 @@
 
 import { useState } from "react";
 import { cn } from "@/lib/utils";
+import { undoLabel } from "../../steer/steerModel";
 import { DecisionButtons } from "../DecisionButtons";
 import { AMBER } from "../nodeTokens";
 import type { DecisionRef } from "../nodeTypes";
@@ -143,3 +144,43 @@ export function AskCard({ decision }: { decision: DecisionRef }) {
     </section>
   );
 }
+
+/**
+ * A verb applied from the cockpit, in its node's thread: what it did and, for
+ * its 10 minutes, its Undo (the same token as the toast's, so it still works
+ * after a reload). An undone one says so in the card after it.
+ */
+export function AppliedCard({
+  text,
+  leftS,
+  busy,
+  onUndo,
+}: {
+  text: string;
+  /** Seconds its Undo is open; none once it closed or ran. */
+  leftS?: number | null;
+  busy?: boolean;
+  onUndo?: () => void;
+}) {
+  const open = leftS != null && leftS > 0 && onUndo;
+  return (
+    <section
+      data-testid="v3-applied"
+      data-undo={open ? "open" : undefined}
+      className={cn(CARD, "flex-row flex-wrap items-baseline gap-x-2 border-border bg-muted/30")}
+    >
+      <span className="min-w-0 flex-1 text-muted-foreground [overflow-wrap:anywhere]">{text}</span>
+      {open && (
+        <button
+          type="button"
+          data-testid="v3-applied-undo"
+          disabled={busy}
+          onClick={onUndo}
+          className={cn(BTN, "border-border-strong bg-card-solid hover:border-status-blue")}
+        >
+          {undoLabel(leftS ?? 0)}
+        </button>
+      )}
+    </section>
+  );
+}
diff --git a/web/src/components/factory/v3/chat/NodeChat.test.tsx b/web/src/components/factory/v3/chat/NodeChat.test.tsx
index 68b7d5be770..3af209c6d9d 100644
--- a/web/src/components/factory/v3/chat/NodeChat.test.tsx
+++ b/web/src/components/factory/v3/chat/NodeChat.test.tsx
@@ -4,6 +4,7 @@ import userEvent from "@testing-library/user-event";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type { ChatMessageView } from "@/lib/factoryApi";
 import { type FakeFetch, renderChat } from "../fixture/renderChat";
+import { sampleNodeSource } from "../fixture/sampleNodeSource";
 import { sampleRoomMessages } from "../fixture/sampleRoom";
 import { CHAT_WIDTH_KEY, createNodeChatSlot } from "./chatLayout";
 
@@ -389,6 +390,90 @@ describe("cockpit v3 · the node chat column", () => {
     expect(empty).toEqual([]);
   });
 
+  it("on a phone, a verb from the full-screen chat closes it and opens its preview on the page", async () => {
+    setWindow("phone");
+    const view = renderChat("assistant-panel-ux", { install, search: "?chat=1" });
+    const full = await screen.findByTestId("v3-chat-full", {}, { timeout: 4000 });
+    await userEvent.setup().click(await within(full).findByTestId("v3-chat-quick-start"));
+    await waitFor(() => expect(screen.queryByTestId("v3-chat-full")).toBeNull());
+    expect(view.search()).not.toContain("chat=1");
+    expect(await screen.findByTestId("v3-preview")).toHaveAttribute("data-label", "Start now");
+  });
+
+  it("reads the per-node threads for its children's news (`?nodes=1`)", async () => {
+    setWindow("desktop");
+    const paths: string[] = [];
+    renderChat("I-1", {
+      install: (f) => {
+        install(((path: string, init?: RequestInit) => {
+          paths.push(path);
+          return f(path, init);
+        }) as FakeFetch);
+      },
+      nodeThreads: true,
+    });
+    await waitFor(() => expect(paths.some((p) => p.endsWith("/chat/threads?nodes=1"))).toBe(true));
+  });
+
+  it("draws a verb's card with its Undo while its token is open and unused", async () => {
+    setWindow("desktop");
+    const base = sampleRoomMessages();
+    const like = base.find((m) => m.thread === "project:assistant-core")!;
+    const now = Math.floor(Date.now() / 1000);
+    const card = (id: string, seq: number, body: string, meta: Record<string, unknown>) => ({
+      ...like,
+      id,
+      seq,
+      author_kind: "system" as const,
+      author: "server",
+      author_title: null,
+      body,
+      card: {
+        type: "preview_applied" as const,
+        ref: "assistant-core",
+        id: null,
+        meta: { kind: "preview_applied" as const, verb: "add", ...meta },
+      },
+    });
+    const extra: ChatMessageView[] = [
+      card("m-old", 900, "Lena added Usage (C-30).", {
+        undo_token: "tok-old",
+        undo_until: now + 400,
+      }),
+      card("m-old-undone", 901, "Undone by Lena: Lena added Usage (C-30).", {
+        undone: true,
+        undo_token: "tok-old",
+      }),
+      card("m-new", 902, "Lena added Docs (C-31).", {
+        label: "Add a task under assistant-core",
+        undo_token: "tok-new",
+        undo_until: now + 400,
+      }),
+      card("m-closed", 903, "Lena added Notes (C-32).", {
+        undo_token: "tok-x",
+        undo_until: now - 5,
+      }),
+    ];
+    const sample = sampleNodeSource();
+    const undo = vi.fn(async () => undefined);
+    renderChat("assistant-core", {
+      install,
+      messages: [...base, ...extra],
+      source: { ...sample, undo },
+    });
+    const list = await screen.findByTestId("room-message-list", {}, { timeout: 4000 });
+    await waitFor(() => expect(within(list).getAllByTestId("v3-applied")).toHaveLength(4));
+    const open = within(list).getAllByTestId("v3-applied-undo");
+    // Only the newest one: the first was undone, the last one's ten minutes are over.
+    expect(open).toHaveLength(1);
+    expect(open[0]).toHaveTextContent("Undo (7 min left)");
+    expect(open[0]!.closest('[data-testid="v3-applied"]')).toHaveTextContent(
+      "Lena added Docs (C-31).",
+    );
+    await userEvent.setup().click(open[0]!);
+    await waitFor(() => expect(undo).toHaveBeenCalledWith(expect.any(String), "tok-new"));
+  });
+
   it("lists the node's verbs after / (the answer opens the card) and quick verbs above the box", async () => {
     setWindow("desktop");
     const onVerb = vi.fn();
diff --git a/web/src/components/factory/v3/chat/NodeChat.tsx b/web/src/components/factory/v3/chat/NodeChat.tsx
index 3d95d02e519..4fee7626ef3 100644
--- a/web/src/components/factory/v3/chat/NodeChat.tsx
+++ b/web/src/components/factory/v3/chat/NodeChat.tsx
@@ -39,13 +39,14 @@ import { swallowEnter } from "../DecisionButtons";
 import { useNodeActions } from "../NodeContext";
 import { Avatar, Kbd } from "../nodeParts";
 import { useNode } from "../nodeQueries";
+import { useUndoToken } from "../nodeSteer";
 import { nodeHref } from "../nodeRoutes";
 import { AMBER, STATE_WORDS } from "../nodeTokens";
 import type { DecisionRef, NodePage, StatusLine, VerbArgs } from "../nodeTypes";
 import { levelName } from "../nodeWire";
 import { statusText } from "../statusModel";
 import { WhyCard } from "../WhyCard";
-import { AskCard, ClosedAlarmCard, OfferCard } from "./ChatCards";
+import { AppliedCard, AskCard, ClosedAlarmCard, OfferCard } from "./ChatCards";
 import { CHAT_BESIDE_QUERY, CHAT_PARAM, useChatWidth, useNodeChatSlot } from "./chatLayout";
 import { parseIntent } from "./chatIntents";
 import {
@@ -157,12 +158,53 @@ function OfferOf({
  * it cannot draw (its node loading or gone, an alarm it knows nothing of)
  * shows `fallback`, the message's own line, so it never renders empty.
  */
+/** What a verb's card needs to offer its Undo: the tokens already undone, now, and how. */
+interface AppliedUndo {
+  undone: ReadonlySet<string>;
+  nowS: number;
+  run: ((token: string, label: string) => Promise<void>) | null;
+}
+
+/** A verb's card: what it did, and its Undo while the token is open and not yet used. */
+function AppliedOf({
+  message,
+  applied,
+  fallback,
+}: {
+  message: ChatMessageView;
+  applied: AppliedUndo;
+  fallback: ReactNode;
+}) {
+  const [busy, setBusy] = useState(false);
+  const meta = message.card?.meta?.kind === "preview_applied" ? message.card.meta : null;
+  if (!meta) return fallback;
+  const token = meta.undone ? null : (meta.undo_token ?? null);
+  const open = token && !applied.undone.has(token) && applied.run;
+  const left = open && meta.undo_until ? meta.undo_until - applied.nowS : null;
+  return (
+    <AppliedCard
+      text={message.body}
+      leftS={left}
+      busy={busy}
+      onUndo={
+        open && token
+          ? () => {
+              setBusy(true);
+              void applied.run!(token, meta.label ?? meta.verb).finally(() => setBusy(false));
+            }
+          : undefined
+      }
+    />
+  );
+}
+
 function NodeMessageCard({
   message,
   attached,
   chat,
   here,
   onVerb,
+  applied,
   fallback,
 }: {
   message: ChatMessageView;
@@ -170,6 +212,7 @@ function NodeMessageCard({
   chat: NodePage;
   here: NodePage;
   onVerb: (verb: string, at: string) => void;
+  applied: AppliedUndo;
   fallback: ReactNode;
 }) {
   const { snapshot } = useFactoryShell();
@@ -177,6 +220,8 @@ function NodeMessageCard({
   if (!card) return fallback;
   const nodeRef = card.ref ?? chat.node.ref;
   switch (card.type) {
+    case "preview_applied":
+      return <AppliedOf message={message} applied={applied} fallback={fallback} />;
     case "why":
       return <WhyOf nodeRef={nodeRef} chat={chat} here={here} fallback={fallback} />;
     case "offer":
@@ -293,7 +338,8 @@ export function NodeChat({ page: here, sample = false }: NodeChatProps) {
   const owner = useNode(ownerRef === here.node.ref ? "" : ownerRef, fid);
   const chat = ownerRef === here.node.ref ? here : (owner.data ?? here);
   const perNode = usePreflight().data?.node_threads === true;
-  const threads = useRoomThreads(fid).data?.data ?? null;
+  // With the per-node threads (`?nodes=1`): a child's own thread can have news.
+  const threads = useRoomThreads(fid, { nodes: perNode }).data?.data ?? null;
   const thread = nodeThread(chat, { snapshot, threads, perNode, sample });
   const room = threads?.find((t) => t.key === thread.key) ?? null;
   // Who answers the thread the chat actually posts to: the node's own
@@ -405,6 +451,9 @@ export function NodeChat({ page: here, sample = false }: NodeChatProps) {
       }
       const v = at === here.node.ref ? here.verbs.find((x) => x.verb === verb && x.enabled) : null;
       if (v) {
+        // The preview opens on the page: a full-screen chat (a phone) steps
+        // back to it first, or the preview would open out of sight.
+        if (full) latestClose.current();
         // Always with an object: the preview then leaves focus in this box.
         actions.onVerb?.(v, args ?? {});
         return;
@@ -413,7 +462,7 @@ export function NodeChat({ page: here, sample = false }: NodeChatProps) {
       for (const [k, value] of Object.entries(args ?? {})) if (value) search.set(k, value);
       navigate(`${nodeHref(fid, at)}?${search.toString()}`);
     },
-    [actions, fid, here.node.ref, here.verbs, navigate],
+    [actions, fid, full, here.node.ref, here.verbs, navigate],
   );
 
   const decision = chat.status.ends === "person" ? (chat.status.decision ?? null) : null;
@@ -538,6 +587,28 @@ export function NodeChat({ page: here, sample = false }: NodeChatProps) {
     </li>
   ));
 
+  // A verb's card offers its Undo until it ran: the server's "undone" card names its token.
+  const messages = useRoomMessages(fid, thread.key);
+  const undoToken = useUndoToken(fid);
+  // "Now" on the server's clock, every 15 s: "Undo (n min left)" counts down and goes at 0.
+  const [nowS, setNowS] = useState(() => Math.floor(Date.now() / 1000 + clockOffsetS));
+  useEffect(() => {
+    const read = () => setNowS(Math.floor(Date.now() / 1000 + clockOffsetS));
+    read();
+    const timer = setInterval(read, 15_000);
+    return () => clearInterval(timer);
+  }, [clockOffsetS]);
+  const applied = useMemo<AppliedUndo>(() => {
+    const undone = new Set<string>();
+    for (const m of flattenPages(messages.data)) {
+      const meta = m.card?.type === "preview_applied" ? m.card.meta : null;
+      if (meta?.kind === "preview_applied" && meta.undone && meta.undo_token) {
+        undone.add(meta.undo_token);
+      }
+    }
+    return { undone, nowS, run: undoToken };
+  }, [messages.data, nowS, undoToken]);
+
   const renderCard = useCallback(
     (message: ChatMessageView, attached: boolean, fallback: ReactNode) => (
       <NodeMessageCard
@@ -546,10 +617,11 @@ export function NodeChat({ page: here, sample = false }: NodeChatProps) {
         chat={chat}
         here={here}
         onVerb={(verb, at) => runVerb(verb, at)}
+        applied={applied}
         fallback={fallback}
       />
     ),
-    [chat, here, runVerb],
+    [applied, chat, here, runVerb],
   );
 
   const threadView = (autoFocus: boolean, className: string) => (
diff --git a/web/src/components/factory/v3/fixture/renderChat.tsx b/web/src/components/factory/v3/fixture/renderChat.tsx
index 02e61487e13..2bbdfe9acd7 100644
--- a/web/src/components/factory/v3/fixture/renderChat.tsx
+++ b/web/src/components/factory/v3/fixture/renderChat.tsx
@@ -16,7 +16,7 @@ import { type NodeChatSlot, NodeChatSlotContext } from "../chat/chatLayout";
 import type { NodeActions } from "../NodeContext";
 import { NodePage } from "../NodePage";
 import { nodeHref } from "../nodeRoutes";
-import { NodeSourceProvider } from "../nodeSource";
+import { type NodeSource, NodeSourceProvider } from "../nodeSource";
 import { sampleRoomRoutes, sampleRoomSnapshot } from "./sampleRoom";
 import { type SampleOptions, sampleNodeSource } from "./sampleNodeSource";
 
@@ -129,6 +129,10 @@ export function renderChat(
     messages?: ChatMessageView[];
     /** The page says its nodes are the sample's, not this factory's (`chat.sample`). */
     sampleNodes?: boolean;
+    /** The node source (default: the sample's with these options). */
+    source?: NodeSource;
+    /** The server routes the per-node threads (preflight `node_threads`). */
+    nodeThreads?: boolean;
     install: (fetch: FakeFetch) => void;
   },
 ) {
@@ -138,18 +142,23 @@ export function renderChat(
     search: query = "",
     messages,
     sampleNodes = false,
+    source,
+    nodeThreads,
     install,
     ...sample
   } = options;
   const snapshot = sampleRoomSnapshot();
-  const fetch = fetchOf(sampleRoomRoutes({ snapshot, messages, ...sample }), snapshot.factory.id);
+  const fetch = fetchOf(
+    sampleRoomRoutes({ snapshot, messages, nodeThreads, ...sample }),
+    snapshot.factory.id,
+  );
   install(fetch);
   const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
   const shell = shellOf(snapshot);
   const chatSlot = slot ?? null;
   const view = render(
     <QueryClientProvider client={client}>
-      <NodeSourceProvider source={sampleNodeSource(sample)}>
+      <NodeSourceProvider source={source ?? sampleNodeSource(sample)}>
         <MemoryRouter initialEntries={[`${nodeHref(FID, nodeRef)}${query}`]}>
           <FactoryShellContext.Provider value={shell}>
             <NodeChatSlotContext.Provider value={chatSlot}>
diff --git a/web/src/components/factory/v3/fixture/renderNode.tsx b/web/src/components/factory/v3/fixture/renderNode.tsx
index cad7838ef1d..a9bbfd28261 100644
--- a/web/src/components/factory/v3/fixture/renderNode.tsx
+++ b/web/src/components/factory/v3/fixture/renderNode.tsx
@@ -9,6 +9,7 @@ import { FactoryToastProvider } from "../../ui/Toast";
 import { NodePage, type NodePageProps } from "../NodePage";
 import { nodeHref } from "../nodeRoutes";
 import { type NodeSource, NodeSourceProvider } from "../nodeSource";
+import { useAnswerAsk } from "../nodeSteer";
 import { V3Sheets } from "../sheets/V3Sheets";
 import { useLocation, useParams } from "@/lib/routing";
 import { type SampleOptions, sampleNodeSource } from "./sampleNodeSource";
@@ -25,15 +26,17 @@ function Probe() {
   return null;
 }
 
-function Routed({ actions }: { actions?: NodePageProps["actions"] }) {
+function Routed({ actions, answers }: { actions?: NodePageProps["actions"]; answers?: boolean }) {
   const { ref = "product", level } = useParams<{ ref: string; level?: string }>();
+  // As the cockpit answers: through the source, with the Undo of an applied proposal.
+  const answer = useAnswerAsk(ref, { factoryId: TEST_FID });
   return (
     <NodePage
       key={`${ref}/${level ?? ""}`}
       factoryId={TEST_FID}
       nodeRef={ref}
       level={level ?? null}
-      actions={actions}
+      actions={answers ? { onAnswer: answer, ...actions } : actions}
     />
   );
 }
@@ -46,9 +49,11 @@ export function renderNode(
     source?: NodeSource;
     /** The address's query (`?verb=add&title=…`, `?peek=needs`). */
     query?: string;
+    /** Answers go through the source as the cockpit's do (`useAnswerAsk`). */
+    answers?: boolean;
   } = {},
 ) {
-  const { level, actions, source: given, query = "", ...sample } = options;
+  const { level, actions, source: given, query = "", answers, ...sample } = options;
   const source = given ?? sampleNodeSource(sample);
   const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
   const view = render(
@@ -57,10 +62,13 @@ export function renderNode(
         <MemoryRouter initialEntries={[`${nodeHref(TEST_FID, nodeRef, level)}${query}`]}>
           <FactoryToastProvider>
             <Routes>
-              <Route path="/factory/:factoryId/n/:ref" element={<Routed actions={actions} />} />
+              <Route
+                path="/factory/:factoryId/n/:ref"
+                element={<Routed actions={actions} answers={answers} />}
+              />
               <Route
                 path="/factory/:factoryId/n/:ref/:level"
-                element={<Routed actions={actions} />}
+                element={<Routed actions={actions} answers={answers} />}
               />
             </Routes>
             <V3Sheets factoryId={TEST_FID} />
diff --git a/web/src/components/factory/v3/fixture/sampleNodeSource.ts b/web/src/components/factory/v3/fixture/sampleNodeSource.ts
index eae8d74d1b5..58e10d12e8f 100644
--- a/web/src/components/factory/v3/fixture/sampleNodeSource.ts
+++ b/web/src/components/factory/v3/fixture/sampleNodeSource.ts
@@ -55,6 +55,7 @@ export function sampleNodeSource(
     answer: async (_fid, decision, action) => {
       engine.answer(decision.id, action.label);
     },
+    undoAnswer: async (_fid, decision) => engine.unanswer(decision.id),
     preview: async (_fid, ref, request) => engine.preview(ref, request),
     apply: async (_fid, ref, request) => engine.apply(ref, request),
     undo: async (_fid, token) => engine.undo(token),
diff --git a/web/src/components/factory/v3/fixture/sampleRoom.ts b/web/src/components/factory/v3/fixture/sampleRoom.ts
index a6288260ccf..3566c41d934 100644
--- a/web/src/components/factory/v3/fixture/sampleRoom.ts
+++ b/web/src/components/factory/v3/fixture/sampleRoom.ts
@@ -319,9 +319,14 @@ export function sampleRoomPreflight(nodeThreads = false): Preflight {
 
 /** Every route the node chat reads: the Room, the node API and preflight, under the sample snapshot's id. */
 export function sampleRoomRoutes(
-  options: SampleOptions & { snapshot?: FactorySnapshot; messages?: ChatMessageView[] } = {},
+  options: SampleOptions & {
+    snapshot?: FactorySnapshot;
+    messages?: ChatMessageView[];
+    /** The server routes the per-node threads (preflight `node_threads`). */
+    nodeThreads?: boolean;
+  } = {},
 ): StoryRoutes {
-  const { snapshot = sampleRoomSnapshot(), messages, ...sample } = options;
+  const { snapshot = sampleRoomSnapshot(), messages, nodeThreads = false, ...sample } = options;
   const fid = snapshot.factory.id;
   return {
     ...roomRoutes(fid, {
@@ -330,7 +335,7 @@ export function sampleRoomRoutes(
       proposals: [],
     }),
     ...sampleNodeRoutes(fid, sample),
-    "/v1/factory/preflight": { body: sampleRoomPreflight() },
+    "/v1/factory/preflight": { body: sampleRoomPreflight(nodeThreads) },
     [`/v1/factory/factories/${fid}/notify/me/ui`]: { body: { cockpit: "v2" } },
   };
 }
diff --git a/web/src/components/factory/v3/fixture/sampleSteer.ts b/web/src/components/factory/v3/fixture/sampleSteer.ts
index 465623001dd..821a85ff19e 100644
--- a/web/src/components/factory/v3/fixture/sampleSteer.ts
+++ b/web/src/components/factory/v3/fixture/sampleSteer.ts
@@ -56,6 +56,15 @@ function text(value: VerbRequest["args"][string]): string {
   return typeof value === "string" ? value.trim() : "";
 }
 
+/** What a new child waits on: the first ref of `depends_on`, and its reason from `depends_why`. */
+function dependsOn(args: VerbRequest["args"]): { ref: string; why: string } {
+  const list = args.depends_on;
+  const ref = Array.isArray(list) ? (list[0] ?? "").trim() : text(list);
+  const why = args.depends_why;
+  const reason = why && typeof why === "object" && !Array.isArray(why) ? why[ref] : undefined;
+  return { ref, why: typeof reason === "string" ? reason.trim() : "" };
+}
+
 /** A sample engine that also previews and applies verbs, ranks asks, finds nodes and keeps marks. */
 export class SampleSteerEngine extends SampleLensEngine {
   private undos = new Map<string, string>();
@@ -350,8 +359,9 @@ export class SampleSteerEngine extends SampleLensEngine {
         const held = this.heldMatch(n, title);
         const laterNow = this.kids(n.id).filter((k) => k.state === "later").length;
         const who = this.responder(n) ?? "Atlas";
-        const dep = this.N(text(request.args.depends_on));
-        const because = text(request.args.because);
+        const wanted = dependsOn(request.args);
+        const dep = this.N(wanted.ref);
+        const because = wanted.why;
         const progress =
           n.lvl === "feature"
             ? `build progress gets one more unplanned ${noun} (its ring has a dashed tail until its lead plans it).`
@@ -674,17 +684,18 @@ export class SampleSteerEngine extends SampleLensEngine {
 
   // ── Apply and Undo ───────────────────────────────────────────
 
+  private snapshot(): string {
+    return JSON.stringify({
+      nodes: this.data.nodes,
+      decisions: this.data.decisions,
+      trees: this.data.trees,
+    });
+  }
+
   private save(): string {
     this.seq += 1;
     const token = `u-${this.seq}`;
-    this.undos.set(
-      token,
-      JSON.stringify({
-        nodes: this.data.nodes,
-        decisions: this.data.decisions,
-        trees: this.data.trees,
-      }),
-    );
+    this.undos.set(token, this.snapshot());
     return token;
   }
 
@@ -709,10 +720,8 @@ export class SampleSteerEngine extends SampleLensEngine {
         }
         const to = colArg(request.args.col) ?? 0;
         const held = this.heldMatch(n, title);
-        const dep = text(request.args.depends_on);
-        const waits: RawWait[] = dep
-          ? [{ kind: "dep", to: dep, why: text(request.args.because) || undefined }]
-          : [];
+        const { ref: dep, why } = dependsOn(request.args);
+        const waits: RawWait[] = dep ? [{ kind: "dep", to: dep, why: why || undefined }] : [];
         const L = this.levels(n.tree)[this.lvlIdx(n) + 1]!;
         if (held && to !== "later") {
           Object.assign(held, {
@@ -829,6 +838,19 @@ export class SampleSteerEngine extends SampleLensEngine {
     };
   }
 
+  /** Answer a decision, keeping the factory as it was so the answer can be taken back. */
+  override answer(decisionId: string, actionLabel: string): boolean {
+    const before = this.snapshot();
+    const done = super.answer(decisionId, actionLabel);
+    if (done) this.undos.set(`answer:${decisionId}`, before);
+    return done;
+  }
+
+  /** Take an answer back (the proposal it applied is undone): the factory as it was before it. */
+  unanswer(decisionId: string): void {
+    this.undo(`answer:${decisionId}`);
+  }
+
   undo(token: string): void {
     const saved = this.undos.get(token);
     if (!saved) {
diff --git a/web/src/components/factory/v3/nodeParts.tsx b/web/src/components/factory/v3/nodeParts.tsx
index e7c420dee32..20399edd79c 100644
--- a/web/src/components/factory/v3/nodeParts.tsx
+++ b/web/src/components/factory/v3/nodeParts.tsx
@@ -196,6 +196,8 @@ export function NodeLink({
   className,
   children,
   title,
+  "data-testid": testId,
+  "data-kind": kind,
 }: {
   nodeRef: string;
   level?: string | null;
@@ -203,6 +205,8 @@ export function NodeLink({
   className?: string;
   children: ReactNode;
   title?: string;
+  "data-testid"?: string;
+  "data-kind"?: string;
 }) {
   const { factoryId, prefetch } = useNodeActions();
   const ahead = (_event: MouseEvent | FocusEvent) => prefetch?.(nodeRef);
@@ -214,6 +218,8 @@ export function NodeLink({
       onFocus={ahead}
       title={title}
       {...(roving ? { "data-node-link": nodeRef } : {})}
+      data-testid={testId}
+      data-kind={kind}
       className={className}
     >
       {children}
diff --git a/web/src/components/factory/v3/nodeSource.ts b/web/src/components/factory/v3/nodeSource.ts
index 82408191537..ea5b292592e 100644
--- a/web/src/components/factory/v3/nodeSource.ts
+++ b/web/src/components/factory/v3/nodeSource.ts
@@ -7,11 +7,11 @@
 // Steering (verb previews with apply and Undo, Needs you, Find, last-look
 // marks) is optional on a source: a panel that needs a route the source lacks
 // falls back (a toast, the older Needs you list, the snapshot's search). The
-// live source gains each route once its endpoint is on the server
-// (`SERVED_STEER`).
+// live source carries every route the server serves (`SERVED_STEER`).
 
 import { type ReactNode, createContext, createElement, useContext } from "react";
 import { answerDecision, factoryErrorFromResponse } from "@/lib/factoryApi";
+import { undoProposal } from "@/lib/factoryRoomApi";
 import { authenticatedFetch } from "@/lib/identity";
 import type {
   DecisionAction,
@@ -62,6 +62,12 @@ export interface NodeSource {
   ) => Promise<LevelView | null>;
   /** Answer a decision with one of its actions. */
   answer: (factoryId: string, decision: DecisionRef, action: DecisionAction) => Promise<void>;
+  /**
+   * Take back an answer that applied a proposal ("Apply C-16"), within its
+   * window: the proposal's own Undo (`POST …/proposals/{C-n}/undo`). Only for
+   * answers `answerProposal` names.
+   */
+  undoAnswer?: (factoryId: string, decision: DecisionRef, action: DecisionAction) => Promise<void>;
   /** A verb's dry run: nothing changes (`POST …/n/{ref}/preview`). */
   preview?: (
     factoryId: string,
@@ -170,15 +176,19 @@ export const steerRoutes: SteerRoutes = {
 };
 
 /**
- * The steering routes this server has. Each joins the live source once its
- * endpoint is on staging; until then the panels fall back.
- *
- * TODO(S12): `preview`, `apply`, `undo` once `POST …/n/{ref}/preview|apply` and
- * `POST …/undo/{token}` land.
- * TODO(S9): `needsYou`, `find` once `GET …/needs-you` and `GET …/find` land.
- * TODO(S10): `seen` once `PUT …/n/{ref}/seen` lands.
+ * The steering routes this server has: every one api.md §3.8 and §4 names is
+ * on the server (S9 Needs you and Find, S10 last look, S12 preview, apply and
+ * Undo), so the live source carries them all. A source without one (an
+ * older server behind a story) still falls back where a panel needs it.
  */
-export const SERVED_STEER: readonly (keyof SteerRoutes)[] = [];
+export const SERVED_STEER: readonly (keyof SteerRoutes)[] = [
+  "preview",
+  "apply",
+  "undo",
+  "needsYou",
+  "find",
+  "seen",
+];
 
 function served(): Partial<NodeSource> {
   return Object.fromEntries(
@@ -227,8 +237,22 @@ export const liveNodeSource: NodeSource = {
     // The answer route takes the decision's row id; `id` is its ref ("D-45").
     await answerDecision(decision.row_id ?? decision.id, { option_id: action.id });
   },
+  undoAnswer: async (fid, decision, action) => {
+    const proposal = answerProposal(decision, action);
+    if (!proposal) throw new Error(`${decision.id}: ${action.label} cannot be undone here.`);
+    await undoProposal(fid, proposal);
+  },
 };
 
+/**
+ * The proposal an answer applies, which its own Undo takes back ("C-16" for
+ * Apply on D-45, whose subject is C-16), else null: other answers stand.
+ */
+export function answerProposal(decision: DecisionRef, action: DecisionAction): string | null {
+  const subject = decision.subject ?? "";
+  return action.id === "apply" && /^C-\d+$/.test(subject) ? subject : null;
+}
+
 const NodeSourceContext = createContext<NodeSource | null>(null);
 
 export function NodeSourceProvider({
diff --git a/web/src/components/factory/v3/nodeSteer.test.tsx b/web/src/components/factory/v3/nodeSteer.test.tsx
index 58b3dae582f..85abe8de60c 100644
--- a/web/src/components/factory/v3/nodeSteer.test.tsx
+++ b/web/src/components/factory/v3/nodeSteer.test.tsx
@@ -128,11 +128,11 @@ describe("cockpit v3 · since last look (W10)", () => {
 });
 
 describe("cockpit v3 · the steering routes (api.md §3.8, §4)", () => {
-  it("are not on the live source until each endpoint lands", () => {
-    expect(SERVED_STEER).toEqual([]);
-    for (const name of ["preview", "apply", "undo", "needsYou", "find", "seen"] as const) {
-      expect(liveNodeSource[name]).toBeUndefined();
-    }
+  it("are all on the live source: the server serves every one", () => {
+    const names = ["preview", "apply", "undo", "needsYou", "find", "seen"] as const;
+    expect([...SERVED_STEER].sort()).toEqual([...names].sort());
+    for (const name of names) expect(liveNodeSource[name]).toBe(steerRoutes[name]);
+    expect(liveNodeSource.undoAnswer).toBeTypeOf("function");
   });
 
   it("send what api.md names: preview, apply with the preview id, undo by token, seen", async () => {
diff --git a/web/src/components/factory/v3/nodeSteer.ts b/web/src/components/factory/v3/nodeSteer.ts
index e43f947bf59..901aa5da582 100644
--- a/web/src/components/factory/v3/nodeSteer.ts
+++ b/web/src/components/factory/v3/nodeSteer.ts
@@ -26,9 +26,17 @@ import { UNDO_WINDOW_S, undoLeft, versionRows } from "../steer/steerModel";
 import { useDebounced } from "../team/teamQueries";
 import { useFactoryToast } from "../ui/Toast";
 import { useNodeActions } from "./NodeContext";
-import { NODE_STALE_MS, nodeQueryKeys } from "./nodeQueries";
-import { useNodeSource } from "./nodeSource";
-import type { NodePage, NodeSummary, Rollup, VerbPreview, VerbRequest } from "./nodeTypes";
+import { NODE_STALE_MS, nodeQueryKeys, useAnswerDecision } from "./nodeQueries";
+import { answerProposal, useNodeSource } from "./nodeSource";
+import type {
+  DecisionAction,
+  DecisionRef,
+  NodePage,
+  NodeSummary,
+  Rollup,
+  VerbPreview,
+  VerbRequest,
+} from "./nodeTypes";
 
 /** Typing in a preview's form reads the preview again once it pauses. */
 export const PREVIEW_DEBOUNCE_MS = 250;
@@ -102,6 +110,8 @@ export interface NodeUndo {
   /** Epoch ms after which it cannot be undone (a version's own time wins, see `version`). */
   expiresAt: number;
   run: () => Promise<unknown>;
+  /** The server's Undo token (`POST …/undo/{token}`), when it has one: its card in the thread carries it too. */
+  token?: string;
   /**
    * It re-pins a definition version: offered only while `version.version` is
    * the version in force and was made from `version.parent`, for the window
@@ -135,6 +145,14 @@ export function forgetUndo(fid: string, ref: string, undo?: NodeUndo): void {
   notify();
 }
 
+/** Forget the Undo whose server token is `token` (it ran from its card in the thread). */
+export function forgetUndoToken(fid: string, token: string): void {
+  for (const [key, undo] of undos) {
+    if (key.startsWith(`${fid}/`) && undo.token === token) undos.delete(key);
+  }
+  notify();
+}
+
 /** Forget every Undo (tests). */
 export function resetNodeUndos(): void {
   undos.clear();
@@ -282,6 +300,11 @@ export function useVersionUndo(ref: string, factoryId?: string) {
   );
 }
 
+/** Words for why something failed. */
+function errorWords(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 /** "Not applied: …", from a refused write (409 stale, 422 wrong level, 403 with who may). */
 export function refusal(error: unknown): string {
   const message = error instanceof Error ? error.message : String(error);
@@ -335,12 +358,10 @@ export function useApplyVerb(page: NodePage, factoryId?: string) {
       void refresh();
       const token = applied.undo?.token;
       const undoFn = source?.undo;
-      const message = [
-        applied.message ?? `${label}: applied`,
-        applied.filed && `Filed ${applied.filed}.`,
-      ]
-        .filter(Boolean)
-        .join(". ");
+      const said = (applied.message ?? `${label}: applied`).trim();
+      const filed =
+        applied.filed && !said.includes(applied.filed) ? ` Filed ${applied.filed}.` : "";
+      const message = `${/[.!?]$/.test(said) ? said : `${said}.`}${filed}`;
       if (!token || !undoFn) {
         toast.show({ message });
         return;
@@ -348,6 +369,7 @@ export function useApplyVerb(page: NodePage, factoryId?: string) {
       const expires = Date.parse(applied.undo!.expires_at);
       const entry: NodeUndo = {
         label,
+        token,
         expiresAt: Number.isFinite(expires) ? expires : Date.now() + UNDO_WINDOW_S * 1000,
         run: () =>
           undoFn(fid, token).then(
@@ -374,6 +396,100 @@ export function useApplyVerb(page: NodePage, factoryId?: string) {
   });
 }
 
+/**
+ * Undo by the server's token, from a verb's card in its node's thread (the
+ * same Undo as the toast's and "Undo (n min left)", which it also closes).
+ */
+export function useUndoToken(factoryId?: string) {
+  const fid = useFid(factoryId);
+  const source = useNodeSource();
+  const toast = useFactoryToast();
+  const refresh = useRefreshNodes(fid);
+  const undo = source?.undo;
+  return useMemo(
+    () =>
+      undo
+        ? async (token: string, label: string) => {
+            try {
+              await undo(fid, token);
+            } catch (error) {
+              void refresh();
+              toast.show({ message: `Could not undo: ${errorWords(error)}` });
+              return;
+            }
+            forgetUndoToken(fid, token);
+            void refresh();
+            toast.show({ message: `Undone: ${label}` });
+          }
+        : null,
+    [fid, refresh, toast, undo],
+  );
+}
+
+// ── Answers, with Undo when they applied a proposal ────────────
+
+/**
+ * Answer an ask (always a click). An answer that applied a proposal ("Apply
+ * C-16") can be taken back with the proposal's own Undo for 10 minutes: the
+ * toast offers it, and the node it was answered on (`at`) keeps "Apply C-16:
+ * Undo (n min left)" beside its verbs. Every node page reads again after
+ * either. `sample`: the toast says only the sample changed.
+ */
+export function useAnswerAsk(
+  at: string | null,
+  { sample = false, factoryId }: { sample?: boolean; factoryId?: string } = {},
+) {
+  const fid = useFid(factoryId);
+  const source = useNodeSource();
+  const toast = useFactoryToast();
+  const refresh = useRefreshNodes(fid);
+  const { mutate } = useAnswerDecision(fid);
+  return useCallback(
+    (decision: DecisionRef, action: DecisionAction) =>
+      mutate(
+        { decision, action },
+        {
+          onSuccess: () => {
+            const message = sample
+              ? `Sample data: nothing was answered. The sample shows what ${decision.id}: ${action.label} would do.`
+              : `${decision.id}: ${action.label}`;
+            const proposal = answerProposal(decision, action);
+            const back = source?.undoAnswer;
+            if (!proposal || !back) {
+              toast.show({ message });
+              return;
+            }
+            const entry: NodeUndo = {
+              label: `${action.label} ${proposal}`,
+              expiresAt: Date.now() + UNDO_WINDOW_S * 1000,
+              run: () =>
+                back(fid, decision, action).then(
+                  () => {
+                    if (at) forgetUndo(fid, at, entry);
+                    void refresh();
+                    toast.show({
+                      message: `Undone: ${action.label} ${proposal} (${decision.id}).`,
+                    });
+                  },
+                  (error: unknown) => {
+                    // Its window closed, or what it changed moved on: it stays applied.
+                    if (at) forgetUndo(fid, at, entry);
+                    void refresh();
+                    toast.show({ message: `Could not undo: ${errorWords(error)}` });
+                  },
+                ),
+            };
+            if (at) rememberUndo(fid, at, entry);
+            toast.show({ message, undo: () => void entry.run() });
+          },
+          onError: (error) =>
+            toast.show({ message: `${decision.id} was not answered: ${errorWords(error)}` }),
+        },
+      ),
+    [at, fid, mutate, refresh, sample, source?.undoAnswer, toast],
+  );
+}
+
 // ── Needs you, Find, last look ─────────────────────────────────
 
 /** Every open ask in a tree, ranked (null data: this source has no Needs you route). */
diff --git a/web/src/components/factory/v3/nodeTypes.ts b/web/src/components/factory/v3/nodeTypes.ts
index b0ef3394695..0010abf53de 100644
--- a/web/src/components/factory/v3/nodeTypes.ts
+++ b/web/src/components/factory/v3/nodeTypes.ts
@@ -409,10 +409,17 @@ export interface LevelView {
 // ── Steering: verb previews, apply and Undo (api.md §4) ─────────
 
 /** What a verb's preview and apply send: the verb, its arguments and the facts version read. */
+/** One argument of a verb: a word, a number, a switch, a list of refs, or a reason per ref. */
+export type VerbArg = string | number | boolean | null | string[] | Record<string, string>;
+
 export interface VerbRequest {
   verb: string;
-  /** The verb's own arguments (a new child's title and column, a parent to move under …). */
-  args: Record<string, string | number | boolean | null>;
+  /**
+   * The verb's own arguments (a new child's title and column, a parent to move
+   * under …). Add child names what it waits on as `depends_on: [ref]` with
+   * `depends_why: {ref: reason}`, as the server's projects op does.
+   */
+  args: Record<string, VerbArg>;
   /** The page's `version`: a write based on older facts is refused (409 stale). */
   based_on: string;
 }
@@ -448,6 +455,10 @@ export interface VerbPreview {
   parents?: NodeLink[];
   /** The apply button's words ("Pull forward and plan"). (client) */
   apply_label?: string;
+  /** False when this viewer may only look (an owner's verb for an editor; a form's first read). */
+  can_apply?: boolean;
+  /** Who may apply it, in words ("an owner"). */
+  who_may?: string;
 }
 
 /** What `POST …/n/{ref}/apply` returns: the page after, and the Undo for 10 minutes. */
diff --git a/web/src/components/factory/v3/nodeWire.ts b/web/src/components/factory/v3/nodeWire.ts
index 503d4b473db..16e17f4af16 100644
--- a/web/src/components/factory/v3/nodeWire.ts
+++ b/web/src/components/factory/v3/nodeWire.ts
@@ -7,6 +7,7 @@
 import type {
   ChildPage,
   Crumb,
+  DecisionRef,
   FindHit,
   LevelView,
   LineageRow,
@@ -50,11 +51,28 @@ type WireLine = Omit<StatusLine, "also_holds" | "why"> & {
   why?: (WhyItem | string)[];
 };
 
+/** An ask's text as words: a person's proposal arrives as Markdown ("**Why:** …"). */
+export function askWords<T extends DecisionRef>(decision: T): T {
+  const text = decision.text;
+  if (!text || !/[*_`]/.test(text)) return decision;
+  const plain = text
+    .replace(/(\*\*|__)(.+?)\1/g, "$2")
+    .replace(/`([^`]+)`/g, "$1")
+    .trim();
+  return { ...decision, text: plain };
+}
+
 export function normalizeStatus(line: StatusLine): StatusLine {
   const wire = line as WireLine;
-  if (!wire.also_holds && !wire.why) return line;
+  const segments = line.segments ?? [];
+  const asks = line.decision?.text || segments.some((s) => "decision" in s);
+  if (!wire.also_holds && !wire.why && !asks) return line;
   return {
     ...line,
+    ...(line.decision ? { decision: askWords(line.decision) } : {}),
+    segments: segments.map((s) =>
+      "decision" in s && s.decision ? { ...s, decision: askWords(s.decision) } : s,
+    ),
     ...(wire.also_holds ? { also_holds: wire.also_holds.map(link) } : {}),
     ...(wire.why ? { why: wire.why.map(why) } : {}),
   };
@@ -120,7 +138,8 @@ export function normalizeMoney(view: MoneyView): MoneyView {
   return { ...view, rows: view.rows ?? [] };
 }
 
-const escText = (s: string) =>
+/** Text as the limited markup preview lines carry (`RichText` reads it back as text). */
+export const escText = (s: string) =>
   s.replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]!);
 
 type WirePreviewLine = PreviewLine | string | { label?: string; text?: string; html?: string };
@@ -138,12 +157,25 @@ function deltaLine(label: string, value: unknown): PreviewLine | null {
   const d = value as WireDelta;
   if (d.text) return { label: d.label ?? label, html: escText(d.text) };
   if (d.before == null && d.after == null) return null;
-  const before = d.before == null ? "" : `${escText(String(d.before))} → `;
-  return { label: d.label ?? label, html: `${before}<b>${escText(String(d.after ?? ""))}</b>` };
+  // The arrow between before and after is drawn here; a value's own leading "→ " would double it.
+  const words = (v: unknown) => escText(String(v).replace(/^→\s*/, ""));
+  const before = d.before == null ? "" : `${words(d.before)} → `;
+  return {
+    label: d.label ?? label,
+    html: `${before}<b>${d.after == null ? "" : words(d.after)}</b>`,
+  };
 }
 
+/** "Wait: waits on …": a sentence that starts with a one- or two-word label ("Depends on"). */
+const LABELLED = /^([A-Z][a-z]+(?: [a-z]+)?): (.+)$/s;
+
 function lineOf(value: WirePreviewLine): PreviewLine {
-  if (typeof value === "string") return { label: "", html: escText(value) };
+  if (typeof value === "string") {
+    const labelled = LABELLED.exec(value);
+    return labelled
+      ? { label: labelled[1]!, html: escText(labelled[2]!) }
+      : { label: "", html: escText(value) };
+  }
   const wire = value as { label?: string; text?: string; html?: string };
   if (wire.html != null) return { label: wire.label ?? "", html: wire.html };
   return { label: wire.label ?? "", html: escText(wire.text ?? "") };
@@ -200,6 +232,33 @@ function nodeDeltaLines(delta: WireNodeDelta): PreviewLine[] {
   return delta.text ? [...lines, { label: "", html: escText(delta.text) }] : lines;
 }
 
+/**
+ * The parent's columns after the change, as the mini columns draw them. The
+ * server lists the changed node (moved, or new) under `ghosts` with the column
+ * it lands in, keeping a moved node's own state; it is drawn dashed in that
+ * column (`state: "ghost"`). Ghosts with no column are the page's own
+ * proposals: they are not this change and stay apart.
+ */
+function previewColumns(page: ChildPage): ChildPage {
+  const read = children(page);
+  const landed = read.ghosts.filter((g) => g.col != null);
+  if (!landed.length) return read;
+  const ghost = (g: NodeSummary): NodeSummary => ({ ...g, state: "ghost" });
+  const placed = new Set(landed.map((g) => g.ref));
+  const keep = (k: NodeSummary) => !placed.has(k.ref);
+  return {
+    ...read,
+    items: [...read.items.filter(keep), ...landed.filter((g) => g.col !== "later").map(ghost)],
+    later: [...landed.filter((g) => g.col === "later").map(ghost), ...read.later.filter(keep)],
+    ghosts: read.ghosts.filter((g) => g.col == null),
+  };
+}
+
+/** "depends_on_done: x waits on done y" → "x waits on done y": a code prefix is not words. */
+function warningWords(warning: string): string {
+  return warning.replace(/^[a-z][a-z0-9]*(?:_[a-z0-9]+)+: /, "");
+}
+
 export function normalizePreview(preview: VerbPreview): VerbPreview {
   const wire = preview as unknown as Omit<VerbPreview, "effects" | "rollup_delta"> & {
     effects?: WirePreviewLine[];
@@ -217,8 +276,8 @@ export function normalizePreview(preview: VerbPreview): VerbPreview {
     ...preview,
     rollup_delta: rollup,
     effects: (wire.effects ?? []).map(lineOf),
-    warnings: wire.warnings ?? [],
-    ...(wire.columns_after ? { columns_after: children(wire.columns_after) } : {}),
+    warnings: [...new Set((wire.warnings ?? []).map(warningWords))],
+    ...(wire.columns_after ? { columns_after: previewColumns(wire.columns_after) } : {}),
   };
 }
 
@@ -241,15 +300,16 @@ export function normalizeNeedsYou(list: NeedsYouList): NeedsYouList {
   return {
     items: (list.items ?? []).map((i) => ({
       ...i,
+      decision: askWords(i.decision),
       breadcrumb: belowRoot(i.breadcrumb),
       holds: i.holds ?? [],
     })),
     blocks_nothing: quiet.map((q) => {
-      if (!("decision" in q)) return q;
+      if (!("decision" in q)) return askWords(q);
       const crumbs = belowRoot(q.breadcrumb);
       const at = crumbs.at(-1);
       return {
-        ...q.decision,
+        ...askWords(q.decision),
         breadcrumb: crumbs,
         ...(at ? { node: { ref: at.ref, title: at.title } } : {}),
       };
diff --git a/web/src/components/factory/v3/sheets/V3Sheets.tsx b/web/src/components/factory/v3/sheets/V3Sheets.tsx
index 91855c60fd5..1967f93fb00 100644
--- a/web/src/components/factory/v3/sheets/V3Sheets.tsx
+++ b/web/src/components/factory/v3/sheets/V3Sheets.tsx
@@ -24,7 +24,7 @@ import { NodeLink } from "../nodeParts";
 import { useAnswerDecision, useNode } from "../nodeQueries";
 import { PRODUCT_REF } from "../nodeRoutes";
 import { useNodeSource } from "../nodeSource";
-import { useNeedsYou } from "../nodeSteer";
+import { useAnswerAsk, useNeedsYou } from "../nodeSteer";
 import type { DecisionAction, DecisionRef, NeedsYouList, QuietAsk } from "../nodeTypes";
 import { PreviewLines } from "../verbs/PreviewPanel";
 
@@ -324,25 +324,10 @@ function NeedsYouSheet({ factoryId: fid, open, onClose }: SheetProps) {
   const query = useNeedsYou(tree, open, fid);
   const toast = useFactoryToast();
   const source = useNodeSource();
-  const { mutate, mutateAsync } = useAnswerDecision(fid);
+  const { mutateAsync } = useAnswerDecision(fid);
   const sample = source?.kind === "sample";
-  const onAnswer = useCallback(
-    (decision: DecisionRef, action: DecisionAction) =>
-      mutate(
-        { decision, action },
-        {
-          onSuccess: () =>
-            toast.show({
-              message: sample
-                ? `Sample data: ${decision.id} ${action.label} changes only the sample.`
-                : `${decision.id}: ${action.label}`,
-            }),
-          onError: (error) =>
-            toast.show({ message: `${decision.id} was not answered: ${errorWords(error)}` }),
-        },
-      ),
-    [mutate, sample, toast],
-  );
+  // An answer that applied a proposal offers its Undo in the toast.
+  const onAnswer = useAnswerAsk(null, { sample, factoryId: fid });
   /** Every quiet ask with its own first answer, at once; one toast says how it went. */
   const onAnswerAll = useCallback(
     (asks: QuietAsk[]) => {
diff --git a/web/src/components/factory/v3/steerLive.test.tsx b/web/src/components/factory/v3/steerLive.test.tsx
new file mode 100644
index 00000000000..d2774b1e280
--- /dev/null
+++ b/web/src/components/factory/v3/steerLive.test.tsx
@@ -0,0 +1,315 @@
+import { act, screen, waitFor, within } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { renderNode } from "./fixture/renderNode";
+import { sampleNodeSource } from "./fixture/sampleNodeSource";
+import { type NodeSource, answerProposal } from "./nodeSource";
+import { forgetUndoToken, rememberUndo, resetNodeUndos } from "./nodeSteer";
+import type { DecisionRef, NeedsYouList, NodeSummary, StatusLine, VerbPreview } from "./nodeTypes";
+import { normalizeNeedsYou, normalizePreview, normalizeStatus } from "./nodeWire";
+
+// Steering against the live server (S9, S10, S12, S13): the shapes its
+// previews really arrive in, an answer that applied a proposal and its Undo,
+// and Apply staying off for a viewer the server says may only look.
+
+afterEach(() => {
+  resetNodeUndos();
+});
+
+const PANEL = "assistant-panel-ux";
+
+function summary(ref: string, state: NodeSummary["state"], col: NodeSummary["col"]): NodeSummary {
+  return {
+    ref,
+    level: "project",
+    kind: "project",
+    title: ref,
+    state,
+    col,
+    status_compact: { kind: "moving", label: "Moving:", segments: [], ends: "moving" },
+    needs: { open: 0, blocking: 0 },
+  };
+}
+
+/** `POST …/n/assistant-panel-ux/preview {verb: "start"}` as the S12 server answers it. */
+function serverStart(): VerbPreview {
+  return {
+    preview_id: "140f574c6b277f51d9fabf20",
+    title: `Start ${PANEL} now`,
+    effects: [
+      "Wait: waits on assistant-core (Needs you: › T-16 → needs a person: Apply C-16 (D-45)) → needs only PR-9876 · merged (met).",
+      "Order: Then → First in Agent assistant (sample).",
+      "Team: the server starts its lead now.",
+      "Risk: it builds on what is merged now; later work of assistant-core reaches it only when that merges too.",
+    ],
+    rollup_delta: {
+      nodes: [
+        {
+          ref: PANEL,
+          title: PANEL,
+          items: [{ key: "state", label: "State", before: "waiting", after: "moving" }],
+        },
+      ],
+      text: `${PANEL} starts burning its team's rate once its lead runs.`,
+    },
+    columns_after: {
+      level: "project",
+      level_name: "Projects",
+      columns: [
+        { title: "First", col: 0 },
+        { title: "Then", col: 1 },
+      ],
+      items: [
+        summary("assistant-core", "needs", 0),
+        summary("connectors-core", "done", 1),
+        summary("skill-discovery", "done", 1),
+      ],
+      later: [summary("google-ads-integration", "later", "later")],
+      later_title: "Later (held)",
+      // The moved node keeps its own state and names the column it lands in;
+      // a proposal's ghost (no column) is the page's own, not this change.
+      ghosts: [summary("live-search-fix", "ghost", undefined), summary(PANEL, "waiting", 0)],
+      total: 7,
+      tiles: true,
+    },
+    moved_from: { ref: PANEL, col: 1 },
+    approver: "you",
+    approver_note: "You, as owner. Applies now; Undo for 10 min.",
+    can_apply: true,
+    who_may: "an editor or an owner",
+    apply_label: "Start now",
+    warnings: ["depends_on_done: assistant-panel-ux waits on done ux-env-badge-copy"],
+  } as unknown as VerbPreview;
+}
+
+describe("cockpit v3 · the live server's previews", () => {
+  it("draws the moved node dashed where it lands, keeps a proposal's ghost apart, labels each line", () => {
+    const p = normalizePreview(serverStart());
+    const cols = p.columns_after!;
+    expect(cols.items.map((k) => [k.ref, k.state, k.col])).toEqual([
+      ["assistant-core", "needs", 0],
+      ["connectors-core", "done", 1],
+      ["skill-discovery", "done", 1],
+      [PANEL, "ghost", 0],
+    ]);
+    expect(cols.ghosts.map((k) => k.ref)).toEqual(["live-search-fix"]);
+    expect(p.effects.map((e) => e.label)).toEqual(["Wait", "Order", "Team", "Risk"]);
+    expect(p.effects[1]!.html).toBe("Then → First in Agent assistant (sample).");
+    expect(p.rollup_delta[0]).toEqual({
+      label: `${PANEL} · State`,
+      html: "waiting → <b>moving</b>",
+    });
+    // A plan's code is not words.
+    expect(p.warnings).toEqual(["assistant-panel-ux waits on done ux-env-badge-copy"]);
+  });
+
+  it("draws one arrow between before and after, though the server's words start with one", () => {
+    const p = normalizePreview({
+      ...serverStart(),
+      rollup_delta: {
+        nodes: [
+          {
+            ref: "I-1",
+            title: "Agent assistant",
+            items: [
+              { key: "auto_merge", label: "Auto-merge", before: "off", after: "→ main-x (here)" },
+              {
+                key: "auto_merge",
+                label: "Was",
+                before: "→ main-x (from Agent assistant)",
+                after: "off (here)",
+              },
+            ],
+          },
+        ],
+        text: "",
+      },
+    } as never);
+    expect(p.rollup_delta.map((l) => l.html)).toEqual([
+      "off → <b>main-x (here)</b>",
+      "main-x (from Agent assistant) → <b>off (here)</b>",
+    ]);
+  });
+
+  it("renders it: the ghost in First, its place in Then struck, no code in the warnings", async () => {
+    const sample = sampleNodeSource();
+    const source: NodeSource = {
+      ...sample,
+      kind: "live",
+      preview: async () => normalizePreview(serverStart()),
+    };
+    renderNode(PANEL, { source });
+    await waitFor(() =>
+      expect(screen.getByTestId("v3-node-page")).toHaveAttribute("data-ref", PANEL),
+    );
+    await userEvent.click(
+      within(screen.getByTestId("v3-verbs")).getByRole("button", { name: /Start now/ }),
+    );
+    const panel = await screen.findByTestId("v3-preview");
+    const cols = await within(panel).findByTestId("v3-mini-columns");
+    const ghost = within(cols).getByTestId("v3-mini-ghost");
+    expect(ghost).toHaveAttribute("data-ref", PANEL);
+    expect(within(cols).getByTestId("v3-mini-gone")).toHaveAttribute("data-ref", PANEL);
+    expect(cols).not.toHaveTextContent("live-search-fix");
+    expect(panel).toHaveTextContent("assistant-panel-ux waits on done ux-env-badge-copy");
+    expect(panel).not.toHaveTextContent("depends_on_done");
+  });
+
+  it("keeps Apply off for a viewer the server says may only look", async () => {
+    const sample = sampleNodeSource();
+    const preview = normalizePreview({
+      ...serverStart(),
+      approver: "an owner",
+      approver_note: "An owner applies this; you can read what it would do.",
+      can_apply: false,
+      who_may: "an owner",
+    } as never);
+    renderNode(PANEL, { source: { ...sample, kind: "live", preview: async () => preview } });
+    await waitFor(() =>
+      expect(screen.getByTestId("v3-node-page")).toHaveAttribute("data-ref", PANEL),
+    );
+    await userEvent.click(
+      within(screen.getByTestId("v3-verbs")).getByRole("button", { name: /Start now/ }),
+    );
+    const panel = await screen.findByTestId("v3-preview");
+    await waitFor(() => expect(within(panel).getByTestId("v3-preview-lines")).toBeInTheDocument());
+    const apply = within(panel).getByTestId("v3-preview-apply");
+    expect(apply).toBeDisabled();
+    expect(apply).toHaveAttribute("title", "An owner applies this; you can read what it would do.");
+  });
+
+  it("Add child names what it waits on as a list with a reason, as the server's projects op does", async () => {
+    const sample = sampleNodeSource();
+    const asked: unknown[] = [];
+    const source: NodeSource = {
+      ...sample,
+      preview: async (fid, ref, request, signal) => {
+        asked.push(request.args);
+        return sample.preview!(fid, ref, request, signal);
+      },
+    };
+    renderNode("I-1", { source });
+    await waitFor(() =>
+      expect(screen.getByTestId("v3-node-page")).toHaveAttribute("data-ref", "I-1"),
+    );
+    await userEvent.click(
+      within(screen.getByTestId("v3-verbs")).getByRole("button", { name: /Add child/ }),
+    );
+    const panel = await screen.findByTestId("v3-preview");
+    // A new child lands in the first column unless it waits on a sibling.
+    const order = within(panel).getByRole("group", { name: "Order" });
+    expect(within(order).getByRole("button", { name: "First" })).toHaveAttribute(
+      "aria-pressed",
+      "true",
+    );
+    await userEvent.type(within(panel).getByLabelText("Title"), "Usage report");
+    const deps = within(panel).getByRole("group", { name: "Depends on" });
+    await userEvent.click(within(deps).getByRole("button", { name: "connectors-core" }));
+    await userEvent.type(within(panel).getByLabelText("Because"), "it reads connector data");
+    await waitFor(() =>
+      expect(asked.at(-1)).toMatchObject({
+        title: "Usage report",
+        depends_on: ["connectors-core"],
+        depends_why: { "connectors-core": "it reads connector data" },
+      }),
+    );
+  });
+});
+
+describe("cockpit v3 · an answer that applied a proposal can be taken back", () => {
+  const d45 = (subject?: string): DecisionRef => ({
+    id: "D-45",
+    verb: "Apply C-16",
+    actions: [
+      { id: "apply", label: "Apply" },
+      { id: "reject", label: "Reject" },
+    ],
+    asker: "Atlas",
+    age: "6h",
+    ...(subject ? { subject } : {}),
+  });
+
+  it("names the proposal only for its Apply", () => {
+    expect(answerProposal(d45("C-16"), { id: "apply", label: "Apply" })).toBe("C-16");
+    expect(answerProposal(d45("C-16"), { id: "reject", label: "Reject" })).toBeNull();
+    expect(answerProposal(d45("T-16"), { id: "apply", label: "Apply" })).toBeNull();
+    expect(answerProposal(d45(), { id: "apply", label: "Apply" })).toBeNull();
+  });
+
+  it("Apply on the status line offers its Undo beside the verbs, which takes the answer back", async () => {
+    const sample = sampleNodeSource();
+    const undoAnswer = vi.fn(async (fid: string, decision: DecisionRef) =>
+      sample.undoAnswer!(fid, decision, decision.actions[0]!),
+    );
+    renderNode("assistant-core", { source: { ...sample, undoAnswer }, answers: true });
+    await waitFor(() =>
+      expect(screen.getByTestId("v3-status")).toHaveTextContent("needs you: Apply C-16 (D-45)"),
+    );
+    await userEvent.click(
+      within(screen.getByTestId("v3-status")).getByRole("button", { name: "Apply" }),
+    );
+    await waitFor(() => expect(screen.getByTestId("v3-status")).not.toHaveTextContent("D-45"));
+    const undo = await screen.findByTestId("v3-undo-latest");
+    expect(undo).toHaveTextContent("Apply C-16: Undo (10 min left)");
+    await userEvent.click(undo);
+    await waitFor(() => expect(undoAnswer).toHaveBeenCalledTimes(1));
+    expect(undoAnswer.mock.calls[0]![1]).toMatchObject({ id: "D-45" });
+    await waitFor(() =>
+      expect(screen.getByTestId("v3-status")).toHaveTextContent("needs you: Apply C-16 (D-45)"),
+    );
+    expect(screen.queryByTestId("v3-undo-latest")).toBeNull();
+    expect(sample.engine.writes).toContain("undo answer:D-45");
+  });
+
+  it("a verb's Undo run from its card closes the one beside the verbs, and only that one", async () => {
+    const run = vi.fn(async () => undefined);
+    const later = Date.now() + 9 * 60_000;
+    renderNode("I-1");
+    await waitFor(() =>
+      expect(screen.getByTestId("v3-node-page")).toHaveAttribute("data-ref", "I-1"),
+    );
+    act(() =>
+      rememberUndo("f-sample", "I-1", { label: "Add child", expiresAt: later, run, token: "t1" }),
+    );
+    expect(await screen.findByTestId("v3-undo-latest")).toHaveTextContent("Add child: Undo");
+    act(() => forgetUndoToken("f-sample", "t2"));
+    expect(screen.getByTestId("v3-undo-latest")).toBeInTheDocument();
+    act(() => forgetUndoToken("f-sample", "t1"));
+    await waitFor(() => expect(screen.queryByTestId("v3-undo-latest")).toBeNull());
+    expect(run).not.toHaveBeenCalled();
+  });
+});
+
+describe("cockpit v3 · an ask's words", () => {
+  const asked: DecisionRef = {
+    id: "D-45",
+    verb: "Apply C-16",
+    actions: [],
+    asker: "you",
+    age: "6h",
+    text: "**Why:** Implements the `D-42` answer: debit each turn.",
+  };
+
+  it("reads a person's proposal Markdown as words, on status lines and in Needs you", () => {
+    const line: StatusLine = {
+      kind: "needs",
+      label: "Not moving:",
+      segments: [{ sep: "→", person: true, decision: asked }],
+      ends: "person",
+      decision: asked,
+    };
+    const read = normalizeStatus(line);
+    const words = "Why: Implements the D-42 answer: debit each turn.";
+    expect(read.decision!.text).toBe(words);
+    const end = read.segments[0] as { decision: DecisionRef };
+    expect(end.decision.text).toBe(words);
+    const needs = normalizeNeedsYou({
+      items: [{ decision: asked, breadcrumb: [], holds: ["T-16"], weight: 1 }],
+      blocks_nothing: [asked],
+      closed_alarms: [],
+      other_tree: 0,
+    } as NeedsYouList);
+    expect(needs.items[0]!.decision.text).toBe(words);
+    expect(needs.blocks_nothing[0]!.text).toBe(words);
+  });
+});
diff --git a/web/src/components/factory/v3/verbs/PreviewPanel.tsx b/web/src/components/factory/v3/verbs/PreviewPanel.tsx
index 2bd06afd168..a0ed308a8d1 100644
--- a/web/src/components/factory/v3/verbs/PreviewPanel.tsx
+++ b/web/src/components/factory/v3/verbs/PreviewPanel.tsx
@@ -183,7 +183,13 @@ export function PreviewPanel({
         },
       ]
     : [];
-  const off = blocked ?? (preview || bare ? null : "Reading the preview…");
+  // The server says who may apply it: a viewer who may not reads it, and Apply stays off.
+  const notYours =
+    preview?.can_apply === false
+      ? (preview.approver_note ??
+        `${approverWords(preview.who_may ?? preview.approver)} You can read what it would do.`)
+      : null;
+  const off = blocked ?? notYours ?? (preview || bare ? null : "Reading the preview…");
   return (
     <section
       ref={root}
diff --git a/web/src/components/factory/v3/verbs/TeamPanel.live.test.tsx b/web/src/components/factory/v3/verbs/TeamPanel.live.test.tsx
index 8742f3581de..495caf73950 100644
--- a/web/src/components/factory/v3/verbs/TeamPanel.live.test.tsx
+++ b/web/src/components/factory/v3/verbs/TeamPanel.live.test.tsx
@@ -162,6 +162,11 @@ async function applySwap(server: ReturnType<typeof serveFactory>) {
   await waitFor(() =>
     expect(server.calls.some((c) => c.path.endsWith("/definition/preview"))).toBe(true),
   );
+  // The first pick never sends a preview with no changes (the server refuses it).
+  const previews = server.calls.filter((c) => c.path.endsWith("/definition/preview"));
+  for (const call of previews) {
+    expect((call.body as { changes: unknown[] }).changes.length).toBeGreaterThan(0);
+  }
   const lines = await within(panel).findByTestId("v3-preview-lines");
   expect(lines).toHaveTextContent("From each member’s next task.");
   expect(lines).toHaveTextContent("Cost$5.6/h → about $5.9/h while working (estimate)");
diff --git a/web/src/components/factory/v3/verbs/TeamPanel.tsx b/web/src/components/factory/v3/verbs/TeamPanel.tsx
index 526a97c02af..a075554679f 100644
--- a/web/src/components/factory/v3/verbs/TeamPanel.tsx
+++ b/web/src/components/factory/v3/verbs/TeamPanel.tsx
@@ -93,7 +93,7 @@ export function TeamRows({
   return (
     <ul
       data-testid="v3-team-rows"
-      className="flex flex-col overflow-hidden rounded-[10px] ring-1 ring-border"
+      className="@container flex flex-col overflow-hidden rounded-[10px] ring-1 ring-border"
     >
       {rows.map((r) => {
         const vendor = r.options.find((o) => o.vendor === r.vendor);
@@ -106,14 +106,16 @@ export function TeamRows({
             data-changed={r.before ? "" : undefined}
             className={cn(
               "grid grid-cols-[20px_minmax(0,8rem)_minmax(0,7rem)_minmax(0,1fr)_minmax(0,9rem)_4rem] items-center gap-2.5 border-t border-border px-3 py-2 text-[13px] first:border-t-0",
-              "max-md:grid-cols-[20px_minmax(0,1fr)_auto] max-md:gap-y-1",
+              "@max-[38rem]:grid-cols-[20px_minmax(0,1fr)_auto] @max-[38rem]:gap-y-1",
               r.before && "bg-status-blue/8",
             )}
           >
             <Avatar actor={{ name: r.name }} />
             <span className="min-w-0 truncate font-semibold">{r.name}</span>
-            <span className="min-w-0 truncate text-muted-foreground max-md:hidden">{r.role}</span>
-            <span className="flex min-w-0 gap-1.5 max-md:col-span-3 max-md:col-start-1 max-md:row-start-2">
+            <span className="min-w-0 truncate text-muted-foreground @max-[38rem]:hidden">
+              {r.role}
+            </span>
+            <span className="flex min-w-0 gap-1.5 @max-[38rem]:col-span-3 @max-[38rem]:col-start-1 @max-[38rem]:row-start-2">
               <select
                 aria-label={`${r.name} vendor`}
                 value={r.vendor}
@@ -144,7 +146,7 @@ export function TeamRows({
                 ))}
               </select>
             </span>
-            <span className="min-w-0 truncate text-xs text-foreground-tertiary max-md:hidden">
+            <span className="min-w-0 truncate text-xs text-foreground-tertiary @max-[38rem]:hidden">
               {r.before ? `was ${r.before}` : (r.state ?? "")}
             </span>
             <span className="text-right font-mono text-xs text-muted-foreground">
diff --git a/web/src/components/factory/v3/verbs/VerbPreviews.test.tsx b/web/src/components/factory/v3/verbs/VerbPreviews.test.tsx
index a0bd7b2f7ca..2e567da5a7a 100644
--- a/web/src/components/factory/v3/verbs/VerbPreviews.test.tsx
+++ b/web/src/components/factory/v3/verbs/VerbPreviews.test.tsx
@@ -120,7 +120,7 @@ describe("cockpit v3 · verb previews, apply and Undo", () => {
     expect(title).toHaveFocus();
     await userEvent.type(title, "Ads network integration");
     expect(await within(panel).findByTestId("v3-preview-found")).toHaveTextContent(
-      "Ads network integration is already here, held for ad-network credentials and an ad-spend cap. Adding it now pulls it forward into Then instead of making a second copy.",
+      "Ads network integration is already here, held for ad-network credentials and an ad-spend cap. Adding it now pulls it forward into First instead of making a second copy.",
     );
     await waitFor(() =>
       expect(within(panel).getByTestId("v3-preview-apply")).toHaveTextContent(
diff --git a/web/src/components/factory/v3/verbs/VerbPreviews.tsx b/web/src/components/factory/v3/verbs/VerbPreviews.tsx
index b30c9c65173..d339318819a 100644
--- a/web/src/components/factory/v3/verbs/VerbPreviews.tsx
+++ b/web/src/components/factory/v3/verbs/VerbPreviews.tsx
@@ -11,7 +11,7 @@ import { FactoryApiError } from "@/lib/factoryApi";
 import { cn } from "@/lib/utils";
 import { useApplyVerb, useVerbPreview } from "../nodeSteer";
 import type { NodePage, VerbArgs, VerbAvail, VerbRequest } from "../nodeTypes";
-import { levelName } from "../nodeWire";
+import { escText, levelName } from "../nodeWire";
 import {
   FIELD,
   PreviewField,
@@ -74,7 +74,9 @@ function AddChildPreview({ page, verb, args, onClose }: VerbProps) {
   const columns = kids.columns ?? [];
   const laterTitle = kids.later_title ?? (kids.later.length ? "Later" : null);
   const [title, setTitle] = useState(args?.title ?? "");
-  const [col, setCol] = useState<number | "later">(columns[1]?.col ?? columns[0]?.col ?? 0);
+  // A new child with nothing to wait on lands in the first column; it goes
+  // later in the order by what it depends on (the server's rule).
+  const [col, setCol] = useState<number | "later">(columns[0]?.col ?? 0);
   const [dep, setDep] = useState("");
   const [because, setBecause] = useState("");
   const [heldFor, setHeldFor] = useState("");
@@ -83,7 +85,10 @@ function AddChildPreview({ page, verb, args, onClose }: VerbProps) {
   const request: Args = {
     title: title.trim(),
     col,
-    ...(dep && !later ? { depends_on: dep, because: because.trim() } : {}),
+    // What it waits on, as the projects op names it: a list of refs and a reason each.
+    ...(dep && !later
+      ? { depends_on: [dep], ...(because.trim() ? { depends_why: { [dep]: because.trim() } } : {}) }
+      : {}),
     ...(later && heldFor.trim() ? { held_for: heldFor.trim() } : {}),
   };
   // No title yet: no preview (the server would refuse an empty one).
@@ -92,11 +97,23 @@ function AddChildPreview({ page, verb, args, onClose }: VerbProps) {
     ...columns.map((c) => ({ value: c.col as number | "later", label: c.title })),
     ...(laterTitle ? [{ value: "later" as const, label: laterTitle }] : []),
   ];
-  const into = later ? laterTitle : columns.find((c) => c.col === col)?.title;
   const pulled = data?.pulls_forward;
+  // Where it lands, as the server placed it (its column follows what it depends on).
+  const ghost = data?.columns_after?.items.find(
+    (k) => k.state === "ghost" && k.ref === pulled?.ref,
+  );
+  const landed = typeof ghost?.col === "number" ? ghost.col : col;
+  const into = later ? laterTitle : columns.find((c) => c.col === landed)?.title;
+  // The banner says the pull-forward; the server's sentence saying it again is left out.
+  const said = pulled ? `${escText(pulled.title)} is already here` : null;
+  const preview =
+    data && said
+      ? { ...data, effects: data.effects.filter((e) => !e.html.startsWith(said)) }
+      : data;
   return (
     <PreviewPanel
       {...panel}
+      preview={preview}
       label="Add child"
       title={`Add a ${noun} under ${page.node.title}`}
       applyLabel={later ? "Add as held" : "Add and plan"}
@@ -393,7 +410,12 @@ function ParentPreview({ page, verb, onClose, naming }: VerbProps & { naming: bo
       )}
       {parents.length > 0 && (
         <PreviewField
-          label={`Parent${parentCrumb ? ` (${levelName(parentCrumb.level, parentCrumb.level_name)})` : ""}`}
+          label={
+            naming
+              ? // What it is filed under is the server's to say (its line names the level).
+                "File under"
+              : `Parent${parentCrumb ? ` (${levelName(parentCrumb.level, parentCrumb.level_name)})` : ""}`
+          }
         >
           <PreviewOptions
             label="Parent"
diff --git a/web/src/lib/factoryRoomApi.ts b/web/src/lib/factoryRoomApi.ts
index 664f0300076..048576d85ac 100644
--- a/web/src/lib/factoryRoomApi.ts
+++ b/web/src/lib/factoryRoomApi.ts
@@ -79,8 +79,10 @@ export interface PostChatResponse {
 export async function fetchRoomThreads(
   factoryId: string,
   signal?: AbortSignal,
+  { nodes = false }: { nodes?: boolean } = {},
 ): Promise<ThreadsResponse> {
-  return readJson(await authenticatedFetch(factoryPath(factoryId, "/chat/threads"), { signal }));
+  const path = `/chat/threads${nodes ? "?nodes=1" : ""}`;
+  return readJson(await authenticatedFetch(factoryPath(factoryId, path), { signal }));
 }
 
 /**
diff --git a/web/src/pages/factory/NodeRoute.tsx b/web/src/pages/factory/NodeRoute.tsx
index 8e13768c164..c943942ade8 100644
--- a/web/src/pages/factory/NodeRoute.tsx
+++ b/web/src/pages/factory/NodeRoute.tsx
@@ -20,13 +20,12 @@ import {
 } from "@/components/factory/factoryRoutes";
 import { useCockpitV2 } from "@/components/factory/shell/cockpitV2";
 import { useFactoryShell } from "@/components/factory/shell/FactoryShellContext";
-import { useFactoryToast } from "@/components/factory/ui/Toast";
 import { useNodeChatSlot } from "@/components/factory/v3/chat/chatLayout";
 import type { NodeActions } from "@/components/factory/v3/NodeContext";
 import { NodePage } from "@/components/factory/v3/NodePage";
-import { useAnswerDecision } from "@/components/factory/v3/nodeQueries";
 import { PRODUCT_REF } from "@/components/factory/v3/nodeRoutes";
 import { useNodeSource } from "@/components/factory/v3/nodeSource";
+import { useAnswerAsk } from "@/components/factory/v3/nodeSteer";
 import type { FactorySnapshot, TaskView } from "@/lib/factoryApi";
 import { fetchFactoryTasks } from "@/lib/factoryRoomApi";
 import { useParams } from "@/lib/routing";
@@ -98,28 +97,14 @@ function V3Node({ nodeRef, level }: { nodeRef: string; level: string | null }) {
   const { factoryId } = useFactoryShell();
   const cockpit = useCockpitV2();
   const source = useNodeSource();
-  const toast = useFactoryToast();
   const chatSlot = useNodeChatSlot();
-  const { mutate: answer } = useAnswerDecision(factoryId);
-  const openSheet = useOpenSheet();
   const sample = source?.kind === "sample";
+  // An answer that applied a proposal keeps its Undo on this node for 10 minutes.
+  const answer = useAnswerAsk(nodeRef, { sample, factoryId });
+  const openSheet = useOpenSheet();
   const actions = useMemo<Omit<NodeActions, "factoryId" | "prefetch" | "aboveId">>(
     () => ({
-      onAnswer: (decision, action) => {
-        answer(
-          { decision, action },
-          {
-            onSuccess: () =>
-              toast.show({
-                message: sample
-                  ? `Sample data: nothing was answered. The sample shows what ${decision.id}: ${action.label} would do.`
-                  : `${decision.id}: ${action.label}`,
-              }),
-            onError: (error) =>
-              toast.show({ message: `${decision.id} was not answered: ${String(error)}` }),
-          },
-        );
-      },
+      onAnswer: answer,
       // "Open C-16": the ask with its full text and its rank, in Needs you.
       onOpenDecision: () => openSheet("needs"),
       // Talk: the node's chat (the page opens every other verb's preview itself).
@@ -127,7 +112,7 @@ function V3Node({ nodeRef, level }: { nodeRef: string; level: string | null }) {
         if (verb.verb === "talk") chatSlot?.focus();
       },
     }),
-    [answer, chatSlot, openSheet, sample, toast],
+    [answer, chatSlot, openSheet],
   );
   return (
     <NodePage

From 74d1fcd6eb9e96b63b9b3c9018be82470a0bb7af Mon Sep 17 00:00:00 2001
From: Luka Skugor <luka.skugor@dfinity.org>
Date: Wed, 4 Nov 2026 08:13:05 +0100
Subject: [PATCH 2/4] cockpit v3: one live card per proposal in the node chat

A verb filed as a proposal and applied at once posted the same proposal
card twice in its node's thread (filed, then applied). The node chat now
shows the newest as the live card and the earlier one as its line; the
Room's own threads are unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 web/src/components/factory/cards/RoomCard.tsx |  2 ++
 .../factory/cards/RoomCardContext.tsx         |  2 ++
 .../factory/room/RoomThreadView.tsx           |  9 ++++++-
 .../components/factory/room/roomFold.test.ts  | 24 +++++++++++++++++
 web/src/components/factory/room/roomFold.ts   | 26 +++++++++++++++++++
 5 files changed, 62 insertions(+), 1 deletion(-)

diff --git a/web/src/components/factory/cards/RoomCard.tsx b/web/src/components/factory/cards/RoomCard.tsx
index 53660462f5a..e003bdd1abc 100644
--- a/web/src/components/factory/cards/RoomCard.tsx
+++ b/web/src/components/factory/cards/RoomCard.tsx
@@ -43,6 +43,8 @@ export function RoomCard({
   if (!card) return attached ? null : line;
   switch (card.type) {
     case "proposal": {
+      // A newer card of this proposal is in the thread: this one is its line.
+      if (data.repeated?.has(message.id)) return attached ? null : line;
       const proposal =
         data.proposals?.find((p) => p.id === card.id) ??
         data.proposals?.find((p) => p.ref === card.ref) ??
diff --git a/web/src/components/factory/cards/RoomCardContext.tsx b/web/src/components/factory/cards/RoomCardContext.tsx
index c16ba59f255..27969a5c8d9 100644
--- a/web/src/components/factory/cards/RoomCardContext.tsx
+++ b/web/src/components/factory/cards/RoomCardContext.tsx
@@ -33,6 +33,8 @@ export interface RoomCardData {
    */
   nodeCard?:
     ((message: ChatMessageView, attached: boolean, fallback: ReactNode) => ReactNode) | null;
+  /** Messages whose card a newer one of the same object repeats: their line, not the card (v3). */
+  repeated?: ReadonlySet<string> | null;
 }
 
 export const RoomCardContext = createContext<RoomCardData | null>(null);
diff --git a/web/src/components/factory/room/RoomThreadView.tsx b/web/src/components/factory/room/RoomThreadView.tsx
index df4e28d80f6..3c2ec855fb0 100644
--- a/web/src/components/factory/room/RoomThreadView.tsx
+++ b/web/src/components/factory/room/RoomThreadView.tsx
@@ -40,7 +40,7 @@ import { useOptionalFactoryShell } from "../shell/FactoryShellContext";
 import { FoldableMarkdown } from "../transcript/FoldableMarkdown";
 import { roomCandidateList } from "./roomCandidates";
 import { RoomComposer, type RoomComposerNodeOptions } from "./RoomComposer";
-import { foldRoomItems, namesRepos, supersededIssueCards } from "./roomFold";
+import { foldRoomItems, namesRepos, supersededCards, supersededIssueCards } from "./roomFold";
 import { BaseMovesLine, IssueRepeats } from "./RoomFolds";
 import { BusRow, RoomMessage } from "./RoomMessage";
 import {
@@ -265,6 +265,11 @@ export function RoomThreadView({
     issues: issues.data ?? null,
     viewerId: snapshot.viewer?.user_id ?? null,
   };
+  // The node chat shows one live card per proposal: earlier copies are their line.
+  const repeated = useMemo(
+    () => (node ? supersededCards(messages, ["proposal"]) : null),
+    [messages, node],
+  );
   const cardData: RoomCardData = useMemo(
     () => ({
       factoryId: fid,
@@ -276,6 +281,7 @@ export function RoomThreadView({
       people: people.data?.data ?? null,
       compact: dock,
       nodeCard,
+      repeated,
     }),
     [
       fid,
@@ -287,6 +293,7 @@ export function RoomThreadView({
       people.data,
       dock,
       nodeCard,
+      repeated,
     ],
   );
   const candidates = useMemo(
diff --git a/web/src/components/factory/room/roomFold.test.ts b/web/src/components/factory/room/roomFold.test.ts
index 0eca7f9d2fc..9cee7f74f75 100644
--- a/web/src/components/factory/room/roomFold.test.ts
+++ b/web/src/components/factory/room/roomFold.test.ts
@@ -13,6 +13,7 @@ import {
   baseMovesOf,
   foldRoomItems,
   namesRepos,
+  supersededCards,
   supersededIssueCards,
 } from "./roomFold";
 import { interleave, type BusLine } from "./roomModel";
@@ -207,3 +208,26 @@ describe("an incident's cards", () => {
     expect(fold(messages).every((i) => i.type === "message")).toBe(true);
   });
 });
+
+describe("supersededCards", () => {
+  it("keeps one live card per object: earlier copies of a proposal card are repeats", () => {
+    const base = roomMessages()[0]!;
+    const card = (id: string, seq: number, type: string, ref: string, author = "system") =>
+      ({
+        ...base,
+        id,
+        seq,
+        author_kind: author,
+        card: { type, ref, id: null },
+      }) as ChatMessageView;
+    const messages = [
+      card("filed", 1, "proposal", "C-20"),
+      card("control", 2, "control", "C-20"),
+      card("applied", 3, "proposal", "C-20"),
+      card("other", 4, "proposal", "C-21"),
+      card("quoted", 5, "proposal", "C-21", "agent"),
+    ];
+    expect([...supersededCards(messages, ["proposal"])]).toEqual(["filed"]);
+    expect([...supersededCards(messages, ["issue"])]).toEqual([]);
+  });
+});
diff --git a/web/src/components/factory/room/roomFold.ts b/web/src/components/factory/room/roomFold.ts
index 75ba134feac..6fdd4f183ca 100644
--- a/web/src/components/factory/room/roomFold.ts
+++ b/web/src/components/factory/room/roomFold.ts
@@ -67,6 +67,32 @@ export function supersededIssueCards(messages: readonly ChatMessageView[]): Set<
   return out;
 }
 
+/**
+ * System cards of `types` that a newer card of the same object in `messages`
+ * repeats (their ids): a proposal filed and then applied is one live card.
+ */
+export function supersededCards(
+  messages: readonly ChatMessageView[],
+  types: readonly string[],
+): Set<string> {
+  const keyOf = (m: ChatMessageView) =>
+    m.author_kind === "system" && m.card && types.includes(m.card.type)
+      ? `${m.card.type}:${m.card.id ?? m.card.ref ?? ""}`
+      : null;
+  const newest = new Map<string, ChatMessageView>();
+  for (const message of messages) {
+    const key = keyOf(message);
+    const seen = key ? newest.get(key) : undefined;
+    if (key && (!seen || seen.seq < message.seq)) newest.set(key, message);
+  }
+  const out = new Set<string>();
+  for (const message of messages) {
+    const key = keyOf(message);
+    if (key && newest.get(key)?.id !== message.id) out.add(message.id);
+  }
+  return out;
+}
+
 interface BaseItem {
   type: "base";
   key: string;

From c24e7b648951c6409ec25dc0de3ce9b26798de9a Mon Sep 17 00:00:00 2001
From: Luka Skugor <luka.skugor@dfinity.org>
Date: Wed, 4 Nov 2026 09:10:29 +0100
Subject: [PATCH 3/4] cockpit v3: Undo of an answer puts the ask back; Undo
 only where the server keeps one

- POST /v1/factory/decisions/{id}/undo takes back an Apply on a projects
  proposal's decision: the proposal's own Undo runs, then it waits for a
  person again under a fresh decision (as reopen leaves one), so the work held
  for it waits again (a hold the sweep let lapse comes back and its PL is told)
  and the ask is in Needs you again. The answered decision stays answered.
- The web offers an answer's Undo only when the proposal it applied is applied
  with an undo_until (never a rules, tuning or code change), until that time on
  the server's clock; Undo calls the new route and says where the ask is now.
- An answer the server stored but whose proposal failed to apply says so
  ("D-50 answered; applying C-17 failed: ..."), with no Undo; the failure body
  carries the reason.
- A verb card's Undo shows only to the person who applied it (meta.by_user)
  or an owner, and only an open Undo ticks its clock.
- ?nodes=1 lists at most the newest 50 node threads.
- The e2e sweep exempts icons only inside controls; the seed's C-17 and C-18
  add real rules, and a new e2e applies one from the factory tree.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/FACTORY.md                               |  18 +-
 omnigent/server/factory/api/chat.py           |   9 +-
 omnigent/server/factory/api/cockpit_write.py  |  18 +-
 omnigent/server/factory/chat.py               |  11 +-
 omnigent/server/factory/decisions.py          |   3 +-
 omnigent/server/factory/node_verbs.py         |   3 +
 omnigent/server/factory/proposals.py          | 188 +++++++++++++++++-
 omnigent/server/factory/schemas.py            |   2 +
 omnigent/server/factory/tasks.py              |  83 ++++++++
 tests/e2e_ui/factory_v3/checks.py             |  13 +-
 tests/e2e_ui/factory_v3/seed.py               |  27 ++-
 tests/e2e_ui/factory_v3/test_v3_steering.py   |  76 ++++++-
 tests/server/factory/test_human_origin.py     |   2 +-
 tests/server/factory/test_node_threads.py     |  26 ++-
 tests/server/factory/test_undo_answer.py      | 158 +++++++++++++++
 .../factory/v3/answerUndo.live.test.ts        | 124 ++++++++++++
 .../factory/v3/chat/NodeChat.test.tsx         |  63 ++++++
 .../components/factory/v3/chat/NodeChat.tsx   |  71 ++++---
 .../factory/v3/fixture/renderChat.tsx         |   6 +-
 .../factory/v3/fixture/sampleNodeSource.ts    |   1 +
 .../factory/v3/fixture/sampleSteer.ts         |  37 +++-
 web/src/components/factory/v3/nodeSource.ts   |  75 +++++--
 web/src/components/factory/v3/nodeSteer.ts    |  70 +++++--
 web/src/components/factory/v3/nodeTypes.ts    |  18 ++
 .../factory/v3/nodeWire.server.test.tsx       |   4 +-
 .../components/factory/v3/steerLive.test.tsx  |  21 +-
 web/src/lib/factoryApi.ts                     |   2 +
 27 files changed, 1029 insertions(+), 100 deletions(-)
 create mode 100644 tests/server/factory/test_undo_answer.py
 create mode 100644 web/src/components/factory/v3/answerUndo.live.test.ts

diff --git a/docs/FACTORY.md b/docs/FACTORY.md
index ceab02d8930..7d7e2757e1d 100644
--- a/docs/FACTORY.md
+++ b/docs/FACTORY.md
@@ -291,6 +291,7 @@ if they stay silent the board is still right.
 | `GET …/{fid}/proposals?kind=&status=`, `GET …/proposals/{ref}`, `POST …/proposals/{ref}/apply` (`{changes?}`), `…/reject` (`{note?}`), `…/undo` | human (EDIT; MANAGE for an owner-class proposal) | Proposals `C-<n>`; apply and reject answer the mirrored decision, so one of two clicks wins. |
 | `POST /v1/factory/factories/{fid}/control` | human (EDIT; MANAGE for STOP, RESTART, RELAUNCH) | PAUSE, RESUME, STOP, RESTART, RELAUNCH, cadence, PREVIEW / PREVIEW_DOWN of a PR, ENV STATUS: a server-stamped `[Factory control …]` to the members. |
 | `GET /v1/factory/decisions`, `POST …/decisions/{id}/answer`, `…/withdraw` | human | Open decisions (also in `/inbox`); the answer is delivered to the asker as `[Factory decision · D-<n> answered …]`. |
+| `POST …/decisions/{id}/undo` | human (EDIT; MANAGE for an owner-class proposal) | Takes back an Apply on a projects proposal's decision within the proposal's Undo window: the proposal is undone and waits for a person again under a fresh decision (`{proposal, decision}`); the answered decision stays answered. |
 | `POST /v1/factory/prs/{id}/feedback`, `…/refresh` | human | Approve or request changes (`[Factory review …]` to the PL); re-poll GitHub now. |
 | `GET /v1/factory/prs/{id}/preview` | human | Stable live-preview link: 302 to the current preview app URL, or back to the cockpit when there is none. |
 | `GET /v1/factory/demos/{demo_id}/files/{file_id}` | human (READ on the PL) | Demo files with Range/206 (a ranged read of the store) and ETag; only images and video inline, never HTML or SVG. |
@@ -1190,8 +1191,9 @@ only that plan (409 `stale`, with the new preview, when what it touches
 moved), then posts a `preview_applied` card and returns the node page with
 an Undo token; `POST …/undo/{token}` takes it back once within 10 minutes
 (the person who applied it, or an owner). The card carries the token
-(`meta.undo_token`, `undo_until`), so cockpit v3's chat offers the same Undo
-after a reload; the card an Undo posts (`meta.undone`) names the token it
+(`meta.undo_token`, `undo_until`) and who applied it (`meta.by_user`), so
+cockpit v3's chat offers the same Undo after a reload, to that person or an
+owner only; the card an Undo posts (`meta.undone`) names the token it
 undid, and the applied card stops offering it. The verbs run today's cores: `add`
 under a feature files the person's projects proposal extending it and
 applies it at once ("Plan X now" goes to the feature's thread; a title that
@@ -1241,8 +1243,16 @@ parents one level up. Plain words in the node's chat ("start the panel now",
 Team is the team editor in a panel (every member's vendor and model, nothing
 preselected, the $/h before and after) on the definition's own preview, a
 definition version and Undo by re-pinning the version before; the other
-verbs wait for `POST …/n/{ref}/preview|apply` and `POST …/undo/{token}`
-and until then say they cannot be previewed. Sheets open from the address:
+verbs preview and apply through `POST …/n/{ref}/preview|apply` and undo
+through `POST …/undo/{token}`. An answer that applied a projects proposal
+(Apply on D-45 applies C-16) keeps an Undo while the proposal's
+`undo_until` lasts (a rules, tuning or code change, a cancel, split or
+merge has none, so none is offered): `POST /v1/factory/decisions/{id}/undo`
+undoes the proposal and puts it back to pending under a fresh decision, so
+the work held for it waits again (a hold the sweep let lapse comes back,
+and its PL is told `[Factory notice · HOLD BACK …]`) and the ask is in Needs
+you again. An answer the server stored but whose proposal failed to apply
+says so ("D-50 answered; applying C-17 failed: …"), with no Undo. Sheets open from the address:
 `?peek=needs` (Needs you, ranked by what each ask holds, the asks that block
 nothing grouped with "Apply all", the closed alarms, the other tree's count;
 from `GET …/needs-you`), `?peek=env` (the base env), `?peek=try&at=<ref>`
diff --git a/omnigent/server/factory/api/chat.py b/omnigent/server/factory/api/chat.py
index f3964bc23db..21e07c0b28d 100644
--- a/omnigent/server/factory/api/chat.py
+++ b/omnigent/server/factory/api/chat.py
@@ -6,7 +6,7 @@
   responder, last ``seq``, the caller's unread count and ``node_ref`` (the node
   it is about: ``product``, a project's slug, ``PR-<n>``, ``T-16`` …; ``null``
   for ``#discovery``). ``nodes=1`` adds the node threads (``need:``,
-  ``feature:``, ``study:``, ``task:``) that have messages. READ.
+  ``feature:``, ``study:``, ``task:``) that have messages, the newest 50. READ.
 - ``GET /v1/factory/factories/{fid}/chat?thread=&before_seq=&after_seq=&limit=``:
   a page of messages, oldest first. READ.
 
@@ -62,6 +62,8 @@
 PAGE_MAX: Final = 200
 UNREAD_CAP: Final = 99
 MENTION_PREVIEW_CHARS: Final = 200
+NODE_THREADS_MAX: Final = 50
+"""Node threads ``?nodes=1`` lists at most (the newest): each costs a lookup and an unread read."""
 _T = TypeVar("_T")
 
 # Factory events become cards in the Room.
@@ -186,7 +188,8 @@ def thread_views(
 
     :param hidden: Project slugs left out, with their PR threads (and their tasks' threads).
     :param nodes: Also the node threads (``need:``, ``feature:``, ``study:``, ``task:``)
-        that have messages, newest first, after the PRs.
+        that have messages, newest first, after the PRs (the newest
+        :data:`NODE_THREADS_MAX`: each costs a lookup and an unread read).
     :returns: ``ThreadView`` JSON, fixed threads first, then projects, then PRs (newest first).
     """
     store = deps.factory_store
@@ -202,7 +205,7 @@ def thread_views(
     if nodes:
         node_keys = [k for k in stats if thread_kind(k) in chat_routing.NODE_KINDS]
         node_keys.sort(key=lambda k: -stats[k].last_seq)
-        keys += [k for k in node_keys if k not in keys]
+        keys += [k for k in node_keys[:NODE_THREADS_MAX] if k not in keys]
     threads: list[chat.Thread] = []
     for key in keys:
         try:
diff --git a/omnigent/server/factory/api/cockpit_write.py b/omnigent/server/factory/api/cockpit_write.py
index f916a771816..f3483d81232 100644
--- a/omnigent/server/factory/api/cockpit_write.py
+++ b/omnigent/server/factory/api/cockpit_write.py
@@ -3,6 +3,8 @@
 Routes (user JWT; access per route, see each module):
 
 - ``POST /v1/factory/decisions/{id}/answer`` / ``…/withdraw`` (:mod:`..decisions`)
+- ``POST /v1/factory/decisions/{id}/undo``: take back an Apply on a proposal's
+  decision (:func:`..proposals.undo_answer`)
 - ``POST /v1/factory/factories/{fid}/control`` (:mod:`..control`)
 - ``POST /v1/factory/prs/{id}/refresh`` / ``…/feedback`` (:mod:`..control`)
 - ``POST /v1/factory/factories``, ``POST …/{fid}/projects``,
@@ -24,7 +26,7 @@
 from pydantic import BaseModel, ConfigDict, Field
 
 from omnigent.entities.factory import FactoryEvent, FactoryProject
-from omnigent.server.factory import control, decisions, feedback, start
+from omnigent.server.factory import control, decisions, feedback, proposals, start
 from omnigent.server.factory.context import FactoryDeps, factory_deps
 from omnigent.server.factory.control import CockpitError
 from omnigent.server.factory.envelope import display_title
@@ -129,6 +131,20 @@ async def run() -> dict[str, Any]:
     return await _guard(run)
 
 
+@router.post("/decisions/{decision_id}/undo", response_model=None, dependencies=HUMAN_ORIGIN)
+async def undo_answer(request: Request, decision_id: str) -> dict[str, Any] | JSONResponse:
+    """
+    Take back an Apply on a proposal's decision within its Undo window: the
+    proposal is undone and waits for a person again under a fresh decision.
+    """
+    _, user_id = _caller(request)
+
+    async def run() -> dict[str, Any]:
+        return await proposals.undo_answer(request.app.state, decision_id, user_id=user_id)
+
+    return await _guard(run)
+
+
 @router.post("/decisions/{decision_id}/withdraw", response_model=None, dependencies=HUMAN_ORIGIN)
 async def withdraw_decision(
     request: Request, decision_id: str, body: WithdrawBody | None = None
diff --git a/omnigent/server/factory/chat.py b/omnigent/server/factory/chat.py
index 5a8ffb67d35..2cb54ab982c 100644
--- a/omnigent/server/factory/chat.py
+++ b/omnigent/server/factory/chat.py
@@ -869,7 +869,16 @@ def _meta_view(meta: object) -> dict[str, Any] | None:
             "kind": "preview_applied",
             **{
                 k: meta[k]
-                for k in ("verb", "label", "by", "undo_token", "undo_until", "filed", "undone")
+                for k in (
+                    "verb",
+                    "label",
+                    "by",
+                    "by_user",
+                    "undo_token",
+                    "undo_until",
+                    "filed",
+                    "undone",
+                )
                 if isinstance(meta.get(k), str | int | bool) and not isinstance(meta.get(k), float)
             },
         }
diff --git a/omnigent/server/factory/decisions.py b/omnigent/server/factory/decisions.py
index 65a5442ee2e..aa1ddc358df 100644
--- a/omnigent/server/factory/decisions.py
+++ b/omnigent/server/factory/decisions.py
@@ -633,7 +633,8 @@ async def _run_proposal_answer(
             decision=view,
         )
         if isinstance(exc, CockpitError):
-            failure.extra = {**exc.extra, "decision": view}
+            # Why the proposal did not apply, in its own words (a cockpit refusal's text).
+            failure.extra = {**exc.extra, "decision": view, "reason": exc.message}
         return answered, None, None, failure
     if not sent:
         answered = (
diff --git a/omnigent/server/factory/node_verbs.py b/omnigent/server/factory/node_verbs.py
index a26079cc734..1a00f7be0ed 100644
--- a/omnigent/server/factory/node_verbs.py
+++ b/omnigent/server/factory/node_verbs.py
@@ -2793,6 +2793,9 @@ async def _record(env: Env, plan: Plan, applied: Applied) -> dict[str, Any] | No
 
 async def _card(env: Env, plan: Plan, applied: Applied, undo: Mapping[str, Any] | None) -> None:
     meta: dict[str, Any] = {"verb": plan.verb, "label": plan.title, "by": env.by}
+    if env.user_id:
+        # Who may undo it from the card: this person, or an owner.
+        meta["by_user"] = env.user_id
     if applied.filed:
         meta["filed"] = applied.filed
     if undo:
diff --git a/omnigent/server/factory/proposals.py b/omnigent/server/factory/proposals.py
index e27b9238d26..bc877371407 100644
--- a/omnigent/server/factory/proposals.py
+++ b/omnigent/server/factory/proposals.py
@@ -2815,7 +2815,6 @@ async def undo(app_state: Any, factory_id: str, ref: str, *, user_id: str | None
         (cancel those projects instead).
     """
     deps = factory_deps(app_state)
-    store = deps.factory_store
     root = await control.load_factory_root(deps, user_id, factory_id)
     await control.require(deps, user_id, root.id, LEVEL_EDIT)
     row = await asyncio.to_thread(find_proposal, deps, root.id, ref)
@@ -2824,8 +2823,37 @@ async def undo(app_state: Any, factory_id: str, ref: str, *, user_id: str | None
     if row.approval == "owner":
         await control.require(deps, user_id, root.id, LEVEL_MANAGE)
     label = proposal_ref(row.number)
-    now = now_s()
-    if row.status != "applied" or row.undo_until is None or now > row.undo_until:
+    created = await _undo_checks(deps, root, row)
+    actor = await asyncio.to_thread(projects.human_actor, deps, user_id, root.id)
+    row, restored = await _take_back(app_state, root, row, created, actor)
+    by = projects.actor_name(actor)
+    await events.emit(
+        app_state,
+        root.id,
+        "proposal.undone",
+        severity="notice",
+        subject=f"{_SUBJECT_PREFIX}{label}",
+        summary=f"{label} undone by {by}",
+        data={
+            **actor.event_data(),
+            "proposal_id": row.id,
+            "dropped": created,
+            "restored": restored,
+        },
+    )
+    _tell_proposer(app_state, row, closed_text(label, "undone", by), None)
+    return await asyncio.to_thread(proposal_view, deps, row)
+
+
+async def _undo_checks(deps: FactoryDeps, root: Conversation, row: FactoryProposal) -> list[str]:
+    """
+    Whether *row*'s Undo may run now; :returns: the projects it created (Undo drops them).
+
+    :raises CockpitError: 409 ``undo_closed`` / ``undo_stale`` / ``already_spawned``.
+    """
+    store = deps.factory_store
+    label = proposal_ref(row.number)
+    if row.status != "applied" or row.undo_until is None or now_s() > row.undo_until:
         raise CockpitError(
             409, "undo_closed", f"{label} can no longer be undone", status=row.status
         )
@@ -2874,7 +2902,25 @@ async def undo(app_state: Any, factory_id: str, ref: str, *, user_id: str | None
                 project=slug,
                 newer=newer,
             )
-    actor = await asyncio.to_thread(projects.human_actor, deps, user_id, root.id)
+    return created
+
+
+async def _take_back(
+    app_state: Any,
+    root: Conversation,
+    row: FactoryProposal,
+    created: Sequence[str],
+    actor: Actor,
+) -> tuple[FactoryProposal, list[str]]:
+    """
+    Mark *row* undone (a compare-and-set on ``applied``), drop the projects it
+    created and put back the charters it changed.
+
+    :returns: The row as stored and the slugs whose charter was put back.
+    :raises CockpitError: 409 ``undo_closed`` when it was undone meanwhile.
+    """
+    store = factory_deps(app_state).factory_store
+    label = proposal_ref(row.number)
     try:
         row = (
             await asyncio.to_thread(
@@ -2882,7 +2928,7 @@ async def undo(app_state: Any, factory_id: str, ref: str, *, user_id: str | None
                     row.id,
                     expect_status="applied",
                     status="undone",
-                    reverted_at=now,
+                    reverted_at=now_s(),
                     reverted_by=actor.id,
                 )
             )
@@ -2920,23 +2966,145 @@ async def undo(app_state: Any, factory_id: str, ref: str, *, user_id: str | None
                 via=f"undo {label}",
             )
             restored.append(slug)
+    return row, restored
+
+
+def back_to_pending_text(ref: str, by: str, answer: str, decision: str) -> str:
+    """:returns: ``[Factory proposal · C-16 back to pending: …]`` for its proposer."""
+    return (
+        f"[Factory proposal · {ref} back to pending: {by} undid the Apply on {answer}; "
+        f"{decision} asks a person again] Record it in the ledger."
+    )
+
+
+def _applied_answer(decision: FactoryDecision) -> bool:
+    """Whether *decision* was answered with an option that applies its proposal."""
+    if decision.status != "answered" or not decision.answer_option_id:
+        return False
+    option = next(
+        (o for o in decision.options if str(o.get("id")) == decision.answer_option_id), None
+    )
+    return option is not None and option.get("action") == ACTION_APPLY_PROPOSAL
+
+
+async def undo_answer(app_state: Any, decision_id: str, *, user_id: str | None) -> dict:
+    """
+    Take back a person's Apply on a proposal's decision
+    (``POST /v1/factory/decisions/{id}/undo``), within the proposal's Undo window.
+
+    The proposal's own Undo runs (:func:`undo`'s checks; its created projects
+    dropped, its charters put back), and then it waits for a person again:
+    pending under a fresh decision, as :func:`reopen` leaves one. So the work held
+    for it waits again (a hold the sweep let lapse meanwhile comes back) and the
+    ask is in Needs you again. The answered decision stays as it was.
+
+    :returns: ``{proposal, decision}``: the proposal and its fresh decision.
+    :raises CockpitError: 404 ``unknown_decision``; 409 ``undo_closed`` (not an
+        applied proposal's Apply, or its window is over) and :func:`undo`'s refusals.
+    """
+    from omnigent.server.factory import decisions, tasks
+
+    deps = factory_deps(app_state)
+    store = deps.factory_store
+    try:
+        decision = await asyncio.to_thread(store.get_decision, decision_id)
+    except ValueError:
+        decision = None
+    if decision is None:
+        raise CockpitError(404, "unknown_decision", f"no decision {decision_id!r}")
+    root = await control.load_factory_root(deps, user_id, decision.factory_id)
+    await control.require(deps, user_id, root.id, LEVEL_EDIT)
+    raw = (decision.subject or "").removeprefix(_SUBJECT_PREFIX)
+    row = (
+        await asyncio.to_thread(find_proposal, deps, root.id, raw) if is_mirror(decision) else None
+    )
+    if (
+        row is None
+        or row.kind != KIND_PROJECTS
+        or not _applied_answer(decision)
+        or not control.same_id(row.decision_id, decision.id)
+    ):
+        raise CockpitError(
+            409,
+            "undo_closed",
+            f"{decision.ref} did not apply a proposal that can be taken back",
+        )
+    if row.approval == "owner":
+        await control.require(deps, user_id, root.id, LEVEL_MANAGE)
+    label = proposal_ref(row.number)
+    applied_at = row.applied_at or row.decided_at or decision.answered_at or now_s()
+    created = await _undo_checks(deps, root, row)
+    actor = await asyncio.to_thread(projects.human_actor, deps, user_id, root.id)
+    row, restored = await _take_back(app_state, root, row, created, actor)
     by = projects.actor_name(actor)
+    # Pending again, read against the factory as the Undo left it, with no grace
+    # timer: it waits for a person, as a reopened proposal does.
+    plan = await asyncio.to_thread(_cosign_plan, deps, root, row)
+    now = now_s()
+    reason = f"{by} undid the Apply on {decision.ref}"
+    try:
+        row = (
+            await asyncio.to_thread(
+                lambda: store.update_proposal(
+                    row.id,
+                    expect_status="undone",
+                    status="pending",
+                    decided_by=None,
+                    decided_at=None,
+                    applied_at=None,
+                    undo_until=None,
+                    before=None,
+                    after=None,
+                    based_on=plan.based_on or row.based_on,
+                    result={
+                        "reopened": {"by": actor.id, "at": now, "code": "undone", "reason": reason}
+                    },
+                )
+            )
+            or row
+        )
+    except ProposalStateConflict as exc:
+        raise CockpitError(
+            409, "undo_closed", f"{label} is already {exc.proposal.status}"
+        ) from None
+    author = (
+        await asyncio.to_thread(_title_of, deps, row.author)
+        if row.author_kind == "agent"
+        else control.human_name(row.author)
+    )
+    fresh = await _mirror(app_state, root, row, plan, author)
+    row = await asyncio.to_thread(store.update_proposal, row.id, decision_id=fresh.id) or row
+    held = await tasks.hold_again(
+        app_state,
+        root.id,
+        label,
+        since=int(applied_at),
+        why=f"{label} waits for a person again ({fresh.ref}): {reason}",
+        actor=actor,
+    )
     await events.emit(
         app_state,
         root.id,
         "proposal.undone",
         severity="notice",
         subject=f"{_SUBJECT_PREFIX}{label}",
-        summary=f"{label} undone by {by}",
+        summary=f"{label} undone by {by}: it waits for a person again in {fresh.ref}",
         data={
             **actor.event_data(),
             "proposal_id": row.id,
-            "dropped": created,
+            "dropped": list(created),
             "restored": restored,
+            "answer": decision.ref,
+            "decision": fresh.ref,
+            "back_to": "pending",
+            "held_again": held,
         },
     )
-    _tell_proposer(app_state, row, closed_text(label, "undone", by), None)
-    return await asyncio.to_thread(proposal_view, deps, row)
+    _tell_proposer(app_state, row, back_to_pending_text(label, by, decision.ref, fresh.ref), None)
+    return {
+        "proposal": await asyncio.to_thread(proposal_view, deps, row),
+        "decision": await asyncio.to_thread(decisions.decision_view, deps, fresh),
+    }
 
 
 def _changed_since(row: FactoryProposal, slug: str, current: FactoryProject) -> bool:
@@ -3443,6 +3611,7 @@ async def apply_graceful(app_state: Any, factory_id: str, *, now: int | None = N
     "apply_graceful",
     "apply_now",
     "ask_initiative",
+    "back_to_pending_text",
     "charter_hash",
     "check_based_on",
     "close_stale",
@@ -3471,6 +3640,7 @@ async def apply_graceful(app_state: Any, factory_id: str, *, now: int | None = N
     "sent_back_text",
     "stale_reason",
     "undo",
+    "undo_answer",
     "validate",
     "withdraw",
 ]
diff --git a/omnigent/server/factory/schemas.py b/omnigent/server/factory/schemas.py
index 3d904873a48..d63c7241e7f 100644
--- a/omnigent/server/factory/schemas.py
+++ b/omnigent/server/factory/schemas.py
@@ -1603,6 +1603,7 @@ class PreviewAppliedMeta(_View):
     """
     A structural verb applied (or undone) from the cockpit, in its node's thread.
 
+    :param by_user: Who applied it (a user id): they, or an owner, may undo it.
     :param undo_token: ``POST …/undo/{token}`` takes it back until ``undo_until``.
     :param filed: The proposal it was filed as (``C-19``), when it was.
     """
@@ -1611,6 +1612,7 @@ class PreviewAppliedMeta(_View):
     verb: str
     label: str | None = None
     by: str | None = None
+    by_user: str | None = None
     undo_token: str | None = None
     undo_until: int | None = None
     filed: str | None = None
diff --git a/omnigent/server/factory/tasks.py b/omnigent/server/factory/tasks.py
index 8742f8a843c..0d180c5d4e2 100644
--- a/omnigent/server/factory/tasks.py
+++ b/omnigent/server/factory/tasks.py
@@ -2182,6 +2182,87 @@ def run() -> list[tuple[FactoryTask, dict[str, Any], str, bool]]:
     return [row.ref for row, *_ in lapsed]
 
 
+HOLD_BACK_HEAD: Final = "[Factory notice · HOLD BACK"
+
+
+def hold_back_text(task: FactoryTask, hold: Mapping[str, Any], why: str) -> str:
+    """The ``[Factory notice · HOLD BACK · T-n · why]`` mail to the task's PL."""
+    on = waits.clip(str(hold.get("on") or "-"), 80)
+    return (
+        f"{HOLD_BACK_HEAD} · {task.ref}]\n"
+        f'Your hold on {task.ref} ({task.key}) on "{on}" is back: {waits.clip(why, 200)}. '
+        f"Keep {task.ref} waiting until it is answered; if its IC started on it meanwhile, "
+        "stop it at a clean point."
+    )
+
+
+async def hold_again(
+    app_state: Any,
+    factory_id: str,
+    ref: str,
+    *,
+    since: int,
+    why: str,
+    actor: Actor,
+) -> list[str]:
+    """
+    Put back the holds on *ref* (``C-n`` or ``D-n``) that lapsed since *since*
+    because it closed, now that it is open again (an Undo took its answer back).
+
+    Each comes back as it was, until its own ``until``; a task that closed or was
+    held on something else meanwhile is left alone. Logs ``task.held`` and tells
+    the PL. Never raises.
+
+    :param since: When *ref* closed (epoch seconds): older lapses are not its.
+    :returns: The refs of the tasks held again.
+    """
+    number = waits.ref_number(ref)
+    kind = waits.REF_KIND_PROPOSAL if ref.upper().startswith("C-") else waits.REF_KIND_DECISION
+    if number is None:
+        return []
+    deps = factory_deps(app_state)
+    store = deps.factory_store
+
+    def run() -> list[tuple[FactoryTask, dict[str, Any]]]:
+        now = int(time.time())
+        out: list[tuple[FactoryTask, dict[str, Any]]] = []
+        for event in store.find_events(factory_id, ["task.released"], since * 1000, limit=500):
+            data = event.data or {}
+            hold = data.get("hold")
+            if data.get("reason") != "lapsed" or not isinstance(hold, Mapping):
+                continue
+            if hold.get("kind") != kind or waits.ref_number(hold.get("ref")) != number:
+                continue
+            until = waits.hold_until(hold)
+            if until is not None and now >= until:
+                continue
+            try:
+                task = store.get_task(str(data.get("task_id") or ""))
+            except ValueError:
+                task = None
+            if task is None or task.hold or task.state in TASK_CLOSED_STATES:
+                continue
+            row = store.update_task(task.id, hold=dict(hold)) or task
+            out.append((row, dict(hold)))
+        return out
+
+    try:
+        async with lock(factory_id):
+            held = await asyncio.to_thread(run)
+    except Exception:  # noqa: BLE001 - the sweep's next tick reads the holds as they are
+        _logger.warning("factory tasks: holds on %s not put back", ref, exc_info=True)
+        return []
+    for row, hold in held:
+        try:
+            await _hold_event(
+                app_state, factory_id, row, hold, f"{row.ref} held again: {why}", actor
+            )
+            await _mail_pl(app_state, factory_id, row.project_slug, hold_back_text(row, hold, why))
+        except Exception:  # noqa: BLE001 - the hold is already back
+            _logger.warning("factory tasks: hold of %s back but not told", row.id, exc_info=True)
+    return [row.ref for row, _ in held]
+
+
 def reset() -> None:
     """Forget cached observations and locks (tests)."""
     _observed.clear()
@@ -2211,6 +2292,8 @@ def reset() -> None:
     "emit_all",
     "engine_mode",
     "get_view",
+    "hold_again",
+    "hold_back_text",
     "hold_lapsed_text",
     "hold_of_input",
     "hold_task",
diff --git a/tests/e2e_ui/factory_v3/checks.py b/tests/e2e_ui/factory_v3/checks.py
index 5cfc7f4b220..0fac8135415 100644
--- a/tests/e2e_ui/factory_v3/checks.py
+++ b/tests/e2e_ui/factory_v3/checks.py
@@ -2,9 +2,11 @@
 What every cockpit v3 screen must hold, checked in the browser. Not a test module.
 
 - :data:`BODY_CHECKS` sweeps a node page and v3's own parts of its chat
-  column: no line, path or polygon drawn between nodes (icons are glyphs, not
-  links between nodes, and are left out), no leaf that says only "none", "0"
-  or "—", and no sideways scroll of the page.
+  column: no line, path or polygon drawn between nodes (an icon inside a
+  control, a button, a link or a chip, is a glyph and is left out; one anywhere
+  else counts, so a connector drawn with an icon is caught), no leaf that says
+  only "none", "0" or "—", and no sideways scroll of the page. In the chat
+  column the Room's answer cards and the chat's icons stay as they are.
 - :func:`node` is a node page by ref; :func:`api` reads the factory's API as
   the browser's user (single-user server: no header).
 """
@@ -22,12 +24,13 @@
   )];
   const roots = new Set(chat);
   const room = '[data-testid^="decision-card-"], [data-testid^="proposal-card-"], '
-    + '[data-testid^="loop-card-"]';
+    + '[data-testid^="loop-card-"], svg.lucide';
   const own = (el) => {
     const part = el.closest('[data-testid^="v3-"]');
     return part !== null && !roots.has(part) && el.closest(room) === null;
   };
-  const icon = (el) => el.closest('svg.lucide') !== null;
+  const control = 'button, a, [role="button"], [data-testid="v3-chip"]';
+  const icon = (el) => el.closest('svg.lucide') !== null && el.closest(control) !== null;
   const body = (el) => !chat.some((c) => c.contains(el)) || own(el);
   const shown = (sel) => [...document.querySelectorAll(sel)]
     .filter((el) => node.contains(el) || chat.some((c) => c.contains(el)))
diff --git a/tests/e2e_ui/factory_v3/seed.py b/tests/e2e_ui/factory_v3/seed.py
index 2d5dea9ee97..10d9358fbe3 100644
--- a/tests/e2e_ui/factory_v3/seed.py
+++ b/tests/e2e_ui/factory_v3/seed.py
@@ -14,7 +14,8 @@
 - an Atlas proposal (C-12) made ``build-tier-drafts-3``, whose two PRs wait for
   a person to merge them into ``main``;
 - C-14 and C-15 ask things that block nothing; C-19 (D-49) proposes a follow-up
-  under I-1; C-17 and C-18 are rule proposals for the factory tree;
+  under I-1; C-17 and C-18 are rule proposals for the factory tree, each adding
+  a rule (Apply makes a definition version);
 - the server closed three alarms today (D-46, D-47, D-48);
 - the base env (the integration project ``base-env``) runs the base's head,
   which holds every merge, and answers its smoke checks;
@@ -625,11 +626,27 @@ def seed_factory_1340(
         )
 
     # ── C-17, C-18 (rules), C-19 (a follow-up under I-1); D-49…D-51 ──
+    # Each adds a real rule, so Apply makes a definition version (no Undo token).
     rules = [
-        _proposal(fs, fid, title, kind="rules", author=sentinel)
-        for title in (
-            "Spike unproven external capabilities first",
-            "Name pending scope decisions in READY posts",
+        _proposal(
+            fs,
+            fid,
+            title,
+            kind="rules",
+            author=sentinel,
+            ops=[{"op": "add", "path": "rules", "value": {"role": role, "text": text}}],
+        )
+        for title, role, text in (
+            (
+                "Spike unproven external capabilities first",
+                F.ROLE_LEAD,
+                "Spike an unproven external capability before planning work on it (sample).",
+            ),
+            (
+                "Name pending scope decisions in READY posts",
+                F.ROLE_PROJECT_LEAD,
+                "Name the pending scope decision a READY post waits on (sample).",
+            ),
         )
     ]
     follow_up = _proposal(
diff --git a/tests/e2e_ui/factory_v3/test_v3_steering.py b/tests/e2e_ui/factory_v3/test_v3_steering.py
index e1df14e1df5..fb9ff7aa9a0 100644
--- a/tests/e2e_ui/factory_v3/test_v3_steering.py
+++ b/tests/e2e_ui/factory_v3/test_v3_steering.py
@@ -5,7 +5,9 @@
 The server holds a factory shaped like a real one at 13:40 (``seed.py``). Each
 test seeds its own, so what one applies never leaks into another:
 
-- Apply on a decision answers it, and its Undo (the proposal's own) takes it back;
+- Apply on a decision answers it, and its Undo takes it back: the proposal asks
+  a person again (a fresh ask), what it held waits again, Needs you lists it;
+- Apply on a factory-tree rule makes a definition version, with no Undo offered;
 - Start now on the waiting panel: the preview moves it to First in its
   feature's columns, Apply relaxes its wait to the merged change, the status
   line changes, Undo restores it;
@@ -103,6 +105,18 @@ def _thread(v3_server: V3Server, factory: Seeded, key: str) -> list[str]:
 # ── Answer, then Undo ──────────────────────────────────────────
 
 
+def _needs_you(v3_server: V3Server, factory: Seeded, tree: str = "product") -> list[str]:
+    """The ids of the asks in *tree*'s Needs you, ranked."""
+    found = api(v3_server.base_url, factory.fid, "/needs-you", tree=tree)
+    return [i["decision"]["id"] for i in found["items"]]
+
+
+def _status_of(v3_server: V3Server, factory: Seeded, ref: str) -> dict[str, object]:
+    """Node *ref*'s status line as the API gives it, without the ask's id."""
+    status = api(v3_server.base_url, factory.fid, f"/n/{ref}")["status"]
+    return {"label": status.get("label"), "ends": status.get("ends")}
+
+
 def test_apply_on_a_decision_then_undo_takes_it_back(
     open_cockpit: Callable[[int, int, Theme], Cockpit],
     v3_server: V3Server,
@@ -110,6 +124,8 @@ def test_apply_on_a_decision_then_undo_takes_it_back(
 ) -> None:
     cockpit = open_cockpit(1440, 900, "light")
     page = cockpit.page
+    held_before = _status_of(v3_server, factory, factory.held_task)
+    assert factory.apply_decision in _needs_you(v3_server, factory)
     cockpit.open(factory.project)
     status = _status(page, factory.project)
     expect(status).to_contain_text(
@@ -127,26 +143,72 @@ def test_apply_on_a_decision_then_undo_takes_it_back(
     expect(status).not_to_contain_text(factory.apply_decision, timeout=LOAD_MS)
     applied = api(v3_server.base_url, factory.fid, f"/proposals/{factory.proposal}")
     assert applied["proposal"]["status"] == "applied", applied
+    assert _status_of(v3_server, factory, factory.held_task) != held_before
 
-    # The answer applied C-16: its own Undo stays beside the verbs for 10 minutes.
+    # The answer applied C-16: its Undo stays beside the verbs while the server keeps one.
     undo = _undo_latest(page, factory.project, f"Apply {factory.proposal}")
     with page.expect_response(
-        lambda r: (
-            r.request.method == "POST" and r.url.endswith(f"/proposals/{factory.proposal}/undo")
-        )
+        lambda r: r.request.method == "POST" and r.url.endswith("/undo")
     ) as undone:
         undo.click()
     assert undone.value.status == 200, undone.value.text()
+    assert "/decisions/" in undone.value.url, undone.value.url
+    fresh = undone.value.json()["decision"]["ref"]
+    assert fresh != factory.apply_decision
     expect(page.locator("[data-factory-toast]")).to_contain_text(
-        f"Undone: Apply {factory.proposal} ({factory.apply_decision})."
+        f"Undone: Apply {factory.proposal} ({factory.apply_decision}). "
+        f"{factory.proposal} asks again in {fresh}."
     )
     expect(node(page, factory.project).get_by_test_id("v3-undo-latest")).to_have_count(0)
+    # Put back: C-16 waits for a person again, T-16 is held for it, and the ask is in Needs you.
+    expect(status).to_contain_text(
+        f"needs you: Apply {factory.proposal} ({fresh})", timeout=LOAD_MS
+    )
     after = api(v3_server.base_url, factory.fid, f"/proposals/{factory.proposal}")
-    assert after["proposal"]["status"] == "undone", after
+    assert after["proposal"]["status"] == "pending", after
+    assert after["proposal"]["decision_ref"] == fresh, after
+    assert _status_of(v3_server, factory, factory.held_task) == held_before
+    asks = _needs_you(v3_server, factory)
+    assert fresh in asks and factory.apply_decision not in asks, asks
     _clean(page, factory.project, "after undo")
     assert cockpit.errors == [], cockpit.errors
 
 
+def test_apply_on_a_factory_tree_rule_makes_a_version_with_no_undo(
+    open_cockpit: Callable[[int, int, Theme], Cockpit],
+    v3_server: V3Server,
+    factory: Seeded,
+) -> None:
+    cockpit = open_cockpit(1440, 900, "light")
+    page = cockpit.page
+    cockpit.open("product")
+    page.get_by_test_id("cockpit-needs-you").click()
+    sheet = page.get_by_test_id("v3-needs-sheet")
+    expect(sheet).to_be_visible(timeout=LOAD_MS)
+    sheet.get_by_test_id("v3-needs-other-tree").click()
+    items = sheet.get_by_test_id("v3-needs-item")
+    expect(items).to_have_count(2, timeout=LOAD_MS)
+    rule = items.filter(has_text="C-17")
+    ask = rule.get_attribute("data-decision")
+    assert ask, "C-17's ask has an id"
+
+    with page.expect_response(
+        lambda r: r.request.method == "POST" and r.url.endswith("/answer")
+    ) as answered:
+        rule.get_by_role("button", name="Apply", exact=True).click()
+    assert answered.value.status == 200, answered.value.text()
+    toast = page.locator("[data-factory-toast]")
+    expect(toast).to_contain_text(f"{ask}: Apply")
+    # A rule applies as a definition version: there is no proposal Undo to offer.
+    expect(page.locator("[data-factory-toast] [data-toast-undo]")).to_have_count(0)
+    applied = api(v3_server.base_url, factory.fid, "/proposals/C-17")["proposal"]
+    assert applied["status"] in ("applied", "trial"), applied
+    assert applied["undo_until"] is None, applied
+    expect(items).to_have_count(1, timeout=LOAD_MS)
+    assert ask not in _needs_you(v3_server, factory, "factory")
+    assert cockpit.errors == [], cockpit.errors
+
+
 # ── Start now ──────────────────────────────────────────────────
 
 
diff --git a/tests/server/factory/test_human_origin.py b/tests/server/factory/test_human_origin.py
index d0cd26e18a6..5aa8d3ca677 100644
--- a/tests/server/factory/test_human_origin.py
+++ b/tests/server/factory/test_human_origin.py
@@ -304,7 +304,7 @@ def test_every_cockpit_write_route_requires_human_origin() -> None:
         for route in router.routes
         if isinstance(route, APIRoute) and route.methods & {"POST", "PUT", "PATCH", "DELETE"}
     ]
-    assert len(writes) == 9
+    assert len(writes) == 10
     for route in writes:
         calls = [dep.call for dep in route.dependant.dependencies]
         assert require_human_origin in calls, route.path
diff --git a/tests/server/factory/test_node_threads.py b/tests/server/factory/test_node_threads.py
index 33f1d8cd39a..09b6a290858 100644
--- a/tests/server/factory/test_node_threads.py
+++ b/tests/server/factory/test_node_threads.py
@@ -464,7 +464,13 @@ async def test_each_node_card_is_a_valid_chat_message(env: RoomEnv) -> None:
         (
             "preview_applied",
             "alice added T-2.",
-            {"verb": "add", "label": "Add a task", "by": "alice", "undo_token": "0" * 24},
+            {
+                "verb": "add",
+                "label": "Add a task",
+                "by": "alice",
+                "by_user": "alice",
+                "undo_token": "0" * 24,
+            },
         ),
     ]
     for kind, line, meta in cards:
@@ -482,6 +488,7 @@ async def test_each_node_card_is_a_valid_chat_message(env: RoomEnv) -> None:
     assert set(shown) == {"why", "offer", "closed_alarm", "preview_applied"}
     assert shown["closed_alarm"] is not None and shown["closed_alarm"].cause == "held for C-1"
     assert shown["preview_applied"] is not None and shown["preview_applied"].verb == "add"
+    assert shown["preview_applied"].by_user == "alice"
 
 
 async def test_the_thread_list_names_each_threads_node(env: RoomEnv) -> None:
@@ -505,6 +512,23 @@ async def test_the_thread_list_names_each_threads_node(env: RoomEnv) -> None:
     )
 
 
+async def test_the_thread_list_caps_the_node_threads_at_the_newest(
+    env: RoomEnv, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    from omnigent.server.factory.api import chat as chat_api
+
+    await _post(env, "task:T-1", "A question about the route (sample)")
+    base = f"/v1/factory/factories/{env.cockpit.fid}/chat/threads"
+    monkeypatch.setattr(chat_api, "NODE_THREADS_MAX", 0)
+
+    capped = (
+        await env.cockpit.client.get(base, params={"nodes": "1"}, headers={"X-Test-User": "alice"})
+    ).json()["data"]
+
+    keys = {t["key"] for t in capped}
+    assert "task:T-1" not in keys and "factory" in keys
+
+
 async def test_preflight_says_the_server_routes_node_threads(env: RoomEnv) -> None:
     resp = await env.cockpit.client.get("/v1/factory/preflight", headers={"X-Test-User": "alice"})
 
diff --git a/tests/server/factory/test_undo_answer.py b/tests/server/factory/test_undo_answer.py
new file mode 100644
index 00000000000..6a36d5c54e0
--- /dev/null
+++ b/tests/server/factory/test_undo_answer.py
@@ -0,0 +1,158 @@
+"""Taking back a person's Apply on a proposal's decision (``POST …/decisions/{id}/undo``).
+
+Undo of an answer puts things back as they were before it: the proposal's own
+Undo runs (its charters put back), then the proposal waits for a person again
+under a fresh decision, so the work held for it waits again and the ask is in
+Needs you again. The answered decision stays answered (history).
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import AsyncIterator
+from typing import Any
+
+import pytest
+import pytest_asyncio
+
+from omnigent.server.factory import proposals, tasks
+from omnigent.stores.factory_store import now_s
+from tests.server.factory.cockpit_helpers import Cockpit, error_code
+from tests.server.factory.conftest import FactoryWorld
+from tests.server.factory.projects_helpers import header_cockpit, propose
+
+
+@pytest_asyncio.fixture()
+async def cockpit(
+    world: FactoryWorld, db_uri: str, monkeypatch: pytest.MonkeyPatch
+) -> AsyncIterator[Cockpit]:
+    async for value in header_cockpit(world, db_uri, monkeypatch):
+        yield value
+
+
+V2 = "Add GET /version v2."
+"""The goal the proposal sets (an agent's update waits for a person)."""
+
+
+def _goal(cockpit: Cockpit) -> str:
+    row = cockpit.store.get_project(cockpit.fid, "api-version")
+    assert row is not None
+    return str((row.charter or {}).get("goal"))
+
+
+def _held_task(cockpit: Cockpit, on: str) -> Any:
+    row, _ = cockpit.store.upsert_task(
+        cockpit.fid, "api-version", "debit", title="Debit each turn", state="running"
+    )
+    hold = {"on": on, "kind": "proposal", "ref": on, "until": now_s() + 86400}
+    return cockpit.store.update_task(row.id, hold=hold) or row
+
+
+async def _filed(cockpit: Cockpit) -> Any:
+    resp = await propose(cockpit, {"op": "update", "slug": "api-version", "patch": {"goal": V2}})
+    assert resp.status_code == 200, resp.text
+    row = cockpit.store.get_proposal_by_number(cockpit.fid, 1)
+    assert row is not None and row.status == "pending" and row.decision_id
+    return row
+
+
+async def _answer(cockpit: Cockpit, decision_id: str, option: str = "apply") -> Any:
+    return await cockpit.post(f"/v1/factory/decisions/{decision_id}/answer", {"option_id": option})
+
+
+async def _undo(cockpit: Cockpit, decision_id: str, user: str = "alice") -> Any:
+    return await cockpit.post(f"/v1/factory/decisions/{decision_id}/undo", user=user)
+
+
+async def test_undo_of_an_apply_puts_the_proposal_and_its_hold_back(cockpit: Cockpit) -> None:
+    filed = await _filed(cockpit)
+    task = _held_task(cockpit, "C-1")
+    answered = await _answer(cockpit, filed.decision_id)
+    assert answered.status_code == 200, answered.text
+    assert _goal(cockpit) == V2
+    # The tick's sweep lets the hold lapse: what it named closed.
+    lapsed = await tasks.sweep_holds(cockpit.app.state, cockpit.fid, [task], now=time.time())
+    assert lapsed == [task.ref]
+
+    resp = await _undo(cockpit, filed.decision_id)
+
+    assert resp.status_code == 200, resp.text
+    body = resp.json()
+    assert body["proposal"]["status"] == "pending"
+    fresh = body["decision"]
+    old = cockpit.store.get_decision(filed.decision_id)
+    assert old is not None and old.status == "answered"
+    assert fresh["ref"] != old.ref and fresh["status"] == "open"
+    row = cockpit.store.get_proposal_by_number(cockpit.fid, 1)
+    assert row is not None and row.decision_id == fresh["id"]
+    assert row.undo_until is None and row.applied_at is None
+    assert _goal(cockpit) == "Add GET /version."
+    held = cockpit.store.get_task(task.id)
+    assert held is not None and held.hold is not None and held.hold["ref"] == "C-1"
+    told = [t for t in cockpit.mailer.texts_to(cockpit.world.id("pl")) if "HOLD BACK" in t]
+    assert told and told[0].startswith(f"[Factory notice · HOLD BACK · {task.ref}]")
+    [undone] = cockpit.events("proposal.undone")
+    assert undone.data["back_to"] == "pending"
+    assert undone.data["decision"] == fresh["ref"]
+    assert undone.data["held_again"] == [task.ref]
+    back = [
+        t for t in cockpit.mailer.texts_to(cockpit.world.id("lead_a")) if "back to pending" in t
+    ]
+    assert back and f"{fresh['ref']} asks a person again" in back[0]
+
+
+async def test_the_fresh_ask_applies_again(cockpit: Cockpit) -> None:
+    filed = await _filed(cockpit)
+    await _answer(cockpit, filed.decision_id)
+    fresh = (await _undo(cockpit, filed.decision_id)).json()["decision"]
+
+    again = await _answer(cockpit, fresh["id"])
+
+    assert again.status_code == 200, again.text
+    row = cockpit.store.get_proposal_by_number(cockpit.fid, 1)
+    assert row is not None and row.status == "applied" and row.undo_until is not None
+    assert _goal(cockpit) == V2
+
+
+async def test_only_an_applied_answer_within_its_window_is_taken_back(
+    cockpit: Cockpit, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    filed = await _filed(cockpit)
+    open_one = await _undo(cockpit, filed.decision_id)
+    assert (open_one.status_code, error_code(open_one)) == (409, "undo_closed")
+    assert (await _undo(cockpit, "nope")).status_code == 404
+
+    await _answer(cockpit, filed.decision_id)
+    late = now_s() + proposals.UNDO_WINDOW_S + 1
+    monkeypatch.setattr(proposals, "now_s", lambda: late)
+    closed = await _undo(cockpit, filed.decision_id)
+
+    assert (closed.status_code, error_code(closed)) == (409, "undo_closed")
+    row = cockpit.store.get_proposal_by_number(cockpit.fid, 1)
+    assert row is not None and row.status == "applied"
+
+
+async def test_a_reject_or_a_second_undo_is_refused(cockpit: Cockpit) -> None:
+    filed = await _filed(cockpit)
+    await _answer(cockpit, filed.decision_id)
+    first = await _undo(cockpit, filed.decision_id)
+    assert first.status_code == 200, first.text
+
+    second = await _undo(cockpit, filed.decision_id)
+    fresh = first.json()["decision"]
+    await _answer(cockpit, fresh["id"], "reject")
+    rejected = await _undo(cockpit, fresh["id"])
+
+    assert (second.status_code, error_code(second)) == (409, "undo_closed")
+    assert (rejected.status_code, error_code(rejected)) == (409, "undo_closed")
+
+
+async def test_someone_without_access_cannot_take_an_answer_back(cockpit: Cockpit) -> None:
+    filed = await _filed(cockpit)
+    await _answer(cockpit, filed.decision_id)
+
+    resp = await _undo(cockpit, filed.decision_id, user="bob")
+
+    assert resp.status_code in (403, 404), resp.text
+    row = cockpit.store.get_proposal_by_number(cockpit.fid, 1)
+    assert row is not None and row.status == "applied"
diff --git a/web/src/components/factory/v3/answerUndo.live.test.ts b/web/src/components/factory/v3/answerUndo.live.test.ts
new file mode 100644
index 00000000000..6f3c6f7e9da
--- /dev/null
+++ b/web/src/components/factory/v3/answerUndo.live.test.ts
@@ -0,0 +1,124 @@
+// An answer's Undo on the live server: offered only while the proposal it
+// applied keeps one (`undo_until` on an applied projects change), and taken
+// back through `POST /decisions/{id}/undo`, which names the fresh ask.
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { FactoryApiError } from "@/lib/factoryApi";
+import { liveNodeSource, undoOfProposal } from "./nodeSource";
+import { answeredAnyway } from "./nodeSteer";
+import type { DecisionRef } from "./nodeTypes";
+
+const authenticatedFetch = vi.fn();
+vi.mock("@/lib/identity", () => ({
+  authenticatedFetch: (...args: unknown[]) => authenticatedFetch(...args),
+}));
+
+afterEach(() => {
+  authenticatedFetch.mockReset();
+});
+
+function json(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+function ask(id: string, subject: string): DecisionRef {
+  return {
+    id,
+    row_id: `row-${id}`,
+    verb: `Apply ${subject}`,
+    actions: [
+      { id: "apply", label: "Apply" },
+      { id: "reject", label: "Reject" },
+    ],
+    asker: "Atlas",
+    age: "6h",
+    subject,
+  };
+}
+
+const APPLY = { id: "apply", label: "Apply" };
+
+/** The answer, then `GET …/proposals/{ref}` with `proposal`. */
+function serve(proposal: Record<string, unknown>) {
+  authenticatedFetch.mockImplementation(async (url: string) =>
+    url.endsWith("/answer")
+      ? json({ decision: { ref: "D-45", status: "answered" } })
+      : json({ proposal }),
+  );
+}
+
+describe("cockpit v3 · an answer's Undo on the live server", () => {
+  it("offers Undo for an applied projects change, until the server's undo_until", async () => {
+    serve({ status: "applied", kind: "projects", undo_until: 1_700_000_600 });
+    const outcome = await liveNodeSource.answer("f1", ask("D-45", "C-16"), APPLY);
+    expect(outcome).toEqual({ undo: { proposal: "C-16", until_s: 1_700_000_600 } });
+    const urls = authenticatedFetch.mock.calls.map((c) => c[0]);
+    expect(urls).toEqual([
+      "/v1/factory/decisions/row-D-45/answer",
+      "/v1/factory/factories/f1/proposals/C-16",
+    ]);
+  });
+
+  it("offers none for a rules proposal, which keeps no Undo", async () => {
+    serve({ status: "trial", kind: "rules", undo_until: null });
+    const outcome = await liveNodeSource.answer("f1", ask("D-50", "C-17"), APPLY);
+    expect(outcome).toEqual({ undo: null });
+  });
+
+  it("offers none once the proposal's window is gone or it did not apply", () => {
+    expect(undoOfProposal("C-16", { status: "applied", kind: "projects", undo_until: null })).toBe(
+      null,
+    );
+    expect(undoOfProposal("C-16", { status: "refused", kind: "projects", undo_until: 5 })).toBe(
+      null,
+    );
+    expect(undoOfProposal("C-16", null)).toBe(null);
+  });
+
+  it("reads no proposal for an answer that applies none", async () => {
+    authenticatedFetch.mockResolvedValue(json({ decision: { ref: "D-45" } }));
+    const outcome = await liveNodeSource.answer("f1", ask("D-45", "C-16"), {
+      id: "reject",
+      label: "Reject",
+    });
+    expect(outcome).toEqual({});
+    expect(authenticatedFetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("takes the answer back by the decision's row id and names the fresh ask", async () => {
+    authenticatedFetch.mockResolvedValue(
+      json({ proposal: { status: "pending" }, decision: { ref: "D-52" } }),
+    );
+    const undone = await liveNodeSource.undoAnswer!("f1", ask("D-45", "C-16"));
+    expect(undone).toEqual({ decision: "D-52" });
+    const [url, init] = authenticatedFetch.mock.calls[0]!;
+    expect(url).toBe("/v1/factory/decisions/row-D-45/undo");
+    expect(init).toMatchObject({ method: "POST" });
+  });
+
+  it("reads a refusal that still answered the ask, and why its proposal did not apply", () => {
+    const failed = new FactoryApiError(
+      "D-50 is answered, but applying its proposal failed (no_change)",
+      400,
+      "no_change",
+      null,
+      {
+        error: { code: "no_change" },
+        decision: { ref: "D-50", status: "answered" },
+        reason: "C-17: the definition already has these values",
+      },
+    );
+    expect(answeredAnyway(failed)).toEqual({
+      ref: "D-50",
+      reason: "the definition already has these values",
+    });
+    const refused = new FactoryApiError("nope", 409, "decision_not_open", null, {
+      error: { code: "decision_not_open" },
+    });
+    expect(answeredAnyway(refused)).toBeNull();
+    expect(answeredAnyway(new Error("offline"))).toBeNull();
+  });
+});
diff --git a/web/src/components/factory/v3/chat/NodeChat.test.tsx b/web/src/components/factory/v3/chat/NodeChat.test.tsx
index 3af209c6d9d..52573dbd295 100644
--- a/web/src/components/factory/v3/chat/NodeChat.test.tsx
+++ b/web/src/components/factory/v3/chat/NodeChat.test.tsx
@@ -474,6 +474,69 @@ describe("cockpit v3 · the node chat column", () => {
     await waitFor(() => expect(undo).toHaveBeenCalledWith(expect.any(String), "tok-new"));
   });
 
+  it("offers a verb card's Undo only to the person who applied it, or an owner", async () => {
+    setWindow("desktop");
+    const base = sampleRoomMessages();
+    const like = base.find((m) => m.thread === "project:assistant-core")!;
+    const now = Math.floor(Date.now() / 1000);
+    const card = (id: string, seq: number, body: string, by_user: string) => ({
+      ...like,
+      id,
+      seq,
+      author_kind: "system" as const,
+      author: "server",
+      author_title: null,
+      body,
+      card: {
+        type: "preview_applied" as const,
+        ref: "assistant-core",
+        id: null,
+        meta: {
+          kind: "preview_applied" as const,
+          verb: "add",
+          by_user,
+          undo_token: `tok-${id}`,
+          undo_until: now + 400,
+        },
+      },
+    });
+    const can = {
+      post: true,
+      answer: true,
+      review: true,
+      control: true,
+      intervene: true,
+      apply_projects: true,
+      apply_tuning: false,
+      restart: true,
+      stop: true,
+      invite: false,
+      settings: false,
+      terminal: false,
+      start: true,
+    };
+    renderChat("assistant-core", {
+      install,
+      messages: [
+        ...base,
+        card("mine", 900, "Ana added Usage (C-30).", "ana@example.com"),
+        card("theirs", 901, "Bob added Docs (C-31).", "bob@example.com"),
+      ],
+      viewer: {
+        user_id: "ana@example.com",
+        role: "operator",
+        level: 3,
+        is_creator: false,
+        can,
+      },
+    });
+    const list = await screen.findByTestId("room-message-list", {}, { timeout: 4000 });
+    await waitFor(() => expect(within(list).getAllByTestId("v3-applied")).toHaveLength(2));
+    const open = within(list).getAllByTestId("v3-applied-undo");
+    expect(open).toHaveLength(1);
+    expect(open[0]!.closest('[data-testid="v3-applied"]')).toHaveTextContent("Ana added Usage");
+  });
+
   it("lists the node's verbs after / (the answer opens the card) and quick verbs above the box", async () => {
     setWindow("desktop");
     const onVerb = vi.fn();
diff --git a/web/src/components/factory/v3/chat/NodeChat.tsx b/web/src/components/factory/v3/chat/NodeChat.tsx
index 4fee7626ef3..3d908411b10 100644
--- a/web/src/components/factory/v3/chat/NodeChat.tsx
+++ b/web/src/components/factory/v3/chat/NodeChat.tsx
@@ -39,7 +39,7 @@ import { swallowEnter } from "../DecisionButtons";
 import { useNodeActions } from "../NodeContext";
 import { Avatar, Kbd } from "../nodeParts";
 import { useNode } from "../nodeQueries";
-import { useUndoToken } from "../nodeSteer";
+import { undoViewer, useUndoToken } from "../nodeSteer";
 import { nodeHref } from "../nodeRoutes";
 import { AMBER, STATE_WORDS } from "../nodeTokens";
 import type { DecisionRef, NodePage, StatusLine, VerbArgs } from "../nodeTypes";
@@ -153,19 +153,35 @@ function OfferOf({
   );
 }
 
-/**
- * The cards the Room leaves to the node chat: why, closed alarm, offer. One
- * it cannot draw (its node loading or gone, an alarm it knows nothing of)
- * shows `fallback`, the message's own line, so it never renders empty.
- */
-/** What a verb's card needs to offer its Undo: the tokens already undone, now, and how. */
+/** What a verb's card needs to offer its Undo: the tokens already undone, who looks, and how. */
 interface AppliedUndo {
   undone: ReadonlySet<string>;
-  nowS: number;
+  /** The server lets the person who applied it, or an owner, undo it. */
+  viewer: { userId: string | null | undefined; owner: boolean };
+  clockOffsetS: number;
   run: ((token: string, label: string) => Promise<void>) | null;
 }
 
-/** A verb's card: what it did, and its Undo while the token is open and not yet used. */
+/** "Now" on the server's clock, read every 15 s while `until` (epoch s) is ahead; no tick without it. */
+function useNowUntil(clockOffsetS: number, until: number | null): number {
+  const [nowS, setNowS] = useState(() => Math.floor(Date.now() / 1000 + clockOffsetS));
+  useEffect(() => {
+    if (until == null) return;
+    const read = () => Math.floor(Date.now() / 1000 + clockOffsetS);
+    const first = read();
+    setNowS(first);
+    if (first >= until) return;
+    const timer = setInterval(() => {
+      const at = read();
+      setNowS(at);
+      if (at >= until) clearInterval(timer);
+    }, 15_000);
+    return () => clearInterval(timer);
+  }, [clockOffsetS, until]);
+  return nowS;
+}
+
+/** A verb's card: what it did, and its Undo while the token is open, unused and this viewer's. */
 function AppliedOf({
   message,
   applied,
@@ -177,17 +193,22 @@ function AppliedOf({
 }) {
   const [busy, setBusy] = useState(false);
   const meta = message.card?.meta?.kind === "preview_applied" ? message.card.meta : null;
+  const token = meta && !meta.undone ? (meta.undo_token ?? null) : null;
+  const { viewer } = applied;
+  const theirs = viewer.owner || Boolean(viewer.userId && meta?.by_user === viewer.userId);
+  const open = Boolean(token && theirs && !applied.undone.has(token) && applied.run);
+  const until = open ? (meta?.undo_until ?? null) : null;
+  // Only an open Undo ticks, so the rest of the thread never re-renders for the clock.
+  const nowS = useNowUntil(applied.clockOffsetS, until);
   if (!meta) return fallback;
-  const token = meta.undone ? null : (meta.undo_token ?? null);
-  const open = token && !applied.undone.has(token) && applied.run;
-  const left = open && meta.undo_until ? meta.undo_until - applied.nowS : null;
+  const left = until != null ? until - nowS : null;
   return (
     <AppliedCard
       text={message.body}
       leftS={left}
       busy={busy}
       onUndo={
-        open && token
+        token && until != null
           ? () => {
               setBusy(true);
               void applied.run!(token, meta.label ?? meta.verb).finally(() => setBusy(false));
@@ -198,6 +219,11 @@ function AppliedOf({
   );
 }
 
+/**
+ * The cards the Room leaves to the node chat: why, closed alarm, offer, a
+ * verb's card. One it cannot draw (its node loading or gone, an alarm it knows
+ * nothing of) shows `fallback`, the message's own line, so it never renders empty.
+ */
 function NodeMessageCard({
   message,
   attached,
@@ -590,14 +616,8 @@ export function NodeChat({ page: here, sample = false }: NodeChatProps) {
   // A verb's card offers its Undo until it ran: the server's "undone" card names its token.
   const messages = useRoomMessages(fid, thread.key);
   const undoToken = useUndoToken(fid);
-  // "Now" on the server's clock, every 15 s: "Undo (n min left)" counts down and goes at 0.
-  const [nowS, setNowS] = useState(() => Math.floor(Date.now() / 1000 + clockOffsetS));
-  useEffect(() => {
-    const read = () => setNowS(Math.floor(Date.now() / 1000 + clockOffsetS));
-    read();
-    const timer = setInterval(read, 15_000);
-    return () => clearInterval(timer);
-  }, [clockOffsetS]);
+  const viewerId = snapshot.viewer?.user_id;
+  const viewerOwner = undoViewer({ snapshot }).owner;
   const applied = useMemo<AppliedUndo>(() => {
     const undone = new Set<string>();
     for (const m of flattenPages(messages.data)) {
@@ -606,8 +626,13 @@ export function NodeChat({ page: here, sample = false }: NodeChatProps) {
         undone.add(meta.undo_token);
       }
     }
-    return { undone, nowS, run: undoToken };
-  }, [messages.data, nowS, undoToken]);
+    return {
+      undone,
+      viewer: { userId: viewerId, owner: viewerOwner },
+      clockOffsetS,
+      run: undoToken,
+    };
+  }, [clockOffsetS, messages.data, undoToken, viewerId, viewerOwner]);
 
   const renderCard = useCallback(
     (message: ChatMessageView, attached: boolean, fallback: ReactNode) => (
diff --git a/web/src/components/factory/v3/fixture/renderChat.tsx b/web/src/components/factory/v3/fixture/renderChat.tsx
index 2bbdfe9acd7..40c14882df6 100644
--- a/web/src/components/factory/v3/fixture/renderChat.tsx
+++ b/web/src/components/factory/v3/fixture/renderChat.tsx
@@ -7,7 +7,7 @@
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { render } from "@testing-library/react";
 import { MemoryRouter, Route, Routes } from "react-router-dom";
-import type { ChatMessageView, FactorySnapshot } from "@/lib/factoryApi";
+import type { ChatMessageView, FactorySnapshot, ViewerBlock } from "@/lib/factoryApi";
 import type { PostChatRequest } from "@/lib/factoryRoomApi";
 import { useLocation, useParams } from "@/lib/routing";
 import type { StoryResponse, StoryRoutes } from "../../factoryStoryFixtures";
@@ -133,6 +133,8 @@ export function renderChat(
     source?: NodeSource;
     /** The server routes the per-node threads (preflight `node_threads`). */
     nodeThreads?: boolean;
+    /** Who looks (default: no viewer block, every lever open). */
+    viewer?: ViewerBlock;
     install: (fetch: FakeFetch) => void;
   },
 ) {
@@ -144,10 +146,12 @@ export function renderChat(
     sampleNodes = false,
     source,
     nodeThreads,
+    viewer,
     install,
     ...sample
   } = options;
   const snapshot = sampleRoomSnapshot();
+  if (viewer) snapshot.viewer = viewer;
   const fetch = fetchOf(
     sampleRoomRoutes({ snapshot, messages, nodeThreads, ...sample }),
     snapshot.factory.id,
diff --git a/web/src/components/factory/v3/fixture/sampleNodeSource.ts b/web/src/components/factory/v3/fixture/sampleNodeSource.ts
index 58e10d12e8f..7a7b9a3bd9c 100644
--- a/web/src/components/factory/v3/fixture/sampleNodeSource.ts
+++ b/web/src/components/factory/v3/fixture/sampleNodeSource.ts
@@ -54,6 +54,7 @@ export function sampleNodeSource(
     level: async (_fid, ref, level) => engine.level(ref, level),
     answer: async (_fid, decision, action) => {
       engine.answer(decision.id, action.label);
+      return engine.answerOutcome(decision.id, action.label);
     },
     undoAnswer: async (_fid, decision) => engine.unanswer(decision.id),
     preview: async (_fid, ref, request) => engine.preview(ref, request),
diff --git a/web/src/components/factory/v3/fixture/sampleSteer.ts b/web/src/components/factory/v3/fixture/sampleSteer.ts
index 821a85ff19e..201a4cb58f8 100644
--- a/web/src/components/factory/v3/fixture/sampleSteer.ts
+++ b/web/src/components/factory/v3/fixture/sampleSteer.ts
@@ -7,6 +7,8 @@
 
 import { FactoryApiError } from "@/lib/factoryApi";
 import type {
+  AnswerOutcome,
+  AnswerUndone,
   ChildPage,
   FindHit,
   NeedsYouList,
@@ -846,9 +848,40 @@ export class SampleSteerEngine extends SampleLensEngine {
     return done;
   }
 
-  /** Take an answer back (the proposal it applied is undone): the factory as it was before it. */
-  unanswer(decisionId: string): void {
+  /**
+   * What an answer did, as the server says: Apply on a project change's ask
+   * keeps its Undo for 10 minutes; a rule's (the factory tree) has none.
+   */
+  answerOutcome(decisionId: string, actionLabel: string): AnswerOutcome {
+    const d = this.dec(decisionId);
+    const proposal = d?.subject ?? "";
+    const applied = actionLabel === "Apply" && /^C-\d+$/.test(proposal);
+    if (!d || !applied || this.N(d.node)?.tree === "factory") return {};
+    if (!this.undos.has(`answer:${decisionId}`)) return {};
+    return { undo: { proposal, until_s: Math.floor((Date.now() + SAMPLE_UNDO_MS) / 1000) } };
+  }
+
+  /**
+   * Take an answer back as the server does: what its proposal applied is
+   * undone, and the proposal asks a person again under a fresh ask, which what
+   * waited on the old one now waits on. The old ask stays answered.
+   */
+  unanswer(decisionId: string): AnswerUndone {
     this.undo(`answer:${decisionId}`);
+    const old = this.data.decisions.find((d) => d.id === decisionId)!;
+    const top = Math.max(
+      0,
+      ...this.data.decisions.map((d) => Number(/^D-(\d+)$/.exec(d.id)?.[1] ?? 0)),
+    );
+    const fresh: RawDecision = { ...old, id: `D-${top + 1}`, open: true, age: "just now" };
+    delete fresh.expires;
+    old.open = false;
+    this.data.decisions.push(fresh);
+    for (const n of this.data.nodes) {
+      for (const w of n.waits ?? []) if (w.decision === decisionId) w.decision = fresh.id;
+    }
+    this.changed();
+    return { decision: fresh.id };
   }
 
   undo(token: string): void {
diff --git a/web/src/components/factory/v3/nodeSource.ts b/web/src/components/factory/v3/nodeSource.ts
index ea5b292592e..3a6c4385ba0 100644
--- a/web/src/components/factory/v3/nodeSource.ts
+++ b/web/src/components/factory/v3/nodeSource.ts
@@ -11,9 +11,11 @@
 
 import { type ReactNode, createContext, createElement, useContext } from "react";
 import { answerDecision, factoryErrorFromResponse } from "@/lib/factoryApi";
-import { undoProposal } from "@/lib/factoryRoomApi";
 import { authenticatedFetch } from "@/lib/identity";
 import type {
+  AnswerOutcome,
+  AnswerUndo,
+  AnswerUndone,
   DecisionAction,
   DecisionRef,
   FindHit,
@@ -60,14 +62,20 @@ export interface NodeSource {
     signal?: AbortSignal,
     cursor?: string,
   ) => Promise<LevelView | null>;
-  /** Answer a decision with one of its actions. */
-  answer: (factoryId: string, decision: DecisionRef, action: DecisionAction) => Promise<void>;
   /**
-   * Take back an answer that applied a proposal ("Apply C-16"), within its
-   * window: the proposal's own Undo (`POST …/proposals/{C-n}/undo`). Only for
-   * answers `answerProposal` names.
+   * Answer a decision with one of its actions; the outcome carries the
+   * answer's Undo while the proposal it applied keeps one (`undo_until`).
    */
-  undoAnswer?: (factoryId: string, decision: DecisionRef, action: DecisionAction) => Promise<void>;
+  answer: (
+    factoryId: string,
+    decision: DecisionRef,
+    action: DecisionAction,
+  ) => Promise<AnswerOutcome | void>;
+  /**
+   * Take back an answer whose outcome had an Undo (`POST /decisions/{id}/undo`):
+   * the proposal it applied is undone and asks a person again, under a fresh decision.
+   */
+  undoAnswer?: (factoryId: string, decision: DecisionRef) => Promise<AnswerUndone | void>;
   /** A verb's dry run: nothing changes (`POST …/n/{ref}/preview`). */
   preview?: (
     factoryId: string,
@@ -233,26 +241,65 @@ export const liveNodeSource: NodeSource = {
     if (!res.ok) throw await factoryErrorFromResponse(res);
     return (await res.json()) as LevelsInfo;
   },
-  answer: async (_fid, decision, action) => {
+  answer: async (fid, decision, action) => {
     // The answer route takes the decision's row id; `id` is its ref ("D-45").
     await answerDecision(decision.row_id ?? decision.id, { option_id: action.id });
-  },
-  undoAnswer: async (fid, decision, action) => {
     const proposal = answerProposal(decision, action);
-    if (!proposal) throw new Error(`${decision.id}: ${action.label} cannot be undone here.`);
-    await undoProposal(fid, proposal);
+    return proposal ? { undo: await proposalUndo(fid, proposal) } : {};
+  },
+  undoAnswer: async (_fid, decision) => {
+    const res = await sendJson(
+      `/v1/factory/decisions/${enc(decision.row_id ?? decision.id)}/undo`,
+      "POST",
+      {},
+    );
+    const body = (await res.json()) as { decision?: { ref?: string | null } | null };
+    return { decision: body.decision?.ref ?? null };
   },
 };
 
 /**
- * The proposal an answer applies, which its own Undo takes back ("C-16" for
- * Apply on D-45, whose subject is C-16), else null: other answers stand.
+ * The proposal an answer may have applied ("C-16" for Apply on D-45, whose
+ * subject is C-16), else null: other answers apply nothing.
  */
 export function answerProposal(decision: DecisionRef, action: DecisionAction): string | null {
   const subject = decision.subject ?? "";
   return action.id === "apply" && /^C-\d+$/.test(subject) ? subject : null;
 }
 
+/** The parts of `GET …/proposals/{ref}` an answer's Undo reads. */
+interface ProposalUndoView {
+  status?: string;
+  kind?: string;
+  undo_until?: number | null;
+}
+
+/**
+ * The Undo a proposal still has once answered, as the server keeps it: only
+ * an applied projects change with an `undo_until` (a rules, tuning or code
+ * change, a cancel, split or merge has none). Null when it cannot be read.
+ */
+export function undoOfProposal(
+  ref: string,
+  view: ProposalUndoView | null | undefined,
+): AnswerUndo | null {
+  if (view?.status !== "applied" || view.kind !== "projects" || view.undo_until == null)
+    return null;
+  return { proposal: ref, until_s: view.undo_until };
+}
+
+async function proposalUndo(fid: string, ref: string): Promise<AnswerUndo | null> {
+  try {
+    const res = await authenticatedFetch(`${factoryPath(fid)}/proposals/${enc(ref)}`);
+    if (!res.ok) return null;
+    const body = (await res.json()) as { proposal?: ProposalUndoView | null };
+    return undoOfProposal(ref, body.proposal);
+  } catch {
+    // The answer stands; only its Undo is not offered.
+    return null;
+  }
+}
+
 const NodeSourceContext = createContext<NodeSource | null>(null);
 
 export function NodeSourceProvider({
diff --git a/web/src/components/factory/v3/nodeSteer.ts b/web/src/components/factory/v3/nodeSteer.ts
index 901aa5da582..da5c422c41b 100644
--- a/web/src/components/factory/v3/nodeSteer.ts
+++ b/web/src/components/factory/v3/nodeSteer.ts
@@ -18,6 +18,7 @@ import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from
 import {
   type DefinitionVersionsResponse,
   type DefinitionView,
+  FactoryApiError,
   fetchDefinitionVersions,
 } from "@/lib/factoryApi";
 import { learnKey, useDefinitionVersions, usePinDefinition } from "../insights/learnQueries";
@@ -27,8 +28,9 @@ import { useDebounced } from "../team/teamQueries";
 import { useFactoryToast } from "../ui/Toast";
 import { useNodeActions } from "./NodeContext";
 import { NODE_STALE_MS, nodeQueryKeys, useAnswerDecision } from "./nodeQueries";
-import { answerProposal, useNodeSource } from "./nodeSource";
+import { useNodeSource } from "./nodeSource";
 import type {
+  AnswerOutcome,
   DecisionAction,
   DecisionRef,
   NodePage,
@@ -428,12 +430,28 @@ export function useUndoToken(factoryId?: string) {
 
 // ── Answers, with Undo when they applied a proposal ────────────
 
+/**
+ * The ask a refused answer still answered: the server stored the answer but
+ * applying its proposal failed (its error body carries the decision), with why.
+ */
+export function answeredAnyway(error: unknown): { ref: string; reason: string } | null {
+  if (!(error instanceof FactoryApiError)) return null;
+  const body = error.body as { decision?: { ref?: unknown } | null; reason?: unknown } | null;
+  const ref = body?.decision?.ref;
+  if (typeof ref !== "string" || !ref) return null;
+  const why = typeof body?.reason === "string" && body.reason ? body.reason : (error.code ?? "");
+  // "C-17: the definition already has these values" names the proposal the toast names already.
+  return { ref, reason: why.replace(/^C-\d+:\s*/, "") };
+}
+
 /**
  * Answer an ask (always a click). An answer that applied a proposal ("Apply
- * C-16") can be taken back with the proposal's own Undo for 10 minutes: the
- * toast offers it, and the node it was answered on (`at`) keeps "Apply C-16:
- * Undo (n min left)" beside its verbs. Every node page reads again after
- * either. `sample`: the toast says only the sample changed.
+ * C-16") can be taken back while the server keeps its Undo (the proposal's
+ * `undo_until`; a rules or tuning change has none): the toast offers it, and
+ * the node it was answered on (`at`) keeps "Apply C-16: Undo (n min left)"
+ * beside its verbs. Undo puts the proposal back: it asks a person again, so
+ * what it held waits again. Every node page reads again after either.
+ * `sample`: the toast says only the sample changed.
  */
 export function useAnswerAsk(
   at: string | null,
@@ -441,6 +459,7 @@ export function useAnswerAsk(
 ) {
   const fid = useFid(factoryId);
   const source = useNodeSource();
+  const shell = useOptionalFactoryShell();
   const toast = useFactoryToast();
   const refresh = useRefreshNodes(fid);
   const { mutate } = useAnswerDecision(fid);
@@ -449,27 +468,31 @@ export function useAnswerAsk(
       mutate(
         { decision, action },
         {
-          onSuccess: () => {
+          onSuccess: (outcome: AnswerOutcome | void) => {
             const message = sample
               ? `Sample data: nothing was answered. The sample shows what ${decision.id}: ${action.label} would do.`
               : `${decision.id}: ${action.label}`;
-            const proposal = answerProposal(decision, action);
+            const undo = outcome ? outcome.undo : null;
             const back = source?.undoAnswer;
-            if (!proposal || !back) {
+            // Its window on the server's clock, counted from now on this one.
+            const leftMs = undo ? (undo.until_s - serverNowS(shell)) * 1000 : 0;
+            if (!undo || !back || leftMs <= 0) {
               toast.show({ message });
               return;
             }
+            const label = `${action.label} ${undo.proposal}`;
             const entry: NodeUndo = {
-              label: `${action.label} ${proposal}`,
-              expiresAt: Date.now() + UNDO_WINDOW_S * 1000,
+              label,
+              expiresAt: Date.now() + leftMs,
               run: () =>
-                back(fid, decision, action).then(
-                  () => {
+                back(fid, decision).then(
+                  (undone) => {
                     if (at) forgetUndo(fid, at, entry);
                     void refresh();
-                    toast.show({
-                      message: `Undone: ${action.label} ${proposal} (${decision.id}).`,
-                    });
+                    const again = undone?.decision
+                      ? ` ${undo.proposal} asks again in ${undone.decision}.`
+                      : "";
+                    toast.show({ message: `Undone: ${label} (${decision.id}).${again}` });
                   },
                   (error: unknown) => {
                     // Its window closed, or what it changed moved on: it stays applied.
@@ -482,11 +505,22 @@ export function useAnswerAsk(
             if (at) rememberUndo(fid, at, entry);
             toast.show({ message, undo: () => void entry.run() });
           },
-          onError: (error) =>
-            toast.show({ message: `${decision.id} was not answered: ${errorWords(error)}` }),
+          onError: (error) => {
+            const answered = answeredAnyway(error);
+            if (answered) {
+              // Answered, but what it applies did not: nothing to undo.
+              void refresh();
+              const what = decision.subject ? `applying ${decision.subject}` : "applying it";
+              toast.show({
+                message: `${answered.ref} answered; ${what} failed: ${answered.reason}`,
+              });
+              return;
+            }
+            toast.show({ message: `${decision.id} was not answered: ${errorWords(error)}` });
+          },
         },
       ),
-    [at, fid, mutate, refresh, sample, source?.undoAnswer, toast],
+    [at, fid, mutate, refresh, sample, shell, source?.undoAnswer, toast],
   );
 }
 
diff --git a/web/src/components/factory/v3/nodeTypes.ts b/web/src/components/factory/v3/nodeTypes.ts
index 0010abf53de..9667f10b903 100644
--- a/web/src/components/factory/v3/nodeTypes.ts
+++ b/web/src/components/factory/v3/nodeTypes.ts
@@ -61,6 +61,24 @@ export interface DecisionRef {
   row_id?: string;
 }
 
+/** An answer's Undo: the proposal it applied, which can be taken back until `until_s`. (client) */
+export interface AnswerUndo {
+  /** `C-16`. */
+  proposal: string;
+  /** Epoch seconds on the server's clock (the proposal's `undo_until`). */
+  until_s: number;
+}
+
+/** What an answer did: its Undo while the proposal it applied keeps one. (client) */
+export interface AnswerOutcome {
+  undo?: AnswerUndo | null;
+}
+
+/** What taking an answer back left: the proposal asks a person again in `decision` (`D-52`). (client) */
+export interface AnswerUndone {
+  decision?: string | null;
+}
+
 /** A path step: down into the child that blocks most (`›`), a hop or a hold (`→`), or the person. */
 export type Segment =
   | { sep: "›"; ref: string; title?: string }
diff --git a/web/src/components/factory/v3/nodeWire.server.test.tsx b/web/src/components/factory/v3/nodeWire.server.test.tsx
index 38cf16cfff2..a821a8faa47 100644
--- a/web/src/components/factory/v3/nodeWire.server.test.tsx
+++ b/web/src/components/factory/v3/nodeWire.server.test.tsx
@@ -249,9 +249,11 @@ describe("cockpit v3 · the server's node pages", () => {
     authenticatedFetch.mockResolvedValue(new Response("{}", { status: 200 }));
     const decision = PAGES["assistant-core"]!.status.decision!;
     await liveNodeSource.answer("f", decision, decision.actions[0]!);
-    const [url, init] = authenticatedFetch.mock.calls.at(-1)! as [string, RequestInit];
+    // Then the proposal it applied is read, for its Undo.
+    const [url, init] = authenticatedFetch.mock.calls.at(-2)! as [string, RequestInit];
     expect(decision.id).toBe("D-45");
     expect(url).toBe(`/v1/factory/decisions/${decision.row_id}/answer`);
     expect(JSON.parse(String(init.body))).toEqual({ option_id: "apply" });
+    expect(authenticatedFetch.mock.calls.at(-1)![0]).toBe("/v1/factory/factories/f/proposals/C-16");
   });
 });
diff --git a/web/src/components/factory/v3/steerLive.test.tsx b/web/src/components/factory/v3/steerLive.test.tsx
index d2774b1e280..6aba79174c5 100644
--- a/web/src/components/factory/v3/steerLive.test.tsx
+++ b/web/src/components/factory/v3/steerLive.test.tsx
@@ -236,10 +236,10 @@ describe("cockpit v3 · an answer that applied a proposal can be taken back", ()
     expect(answerProposal(d45(), { id: "apply", label: "Apply" })).toBeNull();
   });
 
-  it("Apply on the status line offers its Undo beside the verbs, which takes the answer back", async () => {
+  it("Apply on the status line offers its Undo beside the verbs; Undo puts the ask back", async () => {
     const sample = sampleNodeSource();
     const undoAnswer = vi.fn(async (fid: string, decision: DecisionRef) =>
-      sample.undoAnswer!(fid, decision, decision.actions[0]!),
+      sample.undoAnswer!(fid, decision),
     );
     renderNode("assistant-core", { source: { ...sample, undoAnswer }, answers: true });
     await waitFor(() =>
@@ -254,11 +254,26 @@ describe("cockpit v3 · an answer that applied a proposal can be taken back", ()
     await userEvent.click(undo);
     await waitFor(() => expect(undoAnswer).toHaveBeenCalledTimes(1));
     expect(undoAnswer.mock.calls[0]![1]).toMatchObject({ id: "D-45" });
+    // As on the server: C-16 asks again under a fresh decision; D-45 stays answered.
     await waitFor(() =>
-      expect(screen.getByTestId("v3-status")).toHaveTextContent("needs you: Apply C-16 (D-45)"),
+      expect(screen.getByTestId("v3-status")).toHaveTextContent(/needs you: Apply C-16 \(D-52\)/),
     );
+    expect(screen.getByTestId("v3-status")).not.toHaveTextContent("D-45");
     expect(screen.queryByTestId("v3-undo-latest")).toBeNull();
     expect(sample.engine.writes).toContain("undo answer:D-45");
+    // What C-16 held waits again, and the ask is back in Needs you.
+    expect(sample.engine.node("T-16")!.status.decision?.id).toBe("D-52");
+    const needs = sample.engine.needsYou("product");
+    expect(needs.items.map((i) => i.decision.id)).toContain("D-52");
+  });
+
+  it("offers no Undo for an answer whose proposal keeps none (a rule)", async () => {
+    const engine = sampleNodeSource().engine;
+    engine.answer("D-51", "Apply");
+    expect(engine.answerOutcome("D-51", "Apply")).toEqual({});
+    engine.answer("D-45", "Apply");
+    expect(engine.answerOutcome("D-45", "Apply").undo).toMatchObject({ proposal: "C-16" });
+    expect(engine.answerOutcome("D-45", "Reject")).toEqual({});
   });
 
   it("a verb's Undo run from its card closes the one beside the verbs, and only that one", async () => {
diff --git a/web/src/lib/factoryApi.ts b/web/src/lib/factoryApi.ts
index 0cc2e37a6e3..bb78b0407ba 100644
--- a/web/src/lib/factoryApi.ts
+++ b/web/src/lib/factoryApi.ts
@@ -1258,6 +1258,8 @@ export interface PreviewAppliedMeta {
   verb: string;
   label?: string | null;
   by?: string | null;
+  /** Who applied it (a user id): they, or an owner, may undo it (older servers: absent). */
+  by_user?: string | null;
   /** `POST …/undo/{token}` takes it back until `undo_until` (epoch seconds). */
   undo_token?: string | null;
   undo_until?: number | null;

From 4bc5e91c90d7c699ca430346c5f5e4708c8d0b53 Mon Sep 17 00:00:00 2001
From: Luka Skugor <luka.skugor@dfinity.org>
Date: Wed, 4 Nov 2026 09:14:04 +0100
Subject: [PATCH 4/4] cockpit v3: read labels and ask numbers with String.match

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 web/src/components/factory/v3/fixture/sampleSteer.ts | 2 +-
 web/src/components/factory/v3/nodeWire.ts            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/web/src/components/factory/v3/fixture/sampleSteer.ts b/web/src/components/factory/v3/fixture/sampleSteer.ts
index 201a4cb58f8..98ccd1a0a6a 100644
--- a/web/src/components/factory/v3/fixture/sampleSteer.ts
+++ b/web/src/components/factory/v3/fixture/sampleSteer.ts
@@ -871,7 +871,7 @@ export class SampleSteerEngine extends SampleLensEngine {
     const old = this.data.decisions.find((d) => d.id === decisionId)!;
     const top = Math.max(
       0,
-      ...this.data.decisions.map((d) => Number(/^D-(\d+)$/.exec(d.id)?.[1] ?? 0)),
+      ...this.data.decisions.map((d) => Number(d.id.match(/^D-(\d+)$/)?.[1] ?? 0)),
     );
     const fresh: RawDecision = { ...old, id: `D-${top + 1}`, open: true, age: "just now" };
     delete fresh.expires;
diff --git a/web/src/components/factory/v3/nodeWire.ts b/web/src/components/factory/v3/nodeWire.ts
index 16e17f4af16..97cba2c0976 100644
--- a/web/src/components/factory/v3/nodeWire.ts
+++ b/web/src/components/factory/v3/nodeWire.ts
@@ -171,7 +171,7 @@ const LABELLED = /^([A-Z][a-z]+(?: [a-z]+)?): (.+)$/s;
 
 function lineOf(value: WirePreviewLine): PreviewLine {
   if (typeof value === "string") {
-    const labelled = LABELLED.exec(value);
+    const labelled = value.match(LABELLED);
     return labelled
       ? { label: labelled[1]!, html: escText(labelled[2]!) }
       : { label: "", html: escText(value) };