@aemonge-dev/pi-stardeck 0.9.4 → 0.11.0

package/package.json

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

package/packages/pi-stardeck/README.md

@@ -4,73 +4,40 @@ A dependency-free Pi extension that coordinates the prompt information architect
 through Pi's supported widget and event APIs.
 
 ```text
-─ 󰠭 › ─────────────────────────────────────────────────────────────────────
-( 3 ›  2 · 00:05'12) working ⟩ checking Stabilize runtime and focus · step 3/5     task 1/2 ›  stps 3/5
-󰓾 Stabilize runtime and focus in the cockpit
-┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈
-[󰆧]  ~/projects/example                                     main ⟩  clean
-┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈
-󰚩 Opus › high ⟩ 󰾆 42% › 󰎞 2         10% › 󰜦 $0.10 ⟩  12% ›  375M ›  3/3
-─ 󰏫 ─────────────────────────────────────────────────────────────── ‹ 󰠭 ─
+─ 󰠭 › ────────────────────────────────────────────────────────────────────
+󰠭 [󰆧]  ~/projects/example › main › +0 ~1 1        󰚩 Opus › high › 󰃰 42%
+──────────────────────────────────────────────────────────────────────
+Stabilize runtime and focus in the cockpit              planning 6/7 › 󰄱 9/19
+┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈
+editing deck.ts                                            00:38'00 · 4.2k
+└ (00'12) scout working
+┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈
+󰃰 5h 52% › 󰆧 3% › 󰉡 48% › 󰞏 2 › 󰂻 268M › 󰄠 38% › 󰈛 $5.16          󰠭 abcd1234
 ```
 
-The preferred editor-deck surface keeps two stable semantic rows. The first is a
-left-packed operational strip: runtime capsule, lifecycle, activity, controlled next
-action, and Task/Step progress. The second is a full-width explicit selection canvas
-that wraps to at most two lines. Every slot remains present; zero, idle, unavailable,
-and unselected states are dim instead of appearing or disappearing. Long content may
-wrap responsively, but runtime state never changes the deck topology. Decorative rails
-remain slim and contain no telemetry.
-
-The editor deck uses blue for the active runtime capsule, the bold lifecycle anchor,
-and regular-weight explicit selection. Ordinary active activity remains neutral, except
-that `recovering` and its ordinary suggestion are blue together while only the lifecycle
-is bold. Other ordinary suggestions remain green. Incomplete Task/Step progress is
-neutral until each counter completes and stays right-aligned without a major boundary.
-The lifecycle/activity boundary and rails remain purple; minor separators are dim.
-Human-input and validation cues stay yellow, blockers stay red, and every inactive value
-stays dim.
-
-The legacy above-editor widget owns only current work identity and preserves the
-` ready ⟩ no focused task` idle row when no work is selected. The leading icon is
-runtime-authoritative: `` while Pi is busy in an active lifecycle and `` while
-settled, waiting, blocked, listening, or aborted. Internal lifecycle states render as
-short readable verbs. The Ramona loop remains exact: `understand`, `work`, `assure`,
-`learn`, and `answer`. Runtime boundaries are `wait`, `blocked`, `ready`, or `stopped`.
-The title has four styled groups: lifecycle, a structured active ancestry, focus, and
-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
-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
-green.
-
-Wide rows render lifecycle → active ancestry → optional focus → optional focus detail,
-for example `assure › checking quality › assuring tests ⟩ Implement global flow`. The
-renderer generates every separator. Empty or rejected paths leave no separator or
-placeholder whitespace. As width falls it tries full labels, compact labels, a collapsed
-`… › deepest` ancestry, and finally compact lifecycle plus the deepest active segment.
-Narrative focus disappears before meaningful active ancestry. Terminal display-cell
-measurement and final truncation remain Unicode- and Nerd-Font-aware.
-
-Runtime anchor and lifecycle are bold blue `#076678`; activity ancestry and its minor
-`›` are regular blue; the major `⟩` is purple; focus is bold semantic success green; and
-optional focus hierarchy is regular success green. Dim is reserved for the two empty
-focus fallbacks; muted, text, cyan, yellow, and gray are never used in the title.
-
-The extension hides Pi's separate built-in `Working...` loader row with
-`ctx.ui.setWorkingVisible(false)`, including its vertical space. The header therefore
-uses its complete width for lifecycle, bounded activity, and focus. Runtime age is
-published for the bottom prompt rail as an eight-cell chronometer measuring time since
-the most recent observed foreground provider, assistant, or tool event. It stays
-fixed-width as it advances: `00:00'00`, `00:00'45`, `00:12'30`, or `12:34'56`; hour/day
-fallbacks also remain eight cells. Active timing uses the high-contrast deep-cyan
-`accent` color; settled states display dim `00:00'00` rather than repeating the header's
-`wait`, `ready`, or other lifecycle word. A session-scoped ticker publishes only when
-the formatted chronometer changes and is cleared on shutdown. No message content,
-thinking, reasoning, prompts, tool arguments, or child-agent output enters the widget.
+The deck renders four stable rows above the editor:
+
+1. **Where and what** — identity and companion chips lead, then the project path
+   and Git segment; the right corner carries the engine group (model › thinking ›
+   quota) and any alert.
+2. **Focus** — the session subject (auto-titled from the first real prompt,
+   settable through the `title` tool) with the OpenSpec work tile on the right.
+3. **Pure activity band (optional)** — exists only while an observed activity is
+   live — `editing`, `reading`, `grepping`, `bash`, or `subagent` — with the turn
+   chronometer and token count riding on the right; subagent and bash child runs
+   keep their `└` span rows directly beneath. Between tools and at rest the band
+   retires entirely: Pi's own `Working…` indicator stays visible exactly as the
+   core renders it, and no phase words or `awaiting Human` filler are ever
+   generated.
+4. **Machine and status** — quota, CPU/RAM, context, compactions, and session
+   cost yield right-to-left into the width the status end leaves: notices when
+   present, otherwise the dim ladybug sentinel wearing the short session id.
+
+Rows appear only when they speak — a silent band and spanless state collapse
+their seam. Every slot is bounded, sanitized display vocabulary; no message
+content, thinking, reasoning, prompts, tool arguments, or child-agent output
+enters the widget. Terminal display-cell measurement and final truncation remain
+Unicode- and Nerd-Font-aware.
 
 The additive header protocol projects selection independently from live work:
 

package/packages/pi-stardeck/index.ts

@@ -3,32 +3,16 @@ import type {
   ExtensionContext,
   Theme,
 } from '@earendil-works/pi-coding-agent';
-import { truncateToWidth } from '@earendil-works/pi-tui';
 
 import {
-  buildAgentFooterWidgets,
-  buildPromptStatusSnapshot,
-  COMPACTION_WIDGET_ID,
-  CONTEXT_WIDGET_ID,
   countCompactions,
-  ENVIRONMENT_WIDGET_ID,
-  FANCY_FOOTER_READY_CHANNEL,
   FOOTER_TELEMETRY_CHANNEL,
-  FANCY_FOOTER_WIDGET_CHANNEL,
   formatFooterBranch,
   formatFooterPath,
   GALACTICA_HEADER_CHANNEL,
-  GIT_BRANCH_WIDGET_ID,
-  GIT_CONFLICT_WIDGET_ID,
-  GIT_SCOPE_SEPARATOR_WIDGET_ID,
-  GIT_MODIFIED_WIDGET_ID,
-  GIT_STAGED_WIDGET_ID,
-  GIT_UNTRACKED_WIDGET_ID,
   type FooterTelemetrySnapshot,
   type GitStatusSummary,
   type HeaderSnapshot,
-  LEGACY_GIT_WIDGET_ID,
-  LOCATION_WIDGET_ID,
   normalizeContextPercent,
   parseFooterTelemetry,
   parseGitBranch,
@@ -37,24 +21,12 @@ import {
   parsePiStatusSnapshot,
   PI_NATIVE_STATUS_CHANNEL,
   PI_STATUS_SNAPSHOT_CHANNEL,
-  PROMPT_STATUS_CHANNEL,
-  REASONING_WIDGET_ID,
-  SCOPE_SEPARATOR_WIDGET_ID,
-  runtimeHeaderWork,
   parseVimMode,
   VIM_MODE_CHANNEL,
   type PiStatusSnapshot,
   type VimMode,
 } from './src/gauge.ts';
 import {
-  buildRuntimeFooterWidgets,
-  formatRailChronometer,
-  RUNTIME_SCOPE_SEPARATOR_WIDGET_ID,
-  RUNTIME_STATUS_WIDGET_ID,
-} from './src/activity-age.ts';
-import {
-  buildCapabilityFooterWidget,
-  CAPABILITY_WIDGET_ID,
   LSP_STATUS_EVENT,
   MCP_STATUS_EVENT,
   parseLspCapability,
@@ -64,11 +36,8 @@ import {
 } from './src/capabilities.ts';
 import { shouldRefreshGitAfterTool } from './src/git-refresh.ts';
 import {
-  buildResourceFooterWidgets,
   buildResourceTelemetry,
   calculateCpuPercent,
-  CPU_WIDGET_ID,
-  MEMORY_WIDGET_ID,
   RESOURCE_REFRESH_MS,
   sampleProcessTreeResources,
   updateCpuSmoothing,
@@ -77,7 +46,6 @@ import {
   type ResourceTelemetry,
 } from './src/process-resources.ts';
 import { renderHeaderDeck } from './src/deck.ts';
-import { layoutLifecycleTitle, renderLifecycleTitleSections } from './src/title.ts';
 
 const WIDGET_KEY = 'galactica.work-identity';
 const PI_STATUS_SOURCE_CHANNEL = 'pi-stardeck:status-source/v1';
@@ -103,7 +71,11 @@ export interface ContextHeaderDeckSurface {
 }
 
 export interface ContextHeaderOptions {
-  surface?: 'legacy' | 'deck' | 'editor-deck';
+  /** The deck surface is the product: `'deck'` registers the above-editor
+   * widget, `'editor-deck'` renders into an embedder's component instead
+   * (vim border). The pre-deck legacy title line is retired
+   * (simplify-deck-defaults). */
+  surface?: 'deck' | 'editor-deck';
   deckSurface?: ContextHeaderDeckSurface;
 }
 
@@ -164,7 +136,6 @@ export default function galacticaContextHeader(
   pi: ExtensionAPI,
   options: ContextHeaderOptions = {},
 ): void {
-  const deckMode = options.surface === 'deck' || options.surface === 'editor-deck';
   const editorDeckSurface =
     options.surface === 'editor-deck' ? options.deckSurface : undefined;
   let clearWidget: (() => void) | undefined;
@@ -176,7 +147,6 @@ export default function galacticaContextHeader(
   let header: HeaderSnapshot | null = null;
   let agentBusy = false;
   let lastObservedActivityAt: number | null = null;
-  let lastActivityAgeSignature = '';
   let activityAgeTimer: ReturnType<typeof setInterval> | undefined;
   let sessionGeneration = 0;
   let sessionShortId: string | undefined;
@@ -196,64 +166,9 @@ export default function galacticaContextHeader(
   let piStatus: PiStatusSnapshot | undefined;
   let nativeStatusBridgeAvailable = true;
   let vimMode: VimMode = 'insert';
-  let lastCapabilitySignature = '';
 
   const currentHeader = () => header;
 
-  const publishPromptStatus = () => {
-    if (deckMode) return;
-    pi.events.emit(
-      PROMPT_STATUS_CHANNEL,
-      buildPromptStatusSnapshot(currentHeader(), branch, gitStatus),
-    );
-  };
-
-  const publishFooter = () => {
-    if (deckMode) return;
-    const ctx = activeCtx;
-    if (!ctx) return;
-    const usage = ctx.getContextUsage();
-    const contextPercent = normalizeContextPercent(
-      usage?.percent,
-      usage?.tokens,
-      usage?.contextWindow ?? ctx.model?.contextWindow,
-    );
-    const thinking = pi.getThinkingLevel();
-    for (const message of buildAgentFooterWidgets({
-      cwd: formatFooterPath(activeCwd || ctx.cwd, process.env.HOME),
-      devbox: process.env.DEVBOX_PROJECT_ROOT !== undefined,
-      branch: formatFooterBranch(branch),
-      git: gitStatus,
-      gitAvailable,
-      model: ctx.model?.name || ctx.model?.id || 'no model',
-      ...(thinking && thinking !== 'off' ? { thinking } : {}),
-      contextPercent,
-      compactionCount: countCompactions(ctx.sessionManager.getBranch()),
-    })) {
-      pi.events.emit(FANCY_FOOTER_WIDGET_CHANNEL, message);
-    }
-  };
-
-  const publishLatestResourceFooter = () => {
-    if (deckMode || !latestResourceTelemetry) return;
-    for (const message of buildResourceFooterWidgets(latestResourceTelemetry)) {
-      pi.events.emit(FANCY_FOOTER_WIDGET_CHANNEL, message);
-    }
-  };
-
-  const publishCapabilityFooter = (force = false) => {
-    if (deckMode) return;
-    const signature = [mcpCapability?.healthy ?? '', mcpCapability?.total ?? ''].join(
-      ':',
-    );
-    if (!force && signature === lastCapabilitySignature) return;
-    lastCapabilitySignature = signature;
-    pi.events.emit(
-      FANCY_FOOTER_WIDGET_CHANNEL,
-      buildCapabilityFooterWidget(mcpCapability),
-    );
-  };
-
   const refreshResources = async (): Promise<void> => {
     if (!activeCtx || resourceRefreshInFlight) return;
     resourceRefreshInFlight = true;
@@ -274,58 +189,28 @@ export default function galacticaContextHeader(
       latestResourceTelemetry = telemetry;
       if (signature === lastResourceSignature) return;
       lastResourceSignature = signature;
-      if (deckMode) requestRender?.();
-      else publishLatestResourceFooter();
+      requestRender?.();
     } finally {
       resourceRefreshInFlight = false;
     }
   };
 
-  const removeFooterWidgets = () => {
-    for (const id of [
-      LOCATION_WIDGET_ID,
-      LEGACY_GIT_WIDGET_ID,
-      GIT_BRANCH_WIDGET_ID,
-      GIT_SCOPE_SEPARATOR_WIDGET_ID,
-      GIT_STAGED_WIDGET_ID,
-      GIT_MODIFIED_WIDGET_ID,
-      GIT_UNTRACKED_WIDGET_ID,
-      GIT_CONFLICT_WIDGET_ID,
-      ENVIRONMENT_WIDGET_ID,
-      REASONING_WIDGET_ID,
-      CONTEXT_WIDGET_ID,
-      COMPACTION_WIDGET_ID,
-      CPU_WIDGET_ID,
-      MEMORY_WIDGET_ID,
-      RUNTIME_STATUS_WIDGET_ID,
-      RUNTIME_SCOPE_SEPARATOR_WIDGET_ID,
-      SCOPE_SEPARATOR_WIDGET_ID,
-      CAPABILITY_WIDGET_ID,
-    ]) {
-      pi.events.emit(FANCY_FOOTER_WIDGET_CHANNEL, {
-        protocol: 1,
-        type: 'remove',
-        id,
-      });
-    }
-  };
-
   const currentActivityAge = (): number | null =>
     agentBusy && lastObservedActivityAt !== null
       ? Math.max(0, Date.now() - lastObservedActivityAt)
       : null;
 
-  const publishRuntimeFooter = () => {
-    if (deckMode) return;
-    const activityAge = currentActivityAge();
-    const status = formatRailChronometer(activityAge);
-    const active = activityAge !== null;
-    const signature = `${active ? 'active' : 'idle'}:${status}`;
-    if (signature === lastActivityAgeSignature) return;
-    lastActivityAgeSignature = signature;
-    for (const message of buildRuntimeFooterWidgets(status, active)) {
-      pi.events.emit(FANCY_FOOTER_WIDGET_CHANNEL, message);
-    }
+  const startActivityTicker = (): void => {
+    // Duty-cycled: the 50 ms chronometer ticks only while an activity can
+    // render — idle sessions cost zero wakeups (simplify-deck-defaults).
+    if (activityAgeTimer) return;
+    activityAgeTimer = setInterval(refreshActivityAge, 50);
+  };
+
+  const stopActivityTicker = (): void => {
+    if (activityAgeTimer === undefined) return;
+    clearInterval(activityAgeTimer);
+    activityAgeTimer = undefined;
   };
 
   const publishCapabilityHealth = () => {
@@ -363,12 +248,6 @@ export default function galacticaContextHeader(
     });
   };
 
-  const stopReady = pi.events.on(FANCY_FOOTER_READY_CHANNEL, () => {
-    publishFooter();
-    publishLatestResourceFooter();
-    publishRuntimeFooter();
-    publishCapabilityFooter(true);
-  });
   const stopLspStatus = pi.events.on(LSP_STATUS_EVENT, (raw) => {
     lspCapability = parseLspCapability(raw);
     requestRender?.();
@@ -377,7 +256,6 @@ export default function galacticaContextHeader(
   const stopMcpStatus = pi.events.on(MCP_STATUS_EVENT, (raw) => {
     mcpCapability = parseMcpCapability(raw);
     requestRender?.();
-    publishCapabilityFooter();
     publishCapabilityHealth();
   });
   const stopFooterTelemetry = pi.events.on(FOOTER_TELEMETRY_CHANNEL, (raw) => {
@@ -401,33 +279,28 @@ export default function galacticaContextHeader(
   const stopHeader = pi.events.on(GALACTICA_HEADER_CHANNEL, (raw) => {
     header = parseHeaderSnapshot(raw);
     requestRender?.();
-    publishPromptStatus();
-    publishRuntimeFooter();
   });
 
   const markObservedActivity = () => {
     lastObservedActivityAt = Date.now();
-    lastActivityAgeSignature = '';
+    startActivityTicker();
     requestRender?.();
-    publishRuntimeFooter();
   };
 
   const clearObservedActivity = () => {
     lastObservedActivityAt = null;
-    lastActivityAgeSignature = '';
+    stopActivityTicker();
   };
 
   const refreshActivityAge = () => {
     if (currentActivityAge() === null) return;
-    if (deckMode) requestRender?.();
-    else publishRuntimeFooter();
+    requestRender?.();
   };
 
   pi.on('before_agent_start', (_event, ctx) => {
     if (ctx.mode !== 'tui') return;
     agentBusy = true;
     markObservedActivity();
-    publishPromptStatus();
   });
 
   pi.on('turn_start', markObservedActivity);
@@ -480,11 +353,7 @@ export default function galacticaContextHeader(
         gitStatus = gitAvailable
           ? parseGitStatus(String(statusResult?.stdout ?? ''))
           : { ...EMPTY_GIT };
-        if (deckMode) requestRender?.();
-        else {
-          publishPromptStatus();
-          publishFooter();
-        }
+        requestRender?.();
       } while (gitRefreshQueued && activeCwd);
     } finally {
       gitRefreshInFlight = false;
@@ -495,9 +364,8 @@ export default function galacticaContextHeader(
     clearWidget?.();
     clearFooter?.();
     clearFooter = undefined;
-    if (activityAgeTimer) clearInterval(activityAgeTimer);
+    stopActivityTicker();
     if (resourceTimer) clearInterval(resourceTimer);
-    activityAgeTimer = undefined;
     resourceTimer = undefined;
     ++sessionGeneration;
     activeCtx = ctx;
@@ -519,34 +387,23 @@ export default function galacticaContextHeader(
     cpuSmoothing = undefined;
     latestResourceTelemetry = undefined;
     lastResourceSignature = '';
-    lastCapabilitySignature = '';
     clearObservedActivity();
-    publishFooter();
-    publishPromptStatus();
-    publishRuntimeFooter();
-    publishCapabilityFooter();
     publishCapabilityHealth();
-    if (ctx.mode === 'tui') {
-      ctx.ui.setWorkingVisible(false);
-      activityAgeTimer = setInterval(refreshActivityAge, 50);
-    }
     if (!ctx.hasUI) return;
-    if (deckMode) {
-      clearFooter = installEmptyDeckFooter(
-        ctx,
-        (statuses) => {
-          pi.events.emit(PI_NATIVE_STATUS_CHANNEL, {
-            protocol: 1,
-            type: 'snapshot',
-            statuses,
-          });
-        },
-        (available) => {
-          nativeStatusBridgeAvailable = available;
-          publishCapabilityHealth();
-        },
-      );
-    }
+    clearFooter = installEmptyDeckFooter(
+      ctx,
+      (statuses) => {
+        pi.events.emit(PI_NATIVE_STATUS_CHANNEL, {
+          protocol: 1,
+          type: 'snapshot',
+          statuses,
+        });
+      },
+      (available) => {
+        nativeStatusBridgeAvailable = available;
+        publishCapabilityHealth();
+      },
+    );
     void refreshResources();
     resourceTimer = setInterval(() => void refreshResources(), RESOURCE_REFRESH_MS);
     activeCwd = ctx.cwd;
@@ -610,16 +467,7 @@ export default function galacticaContextHeader(
         requestRender = () => tui.requestRender();
         return {
           render(width: number): string[] {
-            if (deckMode) return renderDeck(width, theme);
-            const { work, idle } = runtimeHeaderWork(currentHeader()?.work, agentBusy);
-            const layout = layoutLifecycleTitle(work, width, agentBusy);
-            const line = renderLifecycleTitleSections(
-              layout,
-              work.lifecycle,
-              idle,
-              theme,
-            );
-            return [truncateToWidth(line, width, '…')];
+            return renderDeck(width, theme);
           },
           invalidate() {},
         };
@@ -634,21 +482,17 @@ export default function galacticaContextHeader(
   });
 
   pi.on('model_select', () => {
-    publishFooter();
     requestRender?.();
   });
 
   pi.on('thinking_level_select', () => {
-    if (deckMode) requestRender?.();
-    else publishFooter();
+    requestRender?.();
   });
   pi.on('message_end', (event) => {
     if (event.message.role === 'assistant') markObservedActivity();
-    publishFooter();
   });
   pi.on('session_compact', () => {
-    if (deckMode) requestRender?.();
-    else publishFooter();
+    requestRender?.();
   });
 
   pi.on('tool_execution_end', (event) => {
@@ -662,9 +506,6 @@ export default function galacticaContextHeader(
     agentBusy = false;
     clearObservedActivity();
     requestRender?.();
-    publishPromptStatus();
-    publishFooter();
-    publishRuntimeFooter();
     void refreshGit();
   });
 
@@ -675,9 +516,7 @@ export default function galacticaContextHeader(
     gitAvailable = false;
     agentBusy = false;
     clearObservedActivity();
-    if (activityAgeTimer) clearInterval(activityAgeTimer);
     if (resourceTimer) clearInterval(resourceTimer);
-    activityAgeTimer = undefined;
     resourceTimer = undefined;
     resourceRefreshInFlight = false;
     previousResourceSample = undefined;
@@ -689,9 +528,7 @@ export default function galacticaContextHeader(
     clearWidget = undefined;
     clearFooter?.();
     clearFooter = undefined;
-    removeFooterWidgets();
     stopHeader();
-    stopReady();
     stopLspStatus();
     stopMcpStatus();
     stopPiStatus();

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

@@ -5,7 +5,6 @@ import type { LspCapability, McpCapability } from './capabilities.ts';
 import type {
   FooterTelemetrySnapshot,
   GitStatusSummary,
-  HeaderActivity,
   HeaderSnapshot,
   PiStatusSnapshot,
   VimMode,
@@ -279,82 +278,34 @@ function spanTreeRows(state: HeaderDeckState, width: number, theme: Theme): stri
   });
 }
 
-const ACTIVITY_LABELS: Record<HeaderActivity['kind'], string> = {
-  understanding: 'interpreting',
-  inspection: 'inspecting',
-  synthesis: 'synthesizing',
-  planning: 'planning',
-  'skill-proposal': 'proposing skill',
-  mutation: 'updating',
-  implementation: 'implementing',
-  'change-review': 'reviewing change',
-  regression: 'testing',
-  verification: 'checking',
-  'result-review': 'reviewing result',
-  answering: 'answering',
-  recovery: 'recovering',
-  'awaiting-validation': 'validation',
-  'awaiting-input': 'input',
-  'operation-aborted': 'stopped',
-};
-
-function activityLabel(state: HeaderDeckState): string {
-  const pathActivity = state.header?.work?.activityPath?.at(-1);
-  const pathLabel = safeText(pathActivity?.compact || pathActivity?.label || '');
-  if (pathLabel) return pathLabel;
-  const activity = state.header?.work?.activity;
-  // `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`. */
+/** The band speaks only when an observed activity is live — one of the
+ * five title-state classes (editing/reading/grepping/bash/subagent).
+ * Fabricated phase words (`interpreting`, `planning`, …), the legacy
+ * activity projection, and the `awaiting Human` placeholder are gone
+ * (Human-directed simplify-deck-defaults): Pi's restored native working
+ * indicator owns mid-turn liveness, and the deck narrates only observed
+ * reality. */
 function titleActivityLabel(activity: { class: string; target: string }): string {
   return activity.class === 'subagent'
     ? `subagent: ${activity.target}`
     : `${activity.class} ${activity.target}`;
 }
 
-/** 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. */
+/** The band's current label: the live observed activity; empty when
+ * nothing is observed — the band then retires wholesale. */
 function observedActivityLabel(state: HeaderDeckState): string {
-  const title = state.header?.title ?? null;
-  if (title) {
-    return title.activity ? titleActivityLabel(title.activity) : liveKindLabel(state);
-  }
-  return activityLabel(state) || liveKindLabel(state);
+  const activity = state.header?.title?.activity ?? null;
+  return activity ? titleActivityLabel(activity) : '';
 }
 
 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;
+  return observedActivityLabel(state) !== '';
 }
 
 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');
+  // Line 3 left: the observed activity owns the slot; the turn cluster
+  // rides its right side and retires with it.
+  return color(theme, 'text', observedActivityLabel(state));
 }
 
 function turnCostTile(state: HeaderDeckState, theme: Theme): string {

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

@@ -191,40 +191,6 @@ export const HEADER_PRESENTATION = {
   locationColor: 'success',
 } as const;
 
-export const IDLE_HEADER_WORK: HeaderWork = {
-  lifecycle: 'listening',
-  titles: ['no focused task'],
-  color: 'accent',
-};
-
-export function displayedHeaderWork(work: HeaderWork | null | undefined): {
-  work: HeaderWork;
-  idle: boolean;
-} {
-  return work ? { work, idle: false } : { work: IDLE_HEADER_WORK, idle: true };
-}
-
-export function runtimeHeaderWork(
-  work: HeaderWork | null | undefined,
-  agentBusy: boolean,
-): { work: HeaderWork; idle: boolean } {
-  const displayed = displayedHeaderWork(work);
-  if (!agentBusy || !displayed.idle) return displayed;
-  return {
-    work: {
-      lifecycle: 'understanding',
-      titles: ['no focus'],
-      color: 'accent',
-      activity: { kind: 'understanding' },
-    },
-    idle: false,
-  };
-}
-
-export function lifecycleStatusLabel(work: HeaderWork | null | undefined): string {
-  return work ? `⟩ ${work.lifecycle}` : '⟩';
-}
-
 export type ContextGauge = {
   percent: number;
   percentText: string;

package/packages/status/README.md

@@ -69,14 +69,16 @@ ephemeral Session Work state. Display priority is OpenSpec
 Task → Session Work → safe direct fallback. OpenSpec focus clears active Session
 Work when acquired, preventing hidden or stale work from resurfacing later.
 
-Session Work is stored only as versioned custom entries on the active Pi session branch;
-it never creates a repository status file. It supports this lifecycle:
+Session Work is a legacy surface: its writer tool and `/work` command are retired, and
+only old sessions' versioned custom entries remain, restored fail-soft on the active
+Pi session branch (never a repository status file). OpenSpec focus is stored the same
+way and supports this lifecycle:
 
 ```text
-/work
-/work set Implement session metadata
-/work validate
-/work clear
+/openspec-focus set <change> <task>
+/openspec-focus validate
+/openspec-focus replace <change> <task>
+/openspec-focus clear
 ```
 
 When no OpenSpec portfolio is available, the matching row-one footer fallback is the
@@ -84,10 +86,14 @@ compact `▶ Focus` or `◇ Validate`; an entirely empty
 project uses ` no OpenSpec`. The detailed Session Work intent remains in the header
 instead of being duplicated in the footer. Active and validation states also replace the
 fallback terminal title. Reload, resume, and tree navigation restore the newest valid
-branch entry. The agent-callable `work_focus` tool exposes the same `status`, `set`,
-`validate`, and `clear` actions. The agent-callable `openspec_focus` tool likewise
-shares the command's `status`, safeguarded `set`, deliberate `replace`, and persistent
-`clear` transitions.
+branch entry. The agent-callable `openspec_focus` tool shares the command's `status`,
+safeguarded `set`, deliberate `replace`, validating `validate`, and persistent `clear`
+transitions; the `awaitingValidation` flag marks a focused task as awaiting Human
+validation and auto-clears on the next `set`, `replace`, or `clear`. The
+agent-callable `title` tool sets the sanitized session title shown when no OpenSpec
+focus owns the row. The retired `work_focus` and `stage` instruments are gone: stages
+derive from events and Taskflow phases, and legacy `session-work` entries from old
+sessions still restore and render, fail-soft.
 
 Global routing belongs to native Ramona policy rather than this status package. This
 package does not inject parent routing prompts, block parent tools, create Session Work

package/packages/status/index.ts

@@ -20,14 +20,15 @@ import {
   sameOpenSpecFocus,
   sameSessionSubject,
   sameSessionWorkFocus,
+  sameTaskFocus,
   SESSION_SUBJECT_ENTRY_TYPE,
   SESSION_WORK_FOCUS_ENTRY_TYPE,
   type SessionSubject,
   type SessionWorkFocus,
   sessionSubject,
-  sessionWorkFocus,
   taskflowRunFocus,
   taskFocus,
+  titleFromPrompt,
 } from './src/active-work.ts';
 import { collectDiagnostics } from './src/diagnostics.ts';
 import { loadConfig } from './src/config.ts';
@@ -77,7 +78,6 @@ import {
 } from './src/reducer.ts';
 import type {
   CockpitSnapshot,
-  StageValue,
   CommandRunner,
   DiagnosticsState,
   LoadedConfig,
@@ -90,7 +90,7 @@ import type {
 
 type SessionContext = ExtensionContext | ExtensionCommandContext;
 type Domain = RuntimeErrorRecord['domain'];
-type OpenSpecFocusAction = 'status' | 'set' | 'replace' | 'clear';
+type OpenSpecFocusAction = 'status' | 'set' | 'replace' | 'validate' | 'clear';
 
 type StatusHealthCondition = {
   id: string;
@@ -229,9 +229,13 @@ class GalacticaStatusRuntime {
     this.workFocus = workFocus;
     this.subject = subject;
     this.sessionName = sessionName;
-    this.liveLifecycle = workFocus.state === 'validation' ? 'waiting' : 'listening';
-    this.liveActivity =
-      workFocus.state === 'validation' ? { kind: 'awaiting-validation' } : undefined;
+    const restoredAwaitingValidation =
+      (focus.mode === 'task' && focus.awaitingValidation) ||
+      workFocus.state === 'validation';
+    this.liveLifecycle = restoredAwaitingValidation ? 'waiting' : 'listening';
+    this.liveActivity = restoredAwaitingValidation
+      ? { kind: 'awaiting-validation' }
+      : undefined;
     this.store = new AtomicStatusStore({
       cwd: ctx.cwd,
       projectRoot: ctx.cwd,
@@ -729,6 +733,11 @@ class GalacticaStatusRuntime {
     this.focus = focus;
     this.recordEvent({ type: 'focus/openspec', at: Date.now(), focus });
     this.store.clearOpenSpec();
+    if (focus.mode === 'task' && focus.awaitingValidation) {
+      this.setLiveProjection('waiting', { kind: 'awaiting-validation' });
+    } else if (focus.mode === 'none' && this.workFocus.state === 'clear') {
+      this.setLiveProjection('listening');
+    }
     this.publish();
     this.launch(this.refresh(false), 'openspec');
   }
@@ -754,20 +763,6 @@ class GalacticaStatusRuntime {
     this.publish();
   }
 
-  declareStage(stage: StageValue): boolean {
-    if (!this.currentTurnId) return false;
-    const changed = this.runtimeSpans.setStage(this.currentTurnId, stage, true);
-    this.recordEvent({
-      type: 'run/stage',
-      at: Date.now(),
-      id: this.currentTurnId,
-      stage,
-      declared: true,
-    });
-    this.setLiveProjection(stage);
-    return changed;
-  }
-
   setLiveProjection(lifecycle: HeaderLifecycle, activity?: HeaderActivity): void {
     if (
       this.liveLifecycle === lifecycle &&
@@ -1081,19 +1076,11 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
     runtime?.setFocus(focus);
   }
 
-  function workStatus(focus: SessionWorkFocus): string {
-    return focus.state === 'clear'
-      ? 'Work focus: clear'
-      : `Work focus: ${focus.state} · ${focus.intent}`;
-  }
-
   function subjectStatus(subject: SessionSubject): string {
-    return subject.state === 'clear'
-      ? 'Session subject: clear'
-      : `Session subject: ${subject.title}`;
+    return subject.state === 'clear' ? 'Title: clear' : `Title: ${subject.title}`;
   }
 
-  function applySubjectAction(
+  function applyTitleAction(
     action: 'status' | 'set',
     title?: string,
   ): { ok: boolean; message: string; subject: SessionSubject } {
@@ -1107,7 +1094,7 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
     if (!next || next.state !== 'set') {
       return {
         ok: false,
-        message: 'Session subject requires a non-empty title',
+        message: 'Title requires a non-empty title',
         subject: current,
       };
     }
@@ -1115,79 +1102,20 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
     return { ok: true, message: subjectStatus(next), subject: next };
   }
 
-  function applyWorkAction(
-    action: 'status' | 'set' | 'validate' | 'clear',
-    intent?: string,
-  ): { ok: boolean; message: string; focus: SessionWorkFocus } {
-    const current = runtime?.currentWorkFocus() ?? NO_SESSION_WORK_FOCUS;
-    const openSpec = runtime?.currentFocus() ?? NO_OPEN_SPEC_FOCUS;
-
-    if (action === 'status') {
-      return { ok: true, message: workStatus(current), focus: current };
-    }
-    if (action === 'clear') {
-      if (current.state !== 'clear') persistAndApplyWorkFocus(NO_SESSION_WORK_FOCUS);
-      return {
-        ok: true,
-        message: 'Work focus cleared',
-        focus: NO_SESSION_WORK_FOCUS,
-      };
-    }
-    if (openSpec.mode === 'task') {
-      return {
-        ok: false,
-        message:
-          `OpenSpec focus is ${openSpec.change} › ${openSpec.taskId}; ` +
-          'clear it before setting ephemeral work',
-        focus: current,
-      };
-    }
-    if (action === 'validate') {
-      if (current.state === 'clear') {
-        return {
-          ok: false,
-          message: 'No active Work focus to validate',
-          focus: current,
-        };
-      }
-      const validation = sessionWorkFocus('validation', current.intent);
-      if (!validation) {
-        return { ok: false, message: 'Invalid Work focus', focus: current };
-      }
-      if (!sameSessionWorkFocus(current, validation)) {
-        persistAndApplyWorkFocus(validation);
-      }
-      return { ok: true, message: workStatus(validation), focus: validation };
-    }
-
-    const active = sessionWorkFocus('active', intent);
-    if (!active) {
-      return {
-        ok: false,
-        message: 'Work focus requires a non-empty intent',
-        focus: current,
-      };
-    }
-    if (!sameSessionWorkFocus(current, active)) persistAndApplyWorkFocus(active);
-    return { ok: true, message: workStatus(active), focus: active };
-  }
-
   function applyOpenSpecFocusAction(
     action: OpenSpecFocusAction,
     change?: string,
     taskId?: string,
   ): { ok: boolean; message: string; focus: OpenSpecFocus } {
     const current = runtime?.currentFocus() ?? NO_OPEN_SPEC_FOCUS;
+    const statusMessage = (focus: OpenSpecFocus): string =>
+      focus.mode === 'task'
+        ? `OpenSpec focus: ${focus.change} › ${focus.taskId}` +
+          (focus.awaitingValidation ? ' — awaiting Human validation' : '')
+        : 'OpenSpec focus: none';
 
     if (action === 'status') {
-      return {
-        ok: true,
-        message:
-          current.mode === 'task'
-            ? `OpenSpec focus: ${current.change} › ${current.taskId}`
-            : 'OpenSpec focus: none',
-        focus: current,
-      };
+      return { ok: true, message: statusMessage(current), focus: current };
     }
     if (action === 'clear') {
       persistAndApplyFocus(NO_OPEN_SPEC_FOCUS);
@@ -1197,6 +1125,18 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
         focus: NO_OPEN_SPEC_FOCUS,
       };
     }
+    if (action === 'validate') {
+      if (current.mode !== 'task') {
+        return {
+          ok: false,
+          message: 'OpenSpec focus has no task to validate',
+          focus: current,
+        };
+      }
+      const validated = { ...current, awaitingValidation: true };
+      if (!sameOpenSpecFocus(current, validated)) persistAndApplyFocus(validated);
+      return { ok: true, message: statusMessage(validated), focus: validated };
+    }
 
     const requested = taskFocus(change, taskId);
     if (!requested) {
@@ -1209,7 +1149,7 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
     if (
       action === 'set' &&
       current.mode === 'task' &&
-      !sameOpenSpecFocus(current, requested)
+      !sameTaskFocus(current, requested)
     ) {
       return {
         ok: false,
@@ -1222,7 +1162,7 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
     if (!sameOpenSpecFocus(current, requested)) persistAndApplyFocus(requested);
     return {
       ok: true,
-      message: `OpenSpec focus: ${requested.change} › ${requested.taskId}`,
+      message: statusMessage(requested),
       focus: requested,
     };
   }
@@ -1258,8 +1198,23 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
     runtime?.settle();
   });
 
-  pi.on('before_agent_start', () => {
+  pi.on('before_agent_start', (event) => {
     runtime?.beginTurn();
+    // Auto-title: the first real user prompt names the session while the
+    // subject is still clear — the agent's `title` call stays optional
+    // polish (every agent skipped the first-turn rule; verified
+    // systematically in simplify-session-focus-surface). Human- or
+    // agent-set titles and restored sessions are never overridden.
+    // The event fields are narrowed structurally: the registry-pinned
+    // @earendil-works/pi-coding-agent types predate messageType/prompt,
+    // while the runtime event carries both (extensions.md, before_agent_start).
+    const promptRun = event as { messageType?: unknown; prompt?: unknown };
+    if (promptRun.messageType !== 'user' || typeof promptRun.prompt !== 'string') {
+      return;
+    }
+    if ((runtime?.currentSubject() ?? NO_SESSION_SUBJECT).state !== 'clear') return;
+    const next = titleFromPrompt(promptRun.prompt);
+    if (next && next.state === 'set') persistAndApplySubject(next);
   });
 
   pi.on('tool_execution_start', (event) => {
@@ -1360,80 +1315,11 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
   });
 
   pi.registerTool({
-    name: 'work_focus',
-    label: 'Work Focus',
-    description:
-      'Show, set, mark for validation, or clear explicit ephemeral work metadata for this Pi session',
-    promptSnippet: 'Manage explicit ephemeral Session Work focus metadata',
-    parameters: Type.Object({
-      action: StringEnum(['status', 'set', 'validate', 'clear'] as const),
-      intent: Type.Optional(
-        Type.String({
-          description: 'Required only for set: the concise current intent',
-        }),
-      ),
-    }),
-    async execute(_toolCallId, params) {
-      const result = applyWorkAction(params.action, params.intent);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: result.ok ? result.message : `Error: ${result.message}`,
-          },
-        ],
-        details: {
-          ok: result.ok,
-          focus: result.focus,
-        },
-      };
-    },
-  });
-
-  pi.registerTool({
-    name: 'stage',
-    label: 'Stage',
-    description:
-      'Declare the current stage of the Ramona loop (status truth; one call per transition)',
-    promptSnippet: 'Declare the current loop stage for status truth',
-    parameters: Type.Object({
-      stage: StringEnum([
-        'understanding',
-        'working',
-        'assuring',
-        'learning',
-        'answering',
-        'waiting',
-        'blocked',
-        'listening',
-        'aborted',
-      ] as const),
-    }),
-    async execute(_toolCallId, params) {
-      const declared = runtime?.declareStage(params.stage) ?? false;
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: declared
-              ? `Stage declared: ${params.stage}`
-              : `Stage recorded: ${params.stage} (no active turn span)`,
-          },
-        ],
-        details: { kind: 'stage-declaration', stage: params.stage },
-      };
-    },
-  });
-
-  pi.registerTool({
-    name: 'subject',
-    label: 'Session Subject',
+    name: 'title',
+    label: 'Session Title',
     description:
-      'Show or set the sanitized session subject that keeps the focus row populated beneath OpenSpec and Session Work',
-    promptSnippet: 'Manage the automatic session subject title',
-    promptGuidelines: [
-      'Author a short sanitized subject (at most 120 characters, never raw prompt text) at the first conversational turn; revise it only when the topic clearly shifts. Never require Human action for it.',
-    ],
+      'Show or set the sanitized session title that keeps the focus row populated beneath OpenSpec and Session Work. The session titles itself from the first real prompt; call this only to name or rename deliberately (at most 120 characters, never raw prompt text), revising when the topic clearly shifts; never require Human action for it',
+    promptSnippet: 'Manage the automatic session title',
     parameters: Type.Object({
       action: StringEnum(['status', 'set'] as const),
       title: Type.Optional(
@@ -1443,7 +1329,7 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
       ),
     }),
     async execute(_toolCallId, params) {
-      const result = applySubjectAction(params.action, params.title);
+      const result = applyTitleAction(params.action, params.title);
       return {
         content: [
           {
@@ -1463,14 +1349,11 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
     name: 'openspec_focus',
     label: 'OpenSpec Focus',
     description:
-      'Show, safely set, deliberately replace, or clear branch-local OpenSpec Task focus',
+      'Show, safely set, deliberately replace, validate, or clear branch-local OpenSpec Task focus. Use only for explicit Human direction or an exact declared OpenSpec Task handoff; never infer material Plan selection or Human validation',
     promptSnippet:
       'Manage exact branch-local OpenSpec Task focus with replacement safeguards',
-    promptGuidelines: [
-      'Use openspec_focus only for explicit Human direction or an exact declared OpenSpec Task handoff; never infer material Plan selection or Human validation.',
-    ],
     parameters: Type.Object({
-      action: StringEnum(['status', 'set', 'replace', 'clear'] as const),
+      action: StringEnum(['status', 'set', 'replace', 'validate', 'clear'] as const),
       change: Type.Optional(
         Type.String({
           description: 'Required for set and replace: the exact OpenSpec change ID',
@@ -1503,32 +1386,6 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
     },
   });
 
-  pi.registerCommand('work', {
-    description: "Show, set, validate, or clear this session's ephemeral Work focus",
-    handler: async (args, ctx) => {
-      const trimmed = args.trim();
-      if (!trimmed || trimmed.toLowerCase() === 'status') {
-        ctx.ui.notify(applyWorkAction('status').message, 'info');
-        return;
-      }
-
-      const [rawAction, ...rest] = trimmed.split(/\s+/u);
-      const action = rawAction?.toLowerCase();
-      if (action === 'set') {
-        const result = applyWorkAction('set', rest.join(' '));
-        ctx.ui.notify(result.message, result.ok ? 'info' : 'warning');
-        return;
-      }
-      if ((action === 'validate' || action === 'clear') && rest.length === 0) {
-        const result = applyWorkAction(action);
-        ctx.ui.notify(result.message, result.ok ? 'info' : 'warning');
-        return;
-      }
-
-      ctx.ui.notify('Usage: /work [status|set <intent>|validate|clear]', 'warning');
-    },
-  });
-
   pi.registerCommand('openspec-focus', {
     description: "Show, clear, or explicitly set this session's OpenSpec task focus",
     handler: async (args, ctx) => {
@@ -1544,6 +1401,12 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
         return;
       }
 
+      if (parts.length === 1 && parts[0]?.toLowerCase() === 'validate') {
+        const result = applyOpenSpecFocusAction('validate');
+        ctx.ui.notify(result.message, result.ok ? 'info' : 'warning');
+        return;
+      }
+
       const rawAction = parts[0]?.toLowerCase();
       const action: 'set' | 'replace' = ['set', 'replace'].includes(rawAction ?? '')
         ? (rawAction as 'set' | 'replace')

package/packages/status/src/active-work.ts

@@ -8,6 +8,7 @@ export type TaskOpenSpecFocus = {
   mode: 'task';
   change: string;
   taskId: string;
+  awaitingValidation: boolean;
 };
 
 export type OpenSpecFocus = { mode: 'none' } | TaskOpenSpecFocus;
@@ -52,18 +53,24 @@ function explicitId(value: unknown): string | undefined {
 export function taskFocus(
   change: unknown,
   taskId: unknown,
+  awaitingValidation?: unknown,
 ): TaskOpenSpecFocus | undefined {
   const normalizedChange = explicitId(change);
   const normalizedTaskId = explicitId(taskId);
   if (!normalizedChange || !normalizedTaskId) return undefined;
-  return { mode: 'task', change: normalizedChange, taskId: normalizedTaskId };
+  return {
+    mode: 'task',
+    change: normalizedChange,
+    taskId: normalizedTaskId,
+    awaitingValidation: awaitingValidation === true,
+  };
 }
 
 export function parseOpenSpecFocus(value: unknown): OpenSpecFocus | undefined {
   if (!isRecord(value)) return undefined;
   if (value.mode === 'none') return NO_OPEN_SPEC_FOCUS;
   if (value.mode !== 'task') return undefined;
-  return taskFocus(value.change, value.taskId);
+  return taskFocus(value.change, value.taskId, value.awaitingValidation);
 }
 
 export function sessionWorkFocus(
@@ -104,6 +111,18 @@ export function parseSessionSubject(value: unknown): SessionSubject | undefined
   return sessionSubject(value.state, value.title);
 }
 
+/** Derive a session title from a raw user prompt — the extension-side
+ * fallback that makes the agent's first-turn `title` call optional
+ * polish instead of a load-bearing bet (every agent skipped it). The
+ * same sanitizer bounds it; slash commands are commands, not subjects:
+ * they never title. */
+export function titleFromPrompt(prompt: unknown): SessionSubject | undefined {
+  if (typeof prompt !== 'string') return undefined;
+  const normalized = normalizeTitlePart(prompt);
+  if (!normalized || normalized.startsWith('/')) return undefined;
+  return sessionSubject('set', normalized);
+}
+
 export function restoreOpenSpecFocus(entries: readonly unknown[]): OpenSpecFocus {
   for (let index = entries.length - 1; index >= 0; index -= 1) {
     const entry = entries[index];
@@ -162,7 +181,9 @@ export function taskflowRunFocus(input: unknown): TaskOpenSpecFocus | undefined
     : undefined;
 }
 
-export function sameOpenSpecFocus(left: OpenSpecFocus, right: OpenSpecFocus): boolean {
+/** Task identity (mode · change · taskId) — the replace-safeguard's
+ *  question; the validation flag is state, not identity. */
+export function sameTaskFocus(left: OpenSpecFocus, right: OpenSpecFocus): boolean {
   if (left.mode !== right.mode) return false;
   return (
     left.mode === 'none' ||
@@ -172,6 +193,17 @@ export function sameOpenSpecFocus(left: OpenSpecFocus, right: OpenSpecFocus): bo
   );
 }
 
+export function sameOpenSpecFocus(left: OpenSpecFocus, right: OpenSpecFocus): boolean {
+  if (left.mode !== right.mode) return false;
+  return (
+    left.mode === 'none' ||
+    (right.mode === 'task' &&
+      left.change === right.change &&
+      left.taskId === right.taskId &&
+      left.awaitingValidation === right.awaitingValidation)
+  );
+}
+
 export function sameSessionWorkFocus(
   left: SessionWorkFocus,
   right: SessionWorkFocus,

package/packages/status/src/openspec.ts

@@ -408,14 +408,20 @@ export async function collectOpenSpec(options: {
     // Progress from `list` remains valid even if apply instructions are unavailable.
   }
 
-  const completedTasks = Math.max(
-    0,
-    Math.trunc(instructionProgress?.complete ?? change.completedTasks),
-  );
-  const totalTasks = Math.max(
-    0,
-    Math.trunc(instructionProgress?.total ?? change.totalTasks),
-  );
+  // File truth first: when the artifact (or apply) task list parsed, its
+  // done flags are what the Human actually ticks — the CLI's done-counting
+  // does not track custom-schema execution artifacts and pinned the Work
+  // tile at 0/N (simplify-deck-defaults). CLI progress and list counts
+  // remain fallbacks; the blocked-apply zero-guard stays for the
+  // no-tasks case.
+  const completedTasks =
+    tasks.length > 0
+      ? tasks.filter((task) => task.done).length
+      : Math.max(0, Math.trunc(instructionProgress?.complete ?? change.completedTasks));
+  const totalTasks =
+    tasks.length > 0
+      ? tasks.length
+      : Math.max(0, Math.trunc(instructionProgress?.total ?? change.totalTasks));
   const complete =
     change.status === 'complete' || (totalTasks > 0 && completedTasks >= totalTasks);