diff --git a/.pi/extensions/fm-calm.ts b/.pi/extensions/fm-calm.ts
index d4a6c75b055..1fb9cf12c48 100644
--- a/.pi/extensions/fm-calm.ts
+++ b/.pi/extensions/fm-calm.ts
@@ -42,6 +42,7 @@ import { installCalmAssistantLayout } from "./lib/fm-calm-assistant-layout.ts";
 import { installCalmOperationalUserLayout } from "./lib/fm-calm-operational-user-layout.ts";
 import {
   CALM_WORKING_SHIP_WIDGET_KEY,
+  createCalmWorkingShipAnimation,
   createCalmWorkingShipWidget,
 } from "./lib/fm-calm-working-ship.ts";
 import {
@@ -105,6 +106,10 @@ export default function (pi: ExtensionAPI) {
   // continuations, retries, or compaction that stay inside the same run.
   let agentRunActive = false;
   let workingShipShown = false;
+  // One animation instance per extension lifetime. Hiding the working widget freezes
+  // this state; the next working period resumes it. session_start resets it so a fresh
+  // Pi session starts at the normal initial position. Never module-global.
+  const workingShipAnimation = createCalmWorkingShipAnimation();
 
   // Single owner of Calm's working-row presentation choice. The widget is only created
   // or removed on a real transition, so repeated starts cannot duplicate its timer.
@@ -117,7 +122,9 @@ export default function (pi: ExtensionAPI) {
       workingShipShown = showShip;
       ui.setWidget(
         CALM_WORKING_SHIP_WIDGET_KEY,
-        showShip ? createCalmWorkingShipWidget : undefined,
+        showShip
+          ? (tui) => createCalmWorkingShipWidget(tui, workingShipAnimation)
+          : undefined,
       );
       ui.setWorkingVisible(!showShip);
     } else if (forceStockVisibility && !showShip) {
@@ -274,6 +281,8 @@ export default function (pi: ExtensionAPI) {
     publishPresentationState();
     agentRunActive = false;
     workingShipShown = false;
+    // A genuine new session lifetime starts the boat at the normal initial position.
+    workingShipAnimation.reset();
     applyWorkingPresentation(ctx.ui, true);
     ctx.ui.setHiddenThinkingLabel(calmPresentationIsActive() ? "" : undefined);
     ctx.ui.setStatus("firstmate-calm", undefined);
diff --git a/.pi/extensions/lib/fm-calm-working-ship.ts b/.pi/extensions/lib/fm-calm-working-ship.ts
index 1efff27007e..390e28baebf 100644
--- a/.pi/extensions/lib/fm-calm-working-ship.ts
+++ b/.pi/extensions/lib/fm-calm-working-ship.ts
@@ -2,10 +2,10 @@
 //
 // Calm replaces Pi's stock working row with a tiny SSHHIP-derived boat while one
 // logical agent run is active. This module owns only the sprite geometry, the bounce
-// track, the two animation cadences, and the temporary TUI widget;
-// `.pi/extensions/fm-calm.ts` owns when the presentation is installed and removed, and
-// stays the sole caller of setWorkingVisible(). docs/calm.md owns the captain-facing
-// contract.
+// track, the two animation cadences, the session-scoped freeze/resume state, and the
+// temporary TUI widget; `.pi/extensions/fm-calm.ts` owns when the presentation is
+// installed and removed, and stays the sole caller of setWorkingVisible().
+// docs/calm.md owns the captain-facing contract.
 //
 // Cadence: one scheduler drives two logically independent clocks. Every tick advances
 // the water phase, and only every CALM_WORKING_SHIP_TICKS_PER_MOVE-th tick moves the
@@ -13,11 +13,19 @@
 // itself reads as calm. Both clocks stop together when the widget is disposed. Ticks,
 // not wall-clock timestamps, drive every state change, so tests can seek time exactly.
 //
+// Continuity: one extension-owned animation instance survives hide/show within the same
+// Pi process and Calm extension lifetime. Disposing the widget freezes column,
+// direction, water phase, and tick cadence without advancing them for hidden wall
+// time. The next working period resumes from that exact logical state. A fresh session
+// or new extension lifetime calls reset() and starts at the normal initial position.
+// State is never a module-level or process-global singleton.
+//
 // Verified against Pi 0.81.1 declarations and the Pi 0.82.0 CLI, which expose
 // ExtensionUIContext.setWidget() with a component factory, per-widget dispose(), and
 // TUI.requestRender(). Pi renders a widget through Component.render(width), so this
 // module recomputes its track from that width on every frame instead of caching a
-// terminal size that a resize would invalidate.
+// terminal size that a resize would invalidate. A resize while the boat is hidden is
+// applied on the first resumed frame through the same clamp path.
 import type { Component, TUI } from "@earendil-works/pi-tui";
 
 // The hull is symmetric and replaces waves on its row rather than adding a third row.
@@ -51,6 +59,14 @@ export type CalmWorkingShipAnimation = {
   render(width: number): string[];
   /** Advance one scheduler tick: water every tick, boat on its slower cadence. */
   tick(): void;
+  restoreLastRendered(): void;
+  /** Restore the normal initial column, direction, water phase, and cadence. */
+  reset(): void;
+  /**
+   * Clamp the frozen column and direction to `width` without advancing time.
+   * Used when a terminal resize lands while the working presentation is hidden.
+   */
+  clampToWidth(width: number): void;
   /** Current hull column, exposed for deterministic motion assertions. */
   position(): number;
   /** Current travel direction: 1 travelling right, -1 travelling left. */
@@ -72,6 +88,11 @@ export function createCalmWorkingShipAnimation(): CalmWorkingShipAnimation {
   let span = 0;
   let phase = 0;
   let ticks = 0;
+  let renderedPosition = position;
+  let renderedDirection = direction;
+  let renderedSpan = span;
+  let renderedPhase = phase;
+  let renderedTicks = ticks;
 
   // Reversing the moment the boat lands on an endpoint means the endpoint frame itself
   // already shows the new heading, so no frame at or after a bounce shows the old sail.
@@ -81,6 +102,33 @@ export function createCalmWorkingShipAnimation(): CalmWorkingShipAnimation {
     else if (position <= 0) direction = 1;
   };
 
+  const applyWidth = (width: number): void => {
+    if (width <= 0) {
+      span = 0;
+      position = 0;
+      return;
+    }
+    span = trackSpan(width);
+    position = Math.min(position, span);
+    settleDirectionAtEdges();
+  };
+
+  const commitRenderedState = (): void => {
+    renderedPosition = position;
+    renderedDirection = direction;
+    renderedSpan = span;
+    renderedPhase = phase;
+    renderedTicks = ticks;
+  };
+
+  const restoreLastRenderedState = (): void => {
+    position = renderedPosition;
+    direction = renderedDirection;
+    span = renderedSpan;
+    phase = renderedPhase;
+    ticks = renderedTicks;
+  };
+
   /** One colored run of water covering absolute columns [from, from + count). */
   const water = (from: number, count: number): string => {
     if (count <= 0) return "";
@@ -98,6 +146,21 @@ export function createCalmWorkingShipAnimation(): CalmWorkingShipAnimation {
     direction: () => direction,
     waterPhase: () => phase,
 
+    restoreLastRendered: restoreLastRenderedState,
+
+    reset(): void {
+      position = 0;
+      direction = 1;
+      span = 0;
+      phase = 0;
+      ticks = 0;
+      commitRenderedState();
+    },
+
+    clampToWidth(width: number): void {
+      applyWidth(width);
+    },
+
     tick(): void {
       ticks += 1;
       phase = (phase + 1) % WAVE_CYCLE.length;
@@ -115,44 +178,51 @@ export function createCalmWorkingShipAnimation(): CalmWorkingShipAnimation {
 
       // A resize lands here before the next frame, so recompute and clamp the track
       // immediately rather than trusting a position measured against the old width.
-      span = trackSpan(width);
-      position = Math.min(position, span);
-      settleDirectionAtEdges();
+      applyWidth(width);
 
       const sail = direction >= 0 ? SAIL_RIGHT : SAIL_LEFT;
 
+      let frame: string[];
       if (width < SAIL_WIDTH) {
         // Too narrow for even the sail: a deterministic single row of water.
-        return [water(0, width)];
-      }
-
-      if (width < HULL_WIDTH) {
+        frame = [water(0, width)];
+      } else if (width < HULL_WIDTH) {
         // Too narrow for the hull: the sail alone rides the water row.
-        return [
+        frame = [
           water(0, position) +
             boat(sail) +
             water(position + SAIL_WIDTH, width - position - SAIL_WIDTH),
         ];
+      } else {
+        frame = [
+          " ".repeat(position + SAIL_OFFSET) + boat(sail),
+          water(0, position) +
+            boat(HULL) +
+            water(position + HULL_WIDTH, width - position - HULL_WIDTH),
+        ];
       }
 
-      return [
-        " ".repeat(position + SAIL_OFFSET) + boat(sail),
-        water(0, position) +
-          boat(HULL) +
-          water(position + HULL_WIDTH, width - position - HULL_WIDTH),
-      ];
+      commitRenderedState();
+      return frame;
     },
   };
 }
 
 /**
- * Build the temporary Calm working widget. Pi disposes the previous component before
- * installing a replacement under the same key and when it clears extension widgets, so
- * the single scheduler driving both cadences cannot outlive the widget or duplicate.
+ * Build the temporary Calm working widget bound to one caller-owned animation.
+ * Pi disposes the previous component before installing a replacement under the same
+ * key and when it clears extension widgets, so the single scheduler driving both
+ * cadences cannot outlive the widget or duplicate. Disposing freezes the shared
+ * animation in place; the next widget bound to the same animation resumes without
+ * applying hidden wall time.
  */
-export function createCalmWorkingShipWidget(tui: TUI): Component & { dispose(): void } {
-  const animation = createCalmWorkingShipAnimation();
+export function createCalmWorkingShipWidget(
+  tui: TUI,
+  animation: CalmWorkingShipAnimation = createCalmWorkingShipAnimation(),
+): Component & { dispose(): void } {
+  let disposed = false;
   const timer = setInterval(() => {
+    if (disposed) return;
     animation.tick();
     tui.requestRender();
   }, CALM_WORKING_SHIP_TICK_MS);
@@ -160,9 +230,14 @@ export function createCalmWorkingShipWidget(tui: TUI): Component & { dispose():
   timer.unref?.();
 
   return {
-    render: (width) => animation.render(width),
+    render: (width) => (disposed ? [] : animation.render(width)),
     // Every frame is rebuilt from fixed standard ANSI codes, so there is no cache.
     invalidate: () => {},
-    dispose: () => clearInterval(timer),
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      clearInterval(timer);
+      animation.restoreLastRendered();
+    },
   };
 }
diff --git a/bin/fm-board.sh b/bin/fm-board.sh
new file mode 100755
index 00000000000..feb01f4e2c7
--- /dev/null
+++ b/bin/fm-board.sh
@@ -0,0 +1,488 @@
+#!/usr/bin/env bash
+# fm-board.sh - captain-facing kanban board renderer over fm-fleet-snapshot.sh.
+#
+# Renders the live fleet as one self-contained HTML board for visual review in
+# Lavish Editor (lavish-axi). Like fm-fleet-view.sh and fm-bearings-snapshot.sh
+# it intentionally does not parse fleet state itself: backlog rows (all states
+# including captain holds), live task rows (recorded harness/model/effort and
+# current stage), and recorded PR links all come from the canonical
+# `fm-fleet-snapshot.sh --json` contract. The only extra input is the
+# hand-maintained effort maps under data/maps/*.md, which no snapshot surface
+# owns; each map contributes a top-band card (destination, decided and open
+# decision counts, fog, out of scope).
+#
+# Columns are the ordered pipeline steps Decide / Queued / Building / Review /
+# Landed:
+#   Decide   - captain-held backlog rows plus live tasks with open keyed
+#              decisions; each card carries an approval panel (radio options
+#              plus a free-text override) that queues exactly one Lavish prompt
+#              per submit.
+#   Queued   - queued backlog rows without a captain hold.
+#   Building - in-flight work with no recorded PR yet.
+#   Review   - work whose PR is recorded in task meta or backlog (the same
+#              recording fm-pr-check.sh makes when it arms the merge poll), so
+#              a Review card always links the PR.
+#   Landed   - Done backlog rows.
+#
+# The board never mutates fleet state: approval submits and card drags queue
+# Lavish prompts that come back to firstmate as exact orders, and the captain
+# releases them with Send to Agent. Approval panels are rendered as siblings
+# AFTER each card's todo <ul>, never inside it - nesting <details> inside the
+# list is the known clipping bug shape.
+#
+# Output: $FM_HOME/.lavish/fleet-board.html by default; --out overrides.
+# The file is a generated view - regenerate rather than edit it.
+#
+# usage: fm-board.sh [--out <path>]
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+FM_ROOT="${FM_ROOT_OVERRIDE:-$(cd "$SCRIPT_DIR/.." && pwd)}"
+FM_HOME="${FM_HOME:-$FM_ROOT}"
+DATA="${FM_DATA_OVERRIDE:-$FM_HOME/data}"
+OUT="$FM_HOME/.lavish/fleet-board.html"
+
+usage() {
+  cat <<'EOF'
+usage: fm-board.sh [--out <path>]
+
+Generate the captain-facing kanban board (Decide / Queued / Building /
+Review / Landed) from the live fleet snapshot plus data/maps/*.md.
+Writes $FM_HOME/.lavish/fleet-board.html unless --out overrides it.
+EOF
+}
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    -h|--help) usage; exit 0 ;;
+    --out)
+      [ $# -ge 2 ] || { usage >&2; exit 2; }
+      OUT=$2; shift 2 ;;
+    *) usage >&2; exit 2 ;;
+  esac
+done
+
+command -v python3 >/dev/null 2>&1 || { echo "fm-board: python3 not found" >&2; exit 1; }
+
+SNAP_FILE=$(mktemp "${TMPDIR:-/tmp}/fm-board.XXXXXX") || exit 1
+trap 'rm -f "$SNAP_FILE"' EXIT
+
+"$SCRIPT_DIR/fm-fleet-snapshot.sh" --json > "$SNAP_FILE" \
+  || { echo "fm-board: fleet snapshot failed" >&2; exit 1; }
+
+mkdir -p "$(dirname "$OUT")" || exit 1
+
+python3 - "$SNAP_FILE" "$DATA/maps" "$OUT" <<'PY'
+import html
+import json
+import os
+import re
+import sys
+
+snap_path, maps_dir, out_path = sys.argv[1], sys.argv[2], sys.argv[3]
+with open(snap_path, encoding="utf-8") as f:
+    snap = json.load(f)
+
+records = snap.get("backlog", {}).get("records", [])
+tasks = {t.get("id"): t for t in snap.get("tasks", [])}
+
+
+def esc(value):
+    return html.escape(str(value or ""), quote=True)
+
+
+def slugify(value):
+    slug = re.sub(r"[^a-zA-Z0-9_-]+", "-", str(value or "")).strip("-")
+    return slug[:80] or "decision"
+
+
+def clip(text, limit):
+    text = str(text or "").strip()
+    return text if len(text) <= limit else text[: limit - 1].rstrip() + "…"
+
+
+def decision_key(record, task):
+    for line in (record or {}).get("body_lines", []) or []:
+        match = re.match(r"\s*Decision key:\s*(\S+)", line)
+        if match:
+            return slugify(match.group(1))
+    for dec in ((task or {}).get("hints", {}) or {}).get("open_decisions", []) or []:
+        if dec.get("key"):
+            return slugify(dec["key"])
+    return slugify((record or {}).get("id") or (task or {}).get("id"))
+
+
+def pr_url(record, task):
+    url = ((task or {}).get("pr", {}) or {}).get("url")
+    return url or (record or {}).get("pr_url")
+
+
+# --- classify every backlog row and live task into one pipeline column ------
+decide, queued, building, review, landed = [], [], [], [], []
+seen_task_ids = set()
+
+for record in records:
+    task = tasks.get(record.get("id")) if record.get("structured") else None
+    if task:
+        seen_task_ids.add(record["id"])
+    state = record.get("state")
+    if not record.get("structured"):
+        target = landed if state == "done" else (queued if state == "queued" else building)
+        target.append((record, None))
+        continue
+    hints = (task or {}).get("hints", {}) or {}
+    if state == "done":
+        landed.append((record, task))
+    elif record.get("hold_kind") == "captain" or hints.get("open_decisions"):
+        decide.append((record, task))
+    elif state == "queued":
+        queued.append((record, task))
+    elif pr_url(record, task):
+        review.append((record, task))
+    else:
+        building.append((record, task))
+
+for task_id in sorted(tasks):
+    task = tasks[task_id]
+    if task_id in seen_task_ids or task.get("kind") == "secondmate":
+        continue
+    if (task.get("hints", {}) or {}).get("open_decisions"):
+        decide.append((None, task))
+    elif pr_url(None, task):
+        review.append((None, task))
+    else:
+        building.append((None, task))
+
+
+# --- effort maps under data/maps/ -------------------------------------------
+def parse_map(path):
+    info = {
+        "title": os.path.basename(path)[:-3],
+        "destination": "",
+        "decided": 0,
+        "open": 0,
+        "fog": [],
+        "out_of_scope": [],
+    }
+    section = None
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            line = line.rstrip()
+            if line.startswith("# "):
+                match = re.match(r"#\s*(?:Effort map:\s*)?(.+)", line)
+                if match:
+                    info["title"] = match.group(1).strip()
+            elif line.startswith("## "):
+                heading = line[3:].strip().lower()
+                if heading.startswith("destination"):
+                    section = "destination"
+                elif heading.startswith("decisions"):
+                    section = "decided"
+                elif heading.startswith("open"):
+                    section = "open"
+                elif heading.startswith("not yet"):
+                    section = "fog"
+                elif heading.startswith("out of scope"):
+                    section = "out_of_scope"
+                else:
+                    section = None
+            elif section == "destination" and line.strip():
+                joiner = " " if info["destination"] else ""
+                info["destination"] += joiner + line.strip()
+            elif line.lstrip().startswith("- "):
+                item = line.lstrip()[2:].strip()
+                if section == "decided":
+                    info["decided"] += 1
+                elif section == "open":
+                    info["open"] += 1
+                elif section == "fog":
+                    info["fog"].append(item)
+                elif section == "out_of_scope":
+                    info["out_of_scope"].append(item)
+    return info
+
+
+maps = []
+if os.path.isdir(maps_dir):
+    for name in sorted(os.listdir(maps_dir)):
+        if name.endswith(".md"):
+            try:
+                maps.append(parse_map(os.path.join(maps_dir, name)))
+            except OSError:
+                continue
+
+
+# --- card rendering ----------------------------------------------------------
+def stage_of(record, task):
+    if task:
+        current = task.get("current_state", {}) or {}
+        state = current.get("state") or "unknown"
+        detail = current.get("detail") or ""
+        return f"{state} - {detail}" if detail else state
+    if record and record.get("hold_kind") == "captain":
+        return "awaiting decision"
+    if record and record.get("blocked_by"):
+        return f"blocked by {record['blocked_by']}"
+    if record and record.get("state") == "done":
+        verb = (record.get("completion", {}) or {}).get("verb") or "done"
+        date = (record.get("completion", {}) or {}).get("date") or ""
+        return f"{verb} {date}".strip()
+    return "no live worker yet"
+
+
+def crew_badge(task):
+    if not task:
+        return ""
+    parts = [task.get("harness") or "?"]
+    if task.get("model") and task["model"] != "default":
+        parts.append(task["model"])
+    if task.get("effort"):
+        parts.append(f"{task['effort']} effort")
+    return " · ".join(parts)
+
+
+def todo_lines(record):
+    lines = []
+    for line in (record or {}).get("body_lines", []) or []:
+        line = line.strip()
+        if line:
+            lines.append(clip(line, 160))
+        if len(lines) == 4:
+            break
+    return lines
+
+
+def approval_panel(record, task):
+    key = decision_key(record, task)
+    reason = (record or {}).get("hold_reason") or ""
+    if not reason:
+        for dec in ((task or {}).get("hints", {}) or {}).get("open_decisions", []) or []:
+            if dec.get("summary"):
+                reason = dec["summary"]
+                break
+    parts = [f'<details class="approval" data-lavish-question="{esc(key)}">']
+    parts.append("<summary>⚑ YOUR APPROVAL - click for options</summary>")
+    if reason:
+        parts.append(f'<p class="text-xs opacity-80">{esc(clip(reason, 320))}</p>')
+    parts.append(f'<form data-question="{esc(key)}" onsubmit="return fbDecide(event)">')
+    options = [
+        ("approve - proceed as recommended", True),
+        ("hold for now", False),
+        ("more detail first - report back before acting", False),
+    ]
+    for value, recommended in options:
+        label = f"<b>{esc(value.capitalize())}</b>" if recommended else esc(value.capitalize())
+        parts.append(
+            f'<label><input type="radio" name="{esc(key)}" value="{esc(value)}"> {label}</label>'
+        )
+    parts.append(
+        '<textarea name="freetext" rows="1" class="textarea textarea-bordered textarea-xs"'
+        ' placeholder="…or write your own answer"></textarea>'
+    )
+    parts.append('<button type="submit" class="btn btn-warning btn-xs mt-1">Queue this answer</button>')
+    parts.append(
+        '<span class="queued-note">✓ queued - press Send to Agent when done choosing</span>'
+    )
+    parts.append("</form></details>")
+    return "".join(parts)
+
+
+TICKET_CLASS = {
+    "decide": "t-captain",
+    "queued": "t-queued",
+    "building": "t-flight",
+    "review": "t-upstream",
+    "landed": "t-done",
+}
+
+
+def card(record, task, column):
+    title = (record or {}).get("title") or (record or {}).get("raw") or (task or {}).get("id") or "untitled"
+    url = pr_url(record, task)
+    heading = f'<a class="link" href="{esc(url)}">{esc(clip(title, 140))}</a>' if url else esc(clip(title, 140))
+    badges = []
+    repo = (record or {}).get("repo")
+    if repo:
+        badges.append(f'<span class="badge badge-xs badge-ghost">{esc(repo)}</span>')
+    kind = (record or {}).get("kind") or (task or {}).get("kind")
+    if kind:
+        badges.append(f'<span class="badge badge-xs badge-ghost">{esc(kind)}</span>')
+    crew = crew_badge(task)
+    if crew:
+        badges.append(f'<span class="badge badge-xs badge-info badge-outline">crew: {esc(crew)}</span>')
+    badges.append(f'<span class="badge badge-xs badge-ghost">stage: {esc(clip(stage_of(record, task), 90))}</span>')
+    blocked_by = (record or {}).get("blocked_by")
+    if blocked_by:
+        badges.append(f'<span class="badge badge-xs badge-warning badge-outline">blocked-by: {esc(blocked_by)}</span>')
+
+    parts = [
+        '<div draggable="true" ondragstart="fbDrag(event, this)"'
+        ' ondragend="this.classList.remove(\'dragging\')"'
+        f' class="card card-compact bg-base-100 ticket {TICKET_CLASS[column]} shadow"'
+        f' data-board-id="{esc((record or {}).get("id") or (task or {}).get("id") or "")}">',
+        '<div class="card-body">',
+        f'<h3 class="font-semibold text-sm">{heading}</h3>',
+        f'<div class="meta-row">{"".join(badges)}</div>',
+    ]
+    lines = todo_lines(record)
+    if not lines and task:
+        note = ((task.get("hints", {}) or {}).get("last_event_text")) or ""
+        if note:
+            lines = [clip(note, 160)]
+    if lines:
+        items = "".join(f"<li>{esc(line)}</li>" for line in lines)
+        parts.append(f'<ul class="todos opacity-80">{items}</ul>')
+    # The approval panel is a SIBLING of the todo list on purpose: a <details>
+    # inside the <ul> is the prototype's clipping bug.
+    if column == "decide":
+        parts.append(approval_panel(record, task))
+    parts.append("</div></div>")
+    return "".join(parts)
+
+
+def column_html(key, number, emoji, title, accent, entries):
+    cards = "".join(card(record, task, key) for record, task in entries)
+    if not cards:
+        cards = '<div class="text-xs opacity-50 italic p-2">nothing here</div>'
+    return (
+        '<section class="col" ondragover="event.preventDefault(); this.classList.add(\'dropover\')"'
+        ' ondragleave="this.classList.remove(\'dropover\')" ondrop="fbDrop(event, this)">'
+        f'<h2 class="font-semibold mb-2 {accent}">{number} · {emoji} {title}</h2>'
+        f'<div class="flex flex-col gap-3">{cards}</div>'
+        "</section>"
+    )
+
+
+def map_card(info):
+    badges = [
+        f'<span class="badge badge-xs badge-success">{info["decided"]} decided</span>',
+        f'<span class="badge badge-xs badge-warning">{info["open"]} open</span>',
+    ]
+    fog = clip("; ".join(info["fog"]), 120) if info["fog"] else "none - remaining work is sharp"
+    badges.append(f'<span class="badge badge-xs badge-ghost">fog: {esc(fog)}</span>')
+    if info["out_of_scope"]:
+        badges.append(
+            f'<span class="badge badge-xs badge-ghost">out of scope: {esc(clip("; ".join(info["out_of_scope"]), 120))}</span>'
+        )
+    return (
+        '<div class="card card-compact bg-base-100 shadow border-l-4" style="border-left-color: oklch(78% 0.14 200);">'
+        '<div class="card-body">'
+        f'<h3 class="font-semibold text-sm">\U0001f5fa️ Effort: {esc(info["title"])}</h3>'
+        f'<p class="text-xs opacity-80"><b>Destination:</b> {esc(clip(info["destination"], 320))}</p>'
+        f'<div class="meta-row">{"".join(badges)}</div>'
+        "</div></div>"
+    )
+
+
+generated = snap.get("generated") or ""
+date = generated[:10]
+counts = [
+    ("badge-warning", f"Your call: {len(decide)}"),
+    ("badge-accent", f"Queued: {len(queued)}"),
+    ("badge-info", f"Building: {len(building)}"),
+    ("badge-secondary", f"Review: {len(review)}"),
+    ("badge-success", f"Landed: {len(landed)}"),
+]
+count_html = "".join(
+    f'<span class="badge {cls} badge-outline">{esc(text)}</span>' for cls, text in counts
+)
+maps_html = ""
+if maps:
+    maps_html = (
+        '<div class="mb-4 grid grid-cols-1 md:grid-cols-2 gap-3">'
+        + "".join(map_card(m) for m in maps)
+        + "</div>"
+    )
+
+columns = "".join(
+    [
+        column_html("decide", 1, "⚓", "Decide", "text-warning", decide),
+        column_html("queued", 2, "\U0001f9ed", "Queued", "text-accent", queued),
+        column_html("building", 3, "⛵", "Building", "text-info", building),
+        column_html("review", 4, "\U0001f30a", "Review", "text-secondary", review),
+        column_html("landed", 5, "\U0001f3c1", "Landed", "text-success", landed),
+    ]
+)
+
+page = f"""<!doctype html>
+<html lang="en" data-theme="dark">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Fleet Board — {esc(date)}</title>
+<script src="https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4"></script>
+<link href="https://cdn.jsdelivr.net/npm/daisyui@5" rel="stylesheet" type="text/css">
+<style>
+  .col {{ min-width: 0; }}
+  .card-compact .card-body {{ padding: 0.85rem; }}
+  .ticket {{ border-left: 4px solid transparent; overflow: visible; }}
+  .card, .card-body, .todos, .todos li, details, summary {{ overflow: visible !important; max-height: none !important; height: auto !important; }}
+  .t-captain {{ border-left-color: oklch(75% 0.18 60); }}
+  .t-flight  {{ border-left-color: oklch(70% 0.15 250); }}
+  .t-queued  {{ border-left-color: oklch(70% 0.12 180); }}
+  .t-upstream{{ border-left-color: oklch(72% 0.14 300); }}
+  .t-done    {{ border-left-color: oklch(72% 0.17 145); }}
+  .todos {{ font-size: 0.72rem; line-height: 1.35; }}
+  .todos li {{ list-style: none; }}
+  .meta-row {{ display:flex; flex-wrap:wrap; gap:0.3rem; margin:0.25rem 0; }}
+  .approval {{ background: oklch(30% 0.06 60 / 0.4); border: 1px solid oklch(75% 0.18 60 / 0.7); border-radius: 0.4rem; padding: 0.25rem 0.45rem; margin: 0.25rem 0; }}
+  .approval summary {{ font-weight: 700; color: oklch(85% 0.16 70); cursor: pointer; font-size: 0.7rem; }}
+  .approval textarea {{ width:100%; font-size:0.7rem; margin-top:0.2rem; }}
+  .approval label {{ display:block; font-size:0.7rem; padding:0.1rem 0; cursor:pointer; }}
+  .approval .queued-note {{ display:none; font-size:0.7rem; color: oklch(80% 0.15 145); font-weight:600; }}
+  .dragging {{ opacity: 0.4; }}
+  .col.dropover {{ outline: 2px dashed oklch(70% 0.15 250); outline-offset: 4px; border-radius: 0.5rem; }}
+</style>
+</head>
+<body class="bg-base-200 min-h-screen p-4 md:p-6">
+<div class="max-w-[1700px] mx-auto">
+  <header class="mb-5 flex flex-wrap items-end justify-between gap-2">
+    <div>
+      <h1 class="text-2xl font-bold">Fleet Board</h1>
+      <p class="text-sm opacity-70">snapshot {esc(generated)} · regenerate with bin/fm-board.sh; say “refresh the board” anytime</p>
+    </div>
+    <div class="flex gap-2 text-xs">{count_html}</div>
+  </header>
+  {maps_html}
+  <div class="grid grid-cols-1 md:grid-cols-2 xl:grid-cols-5 gap-4">
+{columns}
+  </div>
+  <footer class="mt-6 text-xs opacity-60">Static snapshot — answer Decide cards or drag tickets, then press Send to Agent; firstmate dispatches from this board.</footer>
+</div>
+<script>
+let fbDragged=null;
+function fbDrag(ev, el){{ fbDragged=el; el.classList.add('dragging'); ev.dataTransfer.effectAllowed='move'; }}
+function fbDrop(ev, colEl){{
+  ev.preventDefault(); colEl.classList.remove('dropover');
+  if(!fbDragged) return;
+  const ticket=(fbDragged.querySelector('h3')||{{}}).innerText||'ticket';
+  const stage=(colEl.querySelector('h2')||{{}}).innerText||'column';
+  colEl.querySelector('.flex.flex-col').appendChild(fbDragged);
+  if(window.lavish && window.lavish.queuePrompt){{
+    window.lavish.queuePrompt('Move ticket "'+ticket.trim()+'" to stage "'+stage.trim()+'" - advance it accordingly', {{ tag:'move', text:ticket.trim()+' -> '+stage.trim(), element: fbDragged, queueKey:'move-'+ticket.trim() }});
+  }}
+  fbDragged=null;
+}}
+function fbDecide(ev){{
+  ev.preventDefault();
+  const form=ev.currentTarget;
+  const key=form.dataset.question;
+  const fd=new FormData(form);
+  const c=((fd.get('freetext')||'').trim()) || fd.get(key);
+  if(c && window.lavish && window.lavish.queuePrompt){{
+    window.lavish.queuePrompt('Decision '+key+': '+c, {{ tag:'choice', text:key+': '+c, element: form, queueKey:key, data:{{question:key, answer:c}} }});
+    form.querySelector('.queued-note').style.display='block';
+  }}
+  return false;
+}}
+</script>
+</body>
+</html>
+"""
+
+with open(out_path, "w", encoding="utf-8") as f:
+    f.write(page)
+PY
+rc=$?
+[ "$rc" -eq 0 ] || { echo "fm-board: render failed" >&2; exit "$rc"; }
+printf 'board: %s\n' "$OUT"
diff --git a/bin/fm-fleet-snapshot.sh b/bin/fm-fleet-snapshot.sh
index 1dee81bb84a..15ded760f0f 100755
--- a/bin/fm-fleet-snapshot.sh
+++ b/bin/fm-fleet-snapshot.sh
@@ -21,6 +21,8 @@
 #     captain_actionable fields. Repeated blocker tokens remain ordered; a blocker
 #     resolves only when its structured record is Done, and missing ids stay open.
 #   tasks[]: one row per state/<id>.meta, sorted by id.
+#     harness, model, and effort mirror the recorded dispatch profile from the
+#     meta file ("" when unrecorded).
 #     current_state is parsed from bin/fm-crew-state.sh <id> and preserves
 #     state, source, detail, and raw line separately.
 #     paths.status_log.last_event is historical wake-event data only, never
@@ -398,7 +400,7 @@ backlog_json() {  # [<backlog-path>] - defaults to this home's $BACKLOG
 }
 
 task_json_lines() {
-  local meta id kind harness mode yolo project worktree home projects backend target status_log report_path
+  local meta id kind harness model effort mode yolo project worktree home projects backend target status_log report_path
   local pr pr_source event_json current_json endpoint_exists agent_alive meta_json status_json report_json worktree_json home_json
   local last_event_raw current_state current_source pending_decision blocked_event report_present=0 pr_from_status
   local open_decisions_tsv open_decisions_json
@@ -409,6 +411,8 @@ task_json_lines() {
     kind=$(meta_value "$meta" kind)
     [ -n "$kind" ] || kind=ship
     harness=$(meta_value "$meta" harness)
+    model=$(meta_value "$meta" model)
+    effort=$(meta_value "$meta" effort)
     mode=$(meta_value "$meta" mode)
     yolo=$(meta_value "$meta" yolo)
     project=$(meta_value "$meta" project)
@@ -491,6 +495,8 @@ task_json_lines() {
       --arg id "$id" \
       --arg kind "$kind" \
       --arg harness "$harness" \
+      --arg model "$model" \
+      --arg effort "$effort" \
       --arg mode "$mode" \
       --arg yolo "$yolo" \
       --arg project "$project" \
@@ -519,6 +525,8 @@ task_json_lines() {
         id:$id,
         kind:$kind,
         harness:($harness // ""),
+        model:($model // ""),
+        effort:($effort // ""),
         mode:($mode // ""),
         yolo:($yolo // ""),
         project:($project // ""),
diff --git a/docs/architecture.md b/docs/architecture.md
index 8682cfe95c9..fc3dff8c4fe 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -38,7 +38,7 @@ Decision-only events such as `resolved` never become current state or leak their
 In that status-log fallback, a declared external wait reports the distinct `paused` state with its reason.
 The semantic branch reports working only on an exact busy verdict and names the source that produced it; an unknown verdict never becomes working, never permits the status-log fallback, and never becomes a silent idle.
 For whole-fleet read-only review, `bin/fm-fleet-snapshot.sh --json` emits schema `fm-fleet-snapshot.v1` from the backlog, task metadata, current crew state, endpoint probes, PR/report pointers, scout reports, bounded current summaries from registered secondmate homes, and secondmate return-channel guidance.
-`bin/fm-fleet-view.sh` renders that snapshot as Markdown for humans, while `bin/fm-bearings-snapshot.sh` provides the bounded bearings projection, so both views consume one structured contract instead of reparsing raw fleet files.
+`bin/fm-fleet-view.sh` renders that snapshot as Markdown for humans, `bin/fm-bearings-snapshot.sh` provides the bounded bearings projection, and `bin/fm-board.sh` renders the captain-facing kanban board ([board.md](board.md)), so all three views consume one structured contract instead of reparsing raw fleet files.
 The script header owns the exact JSON schema.
 
 ### Registered secondmate current state
diff --git a/docs/board.md b/docs/board.md
new file mode 100644
index 00000000000..e9c0491095e
--- /dev/null
+++ b/docs/board.md
@@ -0,0 +1,34 @@
+# Fleet board
+
+The fleet board is a captain-facing kanban view of everything under way, generated on demand from live fleet state.
+It is a review and decision surface, never a second tracker: the backlog remains the single queue, and firstmate remains the dispatcher.
+
+## Generate
+
+Run `bin/fm-board.sh`.
+It renders the canonical fleet snapshot (`bin/fm-fleet-snapshot.sh --json`) plus the hand-maintained effort maps under `data/maps/*.md` into one self-contained HTML file, `$FM_HOME/.lavish/fleet-board.html` by default (`--out` overrides).
+The script's header and `--help` own the exact flags and column-routing rules.
+
+## Read
+
+The top band shows one card per effort map: the destination, decided and open decision counts, fog (what is not yet specified), and what is out of scope.
+Below it, every backlog row and live task lands in exactly one of five ordered pipeline columns:
+
+1. **Decide** - captain-held items and live tasks parked on an open decision.
+2. **Queued** - queued work waiting on dispatch or a blocker.
+3. **Building** - in-flight work with no pull request recorded yet, with the assigned worker runtime, model, and effort on the card.
+4. **Review** - work whose pull request is recorded and being watched for merge; the card title links the PR.
+5. **Landed** - recently completed work.
+
+## Review and decide
+
+Open the board for visual review with `lavish-axi "$FM_HOME/.lavish/fleet-board.html"`.
+Every interaction queues a prompt instead of mutating anything:
+
+- Each Decide card carries an approval panel: pick a radio option or write a free-text answer, and one prompt per submitted decision is queued.
+- Dragging a card to another column queues a move order for that ticket.
+
+Pressing Send to Agent delivers the queued prompts to firstmate as exact orders; firstmate then applies its normal authority rules before acting on them.
+Nothing on the board bypasses merge authority, captain holds, or any other approval boundary.
+
+The board is a static snapshot: regenerate it with `bin/fm-board.sh` (say "refresh the board") rather than editing the generated file.
diff --git a/docs/calm.md b/docs/calm.md
index 06c505e377e..1018b818b93 100644
--- a/docs/calm.md
+++ b/docs/calm.md
@@ -8,6 +8,9 @@ The water fills the usable width in standard ANSI blue and the complete boat is
 The boat is deliberately calm: it moves one column every 880ms, while the water ripples on its own faster cadence so the surface stays alive between boat steps.
 Its mainsail is directional, showing `<|` while travelling right and `|>` while travelling left, and it flips on the exact frame the boat turns at either edge.
 Every resize reflows the sprite without wrapping, and it disappears when the run settles, aborts, or fails.
+Within one Pi session and Calm extension lifetime, the next working period resumes the boat from its last rendered column and travel direction rather than restarting at the left edge.
+Hidden elapsed time does not advance the animation, and a resize while hidden clamps the frozen boat to the new width without changing its valid travel direction.
+A fresh Pi session or new Calm extension lifetime starts at the normal initial position.
 Very narrow terminals fall back to a smaller deterministic sprite.
 While Calm is off, Pi's stock working row is left exactly as Pi renders it.
 Calm hides collapsed thinking labels, the shells for Pi's seven built-in tools, the `fm_watch_arm_pi` tool shell, and canonically classified Firstmate operational user rows.
diff --git a/docs/documentation-audiences.json b/docs/documentation-audiences.json
index f6075ab0852..9150ee1ecb6 100644
--- a/docs/documentation-audiences.json
+++ b/docs/documentation-audiences.json
@@ -199,6 +199,10 @@
       "path": "docs/arm-pretool-check.md",
       "audience": "maintainer-architecture"
     },
+    {
+      "path": "docs/board.md",
+      "audience": "operator-current"
+    },
     {
       "path": "docs/calm-mode-feasibility.md",
       "audience": "maintainer-verification"
diff --git a/docs/scripts.md b/docs/scripts.md
index 17e0e532cb8..0a8919de19c 100644
--- a/docs/scripts.md
+++ b/docs/scripts.md
@@ -15,6 +15,7 @@ The shared no-mistakes gate refusal for fleet lifecycle entrypoints is summarize
 | `fm-fleet-snapshot.sh`   | Print the read-only structured fleet snapshot JSON (schema `fm-fleet-snapshot.v1`)   |
 | `fm-fleet-view.sh`       | Render the fleet snapshot as a human Markdown view                                   |
 | `fm-bearings-snapshot.sh` | Project the fleet snapshot to the compact TOON bearings view; local-only unless `--include-prs` |
+| `fm-board.sh`            | Render the fleet snapshot plus `data/maps/` as the captain-facing kanban board HTML ([board.md](board.md)) |
 | `fm-update.sh`           | Fast-forward-only self-update of firstmate and secondmate homes from origin          |
 | `fm-backlog-handoff.sh`  | Validate and delegate queued backlog-item moves into a secondmate home               |
 | `fm-decision-hold.sh`    | Create, verify, complete, and resolve durable captain-held decisions                 |
diff --git a/tests/fm-board.test.sh b/tests/fm-board.test.sh
new file mode 100755
index 00000000000..72597c35c94
--- /dev/null
+++ b/tests/fm-board.test.sh
@@ -0,0 +1,224 @@
+#!/usr/bin/env bash
+# Behavior tests for the captain-facing kanban board generator (bin/fm-board.sh).
+set -u
+
+# shellcheck source=tests/lib.sh
+# shellcheck disable=SC1091
+. "$(dirname "${BASH_SOURCE[0]}")/lib.sh"
+
+BOARD="$ROOT/bin/fm-board.sh"
+TMP_ROOT=$(fm_test_tmproot fm-board)
+
+command -v jq >/dev/null 2>&1 || { echo "skip: jq not found"; exit 0; }
+command -v python3 >/dev/null 2>&1 || { echo "skip: python3 not found"; exit 0; }
+
+make_fakebin() {  # <dir>
+  local fb
+  fb=$(fm_fakebin "$1")
+  cat > "$fb/no-mistakes" <<'SH'
+#!/usr/bin/env bash
+exit 0
+SH
+  cat > "$fb/tmux" <<'SH'
+#!/usr/bin/env bash
+set -u
+case "${1:-}" in
+  list-windows)
+    sed -n 's/^window=[^:]*://p' "${FM_HOME:?}"/state/*.meta
+    ;;
+  display-message)
+    case "$*" in
+      *pane_current_command*) printf 'codex\n' ;;
+      *) printf '%%1\n' ;;
+    esac
+    ;;
+  capture-pane)
+    printf 'work in progress\nesc to interrupt\n'
+    ;;
+esac
+exit 0
+SH
+  chmod +x "$fb/no-mistakes" "$fb/tmux"
+  printf '%s\n' "$fb"
+}
+
+make_home() {  # <name>
+  local home=$TMP_ROOT/$1
+  mkdir -p "$home/state" "$home/data" "$home/projects" "$home/config"
+  printf '%s\n' "$home"
+}
+
+write_fixture() {  # <home>
+  local home=$1
+  mkdir -p "$home/projects/build-worktree" "$home/projects/review-worktree" "$home/data/maps"
+  cat > "$home/data/backlog.md" <<'EOF'
+## In flight
+- [ ] build-task - Build The Widget (repo: alpha) (kind: ship) (since 2026-07-29)
+  Widget assembly in progress.
+- [ ] review-task - Review The Rudder (repo: alpha) (kind: ship) (since 2026-07-29)
+
+## Queued
+- [ ] decide-task - Pick The Mast Color (repo: alpha) (kind: captain) (since 2026-07-30) (hold: Two finishes fit; captain picks one) (hold-kind: captain)
+  Decision key: mast-color
+- [ ] queued-task - Queued Chore blocked-by: build-task (repo: alpha) (kind: ship) (since 2026-07-30)
+
+## Done
+- [x] landed-task - Landed Improvement https://github.com/kunchenguid/firstmate/pull/7 (repo: alpha) (kind: ship) (merged 2026-07-28)
+EOF
+  fm_write_meta "$home/state/build-task.meta" \
+    "window=firstmate:fm-build-task" \
+    "worktree=$home/projects/build-worktree" \
+    "project=alpha" \
+    "harness=codex" \
+    "model=opus" \
+    "effort=high" \
+    "kind=ship" \
+    "mode=no-mistakes" \
+    "yolo=off"
+  printf 'working: assembling the widget\n' > "$home/state/build-task.status"
+  fm_write_meta "$home/state/review-task.meta" \
+    "window=firstmate:fm-review-task" \
+    "worktree=$home/projects/review-worktree" \
+    "project=alpha" \
+    "harness=claude" \
+    "kind=ship" \
+    "mode=no-mistakes" \
+    "yolo=off" \
+    "pr=https://github.com/kunchenguid/firstmate/pull/9"
+  printf 'done: PR https://github.com/kunchenguid/firstmate/pull/9 checks green\n' > "$home/state/review-task.status"
+  cat > "$home/data/maps/alpha-refit.md" <<'EOF'
+# Effort map: alpha refit
+
+## Destination
+Alpha sails clean: refit landed and every mast decision settled.
+
+## Decisions so far
+- keel shape approved
+- sail cut approved
+
+## Not yet specified
+- rigging vendor
+
+## Out of scope
+- new hull
+
+## Open captain decisions (live tickets)
+- mast color
+EOF
+}
+
+test_board_renders_columns_and_cards() {
+  local home fakebin out html
+  home=$(make_home fixture)
+  write_fixture "$home"
+  fakebin=$(make_fakebin "$home")
+  out="$home/board.html"
+  PATH="$fakebin:$PATH" FM_HOME="$home" "$BOARD" --out "$out" >/dev/null \
+    || fail "board generation failed"
+  [ -f "$out" ] || fail "board output file missing"
+  html=$(cat "$out")
+
+  local col
+  for col in Decide Queued Building Review Landed; do
+    assert_contains "$html" "$col" "board must contain the $col column"
+  done
+
+  assert_contains "$html" "Pick The Mast Color" "captain hold card must land in the board"
+  assert_contains "$html" 'data-lavish-question="mast-color"' \
+    "approval panel must carry the decision key from the backlog body"
+  assert_contains "$html" 'type="radio"' "approval panel must offer radio options"
+  assert_contains "$html" 'name="freetext"' "approval panel must offer a free-text override"
+  assert_contains "$html" "window.lavish.queuePrompt" "interactions must queue Lavish prompts"
+
+  assert_contains "$html" "Build The Widget" "in-flight card must render"
+  assert_contains "$html" "crew: codex · opus · high effort" \
+    "building card must show the assigned harness, model, and effort"
+  assert_contains "$html" "Queued Chore" "queued card must render"
+  assert_contains "$html" "blocked-by: build-task" "queued card must surface its blocker"
+  assert_contains "$html" 'href="https://github.com/kunchenguid/firstmate/pull/9"' \
+    "review card must link the armed PR"
+  assert_contains "$html" "Landed Improvement" "done card must render in Landed"
+
+  assert_contains "$html" "Alpha sails clean" "effort-map destination must render in the top band"
+  assert_contains "$html" "2 decided" "effort-map decided count must render"
+  assert_contains "$html" "1 open" "effort-map open count must render"
+
+  assert_contains "$html" 'draggable="true"' "cards must be draggable"
+  assert_contains "$html" "fbDrop" "columns must accept drops that queue move orders"
+  pass "board renders all five columns, cards, decision panels, and effort maps"
+}
+
+test_review_and_decide_routing() {
+  local home fakebin out html
+  home=$(make_home routing)
+  write_fixture "$home"
+  fakebin=$(make_fakebin "$home")
+  out="$home/board.html"
+  PATH="$fakebin:$PATH" FM_HOME="$home" "$BOARD" --out "$out" >/dev/null \
+    || fail "board generation failed"
+  html=$(cat "$out")
+  # Column routing: the PR-recorded task reaches Review, the hold reaches
+  # Decide, and each card appears exactly once on the board.
+  local review_col decide_col
+  review_col=${html#*"🌊 Review"}
+  assert_contains "$review_col" "Review The Rudder" "PR-recorded card must be in or after the Review column"
+  decide_col=${html%%"🧭 Queued"*}
+  assert_contains "$decide_col" "Pick The Mast Color" "captain hold must be in the Decide column"
+  case "$html" in
+    *"Review The Rudder"*"Review The Rudder"*) fail "cards must appear exactly once" ;;
+  esac
+  pass "captain holds route to Decide and PR-recorded work routes to Review"
+}
+
+test_approval_panels_stay_out_of_lists() {
+  local home fakebin out
+  home=$(make_home clipping)
+  write_fixture "$home"
+  fakebin=$(make_fakebin "$home")
+  out="$home/board.html"
+  PATH="$fakebin:$PATH" FM_HOME="$home" "$BOARD" --out "$out" >/dev/null \
+    || fail "board generation failed"
+  python3 - "$out" <<'PY' || fail "an approval details block is nested inside a list (clipping bug)"
+import sys
+from html.parser import HTMLParser
+
+class Check(HTMLParser):
+    VOID = {"meta", "link", "input", "br", "img", "progress", "hr"}
+    def __init__(self):
+        super().__init__()
+        self.stack = []
+        self.bad = False
+    def handle_starttag(self, tag, attrs):
+        if tag == "details" and "ul" in self.stack:
+            self.bad = True
+        if tag not in self.VOID:
+            self.stack.append(tag)
+    def handle_endtag(self, tag):
+        if self.stack and self.stack[-1] == tag:
+            self.stack.pop()
+
+check = Check()
+with open(sys.argv[1], encoding="utf-8") as f:
+    check.feed(f.read())
+sys.exit(1 if check.bad else 0)
+PY
+  pass "approval panels are siblings of the todo list, never nested in it"
+}
+
+test_default_output_path_and_empty_home() {
+  local home fakebin
+  home=$(make_home empty)
+  fakebin=$(make_fakebin "$home")
+  PATH="$fakebin:$PATH" FM_HOME="$home" "$BOARD" >/dev/null \
+    || fail "board generation must succeed on an empty home"
+  [ -f "$home/.lavish/fleet-board.html" ] \
+    || fail "default output must land in \$FM_HOME/.lavish/fleet-board.html"
+  assert_contains "$(cat "$home/.lavish/fleet-board.html")" "nothing here" \
+    "empty columns must render an explicit placeholder"
+  pass "default output path works and an empty fleet renders explicit placeholders"
+}
+
+test_board_renders_columns_and_cards
+test_review_and_decide_routing
+test_approval_panels_stay_out_of_lists
+test_default_output_path_and_empty_home
diff --git a/tests/fm-calm-pi-extension.test.sh b/tests/fm-calm-pi-extension.test.sh
index b528b97fd9c..f1109e787ec 100755
--- a/tests/fm-calm-pi-extension.test.sh
+++ b/tests/fm-calm-pi-extension.test.sh
@@ -1646,6 +1646,7 @@ const {
   CALM_WORKING_SHIP_TICK_MS,
   CALM_WORKING_SHIP_TICKS_PER_MOVE,
   createCalmWorkingShipAnimation,
+  createCalmWorkingShipWidget,
 } = ship;
 
 const ESC = "\u001b";
@@ -1919,6 +1920,243 @@ for (const width of [40, 16, 8, 6, 5, 4, 3, 2]) {
   }
 }
 
+// --- Freeze/resume continuity on one shared animation instance ---------------------
+// Hiding the working presentation must freeze column and direction. The next widget
+// bound to the same animation resumes exactly there; hidden wall time must not jump.
+{
+  const animation = createCalmWorkingShipAnimation();
+  const tui = { requestRender() {} };
+  animation.render(40);
+  for (let step = 0; step < CALM_WORKING_SHIP_TICKS_PER_MOVE * 7; step += 1) animation.tick();
+  animation.render(40);
+  const frozenColumn = animation.position();
+  const frozenDirection = animation.direction();
+  const frozenPhase = animation.waterPhase();
+  check(frozenColumn > 0, `continuity setup never left the left edge: ${frozenColumn}`);
+
+  const first = createCalmWorkingShipWidget(tui, animation);
+  check(first.render(40) && animation.position() === frozenColumn, "binding a widget moved the frozen boat");
+  first.dispose();
+  // Dispose freezes; further wall time without ticks must not change logical state.
+  check(animation.position() === frozenColumn, "dispose changed the frozen column");
+  check(animation.direction() === frozenDirection, "dispose changed the frozen direction");
+  check(animation.waterPhase() === frozenPhase, "dispose changed the frozen water phase");
+
+  const resumed = createCalmWorkingShipWidget(tui, animation);
+  const firstFrame = resumed.render(40);
+  check(
+    animation.position() === frozenColumn && animation.direction() === frozenDirection,
+    `resume first frame left frozen state: col=${animation.position()} dir=${animation.direction()}`,
+  );
+  check(sailOf(firstFrame) === (frozenDirection >= 0 ? "<|" : "|>"), "resume first frame lost sail heading");
+  check(animation.waterPhase() === frozenPhase, "resume advanced water phase without a tick");
+  // After resume, motion continues from the frozen state rather than restarting.
+  for (let step = 0; step < CALM_WORKING_SHIP_TICKS_PER_MOVE; step += 1) animation.tick();
+  check(
+    animation.position() === frozenColumn + frozenDirection,
+    `post-resume motion did not continue from frozen column: ${animation.position()}`,
+  );
+  resumed.dispose();
+
+  // Hidden resize clamps without needing a live widget, and preserves a valid heading.
+  animation.render(80);
+  while (animation.position() < 76) animation.tick();
+  animation.render(80);
+  check(animation.position() === 76 && animation.direction() === -1, "endpoint setup failed before hidden resize");
+  const beforeHiddenResize = { column: animation.position(), direction: animation.direction(), phase: animation.waterPhase() };
+  animation.clampToWidth(20);
+  check(animation.position() === 16, `hidden shrink did not clamp: ${animation.position()}`);
+  check(animation.direction() === -1, "hidden shrink lost the leftward heading at the right edge");
+  check(animation.waterPhase() === beforeHiddenResize.phase, "hidden clamp advanced water phase");
+  // Growing while hidden must not invent motion either.
+  animation.clampToWidth(60);
+  check(animation.position() === 16, `hidden grow moved the boat: ${animation.position()}`);
+  check(animation.direction() === -1, "hidden grow changed direction without cause");
+
+  // Endpoint and bounce continuity: pause immediately before, at, and after each edge.
+  for (const scenario of [
+    { label: "before-right", setup(anim) {
+      anim.reset(); anim.render(12);
+      while (anim.position() < 7) anim.tick();
+      check(anim.position() === 7 && anim.direction() === 1, "before-right setup");
+    }},
+    { label: "at-right", setup(anim) {
+      anim.reset(); anim.render(12);
+      while (anim.position() < 8) anim.tick();
+      check(anim.position() === 8 && anim.direction() === -1, "at-right setup");
+    }},
+    { label: "after-right", setup(anim) {
+      anim.reset(); anim.render(12);
+      while (anim.position() < 8) anim.tick();
+      for (let step = 0; step < CALM_WORKING_SHIP_TICKS_PER_MOVE; step += 1) anim.tick();
+      check(anim.position() === 7 && anim.direction() === -1, "after-right setup");
+    }},
+    { label: "before-left", setup(anim) {
+      anim.reset(); anim.render(12);
+      while (anim.position() < 8) anim.tick();
+      while (!(anim.position() === 1 && anim.direction() === -1)) anim.tick();
+    }},
+    { label: "at-left", setup(anim) {
+      anim.reset(); anim.render(12);
+      while (anim.position() < 8) anim.tick();
+      while (!(anim.position() === 0 && anim.direction() === 1)) anim.tick();
+    }},
+    { label: "after-left", setup(anim) {
+      anim.reset(); anim.render(12);
+      while (anim.position() < 8) anim.tick();
+      while (!(anim.position() === 0 && anim.direction() === 1)) anim.tick();
+      for (let step = 0; step < CALM_WORKING_SHIP_TICKS_PER_MOVE; step += 1) anim.tick();
+      check(anim.position() === 1 && anim.direction() === 1, "after-left setup");
+    }},
+  ]) {
+    const edge = createCalmWorkingShipAnimation();
+    scenario.setup(edge);
+    edge.render(12);
+    const frozen = { column: edge.position(), direction: edge.direction(), phase: edge.waterPhase() };
+    const paused = createCalmWorkingShipWidget(tui, edge);
+    paused.dispose();
+    const again = createCalmWorkingShipWidget(tui, edge);
+    again.render(12);
+    check(
+      edge.position() === frozen.column && edge.direction() === frozen.direction && edge.waterPhase() === frozen.phase,
+      `${scenario.label} resume changed frozen edge state`,
+    );
+    for (let step = 0; step < CALM_WORKING_SHIP_TICKS_PER_MOVE; step += 1) edge.tick();
+    const expectedColumn = Math.min(8, Math.max(0, frozen.column + frozen.direction));
+    let expectedDirection = frozen.direction;
+    if (expectedColumn >= 8) expectedDirection = -1;
+    else if (expectedColumn <= 0) expectedDirection = 1;
+    check(
+      edge.position() === expectedColumn && edge.direction() === expectedDirection,
+      `${scenario.label} post-resume bounce drifted: col=${edge.position()} dir=${edge.direction()}`,
+    );
+    again.dispose();
+  }
+
+  // reset() returns a genuine fresh-session initial state.
+  animation.reset();
+  check(
+    animation.position() === 0 && animation.direction() === 1 && animation.waterPhase() === 0,
+    "reset() did not restore the normal initial boat state",
+  );
+  animation.render(40);
+  check(sailOf(animation.render(40)) === "<|", "reset() first frame was not the initial rightward sail");
+
+  // Two controller instances never share motion state.
+  const left = createCalmWorkingShipAnimation();
+  const right = createCalmWorkingShipAnimation();
+  left.render(40);
+  right.render(40);
+  for (let step = 0; step < CALM_WORKING_SHIP_TICKS_PER_MOVE * 3; step += 1) left.tick();
+  check(left.position() === 3 && right.position() === 0, "separate animations leaked motion state");
+}
+
+{
+  const realSetInterval = globalThis.setInterval;
+  const realClearInterval = globalThis.clearInterval;
+  const callbacks = [];
+  const handles = new Set();
+  globalThis.setInterval = (callback) => {
+    callbacks.push(callback);
+    const handle = { unref() {} };
+    handles.add(handle);
+    return handle;
+  };
+  globalThis.clearInterval = (handle) => {
+    handles.delete(handle);
+  };
+
+  try {
+    const tui = { renderRequests: 0, requestRender() { this.renderRequests += 1; } };
+    const animation = createCalmWorkingShipAnimation();
+    const first = createCalmWorkingShipWidget(tui, animation);
+    first.render(40);
+    callbacks[callbacks.length - 1]();
+    callbacks[callbacks.length - 1]();
+    check(tui.renderRequests === 2, "unpainted timer ticks did not request renders");
+    first.dispose();
+    check(handles.size === 0, "disposing the unpainted widget left its timer scheduled");
+    check(
+      animation.position() === 0 && animation.direction() === 1 && animation.waterPhase() === 0,
+      "dispose retained state from unpainted timer ticks",
+    );
+
+    const resumed = createCalmWorkingShipWidget(tui, animation);
+    resumed.render(40);
+    for (let step = 0; step < CALM_WORKING_SHIP_TICKS_PER_MOVE; step += 1) {
+      callbacks[callbacks.length - 1]();
+    }
+    resumed.render(40);
+    check(animation.position() === 1, "unpainted ticks leaked into the resumed cadence");
+    check(animation.waterPhase() === 0, "resumed cadence did not restore the rendered water phase");
+    resumed.dispose();
+
+    const committed = createCalmWorkingShipAnimation();
+    const progressing = createCalmWorkingShipWidget(tui, committed);
+    progressing.render(40);
+    callbacks[callbacks.length - 1]();
+    progressing.render(40);
+    const renderedPhase = committed.waterPhase();
+    callbacks[callbacks.length - 1]();
+    progressing.dispose();
+    check(committed.position() === 0, "dispose changed the committed column after an unpainted tick");
+    check(committed.waterPhase() === renderedPhase, "dispose changed the committed phase after an unpainted tick");
+
+    const committedResume = createCalmWorkingShipWidget(tui, committed);
+    committedResume.render(40);
+    for (let step = 0; step < CALM_WORKING_SHIP_TICKS_PER_MOVE - 2; step += 1) {
+      callbacks[callbacks.length - 1]();
+    }
+    check(committed.position() === 0, "serviced render did not preserve the committed cadence");
+    callbacks[callbacks.length - 1]();
+    committedResume.render(40);
+    check(committed.position() === 1, "serviced render did not commit progress for the next cadence");
+    committedResume.dispose();
+
+    const boundaryCases = [
+      [7, 1], [8, -1], [7, -1], [1, -1], [0, 1], [1, 1],
+    ];
+    for (const [targetPosition, targetDirection] of boundaryCases) {
+      const edge = createCalmWorkingShipAnimation();
+      edge.render(12);
+      let reached = false;
+      for (let step = 0; step < 160; step += 1) {
+        if (edge.position() === targetPosition && edge.direction() === targetDirection) {
+          edge.render(12);
+          reached = true;
+          break;
+        }
+        edge.tick();
+        edge.render(12);
+      }
+      check(reached, `could not prepare bounce state ${targetPosition}/${targetDirection}`);
+      const before = { position: edge.position(), direction: edge.direction(), phase: edge.waterPhase() };
+      const paused = createCalmWorkingShipWidget(tui, edge);
+      paused.render(12);
+      for (let step = 0; step < CALM_WORKING_SHIP_TICKS_PER_MOVE; step += 1) {
+        callbacks[callbacks.length - 1]();
+      }
+      paused.dispose();
+      check(
+        edge.position() === before.position &&
+          edge.direction() === before.direction &&
+          edge.waterPhase() === before.phase,
+        `unpainted bounce tick escaped ${targetPosition}/${targetDirection}`,
+      );
+      const resumedEdge = createCalmWorkingShipWidget(tui, edge);
+      resumedEdge.render(12);
+      check(
+        edge.position() === before.position && edge.direction() === before.direction,
+        `bounce state ${targetPosition}/${targetDirection} changed on resume`,
+      );
+      resumedEdge.dispose();
+    }
+  } finally {
+    globalThis.setInterval = realSetInterval;
+    globalThis.clearInterval = realClearInterval;
+  }
+}
+
 // --- Lifecycle through the Calm extension's registered handlers --------------------
 let liveTimers = 0;
 const realSetInterval = globalThis.setInterval;
@@ -2068,6 +2306,19 @@ check(shipWidget() === widget, "repeated starts replaced the running widget");
 }
 
 // --- Settling removes the boat, stops the animation, and restores the stock row ----
+// Drive the live widget far enough that a left-edge reset would be observable.
+{
+  const moving = shipWidget();
+  check(!!moving, "continuity setup lost the live working widget");
+  moving.render(40);
+  await new Promise((resolve) => setTimeout(resolve, CALM_WORKING_SHIP_TICK_MS * CALM_WORKING_SHIP_TICKS_PER_MOVE * 5 + 40));
+  moving.render(40);
+}
+const hullColumn = (widget) => strip(widget.render(40)[1]).indexOf("\\__/");
+const freezeColumn = hullColumn(shipWidget());
+const freezeSail = sailOf(shipWidget().render(40));
+check(freezeColumn > 0, `lifecycle continuity setup never left the left edge: ${freezeColumn}`);
+
 reset();
 await fire("agent_settled");
 check(
@@ -2085,13 +2336,50 @@ check(
 {
   // No stale rows survive the removal: the widget renders nothing once disposed.
   const renderRequestsAfterDispose = renderRequests;
-  await new Promise((resolve) => setTimeout(resolve, CALM_WORKING_SHIP_TICK_MS * 3));
+  await new Promise((resolve) => setTimeout(resolve, CALM_WORKING_SHIP_TICK_MS * CALM_WORKING_SHIP_TICKS_PER_MOVE * 3));
   check(
     renderRequests === renderRequestsAfterDispose,
     "the animation kept running after the widget was removed",
   );
 }
 
+// --- Later working period resumes the frozen column and direction -----------------
+reset();
+await fire("agent_start");
+check(liveTimers === 1, `resume start left ${liveTimers} animation timers instead of one`);
+check(ui.widgets.size === 1, "resume start did not install exactly one working widget");
+const resumedWidget = shipWidget();
+const resumeColumn = hullColumn(resumedWidget);
+const resumeSail = sailOf(resumedWidget.render(40));
+check(
+  resumeColumn === freezeColumn && resumeSail === freezeSail,
+  `resume reset the boat instead of continuing: froze ${freezeColumn}/${freezeSail}, resumed ${resumeColumn}/${resumeSail}`,
+);
+// Repeated start/settle cycles must not duplicate scheduler or widget ownership.
+for (let cycle = 0; cycle < 3; cycle += 1) {
+  await fire("agent_settled");
+  check(liveTimers === 0, `cycle ${cycle} settle left ${liveTimers} timers`);
+  check(ui.widgets.size === 0, `cycle ${cycle} settle left a residual widget`);
+  await fire("agent_start");
+  check(liveTimers === 1, `cycle ${cycle} start left ${liveTimers} timers`);
+  check(ui.widgets.size === 1, `cycle ${cycle} start left ${ui.widgets.size} widgets`);
+  check(
+    hullColumn(shipWidget()) >= freezeColumn,
+    `cycle ${cycle} lost continuity after repeated settle/start`,
+  );
+}
+await fire("agent_settled");
+check(liveTimers === 0 && ui.widgets.size === 0, "repeated continuity cycles did not finish clean");
+
+// A genuine fresh session resets to the normal initial position.
+reset();
+await fire("session_start", { reason: "new" });
+check(liveTimers === 0 && ui.widgets.size === 0, "fresh session left a stale boat");
+await fire("agent_start");
+check(hullColumn(shipWidget()) === 0, "fresh session did not restart at the left edge");
+check(sailOf(shipWidget().render(40)) === "<|", "fresh session lost the initial rightward sail");
+await fire("agent_settled");
+
 // --- Abort and failure share Pi's agent_settled path ------------------------------
 // Pi emits agent_settled from a finally block, so an aborted or failed run reaches
 // exactly this handler; the real-TUI regression covers the Escape abort path.
@@ -2173,11 +2461,11 @@ JS
   status=$?
   [ "$status" -eq 0 ] || fail "Pi Calm working-ship checks failed: $out"
   [ -z "$out" ] || fail "Pi Calm working-ship test printed output: $out"
-  pass "Pi Calm working ship moves on a slow independent cadence over faster fixed-cell blue water, paints the complete boat standard yellow with balanced resets, keeps ANSI-stripped width exact, flips the directional sail on the exact bounce at both edges and every width, clamps resizes, falls back deterministically when narrow, and installs and removes one scheduler-owning widget across starts, settle, abort, failure, shutdown, reload, replacement, and Calm toggles while leaving Calm-off visibility untouched"
+  pass "Pi Calm working ship moves on a slow independent cadence over faster fixed-cell blue water, paints the complete boat standard yellow with balanced resets, keeps ANSI-stripped width exact, flips the directional sail on the exact bounce at both edges and every width, clamps visible and hidden resizes, falls back deterministically when narrow, freezes and resumes column/direction across settle/start without hidden-time jumps or duplicate timers, resets only on a fresh session, and installs and removes one scheduler-owning widget across starts, settle, abort, failure, shutdown, reload, replacement, and Calm toggles while leaving Calm-off visibility untouched"
 }
 
 test_interactive_terminal_e2e() {
-  local project config home session_file export_file export_dom default_snapshot expanded_snapshot hidden_snapshot active_before_snapshot active_hidden_snapshot export_snapshot restored_snapshot working_snapshot working_response_snapshot restarted_snapshot resumed_restored_snapshot hash_before hash_after now version chrome chrome_pid chrome_wait active_wait active_screen_wait boat_frame_one boat_frame_two boat_resized_snapshot boat_focus_snapshot boat_cleared_snapshot boat_hull_line boat_sail_line boat_column_one boat_column_two boat_line boat_color_snapshot boat_color_line boat_water_snapshot boat_water_line boat_water_first boat_water_changed boat_narrow_snapshot boat_narrow_sails
+  local project config home session_file export_file export_dom default_snapshot expanded_snapshot hidden_snapshot active_before_snapshot active_hidden_snapshot export_snapshot restored_snapshot working_snapshot working_response_snapshot restarted_snapshot resumed_restored_snapshot hash_before hash_after now version chrome chrome_pid chrome_wait active_wait active_screen_wait boat_frame_one boat_frame_two boat_resized_snapshot boat_focus_snapshot boat_cleared_snapshot boat_hull_line boat_sail_line boat_column_one boat_column_two boat_line boat_color_snapshot boat_color_line boat_water_snapshot boat_water_line boat_water_first boat_water_changed boat_narrow_snapshot boat_narrow_sails boat_freeze_snapshot boat_resume_snapshot boat_freeze_column boat_freeze_sail boat_resume_column boat_resume_sail
   if ! command -v pi >/dev/null 2>&1 || ! command -v tmux >/dev/null 2>&1; then
     echo "skip: pi or tmux not found for Pi calm interactive E2E"
     return 0
@@ -2208,6 +2496,8 @@ test_interactive_terminal_e2e() {
   boat_color_snapshot="$TMP_ROOT/boat-color.txt"
   boat_water_snapshot="$TMP_ROOT/boat-water.txt"
   boat_narrow_snapshot="$TMP_ROOT/boat-narrow.txt"
+  boat_freeze_snapshot="$TMP_ROOT/boat-freeze.txt"
+  boat_resume_snapshot="$TMP_ROOT/boat-resume.txt"
   restarted_snapshot="$TMP_ROOT/restarted.txt"
   resumed_restored_snapshot="$TMP_ROOT/resumed-restored.txt"
   mkdir -p "$project/.pi/extensions/lib" "$project/bin" "$project/state" "$config" "$home/config"
@@ -2828,6 +3118,19 @@ JS
     i=$((i + 1))
   done
 
+  # Capture the last on-screen column and sail before settling so the next working
+  # period in this same Pi session can prove freeze/resume continuity.
+  tmux -L "$TMUX_SOCKET" capture-pane -p -t "$TMUX_SESSION" >"$boat_freeze_snapshot"
+  boat_freeze_column=$(awk 'index($0,"\\__/"){print index($0,"\\__/"); exit}' "$boat_freeze_snapshot")
+  boat_freeze_sail=$(grep -E '<\||\|>' "$boat_freeze_snapshot" | tail -1 || true)
+  case "$boat_freeze_sail" in
+    *'<|'*) boat_freeze_sail='<|' ;;
+    *'|>'*) boat_freeze_sail='|>' ;;
+    *) fail "could not read the freeze-frame sail heading" ;;
+  esac
+  [ -n "$boat_freeze_column" ] && [ "$boat_freeze_column" -gt 1 ] \
+    || fail "freeze frame never left the left edge (column '${boat_freeze_column:-empty}')"
+
   # Escape aborts the run, and the abort path removes the ship with no residue.
   tmux -L "$TMUX_SOCKET" send-keys -t "$TMUX_SESSION" Escape
   active_screen_wait=0
@@ -2843,6 +3146,50 @@ JS
   assert_not_contains "$(cat "$boat_cleared_snapshot")" "CALM_WORKING_E2E_RESPONSE" "the long-delay fixture settled instead of aborting on Escape"
   assert_not_contains "$(cat "$boat_cleared_snapshot")" "FOCUSPROBE" "the editor kept the focus probe text after Escape"
 
+  # A later working period in the same Pi process must resume the frozen column and
+  # sail rather than recreating the boat at the left edge. Capture the first resumed
+  # frames quickly so the slow boat cadence cannot advance before the assertion.
+  tmux -L "$TMUX_SOCKET" send-keys -t "$TMUX_SESSION" -l "/calm-boat-e2e"
+  tmux -L "$TMUX_SOCKET" send-keys -t "$TMUX_SESSION" M-s
+  boat_resume_column=""
+  boat_resume_sail=""
+  active_screen_wait=0
+  while [ "$active_screen_wait" -lt 200 ]; do
+    tmux -L "$TMUX_SOCKET" capture-pane -p -t "$TMUX_SESSION" >"$boat_resume_snapshot"
+    if grep -Fq '\__/' "$boat_resume_snapshot"; then
+      boat_resume_column=$(awk 'index($0,"\\__/"){print index($0,"\\__/"); exit}' "$boat_resume_snapshot")
+      boat_resume_sail=$(grep -E '<\||\|>' "$boat_resume_snapshot" | tail -1 || true)
+      case "$boat_resume_sail" in
+        *'<|'*) boat_resume_sail='<|' ;;
+        *'|>'*) boat_resume_sail='|>' ;;
+      esac
+      break
+    fi
+    sleep 0.025
+    active_screen_wait=$((active_screen_wait + 1))
+  done
+  [ -n "$boat_resume_column" ] \
+    || fail "the second working period never showed the working ship"
+  [ "$boat_resume_column" -eq "$boat_freeze_column" ] \
+    || fail "the second working period reset the boat from column $boat_freeze_column to $boat_resume_column instead of resuming"
+  [ "$boat_resume_sail" = "$boat_freeze_sail" ] \
+    || fail "the second working period changed sail from $boat_freeze_sail to $boat_resume_sail"
+  assert_not_contains "$(cat "$boat_resume_snapshot")" "Working..." \
+    "the second working period left Pi's stock working row visible"
+
+  # Clear the resumed run before the Calm-off stock-row probe.
+  tmux -L "$TMUX_SOCKET" send-keys -t "$TMUX_SESSION" Escape
+  active_screen_wait=0
+  while [ "$active_screen_wait" -lt 200 ]; do
+    tmux -L "$TMUX_SOCKET" capture-pane -p -t "$TMUX_SESSION" >"$boat_cleared_snapshot"
+    if ! grep -Fq '\__/' "$boat_cleared_snapshot"; then
+      break
+    fi
+    sleep 0.05
+    active_screen_wait=$((active_screen_wait + 1))
+  done
+  assert_not_contains "$(cat "$boat_cleared_snapshot")" '\__/' "Escape did not remove the resumed working ship"
+
   # Calm off restores Pi's stock working row and never shows the ship.
   tmux -L "$TMUX_SOCKET" send-keys -t "$TMUX_SESSION" -l "/calm"
   tmux -L "$TMUX_SOCKET" send-keys -t "$TMUX_SESSION" M-s
@@ -2923,7 +3270,7 @@ JS
   [ "$(cat "$home/config/calm")" = off ] || fail "/calm after restart did not persist the inactive choice"
   tmux -L "$TMUX_SOCKET" send-keys -t "$TMUX_SESSION" -l "/quit"
   tmux -L "$TMUX_SOCKET" send-keys -t "$TMUX_SESSION" M-s
-  pass "Pi calm native E2E replaces the stock working row with a moving, resize-clamped working ship that clears on abort, keeps captain turns visible, hides exact operational user rows without changing persistence, restores stock rendering Calm-off, survives restart, and preserves export plus Ctrl+O behavior"
+  pass "Pi calm native E2E replaces the stock working row with a moving, resize-clamped working ship that freezes and resumes across two working periods in one Pi session, clears on abort, keeps captain turns visible, hides exact operational user rows without changing persistence, restores stock rendering Calm-off, survives restart, and preserves export plus Ctrl+O behavior"
 }
 
 test_home_resolution