@aemonge-dev/pi-stardeck 0.9.2 → 0.9.4

package/package.json

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

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

@@ -12,7 +12,7 @@ import type {
 } from './gauge.ts';
 import type { ResourceTelemetry } from './process-resources.ts';
 import { formatDeckCountdown } from './gauge.ts';
-import { formatDeckWorkLabel } from './title-state.ts';
+import { deckWorkSegments } from './title-state.ts';
 
 export interface HeaderDeckModeRail {
   plain: string;
@@ -164,21 +164,40 @@ function wrapFocus(text: string, width: number, maximumLines: number): string[]
   return lines.slice(0, maximumLines);
 }
 
+function mirrorKey(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9]/gu, '');
+}
+
+function bandWrap(
+  content: string,
+  width: number,
+  theme: Theme,
+  contentColor: string,
+): string[] {
+  return wrapFocus(content, Math.max(1, width), 2).map((line) =>
+    color(theme, contentColor, line),
+  );
+}
+
 function titleBandLines(state: HeaderDeckState, width: number, theme: Theme): string[] {
-  // Line 2 anchor: the clock always leads the band with its icon; the
-  // Subject follows when the title state carries one, and a fresh session
-  // (subject null) leaves the clock leading alone — no dangling separator.
-  const clock = `${color(theme, 'customMessageLabel', '󰠭')} ${timerTile(state, theme)}`;
+  // Human amendment 2026-10-23: line 2 is sacred — Subject and the Work
+  // tile only; no timers, no icons, no chrome. The session clock is
+  // discarded; liveness lives in the turn cluster on the activity lane.
   const title = state.header?.title ?? null;
   if (title) {
     const subject = safeText(title.subject ?? '');
     if (!subject) {
       // Human amendment 2026-10-19: the empty slot renders its dim
       // placeholder — mirroring the Work side's `— no change owns the
-      // moment` — instead of leaving the clock leading alone.
-      return focusWrapLines('— no subject', clock, width, theme, 'dim');
+      // moment` — never an empty band while the session talks.
+      return bandWrap('— no subject', width, theme, 'dim');
     }
-    return focusWrapLines(subject, clock, width, theme, 'accent');
+    // When the subject mirrors the focused change (the gate law's
+    // "subject mirrors its title"), it renders success-green like the
+    // PWD — the mirror visible at a glance.
+    const work = title.work;
+    const mirrorsFocus = work !== null && mirrorKey(subject) === mirrorKey(work.change);
+    return bandWrap(subject, width, theme, mirrorsFocus ? 'success' : 'accent');
   }
   // Pre-title publishers: the legacy selection keeps the band alive.
   const selection = state.header?.selection;
@@ -187,35 +206,16 @@ function titleBandLines(state: HeaderDeckState, width: number, theme: Theme): st
     .filter(Boolean);
   if (!selection || titles.length === 0) {
     if (!state.header) {
-      // Frozen contract: a publisher that reports nothing at all keeps
-      // the collapsed frame — clock alone, no placeholder dashes.
-      return [clock];
+      // Frozen contract (amended 2026-10-23): a publisher that reports
+      // nothing keeps the collapsed frame — an empty band, no dashes.
+      return [''];
     }
-    // Amendment: a live session (header present, Work rendering) that
-    // simply has no subject gets the dim placeholder — the title slot
-    // never renders empty when the session is talking to us.
-    return focusWrapLines('— no subject', clock, width, theme, 'dim');
+    return bandWrap('— no subject', width, theme, 'dim');
   }
   const selectionColor = ['accent', 'success'].includes(selection.color)
     ? 'accent'
     : selection.color;
-  return focusWrapLines(titles.join(' › '), clock, width, theme, selectionColor);
-}
-
-function focusWrapLines(
-  content: string,
-  clock: string,
-  width: number,
-  theme: Theme,
-  contentColor: string,
-): string[] {
-  const lead = `${clock} ${semanticSeparator(theme)} `;
-  const indent = ' '.repeat(visibleWidth(lead));
-  const contentWidth = Math.max(1, width - visibleWidth(lead));
-  return wrapFocus(content, contentWidth, 2).map(
-    (line, index) =>
-      `${index === 0 ? lead : indent}${color(theme, contentColor, line)}`,
-  );
+  return bandWrap(titles.join(' › '), width, theme, selectionColor);
 }
 
 function semanticSeparator(theme: Theme): string {
@@ -246,22 +246,9 @@ function workTile(state: HeaderDeckState, theme: Theme): string {
   if (!title) return '';
   const work = title.work;
   if (!work) return color(theme, 'dim', '— no change owns the moment');
-  return color(
-    theme,
-    work.total > 0 && work.done >= work.total ? 'success' : 'text',
-    formatDeckWorkLabel(work),
-  );
-}
-
-// Relocation phase (Human-directed): the clock leads the title band beside
-// the anchor, runs ride the lifecycle row, and Work keeps the title's
-// right end — real values when live, the dim hint when idle.
-function timerTile(state: HeaderDeckState, theme: Theme): string {
-  const elapsed = state.elapsedMs;
-  const idle = state.idleMs;
-  return elapsed != null
-    ? color(theme, 'accent', formatDeckElapsed(elapsed))
-    : color(theme, 'dim', formatDeckElapsed(idle ?? 0));
+  return deckWorkSegments(work)
+    .map((segment) => color(theme, segment.color, segment.text, segment.bold === true))
+    .join('');
 }
 
 function spanElapsed(ms: number): string {
@@ -370,29 +357,22 @@ function activityTile(state: HeaderDeckState, theme: Theme): string {
   return label ? color(theme, 'text', label) : color(theme, 'dim', 'awaiting Human');
 }
 
-function formatTurnElapsed(ms: number): string {
-  // Matches the turn meter's span-idle ceiling: 99m59s999ms → `99:59`.
-  const bounded = Math.min(
-    (99 * 60 + 59) * 1_000 + 999,
-    Math.max(0, Math.floor(Number.isFinite(ms) ? ms : 0)),
-  );
-  const totalSeconds = Math.floor(bounded / 1_000);
-  return `${Math.floor(totalSeconds / 60)}:${String(totalSeconds % 60).padStart(2, '0')}`;
-}
-
 function turnCostTile(state: HeaderDeckState, theme: Theme): string {
-  // Line 3 right: the per-turn cost meter. Idle renders the accepted
-  // `— · 0 tok`; pre-title publishers (no meter) stay silent.
+  // Activity lane right: the turn cluster — turn time and tokens in one
+  // aligned group (Human amendment 2026-10-23: the deck's only timer;
+  // Human amendment 2026-10-24: the liveness icon is gone — the ticking
+  // chronometer `mmm:ss'cc` is the liveness). Idle keeps the accepted
+  // dim `— · 0 tok`; the quiet-activity-row contract depends on it.
   const turn = state.header?.turn ?? null;
   if (!turn) return '';
   if (turn.tokens <= 0 && turn.elapsedMs <= 0) {
     return color(theme, 'dim', '— · 0 tok');
   }
-  return color(
+  return `${color(theme, 'warning', formatDeckElapsed(turn.elapsedMs), true)} ${color(
     theme,
-    'accent',
-    `this turn ${formatTokens(turn.tokens)} · ${formatTurnElapsed(turn.elapsedMs)}`,
-  );
+    'dim',
+    '·',
+  )} ${color(theme, 'warning', formatTokens(turn.tokens))}`;
 }
 
 function gitRight(state: HeaderDeckState, theme: Theme): string {
@@ -820,9 +800,9 @@ export function renderHeaderDeck(
   const lineColor = 'thinkingHigh';
   const solidRule = color(theme, lineColor, '─'.repeat(boundedWidth));
   const dottedRule = `\u001b[2m${color(theme, 'text', '┈'.repeat(boundedWidth))}\u001b[22m`;
-  // Line 2 (four-line deck): the clock and Subject lead with Work on the
-  // right end. Narrow frames: the Work slot yields before the clock anchor
-  // does.
+  // Line 2 (four-line deck): the Subject leads with Work on the right end
+  // (Human amendment 2026-10-23 — no clock, no chrome). Narrow frames: the
+  // Work slot yields before the Subject does.
   const titleRight = boundedWidth >= 40 ? workTile(state, theme) : '';
   const focusLines = titleBandLines(state, boundedWidth, theme);
   const titleRows = [

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

@@ -24,8 +24,10 @@ export const DECK_TITLE_ACTIVITY_CLASSES = [
 
 export type DeckTitleActivityClass = (typeof DECK_TITLE_ACTIVITY_CLASSES)[number];
 
-/** Short target label bound from the accepted schema. */
-export const DECK_TITLE_TARGET_MAX = 48;
+/** Short target label bound from the accepted schema (Human amendment
+ * 2026-10-24: 48 → 120, mirroring the status producer — the deck's
+ * render-time width crop owns the real limit now). */
+export const DECK_TITLE_TARGET_MAX = 120;
 
 /** Task/step totals bound from the accepted schema. */
 export const DECK_TITLE_TOTAL_MAX = 999;
@@ -42,8 +44,10 @@ const TURN_ELAPSED_MAX = (99 * 60 + 59) * 1_000 + 999;
 export type DeckTitleWorkState = {
   change: string;
   task?: string;
-  done: number;
-  total: number;
+  done?: number;
+  total?: number;
+  schemaName?: string;
+  ladder?: { done: number; total: number; rung?: string };
 };
 
 export type DeckTitleActivityState = {
@@ -116,12 +120,47 @@ function parseTitleWork(value: unknown): DeckTitleWorkState | null | undefined {
   if (value === null) return null;
   if (!isRecord(value)) return undefined;
   const change = boundedText(value.change, IDENTIFIER_MAX);
-  const done = boundedTotal(value.done);
-  const total = boundedTotal(value.total);
-  if (!change || done === null || total === null) return undefined;
+  if (!change) return undefined;
+  // Counts are optional as a pair: absent means unknown (never fabricated
+  // zeros); present-but-invalid rejects the object.
+  const hasCounts = 'done' in value && 'total' in value;
+  if ('done' in value !== 'total' in value) return undefined;
+  const boundedDone = hasCounts ? boundedTotal(value.done) : undefined;
+  const boundedTotalValue = hasCounts ? boundedTotal(value.total) : undefined;
+  if (hasCounts && (boundedDone === null || boundedTotalValue === null)) {
+    return undefined;
+  }
   const task = boundedText(value.task, TASK_ID_MAX, { required: false });
   if (task === null) return undefined;
-  return task === undefined ? { change, done, total } : { change, task, done, total };
+  const schemaName = boundedText(value.schemaName, IDENTIFIER_MAX, {
+    required: false,
+  });
+  if (schemaName === null) return undefined;
+  let ladder: { done: number; total: number; rung?: string } | undefined;
+  if ('ladder' in value) {
+    if (!isRecord(value.ladder)) return undefined;
+    const ladderDone = boundedTotal(value.ladder.done);
+    const ladderTotal = boundedTotal(value.ladder.total);
+    if (ladderDone === null || ladderTotal === null) return undefined;
+    const ladderRung = boundedText(value.ladder.rung, 32, { required: false });
+    if (ladderRung === null) return undefined;
+    ladder = {
+      done: ladderDone,
+      total: ladderTotal,
+      ...(ladderRung ? { rung: ladderRung } : {}),
+    };
+  }
+  const counts =
+    typeof boundedDone === 'number' && typeof boundedTotalValue === 'number'
+      ? { done: boundedDone, total: boundedTotalValue }
+      : {};
+  const extras = {
+    ...(schemaName ? { schemaName } : {}),
+    ...(ladder ? { ladder } : {}),
+  };
+  return task === undefined
+    ? { change, ...counts, ...extras }
+    : { change, task, ...counts, ...extras };
 }
 
 function parseTitleWaiver(value: unknown): DeckTitleWaiverState | null | undefined {
@@ -189,7 +228,46 @@ export function parseDeckTurnCost(value: unknown): DeckTurnCost | null {
   }
 }
 
-/** `change · done/total` — the Work label from the accepted mockups. */
+/** One colored piece of the Work label. */
+export type DeckWorkSegment = { text: string; color: string; bold?: boolean };
+
+/**
+ * The Work label as colored segments — the human-chosen design: `change ⟩
+ * done/total rung › 󰄱 done/total` in one hue per state (accent, success at
+ * complete with a filled checkbox and bold counts). The rung name comes
+ * straight from OpenSpec's status artifacts — never an invented phase
+ * word. Separators are chrome with hard deck-wide colors — `⟩`
+ * thinkingHigh-bold like every semantic separator, `›` accent like every
+ * minor one. Unknown facts degrade honestly; the bare change is the floor.
+ */
+export function deckWorkSegments(work: DeckTitleWorkState): DeckWorkSegment[] {
+  const complete =
+    work.done !== undefined &&
+    work.total !== undefined &&
+    work.total > 0 &&
+    work.done >= work.total;
+  const base = complete ? 'success' : 'accent';
+  const segments: DeckWorkSegment[] = [{ text: work.change, color: base }];
+  const ladder = work.ladder;
+  if (ladder) {
+    segments.push({ text: ' ⟩ ', color: 'thinkingHigh', bold: true });
+    const group = `${ladder.done}/${ladder.total}${ladder.rung ? ` ${ladder.rung}` : ''}`;
+    segments.push({ text: group, color: base });
+  }
+  if (work.done !== undefined && work.total !== undefined) {
+    segments.push({ text: ' › ', color: 'accent' });
+    segments.push({
+      text: `${complete ? '✔' : '󰄱'} ${work.done}/${work.total}`,
+      color: base,
+      ...(complete ? { bold: true } : {}),
+    });
+  }
+  return segments;
+}
+
+/** The plain-text Work label — the segment join without colors. */
 export function formatDeckWorkLabel(work: DeckTitleWorkState): string {
-  return `${work.change} · ${work.done}/${work.total}`;
+  return deckWorkSegments(work)
+    .map((segment) => segment.text)
+    .join('');
 }

package/packages/status/src/openspec.ts

@@ -204,12 +204,19 @@ export function parseApplyInstructions(value: unknown): ApplyInstructionsResult
     );
   }
 
-  const progress = isRecord(value.progress)
+  const state = typeof value.state === 'string' ? value.state : undefined;
+  const reportedProgress = isRecord(value.progress)
     ? {
         total: finiteNumber(value.progress.total),
         complete: finiteNumber(value.progress.complete),
       }
     : undefined;
+  // A blocked apply (mid-ladder, artifacts missing) reports zero progress;
+  // those zeros must never shadow the honest `openspec list` counts.
+  const progress =
+    state !== 'blocked' && (reportedProgress?.total ?? 0) > 0
+      ? reportedProgress
+      : undefined;
 
   return { tasks, tasksPath, progress };
 }
@@ -227,6 +234,33 @@ function chooseChange(
   return selected;
 }
 
+function parseOpenSpecStatus(value: unknown): {
+  schemaName?: string;
+  ladder?: { done: number; total: number; rung?: string };
+} {
+  if (!isRecord(value)) return {};
+  const schemaName =
+    typeof value.schemaName === 'string' && value.schemaName.trim()
+      ? value.schemaName.trim()
+      : undefined;
+  let ladder: { done: number; total: number; rung?: string } | undefined;
+  if (Array.isArray(value.artifacts) && value.artifacts.length > 0) {
+    let done = 0;
+    let rung: string | undefined;
+    for (const artifact of value.artifacts) {
+      if (!isRecord(artifact)) continue;
+      const id = typeof artifact.id === 'string' ? artifact.id : undefined;
+      if (rung === undefined && id) rung = id;
+      if (artifact.status === 'done') {
+        done += 1;
+        if (id) rung = id;
+      }
+    }
+    ladder = { done, total: value.artifacts.length, ...(rung ? { rung } : {}) };
+  }
+  return { ...(schemaName ? { schemaName } : {}), ...(ladder ? { ladder } : {}) };
+}
+
 async function runJson(
   runner: CommandRunner,
   args: string[],
@@ -326,6 +360,23 @@ export async function collectOpenSpec(options: {
     // The list result is still useful when an optional title lookup fails.
   }
 
+  let schemaName: string | undefined;
+  let ladder: OpenSpecState['ladder'];
+  try {
+    const status = parseOpenSpecStatus(
+      await runJson(
+        options.runner,
+        ['status', '--change', change.name, '--json'],
+        projectRoot,
+        'openspec status',
+      ),
+    );
+    schemaName = status.schemaName;
+    ladder = status.ladder;
+  } catch {
+    // Ladder facts are optional; the list counts remain valid without them.
+  }
+
   let tasks: OpenSpecTask[] = [];
   let tasksPath: string | undefined;
   let instructionProgress: ApplyInstructionsResult['progress'];
@@ -383,6 +434,8 @@ export async function collectOpenSpec(options: {
     allTasks: tasks,
     ...(tasksPath ? { tasksPath } : {}),
     ...(hierarchy ? { hierarchy } : {}),
+    ...(schemaName ? { schemaName } : {}),
+    ...(ladder ? { ladder } : {}),
     meta: {
       source: 'openspec-cli',
       refreshedAt: now,

package/packages/status/src/title-state.ts

@@ -22,8 +22,11 @@ export const TITLE_ACTIVITY_CLASSES = [
 
 export type TitleActivityClass = (typeof TITLE_ACTIVITY_CLASSES)[number];
 
-/** Short target label bound from the accepted schema. */
-export const TITLE_TARGET_MAX = 48;
+/** Short target label bound from the accepted schema (Human amendment
+ * 2026-10-24: 48 → 120 — the deck's activity lane now owns the full
+ * width beside the turn cluster, so the protocol bound yields to the
+ * render-time crop instead of pre-cutting subagent/bash labels). */
+export const TITLE_TARGET_MAX = 120;
 
 /** Task/step totals bound from the accepted schema. */
 export const TITLE_TOTAL_MAX = 999;
@@ -38,8 +41,10 @@ const NOTICE_MAX = 180;
 export type TitleWorkState = {
   change: string;
   task?: string;
-  done: number;
-  total: number;
+  done?: number;
+  total?: number;
+  schemaName?: string;
+  ladder?: { done: number; total: number; rung?: string };
 };
 
 export type TitleActivityState = {
@@ -109,12 +114,47 @@ function parseTitleWork(value: unknown): TitleWorkState | null | undefined {
   if (value === null) return null;
   if (!isRecord(value)) return undefined;
   const change = boundedText(value.change, IDENTIFIER_MAX);
-  const done = boundedTotal(value.done);
-  const total = boundedTotal(value.total);
-  if (!change || done === null || total === null) return undefined;
+  if (!change) return undefined;
+  // Counts are optional as a pair: absent means unknown (never fabricated
+  // zeros); present-but-invalid rejects the object.
+  const hasCounts = 'done' in value && 'total' in value;
+  if ('done' in value !== 'total' in value) return undefined;
+  const boundedDone = hasCounts ? boundedTotal(value.done) : undefined;
+  const boundedTotalValue = hasCounts ? boundedTotal(value.total) : undefined;
+  if (hasCounts && (boundedDone === null || boundedTotalValue === null)) {
+    return undefined;
+  }
   const task = boundedText(value.task, TASK_ID_MAX, { required: false });
   if (task === null) return undefined;
-  return task === undefined ? { change, done, total } : { change, task, done, total };
+  const schemaName = boundedText(value.schemaName, IDENTIFIER_MAX, {
+    required: false,
+  });
+  if (schemaName === null) return undefined;
+  let ladder: { done: number; total: number; rung?: string } | undefined;
+  if ('ladder' in value) {
+    if (!isRecord(value.ladder)) return undefined;
+    const ladderDone = boundedTotal(value.ladder.done);
+    const ladderTotal = boundedTotal(value.ladder.total);
+    if (ladderDone === null || ladderTotal === null) return undefined;
+    const ladderRung = boundedText(value.ladder.rung, 32, { required: false });
+    if (ladderRung === null) return undefined;
+    ladder = {
+      done: ladderDone,
+      total: ladderTotal,
+      ...(ladderRung ? { rung: ladderRung } : {}),
+    };
+  }
+  const counts =
+    typeof boundedDone === 'number' && typeof boundedTotalValue === 'number'
+      ? { done: boundedDone, total: boundedTotalValue }
+      : {};
+  const extras = {
+    ...(schemaName ? { schemaName } : {}),
+    ...(ladder ? { ladder } : {}),
+  };
+  return task === undefined
+    ? { change, ...counts, ...extras }
+    : { change, task, ...counts, ...extras };
 }
 
 function parseTitleWaiver(value: unknown): TitleWaiverState | null | undefined {
@@ -128,7 +168,7 @@ function parseTitleWaiver(value: unknown): TitleWaiverState | null | undefined {
 
 /**
  * Defensive parser for incoming title-state payloads. Unknown versions,
- * malformed shapes, and out-of-bounds values (target > 48 characters,
+ * malformed shapes, and out-of-bounds values (target > 120 characters,
  * totals > 999) reject the whole object with `null`; it never throws.
  */
 export function parseTitleState(value: unknown): TitleState | null {
@@ -180,16 +220,28 @@ export function deriveTitleWork(
     done: boundedCount(state.hierarchy?.tasks?.completed, state.completedTasks),
     total: boundedCount(state.hierarchy?.tasks?.total, state.totalTasks),
   });
+  // Human steering 2026-10-23: no invented phase words — the ladder's
+  // rung name comes straight from OpenSpec.
+  const extras = (state: OpenSpecState | undefined) => {
+    if (!state) return {};
+    return {
+      ...(state.schemaName ? { schemaName: state.schemaName } : {}),
+      ...(state.ladder ? { ladder: state.ladder } : {}),
+    };
+  };
   if (focus.mode === 'task') {
     const state = openspec && openspec.changeId === focus.change ? openspec : undefined;
+    const taskCounts = state ? counts(state) : undefined;
     return {
       change: focus.change,
       task: focus.taskId,
-      ...(state ? counts(state) : { done: 0, total: 0 }),
+      ...(taskCounts ?? {}),
+      ...extras(state),
     };
   }
   if (!openspec) return null;
-  return { change: openspec.changeId, ...counts(openspec) };
+  const taskCounts = counts(openspec);
+  return { change: openspec.changeId, ...taskCounts, ...extras(openspec) };
 }
 
 /**

package/packages/status/src/types.ts

@@ -89,6 +89,8 @@ export interface OpenSpecState {
   allTasks?: OpenSpecTask[];
   tasksPath?: string;
   hierarchy?: OpenSpecHierarchyProgress;
+  schemaName?: string;
+  ladder?: { done: number; total: number; rung?: string };
   meta: SourceMeta;
 }