@aemonge-dev/pi-stardeck 0.13.0 → 0.15.0

package/packages/status/src/openspec.ts

@@ -270,7 +270,7 @@ export function parseApplyInstructions(value: unknown): ApplyInstructionsResult
         complete: finiteNumber(value.progress.complete),
       }
     : undefined;
-  // A blocked apply (mid-ladder, artifacts missing) reports zero progress;
+  // A blocked apply (part-way through, artifacts missing) reports zero progress;
   // those zeros must never shadow the honest `openspec list` counts.
   const progress =
     state !== 'blocked' && (reportedProgress?.total ?? 0) > 0
@@ -517,7 +517,6 @@ export async function collectOpenSpec(options: {
 
   let tasks: OpenSpecTask[] = [];
   let tasksPath: string | undefined;
-  let instructionProgress: ApplyInstructionsResult['progress'];
   let hierarchy: OpenSpecHierarchyProgress | undefined;
   try {
     const instructions = parseApplyInstructions(
@@ -530,7 +529,6 @@ export async function collectOpenSpec(options: {
     );
     tasks = instructions.tasks;
     tasksPath = instructions.tasksPath;
-    instructionProgress = instructions.progress;
 
     if (tasksPath) {
       try {
@@ -552,28 +550,38 @@ export async function collectOpenSpec(options: {
   // 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.
+  // File-truth precedence: checkbox tasks first, then done/total artifacts
+  // (file presence via `openspec status`) — CLI task opinion cannot count
+  // custom schemas and pins 0/N (truthful-rendered-state). With neither
+  // readable, counts stay absent — absence never becomes zero.
+  const artifactCounts = artifacts
+    ? {
+        done: artifacts.filter((artifact) => artifact.done).length,
+        total: artifacts.length,
+      }
+    : undefined;
   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));
+    tasks.length > 0 ? tasks.filter((task) => task.done).length : artifactCounts?.done;
+  const totalTasks = tasks.length > 0 ? tasks.length : artifactCounts?.total;
   const complete =
-    change.status === 'complete' || (totalTasks > 0 && completedTasks >= totalTasks);
+    change.status === 'complete' ||
+    (totalTasks !== undefined && totalTasks > 0 && (completedTasks ?? 0) >= totalTasks);
 
   return {
     projectRoot,
     changeId: change.name,
     title,
     phase: complete ? 'complete' : change.status,
-    completedTasks,
-    totalTasks,
-    progressPercent:
-      totalTasks > 0
-        ? Math.max(0, Math.min(100, Math.round((completedTasks / totalTasks) * 100)))
-        : 0,
+    ...(completedTasks !== undefined ? { completedTasks } : {}),
+    ...(totalTasks !== undefined ? { totalTasks } : {}),
+    ...(totalTasks !== undefined && totalTasks > 0
+      ? {
+          progressPercent: Math.max(
+            0,
+            Math.min(100, Math.round(((completedTasks ?? 0) / totalTasks) * 100)),
+          ),
+        }
+      : {}),
     pendingTasks: tasks.filter((task) => !task.done),
     allTasks: tasks,
     ...(tasksPath ? { tasksPath } : {}),

package/packages/status/src/publisher.ts

@@ -23,7 +23,6 @@ export const GALACTICA_HEADER_CHANNEL = 'galactica-status:header';
 
 const OPEN_SPEC_WIDGET_ID = 'galactica.openspec';
 const OPEN_SPEC_SCOPE_SEPARATOR_WIDGET_ID = 'galactica.openspec-scope-separator';
-const OPEN_SPEC_PROGRESS_WIDGET_ID = 'galactica.openspec-progress';
 const DIAGNOSTICS_WIDGET_ID = 'galactica.diagnostics';
 const ORCHESTRATION_WIDGET_ID = 'galactica.orchestration';
 
@@ -48,17 +47,6 @@ function compactChangeTitle(title: string, maximum: number): string {
   return shorten(normalizeChangeTitle(title), maximum);
 }
 
-function focusedTaskText(
-  task: { id: string; title: string },
-  compact: boolean,
-): string {
-  const title = normalizeInline(task.title);
-  const step = title.match(/^(?:Step|Task)\s+(\d+(?:\.\d+)*)(?:[.:])?\s+(.+)$/iu);
-  const id = step?.[1] ?? task.id;
-  const body = step?.[2] ?? title;
-  return `${id} ${compact ? shorten(body, 14) : body}`;
-}
-
 function formatDuration(ms: number | undefined): string | undefined {
   if (ms === undefined || ms < 0) return undefined;
   if (ms < 60_000) return `${Math.max(1, Math.round(ms / 1_000))}s`;
@@ -94,12 +82,14 @@ export function formatOpenSpecOverview(overview: OpenSpecOverview): string {
   );
 }
 
-export function formatOpenSpec(
-  state: OpenSpecState,
-  focusedTaskId: string | null,
-  compact = false,
-): string {
-  const progress = `${state.completedTasks}/${state.totalTasks}`;
+export function formatOpenSpec(state: OpenSpecState, compact = false): string {
+  // File-truth counts only — absent counts render no progress prefix at
+  // all (absence never becomes zero, truthful-rendered-state).
+  const progress =
+    state.totalTasks !== undefined
+      ? `${state.completedTasks ?? 0}/${state.totalTasks}`
+      : '';
+  const lead = progress ? `${progress}  ` : '';
   const title = compact
     ? compactChangeTitle(state.title, 26)
     : normalizeChangeTitle(state.title);
@@ -107,16 +97,9 @@ export function formatOpenSpec(
     ? `  stale ${ageText(state.meta.updatedAt, Date.now()) ?? ''}`.trimEnd()
     : '';
 
-  if (state.phase === 'complete') return `${progress}  ${title}${stale}`;
+  if (state.phase === 'complete') return `${lead}${title}${stale}`;
 
-  const activeTask = focusedTaskId
-    ? (state.allTasks ?? state.pendingTasks).find((task) => task.id === focusedTaskId)
-    : undefined;
-  if (activeTask) {
-    return `${progress}  ▶ ${focusedTaskText(activeTask, compact)}${stale}`;
-  }
-
-  return `${progress}  ${title}${stale}`;
+  return `${lead}${title}${stale}`;
 }
 
 function diagnosticsColor(state: DiagnosticsState, now: number): WidgetColor {
@@ -197,7 +180,6 @@ export function buildWidgetSnapshots(
   options: {
     compact?: boolean;
     now?: number;
-    focusedTaskId?: string;
     openSpecFeedback?: OpenSpecFeedback;
     openSpecOverview?: OpenSpecOverview;
     openSpecProjectDetected?: boolean;
@@ -206,7 +188,6 @@ export function buildWidgetSnapshots(
   const compact = options.compact ?? false;
   const now = options.now ?? Date.now();
   const widgets: FancyFooterWidget[] = [];
-
   if (options.openSpecOverview || options.openSpecProjectDetected === false) {
     widgets.push({
       id: OPEN_SPEC_SCOPE_SEPARATOR_WIDGET_ID,
@@ -225,29 +206,8 @@ export function buildWidgetSnapshots(
     });
   }
 
-  if (options.openSpecOverview && options.focusedTaskId) {
-    const overview = options.openSpecOverview;
-    const complete =
-      overview.totalPlans > 0 &&
-      overview.completedPlans >= overview.totalPlans &&
-      (overview.totalTasks === 0 || overview.completedTasks >= overview.totalTasks);
-    const color: WidgetColor =
-      overview.totalPlans === 0 ? 'dim' : complete ? 'success' : 'accent';
-    widgets.push({
-      id: OPEN_SPEC_PROGRESS_WIDGET_ID,
-      label: 'OpenSpec progress',
-      description: 'Aggregate completion across OpenSpec Plans and their Tasks',
-      content: { type: 'text', text: formatOpenSpecOverview(overview) },
-      icon: {
-        glyphs: { nerd: '', emoji: '📋', unicode: '▤', ascii: 'P' },
-        color,
-      },
-      style: { textColor: color },
-      layout: { row: 0, position: 0, align: 'right', fill: 'none', minWidth: 8 },
-    });
-  }
-  // Frozen contract: without an OpenSpec focus there is no progress surface —
-  // no aggregate overview, no 'no OpenSpec' narration.
+  // Frozen contract: without a task focus there is no aggregate progress
+  // surface — no overview widget, no 'no OpenSpec' narration.
 
   if (!snapshot.openspec && options.openSpecFeedback) {
     const unavailable = options.openSpecFeedback === 'unavailable';
@@ -297,7 +257,7 @@ export function buildWidgetSnapshots(
       description: 'Focused OpenSpec change, task progress, and pending work',
       content: {
         type: 'text',
-        text: formatOpenSpec(snapshot.openspec, options.focusedTaskId ?? null, compact),
+        text: formatOpenSpec(snapshot.openspec, compact),
       },
       icon: {
         glyphs: {
@@ -471,34 +431,18 @@ export type HeaderStatusEvent = {
   progress: { icon: string; completed: number; total: number; color: WidgetColor }[];
 };
 
-function narrativeTaskTitle(title: string): string {
-  return normalizeInline(title).replace(
-    /^(?:Step|Task)\s+\d+(?:\.\d+)*(?:[.:])?\s+/iu,
-    '',
-  );
-}
-
-function selectedOpenSpecTitles(
-  state: OpenSpecState,
-  focusedTaskId: string | undefined,
-): string[] {
-  const activeTask = focusedTaskId
-    ? (state.allTasks ?? state.pendingTasks).find((task) => task.id === focusedTaskId)
-    : undefined;
-  return activeTask
-    ? [normalizeInline(state.title), narrativeTaskTitle(activeTask.title)]
-    : [normalizeInline(state.changeId), normalizeInline(focusedTaskId ?? 'no focus')];
+function selectedOpenSpecTitles(state: OpenSpecState): string[] {
+  return [normalizeInline(state.changeId)];
 }
 
 export function headerSelection(options: {
   openSpec?: OpenSpecState | null;
-  focusedTaskId?: string;
   subject?: SessionSubject;
 }): HeaderSelection | null {
   if (options.openSpec) {
     return {
       source: 'openspec',
-      titles: selectedOpenSpecTitles(options.openSpec, options.focusedTaskId),
+      titles: selectedOpenSpecTitles(options.openSpec),
       color: openSpecColor(options.openSpec),
     };
   }
@@ -821,7 +765,6 @@ export function buildHeaderStatusEvent(
   widgets: readonly FancyFooterWidget[],
   options: {
     openSpec?: OpenSpecState | null;
-    focusedTaskId?: string;
     subject?: SessionSubject;
     orchestration?: OrchestrationState | null;
     lifecycle?: HeaderLifecycle;
@@ -893,7 +836,7 @@ export function buildHeaderStatusEvent(
     const state = options.openSpec;
     work = {
       lifecycle,
-      titles: selectedOpenSpecTitles(state, options.focusedTaskId),
+      titles: selectedOpenSpecTitles(state),
       color: openSpecColor(state),
       ...projectedActivity,
     };
@@ -917,16 +860,19 @@ export function buildHeaderStatusEvent(
       ...projectedActivity,
     };
   }
-  const progress = options.openSpec?.totalTasks
-    ? [
-        {
-          icon: '󰘬',
-          completed: options.openSpec.completedTasks,
-          total: options.openSpec.totalTasks,
-          color: openSpecColor(options.openSpec),
-        },
-      ]
-    : [];
+  const openSpec = options.openSpec;
+  const progress =
+    typeof openSpec?.totalTasks === 'number' &&
+    typeof openSpec.completedTasks === 'number'
+      ? [
+          {
+            icon: '󰘬',
+            completed: openSpec.completedTasks,
+            total: openSpec.totalTasks,
+            color: openSpecColor(openSpec),
+          },
+        ]
+      : [];
 
   return {
     protocol: 1,
@@ -970,13 +916,6 @@ export function buildHeaderStatusEvent(
       ...(options.openSpec?.hierarchy
         ? { tasks: options.openSpec.hierarchy.tasks }
         : {}),
-      ...(options.openSpec?.hierarchy &&
-      options.focusedTaskId &&
-      options.openSpec.hierarchy.stepsByTask[options.focusedTaskId]
-        ? {
-            steps: options.openSpec.hierarchy.stepsByTask[options.focusedTaskId],
-          }
-        : {}),
       ...(orchestration?.completedFiles === undefined ||
       orchestration.totalFiles === undefined
         ? {}

package/packages/status/src/reducer.ts

@@ -1,5 +1,5 @@
 import type { LedgerEvent } from './ledger.ts';
-import type { OpenSpecFocus, SessionSubject } from './active-work.ts';
+import type { SessionSubject } from './active-work.ts';
 import type {
   CockpitSnapshot,
   ProgressFact,
@@ -18,7 +18,6 @@ import type {
  */
 
 export type ReducerFacts = {
-  openSpec: OpenSpecFocus;
   subject: SessionSubject;
   runs: ReadonlyMap<string, RunSpan>;
   progress: ProgressFact | null;
@@ -28,7 +27,6 @@ export const NO_SELECTION: SelectionState = { kind: 'none' };
 
 export function emptyFacts(): ReducerFacts {
   return {
-    openSpec: { mode: 'none' },
     subject: { state: 'clear' },
     runs: new Map(),
     progress: null,
@@ -36,17 +34,7 @@ export function emptyFacts(): ReducerFacts {
 }
 
 /** The single selection resolver. Priority order is contract-frozen. */
-export function resolveSelection(facts: {
-  openSpec: OpenSpecFocus;
-  subject: SessionSubject;
-}): SelectionState {
-  if (facts.openSpec.mode === 'task') {
-    return {
-      kind: 'openspec-task',
-      change: facts.openSpec.change,
-      task: facts.openSpec.taskId,
-    };
-  }
+export function resolveSelection(facts: { subject: SessionSubject }): SelectionState {
   if (facts.subject.state === 'set') {
     return { kind: 'subject', title: facts.subject.title };
   }
@@ -61,8 +49,6 @@ function applyStageRule(span: RunSpan, stage: StageValue, declared: boolean): Ru
 
 export function applyEvent(facts: ReducerFacts, event: LedgerEvent): ReducerFacts {
   switch (event.type) {
-    case 'focus/openspec':
-      return { ...facts, openSpec: event.focus };
     case 'focus/subject':
       return { ...facts, subject: event.subject };
     case 'run/start': {
@@ -129,23 +115,3 @@ export function rootRun(snapshot: CockpitSnapshot): RunSpan | undefined {
 export function derivedStage(snapshot: CockpitSnapshot): StageValue {
   return rootRun(snapshot)?.stage ?? 'listening';
 }
-
-/**
- * Derived terminal title. `title = f(selection, stage, progress)` — never stored,
- * never updated independently, never a placeholder.
- */
-export function deriveTitle(snapshot: CockpitSnapshot): string {
-  const selection = snapshot.selection;
-  let detail: string;
-  switch (selection.kind) {
-    case 'openspec-task':
-      detail = `${selection.change} › ${selection.task}`;
-      break;
-    case 'subject':
-      detail = selection.title;
-      break;
-    default:
-      detail = '';
-  }
-  return detail ? `π ${detail}` : 'π';
-}

package/packages/status/src/room-aim.ts

@@ -0,0 +1,151 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+/**
+ * The room aim — `openspec/.focus`, the Human's standing word for the
+ * room. Render law (observe-room-aim 2026-11-11): the deck reads it
+ * as-is and prints it as-is — a printer, not a translator. Five flat
+ * YAML fields; a missing field drops its segment and the separator that
+ * led it; absence never becomes zero; `change` is the keystone — no
+ * change, no aim.
+ */
+export type RoomAim = {
+  change: string;
+  artifactName?: string;
+  artifactIdx?: string;
+  task?: string;
+  nextStep?: string;
+  /** The aim file's mtime — cache key only, never rendered. */
+  mtimeMs: number;
+};
+
+const CHANGE_MAX = 120;
+const ARTIFACT_NAME_MAX = 120;
+const COUNT_MAX = 32;
+const NEXT_STEP_MAX = 180;
+const WALK_LIMIT = 40;
+const ABSENT_TTL_MS = 30_000;
+const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/gu;
+
+const AIM_FIELDS = new Set([
+  'change',
+  'artifact-name',
+  'artifact-idx',
+  'task',
+  'next-step',
+]);
+
+/** Collapse control characters to spaces and trim — the one cleanliness a
+ * terminal printer owes; honest content passes untouched. A symmetric
+ * YAML quote pair is syntax, not content: `"…"` and '…' unwrap before the
+ * emptiness check, so `task: ""` drops its segment like any missing
+ * field. */
+function printable(value: string): string {
+  const text = value.replace(CONTROL_CHARACTERS, ' ').trim();
+  if (
+    text.length >= 2 &&
+    ((text.startsWith('"') && text.endsWith('"')) ||
+      (text.startsWith("'") && text.endsWith("'")))
+  ) {
+    return text.slice(1, -1).trim();
+  }
+  return text;
+}
+
+/** Over-bound or empty values drop their field — absence, never a
+ * mid-token ellipsis; the Human re-aims rather than the deck inventing. */
+function field(value: string | undefined, maximum: number): string | undefined {
+  if (value === undefined) return undefined;
+  const text = printable(value);
+  if (text.length === 0 || Array.from(text).length > maximum) return undefined;
+  return text;
+}
+
+/**
+ * Parse the aim text into its five fields. Garbage lines are ignored;
+ * duplicate keys — last one wins; empty or comment-only values count as
+ * missing. An aim without `change` is not an aim.
+ */
+export function parseRoomAim(text: string, mtimeMs: number): RoomAim | undefined {
+  const values = new Map<string, string>();
+  for (const line of text.split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith('#')) continue;
+    const colon = trimmed.indexOf(':');
+    if (colon <= 0) continue;
+    const key = trimmed.slice(0, colon).trim();
+    if (!AIM_FIELDS.has(key)) continue;
+    values.set(key, trimmed.slice(colon + 1).trim());
+  }
+  const change = field(values.get('change'), CHANGE_MAX);
+  if (!change) return undefined;
+  const artifactName = field(values.get('artifact-name'), ARTIFACT_NAME_MAX);
+  const artifactIdx = field(values.get('artifact-idx'), COUNT_MAX);
+  const task = field(values.get('task'), COUNT_MAX);
+  const nextStep = field(values.get('next-step'), NEXT_STEP_MAX);
+  return {
+    change,
+    ...(artifactName ? { artifactName } : {}),
+    ...(artifactIdx ? { artifactIdx } : {}),
+    ...(task ? { task } : {}),
+    ...(nextStep ? { nextStep } : {}),
+    mtimeMs,
+  };
+}
+
+function findOpenspecRoot(cwd: string): string | undefined {
+  let dir = resolve(cwd);
+  for (let step = 0; step < WALK_LIMIT; step += 1) {
+    if (existsSync(join(dir, 'openspec'))) return join(dir, 'openspec');
+    const parent = dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+  return undefined;
+}
+
+type Cache =
+  | { path: string; mtimeMs: number; aim: RoomAim | undefined }
+  | { path: string; absentAt: number };
+
+let cache: Cache | undefined;
+
+/**
+ * Read the room aim for `cwd`. One `stat` per refresh — the file is only
+ * re-read when the mtime moves; an absent file is remembered for
+ * ABSENT_TTL_MS so a missing aim costs no per-render stat storm.
+ */
+export function readRoomAim(
+  cwd: string,
+  now: number = Date.now(),
+): RoomAim | undefined {
+  const root = findOpenspecRoot(cwd);
+  if (!root) return undefined;
+  const file = join(root, '.focus');
+  let mtimeMs: number;
+  try {
+    mtimeMs = statSync(file).mtimeMs;
+  } catch {
+    if (
+      cache &&
+      'absentAt' in cache &&
+      cache.path === file &&
+      now - cache.absentAt < ABSENT_TTL_MS
+    ) {
+      return undefined;
+    }
+    cache = { path: file, absentAt: now };
+    return undefined;
+  }
+  if (cache && 'aim' in cache && cache.path === file && cache.mtimeMs === mtimeMs) {
+    return cache.aim;
+  }
+  let aim: RoomAim | undefined;
+  try {
+    aim = parseRoomAim(readFileSync(file, 'utf8'), mtimeMs);
+  } catch {
+    aim = undefined;
+  }
+  cache = { path: file, mtimeMs, aim };
+  return aim;
+}