@aemonge-dev/pi-stardeck 0.9.1 → 0.9.3

package/docs/architecture.md

@@ -44,7 +44,7 @@ The composed modules currently coordinate through:
 
 These channels are compatibility boundaries. Consolidation may centralize their types
 but must not silently change semantics or permit sensitive payloads. Selection is an
-additive protocol-1 projection of explicit OpenSpec, Goal, or Session Work state;
+additive protocol-1 projection of explicit OpenSpec or Session Work state;
 suggestion is controlled vocabulary rather than generated prose. Active-run telemetry
 contains only bounded child and subagent counts derived from Pi lifecycle events. It
 never carries prompts, names, process identities, arguments, or child output. The deck

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aemonge-dev/pi-stardeck",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "A Vim- and tmux-inspired command deck for Pi",
   "type": "module",
   "keywords": [

package/packages/pi-stardeck/README.md

@@ -41,7 +41,7 @@ The title has four styled groups: lifecycle, a structured active ancestry, focus
 optional focus detail. Each activity-path segment receives the blue minor `›`; the
 violet-pink major `⟩` divides runtime ancestry from the green narrative focus. Human
 prompt text is never converted into focus automatically. OpenSpec may add its exact Task
-after another green `›`. Focus selection prefers an exact OpenSpec Task, then Goal, then
+after another green `›`. Focus selection prefers an exact OpenSpec Task, then
 Session Work. Active turns without a selection use the explicit `OpenSpec › no focus`,
 `no OpenSpec`, or `no focus` state supplied by the status producer; `Direct response` is
 never presented as a focus. Empty states are dim while real focus remains bold semantic
@@ -76,14 +76,14 @@ The additive header protocol projects selection independently from live work:
 
 ```ts
 selection: {
-  source: 'openspec' | 'goal' | 'session-work';
+  source: 'openspec' | 'session-work';
   titles: string[]; // one or two bounded, normalized titles
   color: HeaderColor;
 } | null;
 suggestion: HeaderSuggestion | null; // controlled enum, never generated prose
 ```
 
-Selection priority remains exact OpenSpec Task, Goal, then Session Work. Older
+Selection priority remains exact OpenSpec Task, then Session Work. Older
 protocol-1 events may use sanitized non-placeholder work titles as a legacy selection;
 explicit malformed selection is rejected rather than borrowing a fallback. The
 suggestion vocabulary is producer-owned, appears only in waiting, blocked, approval,
@@ -133,7 +133,7 @@ the otherwise missing project slot and yields before core project/work informati
 narrow terminals. Slash-prefixed Git branches collapse the prefix to its initial and cap
 display at 30 cells with `...` (`feat/persist-versioned-prompts-in-duckdb` →
 `f/persist-versioned-prompts...`). The right side shows compact OpenSpec Plan/Task
-progress, or the simple Goal, Focus, or `no OpenSpec` fallback when no OpenSpec
+progress, or the simple Focus or `no OpenSpec` fallback when no OpenSpec
 portfolio is available. The footer reserves a four-cell visual split between alignment
 groups. OpenSpec uses icons instead of repeated labels: task-list `` for Plans and
 notebook `` for Tasks, with minor `›` between them. Their Nerd Font glyphs exactly

package/packages/pi-stardeck/index.ts

@@ -153,6 +153,13 @@ export function installEmptyDeckFooter(
   return () => ctx.ui.setFooter(undefined);
 }
 
+/** Git-style short id of the running Pi session — 8 hex chars of the
+ * UUIDv7, undefined when the id does not match the expected shape. */
+function shortSessionId(ctx: ExtensionContext): string | undefined {
+  const short = ctx.sessionManager.getSessionId().slice(0, 8);
+  return /^[0-9a-f]{8}$/u.test(short) ? short : undefined;
+}
+
 export default function galacticaContextHeader(
   pi: ExtensionAPI,
   options: ContextHeaderOptions = {},
@@ -172,6 +179,7 @@ export default function galacticaContextHeader(
   let lastActivityAgeSignature = '';
   let activityAgeTimer: ReturnType<typeof setInterval> | undefined;
   let sessionGeneration = 0;
+  let sessionShortId: string | undefined;
   let activeCwd = '';
   let activeCtx: ExtensionContext | undefined;
   let gitRefreshInFlight = false;
@@ -493,6 +501,7 @@ export default function galacticaContextHeader(
     resourceTimer = undefined;
     ++sessionGeneration;
     activeCtx = ctx;
+    sessionShortId = shortSessionId(ctx);
     activeCwd = '';
     branch = '';
     gitAvailable = false;
@@ -578,6 +587,7 @@ export default function galacticaContextHeader(
           lsp: lspCapability,
           mcp: mcpCapability,
           mode: vimMode,
+          ...(sessionShortId !== undefined ? { sessionShortId } : {}),
         },
         width,
         theme,

package/packages/pi-stardeck/src/deck.ts

@@ -2,7 +2,6 @@ import type { Theme } from '@earendil-works/pi-coding-agent';
 import { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
 
 import type { LspCapability, McpCapability } from './capabilities.ts';
-import type { HeaderSelection } from './gauge.ts';
 import type {
   FooterTelemetrySnapshot,
   GitStatusSummary,
@@ -13,7 +12,7 @@ import type {
 } from './gauge.ts';
 import type { ResourceTelemetry } from './process-resources.ts';
 import { formatDeckCountdown } from './gauge.ts';
-import { formatDeckWorkLabel } from './title-state.ts';
+import { deckWorkSegments } from './title-state.ts';
 
 export interface HeaderDeckModeRail {
   plain: string;
@@ -41,6 +40,8 @@ export interface HeaderDeckState {
   lsp: LspCapability | null;
   mcp: McpCapability | null;
   mode: VimMode;
+  /** Git-style first 8 chars of the Pi session id; worn by the sentinel. */
+  sessionShortId?: string;
 }
 
 const ANSI_ESCAPE = new RegExp(
@@ -163,23 +164,40 @@ function wrapFocus(text: string, width: number, maximumLines: number): string[]
   return lines.slice(0, maximumLines);
 }
 
+function mirrorKey(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9]/gu, '');
+}
+
+function bandWrap(
+  content: string,
+  width: number,
+  theme: Theme,
+  contentColor: string,
+): string[] {
+  return wrapFocus(content, Math.max(1, width), 2).map((line) =>
+    color(theme, contentColor, line),
+  );
+}
+
 function titleBandLines(state: HeaderDeckState, width: number, theme: Theme): string[] {
-  // Line 2 anchor: the clock always leads the band with its icon; the
-  // Subject follows when the title state carries one, and a fresh session
-  // (subject null) leaves the clock leading alone — no dangling separator.
-  // Task 3.1: the unfocused open-goal hint left this band for the notice
-  // slot (design: "notices absorb the unfocused open-goal hint").
-  const clock = `${color(theme, 'customMessageLabel', '󰠭')} ${timerTile(state, theme)}`;
+  // Human amendment 2026-10-23: line 2 is sacred — Subject and the Work
+  // tile only; no timers, no icons, no chrome. The session clock is
+  // discarded; liveness lives in the turn cluster on the activity lane.
   const title = state.header?.title ?? null;
   if (title) {
     const subject = safeText(title.subject ?? '');
     if (!subject) {
       // Human amendment 2026-10-19: the empty slot renders its dim
       // placeholder — mirroring the Work side's `— no change owns the
-      // moment` — instead of leaving the clock leading alone.
-      return focusWrapLines('— no subject', clock, width, theme, 'dim');
+      // moment` — never an empty band while the session talks.
+      return bandWrap('— no subject', width, theme, 'dim');
     }
-    return focusWrapLines(subject, clock, width, theme, 'accent');
+    // When the subject mirrors the focused change (the gate law's
+    // "subject mirrors its title"), it renders success-green like the
+    // PWD — the mirror visible at a glance.
+    const work = title.work;
+    const mirrorsFocus = work !== null && mirrorKey(subject) === mirrorKey(work.change);
+    return bandWrap(subject, width, theme, mirrorsFocus ? 'success' : 'accent');
   }
   // Pre-title publishers: the legacy selection keeps the band alive.
   const selection = state.header?.selection;
@@ -188,35 +206,16 @@ function titleBandLines(state: HeaderDeckState, width: number, theme: Theme): st
     .filter(Boolean);
   if (!selection || titles.length === 0) {
     if (!state.header) {
-      // Frozen contract: a publisher that reports nothing at all keeps
-      // the collapsed frame — clock alone, no placeholder dashes.
-      return [clock];
+      // Frozen contract (amended 2026-10-23): a publisher that reports
+      // nothing keeps the collapsed frame — an empty band, no dashes.
+      return [''];
     }
-    // Amendment: a live session (header present, Work rendering) that
-    // simply has no subject gets the dim placeholder — the title slot
-    // never renders empty when the session is talking to us.
-    return focusWrapLines('— no subject', clock, width, theme, 'dim');
+    return bandWrap('— no subject', width, theme, 'dim');
   }
   const selectionColor = ['accent', 'success'].includes(selection.color)
     ? 'accent'
     : selection.color;
-  return focusWrapLines(titles.join(' › '), clock, width, theme, selectionColor);
-}
-
-function focusWrapLines(
-  content: string,
-  clock: string,
-  width: number,
-  theme: Theme,
-  contentColor: string,
-): string[] {
-  const lead = `${clock} ${semanticSeparator(theme)} `;
-  const indent = ' '.repeat(visibleWidth(lead));
-  const contentWidth = Math.max(1, width - visibleWidth(lead));
-  return wrapFocus(content, contentWidth, 2).map(
-    (line, index) =>
-      `${index === 0 ? lead : indent}${color(theme, contentColor, line)}`,
-  );
+  return bandWrap(titles.join(' › '), width, theme, selectionColor);
 }
 
 function semanticSeparator(theme: Theme): string {
@@ -247,22 +246,9 @@ function workTile(state: HeaderDeckState, theme: Theme): string {
   if (!title) return '';
   const work = title.work;
   if (!work) return color(theme, 'dim', '— no change owns the moment');
-  return color(
-    theme,
-    work.total > 0 && work.done >= work.total ? 'success' : 'text',
-    formatDeckWorkLabel(work),
-  );
-}
-
-// Relocation phase (Human-directed): the clock leads the title band beside
-// the anchor, runs ride the lifecycle row, and Work keeps the title's
-// right end — real values when live, the dim hint when idle.
-function timerTile(state: HeaderDeckState, theme: Theme): string {
-  const elapsed = state.elapsedMs;
-  const idle = state.idleMs;
-  return elapsed != null
-    ? color(theme, 'accent', formatDeckElapsed(elapsed))
-    : color(theme, 'dim', formatDeckElapsed(idle ?? 0));
+  return deckWorkSegments(work)
+    .map((segment) => color(theme, segment.color, segment.text, segment.bold === true))
+    .join('');
 }
 
 function spanElapsed(ms: number): string {
@@ -305,6 +291,7 @@ const ACTIVITY_LABELS: Record<HeaderActivity['kind'], string> = {
   regression: 'testing',
   verification: 'checking',
   'result-review': 'reviewing result',
+  answering: 'answering',
   recovery: 'recovering',
   'awaiting-validation': 'validation',
   'awaiting-input': 'input',
@@ -316,7 +303,10 @@ function activityLabel(state: HeaderDeckState): string {
   const pathLabel = safeText(pathActivity?.compact || pathActivity?.label || '');
   if (pathLabel) return pathLabel;
   const activity = state.header?.work?.activity;
-  return activity ? ACTIVITY_LABELS[activity.kind] : '';
+  // `awaiting-*` kinds are the rest face — they never speak for the band
+  // (a focused session still retires; quiet-activity-row amendment).
+  if (!activity || activity.kind.startsWith('awaiting-')) return '';
+  return ACTIVITY_LABELS[activity.kind];
 }
 
 /** `editing deck.ts` / `reading schema.yaml` / `subagent: scout`. */
@@ -326,17 +316,45 @@ function titleActivityLabel(activity: { class: string; target: string }): string
     : `${activity.class} ${activity.target}`;
 }
 
-function activityTile(state: HeaderDeckState, theme: Theme): string {
-  // Line 3 left: the observed activity owns the slot — `awaiting Human`
-  // when idle, the legacy observed label for pre-title publishers.
+/** The line-3 band speaks when either side carries a real signal:
+ * an observed activity (title-state or legacy) or a turn meter that
+ * cost tokens or time. Both idle (`awaiting Human` + `— · 0 tok` or
+ * no meter) is zero activity — the band and its seam retire
+ * (Human-directed 2026-10-20, quiet-activity-row). */
+/** Live phase word from the header's kind-based activity projection —
+ * fills the gaps between tools (thinking, planning, checking) so the
+ * band never claims `awaiting Human` mid-turn. The `awaiting-*` kinds
+ * are the REST face (awaiting Human review/input after settle): they
+ * never speak for the band, or a focused session would never rest
+ * (quiet-activity-row amendment). */
+function liveKindLabel(state: HeaderDeckState): string {
+  const activity = state.header?.activity ?? null;
+  if (!activity || activity.kind.startsWith('awaiting-')) return '';
+  return ACTIVITY_LABELS[activity.kind] ?? '';
+}
+
+/** The band's current left label: the precise title-state activity when a
+ * tool is observed, else the live phase word; empty when truly idle. */
+function observedActivityLabel(state: HeaderDeckState): string {
   const title = state.header?.title ?? null;
   if (title) {
-    return title.activity
-      ? color(theme, 'text', titleActivityLabel(title.activity))
-      : color(theme, 'dim', 'awaiting Human');
+    return title.activity ? titleActivityLabel(title.activity) : liveKindLabel(state);
   }
-  const legacy = activityLabel(state);
-  return legacy ? color(theme, 'text', legacy) : color(theme, 'dim', 'awaiting Human');
+  return activityLabel(state) || liveKindLabel(state);
+}
+
+function activityBandSpeaks(state: HeaderDeckState): boolean {
+  const activitySpeaks = observedActivityLabel(state) !== '';
+  const turn = state.header?.turn ?? null;
+  const costSpeaks = turn !== null && (turn.tokens > 0 || turn.elapsedMs > 0);
+  return activitySpeaks || costSpeaks;
+}
+
+function activityTile(state: HeaderDeckState, theme: Theme): string {
+  // Line 3 left: the observed activity owns the slot — the live phase word
+  // between tools, `awaiting Human` only when the session truly rests.
+  const label = observedActivityLabel(state);
+  return label ? color(theme, 'text', label) : color(theme, 'dim', 'awaiting Human');
 }
 
 function formatTurnElapsed(ms: number): string {
@@ -350,18 +368,21 @@ function formatTurnElapsed(ms: number): string {
 }
 
 function turnCostTile(state: HeaderDeckState, theme: Theme): string {
-  // Line 3 right: the per-turn cost meter. Idle renders the accepted
-  // `— · 0 tok`; pre-title publishers (no meter) stay silent.
+  // Activity lane right: the turn cluster — liveness icon, turn time,
+  // and tokens in one aligned group (Human amendment 2026-10-23: the
+  // deck's only timer). Idle keeps the accepted dim `— · 0 tok`; the
+  // quiet-activity-row contract depends on it.
   const turn = state.header?.turn ?? null;
   if (!turn) return '';
   if (turn.tokens <= 0 && turn.elapsedMs <= 0) {
     return color(theme, 'dim', '— · 0 tok');
   }
-  return color(
+  return `${color(theme, 'customMessageLabel', '󰠭')} ${color(
     theme,
-    'accent',
-    `this turn ${formatTokens(turn.tokens)} · ${formatTurnElapsed(turn.elapsedMs)}`,
-  );
+    'warning',
+    formatTurnElapsed(turn.elapsedMs),
+    true,
+  )} ${color(theme, 'dim', '·')} ${color(theme, 'warning', formatTokens(turn.tokens))}`;
 }
 
 function gitRight(state: HeaderDeckState, theme: Theme): string {
@@ -478,7 +499,7 @@ function identityCluster(
   // the bare→bare chip spacing).
   const texts = new Map<string, string>();
   for (const item of state.piStatus?.nativeStatuses ?? []) {
-    if (item.key === 'goal' || texts.has(item.key)) continue;
+    if (texts.has(item.key)) continue;
     texts.set(item.key, item.text);
   }
   const parts: string[] = [];
@@ -512,12 +533,17 @@ function identityCluster(
 const BLOCKED_NOTICE = '\u26d4 blocked';
 const APPROVAL_NOTICE = 'approval required';
 
+/** Narrowest frame that hosts the id-bearing sentinel cluster (12 cells
+ * plus breathing room for the machine ladder). */
+const SENTINEL_ID_MIN_WIDTH = 24;
+const SENTINEL_BUG = '\u{F082D}';
+
 function companionWarningTexts(state: HeaderDeckState): string[] {
   // Same sources as the capability-health chips: the known companions'
-  // native-status texts, goal key filtered, ranked after blocked/approval.
+  // native-status texts, ranked after blocked/approval.
   const texts = new Map<string, string>();
   for (const item of state.piStatus?.nativeStatuses ?? []) {
-    if (item.key === 'goal' || texts.has(item.key)) continue;
+    if (texts.has(item.key)) continue;
     texts.set(item.key, item.text);
   }
   const warnings: string[] = [];
@@ -535,17 +561,13 @@ function companionWarningTexts(state: HeaderDeckState): string[] {
 
 /**
  * Aggregate the deck's scattered warning signals into one notice slot
- * (Task 3.1). Ranked per the spec's accepted mixed render: the unfocused
- * open-goal hint, then the companion group (blocked, approval, warning
- * texts), then the diagnostics count — `·`-joined, empty when clean.
+ * (Task 3.1). Ranked per the spec's accepted mixed render: the companion
+ * group (blocked, approval, warning texts), then the diagnostics count —
+ * `·`-joined, empty when clean.
  */
 export function collectDeckNotices(state: HeaderDeckState): string[] {
   const header = state.header;
-  const openGoals = header?.selection?.source === 'goal' ? 0 : (header?.openGoals ?? 0);
   const notices: string[] = [];
-  if (openGoals > 0) {
-    notices.push(`${openGoals} open goal${openGoals === 1 ? '' : 's'} · /goal-focus`);
-  }
   if (header?.blocked) notices.push(BLOCKED_NOTICE);
   if (header?.approvalRequired) notices.push(APPROVAL_NOTICE);
   notices.push(...companionWarningTexts(state));
@@ -559,18 +581,28 @@ export function collectDeckNotices(state: HeaderDeckState): string[] {
   return waiver ? notices.filter((notice) => notice !== waiver.notice) : notices;
 }
 
-function noticeTile(state: HeaderDeckState, theme: Theme): string {
+function noticeTile(state: HeaderDeckState, theme: Theme, width: number): string {
   const notices = collectDeckNotices(state);
   // Healthy sentinel (Human-directed 2026-10-19, reversing the retirement):
   // when the ladder is silent the dim ladybug holds the right end — the
   // deck's signature glyph and a reserved one (safeText strips 󰠭 from
   // published text), so the status row always speaks: ⚠ with notices,
-  // the quiet ladybug when all is well.
-  if (notices.length === 0) return color(theme, 'dim', '󰠭');
+  // the quiet ladybug when all is well. Ladybug-session-id amendment
+  // (Human-directed 2026-10-20): a clean frame with a known session id
+  // wears it between two ladybugs — blue bugs, purple id — so the deck
+  // doubles as a track-and-restore handle; the plain dim bug stays when
+  // the id is unknown or the frame is too narrow for the cluster.
+  if (notices.length === 0) {
+    const id = state.sessionShortId;
+    if (id !== undefined && width >= SENTINEL_ID_MIN_WIDTH) {
+      return `${color(theme, 'accent', SENTINEL_BUG)} ${color(theme, 'thinkingHigh', id)} ${color(theme, 'accent', SENTINEL_BUG)}`;
+    }
+    return color(theme, 'dim', SENTINEL_BUG);
+  }
   // Blocked carries the error severity it wore on the deleted lifecycle
   // tile; every other notice renders at warning.
   const semantic = notices.includes(BLOCKED_NOTICE) ? 'error' : 'warning';
-  return color(theme, semantic, `⚠ ${notices.join(' · ')}`);
+  return color(theme, semantic, `\u26a0 ${notices.join(' · ')}`);
 }
 
 export function machineCornerSegments(
@@ -761,65 +793,12 @@ function statusAlertTile(
   return visibleWidth(count) < width ? count : '';
 }
 
-function formatGoalElapsed(seconds: number): string {
-  if (seconds < 60) return `${Math.floor(seconds)}s`;
-  const totalMinutes = Math.floor(seconds / 60);
-  if (totalMinutes < 60) return `${totalMinutes}m ${Math.floor(seconds % 60)}s`;
-  return `${Math.floor(totalMinutes / 60)}h ${totalMinutes % 60}m`;
-}
-
 function formatTokens(tokens: number): string {
   if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}M`;
   if (tokens >= 1_000) return `${(tokens / 1_000).toFixed(1)}k`;
   return `${Math.floor(tokens)}`;
 }
 
-const GOAL_STATUS_COLORS: Record<string, string> = {
-  active: 'accent',
-  complete: 'success',
-  paused: 'warning',
-  blocked: 'error',
-  usage_limited: 'warning',
-  budget_limited: 'warning',
-  queued: 'dim',
-};
-
-function goalBadgeTile(
-  goal: NonNullable<HeaderSelection['goal']>,
-  theme: Theme,
-): string {
-  const semantic = GOAL_STATUS_COLORS[goal.status] ?? 'text';
-  const elapsed =
-    goal.elapsedSeconds !== undefined
-      ? ` · ${formatGoalElapsed(goal.elapsedSeconds)}`
-      : '';
-  return `${color(theme, semantic, `● ${goal.status}`)}${color(theme, 'dim', elapsed)}`;
-}
-
-function goalTreeLines(
-  goal: NonNullable<HeaderSelection['goal']>,
-  width: number,
-  theme: Theme,
-): string[] {
-  if (width < 56) return [];
-  const rows: string[] = [];
-  if (goal.tasksTotal !== undefined && goal.tasksDone !== undefined) {
-    const active =
-      goal.tasksActive !== undefined && goal.tasksActive > 0
-        ? ` · ${goal.tasksActive} active`
-        : '';
-    rows.push(`  ├ tasks ${goal.tasksDone}/${goal.tasksTotal} done${active}`);
-  }
-  if (goal.tokensUsed !== undefined) {
-    const budget =
-      goal.tokenBudget !== undefined && goal.tokenBudget > 0
-        ? ` · budget ${Math.min(999, Math.round((goal.tokensUsed / goal.tokenBudget) * 100))}%`
-        : '';
-    rows.push(`  └ usage ${formatTokens(goal.tokensUsed)} tokens${budget}`);
-  }
-  return rows.map((line) => color(theme, 'dim', line));
-}
-
 export function renderHeaderDeck(
   state: HeaderDeckState,
   width: number,
@@ -831,41 +810,35 @@ export function renderHeaderDeck(
   const lineColor = 'thinkingHigh';
   const solidRule = color(theme, lineColor, '─'.repeat(boundedWidth));
   const dottedRule = `\u001b[2m${color(theme, 'text', '┈'.repeat(boundedWidth))}\u001b[22m`;
-  // Line 2 (four-line deck): the clock and Subject lead with Work on the
-  // right end; goal progress rows keep their home beneath this line.
-  // Narrow frames: the Work slot yields before the clock anchor does.
-  const goalDetail =
-    state.header?.selection?.source === 'goal'
-      ? state.header.selection.goal
-      : undefined;
-  const titleRight =
-    boundedWidth >= 40
-      ? goalDetail
-        ? goalBadgeTile(goalDetail, theme)
-        : workTile(state, theme)
-      : '';
+  // Line 2 (four-line deck): the Subject leads with Work on the right end
+  // (Human amendment 2026-10-23 — no clock, no chrome). Narrow frames: the
+  // Work slot yields before the Subject does.
+  const titleRight = boundedWidth >= 40 ? workTile(state, theme) : '';
   const focusLines = titleBandLines(state, boundedWidth, theme);
   const titleRows = [
     alignedSingleRow(focusLines[0] ?? '', titleRight, boundedWidth),
     ...focusLines.slice(1),
   ];
-  const goalRows = goalDetail ? goalTreeLines(goalDetail, boundedWidth, theme) : [];
 
   // Line 3 (four-line deck): Activity left with the per-turn cost right —
   // the superseded lifecycle/suggestion/runs tiles are gone; Work,
   // Activity, and the spans rows are their replacements. The spans rows
   // keep their home directly beneath this line.
-  const activityRow = alignedSingleRow(
-    activityTile(state, theme),
-    turnCostTile(state, theme),
-    boundedWidth,
-  );
+  const spanRows = spanTreeRows(state, boundedWidth, theme);
+  const bandSpeaks = activityBandSpeaks(state);
+  const activityRow = bandSpeaks
+    ? alignedSingleRow(
+        activityTile(state, theme),
+        turnCostTile(state, theme),
+        boundedWidth,
+      )
+    : '';
   // deck-reshape, swap amendment: the bottom row carries the MACHINE
   // tail on the left (yielding right-to-left into whatever width the
   // status leaves) and the status on the right — which always speaks
   // now: ⚠ notices or the dim ladybug sentinel when clean. The engine
   // group moved to line 1 right.
-  const statusRight = noticeTile(state, theme);
+  const statusRight = noticeTile(state, theme, boundedWidth);
   const machineRow = machineCornerLadder(
     state,
     theme,
@@ -879,7 +852,9 @@ export function renderHeaderDeck(
   // Band adjacency (Human-directed, accepted mockups; third 2.4
   // amendment): the deck opens with a full ─ rule directly beneath the
   // line-1 strip; the internal seams stay dotted ┈ between lines 2 and
-  // 3 and between line 3 (spans rows included) and the status row.
+  // 3 and between line 3 (spans rows included) and the status row —
+  // except the 2/3 seam retires with a silent, spanless line-3 band
+  // (quiet-activity-row): idle + zero cost never narrates itself.
   const identity = identityCluster(state, theme);
   const corner = deckCornerRight(state, theme, boundedWidth);
   const alert = statusAlertTile(
@@ -896,10 +871,9 @@ export function renderHeaderDeck(
     ),
     solidRule,
     ...titleRows,
-    ...goalRows,
-    dottedRule,
-    activityRow,
-    ...spanTreeRows(state, boundedWidth, theme),
+    ...(bandSpeaks || spanRows.length > 0 ? [dottedRule] : []),
+    ...(bandSpeaks ? [activityRow] : []),
+    ...spanRows,
     ...(engineRow.trim() !== '' ? [dottedRule, engineRow] : []),
   ];
   return rows.map((line) => fitWithoutDanglingSeparator(line, boundedWidth));