@aemonge-dev/pi-stardeck 0.9.1 → 0.9.2

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.2",
   "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,
@@ -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(
@@ -167,8 +168,6 @@ function titleBandLines(state: HeaderDeckState, width: number, theme: Theme): st
   // 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)}`;
   const title = state.header?.title ?? null;
   if (title) {
@@ -305,6 +304,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 +316,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 +329,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 {
@@ -478,7 +509,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 +543,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 +571,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 +591,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 +803,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,
@@ -832,40 +821,34 @@ export function renderHeaderDeck(
   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)
-      : '';
+  // right end. Narrow frames: the Work slot yields before the clock anchor
+  // 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 +862,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 +881,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));

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

@@ -62,6 +62,7 @@ export const HEADER_ACTIVITY_KINDS = [
   'regression',
   'verification',
   'result-review',
+  'answering',
   'recovery',
   'awaiting-validation',
   'awaiting-input',
@@ -97,27 +98,15 @@ export type HeaderWork = {
 
 export const HEADER_SELECTION_SOURCES = [
   'openspec',
-  'goal',
   'session-work',
   'subject',
   'legacy',
 ] as const;
 
-export type HeaderSelectionGoalDetail = {
-  status: string;
-  elapsedSeconds?: number;
-  tasksDone?: number;
-  tasksActive?: number;
-  tasksTotal?: number;
-  tokensUsed?: number;
-  tokenBudget?: number;
-};
-
 export type HeaderSelection = {
   source: (typeof HEADER_SELECTION_SOURCES)[number];
   titles: string[];
   color: HeaderColor;
-  goal?: HeaderSelectionGoalDetail;
 };
 
 export const HEADER_SUGGESTIONS = [
@@ -131,7 +120,6 @@ export const HEADER_SUGGESTIONS = [
 export type HeaderSuggestion = (typeof HEADER_SUGGESTIONS)[number];
 
 export type HeaderSnapshot = {
-  openGoals?: number;
   activity?: HeaderActivity | null;
   selection?: HeaderSelection | null;
   suggestion?: HeaderSuggestion | null;
@@ -954,46 +942,10 @@ function parseHeaderSelection(value: unknown): HeaderSelection | null {
   });
   if (titles.length !== candidate.titles.length) return null;
 
-  let goal: HeaderSelectionGoalDetail | undefined;
-  if (
-    candidate.source === 'goal' &&
-    candidate.goal &&
-    typeof candidate.goal === 'object' &&
-    !Array.isArray(candidate.goal)
-  ) {
-    const raw = candidate.goal as Record<string, unknown>;
-    const boundedNumber = (input: unknown): number | undefined =>
-      typeof input === 'number' &&
-      Number.isFinite(input) &&
-      input >= 0 &&
-      input <= 9_999_999_999
-        ? input
-        : undefined;
-    if (typeof raw.status === 'string' && raw.status.length <= 24) {
-      const detail: HeaderSelectionGoalDetail = { status: raw.status };
-      const elapsed = boundedNumber(raw.elapsedSeconds);
-      if (elapsed !== undefined) detail.elapsedSeconds = elapsed;
-      for (const [key, value] of [
-        ['tasksDone', raw.tasksDone],
-        ['tasksActive', raw.tasksActive],
-        ['tasksTotal', raw.tasksTotal],
-        ['tokenBudget', raw.tokenBudget],
-      ] as const) {
-        const parsed = boundedNumber(value);
-        if (parsed !== undefined && parsed <= 9_999) {
-          detail[key] = parsed;
-        }
-      }
-      const tokensUsed = boundedNumber(raw.tokensUsed);
-      if (tokensUsed !== undefined) detail.tokensUsed = tokensUsed;
-      goal = detail;
-    }
-  }
   return {
     source: candidate.source as HeaderSelection['source'],
     titles,
     color: candidate.color,
-    ...(goal !== undefined ? { goal } : {}),
   };
 }
 
@@ -1066,14 +1018,6 @@ export function parseHeaderSnapshot(raw: unknown): HeaderSnapshot | null {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
   const message = raw as Record<string, unknown>;
   if (message.protocol !== 1) return null;
-  const openGoals =
-    typeof message.openGoals === 'number' &&
-    Number.isInteger(message.openGoals) &&
-    message.openGoals >= 0 &&
-    message.openGoals <= 99
-      ? message.openGoals
-      : 0;
-
   const standaloneActivity = parseHeaderActivity(message.activity) ?? null;
   let work: HeaderWork | null = null;
   if (
@@ -1190,7 +1134,6 @@ export function parseHeaderSnapshot(raw: unknown): HeaderSnapshot | null {
   const hasExplicitTurn = Object.prototype.hasOwnProperty.call(message, 'turn');
 
   return {
-    openGoals,
     activity: standaloneActivity,
     selection: hasExplicitSelection
       ? parseHeaderSelection(message.selection)

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

@@ -45,6 +45,7 @@ const ACTIVITY_LABELS: Record<HeaderActivity['kind'], ActivityLabels> = {
     full: 'reviewing check results',
     compact: 'reviewing results',
   },
+  answering: { full: 'answering the Human', compact: 'answering' },
   recovery: { full: 'repairing bounded failure', compact: 'repair' },
   'awaiting-validation': {
     full: 'Human validation',

package/packages/pi-vim-top-border/prompt-rail.ts

@@ -6,7 +6,6 @@ const TRACKED_WIDGET_IDS = new Set([
   'galactica.openspec-progress',
   'galactica.openspec',
   'galactica.work',
-  'galactica.goal',
   'galactica.project-capabilities',
   'galactica.session-memory',
   'galactica.session-cpu',
@@ -214,7 +213,6 @@ function workWidget(widgets: ReadonlyMap<string, RailWidget>): RailWidget | unde
   for (const id of [
     'galactica.openspec-progress',
     'galactica.openspec',
-    'galactica.goal',
     'galactica.work',
   ]) {
     const widget = widgets.get(id);

package/packages/status/README.md

@@ -7,7 +7,7 @@ editor widget itself.
 ## Architecture
 
 ```text
-Pi tool lifecycle + session/Goal metadata + OpenSpec CLI + aggregate JSON state
+Pi tool lifecycle + session metadata + OpenSpec CLI + aggregate JSON state
                                   │
                                   ▼
                         normalized immutable state
@@ -64,9 +64,9 @@ active OpenSpec footer by themselves.
 
 ## Session focus and terminal title
 
-A Pi session has zero or one explicit OpenSpec task focus, optional read-only Pi Goal
-state, and an independent ephemeral Session Work state. Display priority is OpenSpec
-Task → Goal → Session Work → safe direct fallback. OpenSpec focus clears active Session
+A Pi session has zero or one explicit OpenSpec task focus and an independent
+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;
@@ -80,7 +80,7 @@ it never creates a repository status file. It supports this lifecycle:
 ```
 
 When no OpenSpec portfolio is available, the matching row-one footer fallback is the
-compact `▶ Focus` or `◇ Validate`; an active Goal uses `󰊕 Goal`, and an entirely empty
+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
@@ -97,25 +97,14 @@ publication.
 
 The header projection uses the rich lifecycle `understanding`, `working`, `waiting`,
 `assuring`, `learning`, `answering`, `blocked`, `listening`, or `aborted`. It separately
-publishes one explicit selection with OpenSpec Task → Goal → Session Work precedence,
+publishes one explicit selection with OpenSpec Task → Session Work precedence,
 or `null` when no work is selected. A controlled suggestion enum communicates only
 Human-facing reporting cues such as `requesting-validation`,
 `awaiting-continuation`, or `requesting-redirection`; it never carries generated
 prose. Direct tool
-categories, read-only Pi Goal state, and known Taskflow phases move the lifecycle
-without exposing arguments or raw node prose. Goal state is restored from Pi's canonical
-`goal-state` session entries without enabling Goal RPC. An active Goal renders bounded
-automatic-turn progress from `pi-goal.json`; paused, blocked, limited, external-wait,
-and complete states render controlled labels. Complete projects as
-`awaiting Human validation` rather than Human acceptance. Raw Goal objectives, wait
-reasons, completion summaries, paths, and Goal IDs never enter the visible header. While
-a Goal exists, a session-scoped 500 ms in-memory branch monitor catches idle
-`/goal pause`, clear, and menu transitions; it performs no filesystem, process,
-provider, or network work and stops when Goal state is cleared. A stopped Goal remains
-visible while Pi is idle so its terminal reason is honest, but the next ordinary
-non-Goal turn automatically returns the title to current Ramona, OpenSpec, Session Work,
-or direct activity. This display transition never mutates Goal or focus state; a later
-Goal resume automatically reclaims the title. During a Taskflow tool run, structured
+categories and known Taskflow phases move the lifecycle
+without exposing arguments or raw node prose. Complete projects as
+`awaiting Human validation` rather than Human acceptance. During a Taskflow tool run, structured
 streaming state temporarily replaces the normal focus with the running top-level phase
 ID, such as `working ⟩ work-fragment`; promoted child IDs and generated output remain
 hidden. Visible assistant text moves it to `answering`; settling with selected work
@@ -128,7 +117,7 @@ operation transitions to bounded recovery. This prevents a completed command fro
 looking permanently active while Pi prepares its next action. A Ctrl-C assistant stop
 reason moves it to `aborted` and remains visible until the next turn resets it to
 `understanding`. Legacy work titles still preserve the existing explicit fallback states for compatible
-consumers. The additive selection field contains only an exact OpenSpec Task, Goal, or
+consumers. The additive selection field contains only an exact OpenSpec Task or
 Session Work; otherwise it is `null`, so the deck renders a stable dim `󰓾 —`. `Direct
 response` is never presented as selection and Human prompt text is never copied into it.
 
@@ -181,7 +170,7 @@ Aggregate portfolio progress is independent of focus and remains visible as:
 It occupies the right side of footer row one, opposite the full PWD and Git state. It
 updates from `openspec list --json`; task-list `` replaces `Plans` and notebook ``
 replaces `Tasks`. If no OpenSpec portfolio exists, the slot prefers compact active scope
-(`󰊕 Goal`, then `▶ Focus` or `◇ Validate`) before falling back to dim ` no OpenSpec`.
+(`▶ Focus` or `◇ Validate`) before falling back to dim ` no OpenSpec`.
 Focused-change metadata remains separate and does not replace these totals. The
 no-argument form reports the current focus without changing it. The matching tool calls
 are:
@@ -220,7 +209,7 @@ legacy focused-status producer also gives quiet state feedback:
 
 - actionable task work exists: dim `○ OpenSpec · no focus`
 - no actionable task work exists: dim `○ OpenSpec · clear`
-- no `openspec/` project exists: row one shows Goal or Focus when active, otherwise dim
+- no `openspec/` project exists: row one shows Focus when active, otherwise dim
   ` no OpenSpec`
 - OpenSpec status cannot be read: the last aggregate remains while focused status
   reports unavailable
@@ -282,7 +271,7 @@ A configured `orchestration.stateFile` takes precedence. Useful fields include `
 or node vocabulary is classified into an allowlisted title activity—understanding,
 inspection, synthesis, planning, skill proposal, mutation, implementation, change
 review, regression, verification, result review, recovery, waiting reason, or abort—and
-attached to the current OpenSpec, Goal, Session Work, or explicit empty focus. Task
+attached to the current OpenSpec, Session Work, or explicit empty focus. Task
 text, paths, generated prose, and promoted child IDs never enter the lifecycle title;
 unknown vocabulary produces no activity. The bounded top-level phase ID is the only
 exact Taskflow identifier shown. Named Taskflow runs invoked by the assistant through