@aemonge-dev/pi-stardeck 0.11.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aemonge-dev/pi-stardeck",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "A Vim- and tmux-inspired command deck for Pi",
   "type": "module",
   "keywords": [
@@ -48,10 +48,11 @@
     "check:openspec": "node scripts/check-openspec.mjs",
     "test:tooling": "node --import tsx/esm --test test/*.test.ts",
     "test:status": "npm --prefix packages/status test",
+    "test:work-state": "npm --prefix packages/work-state test",
     "test:stardeck": "npm --prefix packages/pi-stardeck test",
     "test:footer": "npm --prefix packages/footer test",
     "test:vim": "npm --prefix packages/pi-vim-top-border test",
-    "test:components": "npm run test:status && npm run test:stardeck && npm run test:footer && npm run test:vim"
+    "test:components": "npm run test:status && npm run test:work-state && npm run test:stardeck && npm run test:footer && npm run test:vim"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",

package/packages/pi-stardeck/README.md

@@ -43,7 +43,7 @@ The additive header protocol projects selection independently from live work:
 
 ```ts
 selection: {
-  source: 'openspec' | 'session-work';
+  source: 'openspec' | 'subject' | 'legacy';
   titles: string[]; // one or two bounded, normalized titles
   color: HeaderColor;
 } | null;

package/packages/pi-stardeck/src/activity-age.ts

@@ -66,7 +66,7 @@ function standardActivityAge(ageMs: number): string {
   return `${Math.min(99, Math.floor(hours / 24))}d`;
 }
 
-function compactActivityAge(ageMs: number): string {
+export function compactActivityAge(ageMs: number): string {
   const age = boundedAge(ageMs);
   const seconds = Math.floor(age / 1_000);
   if (seconds < 100) return `${seconds}s`;

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

@@ -237,15 +237,18 @@ function alignedSingleRow(left: string, right: string, width: number): string {
   return `${fittedLeft}${' '.repeat(gap)}${right}`;
 }
 
-function workTile(state: HeaderDeckState, theme: Theme): string {
+function workTile(state: HeaderDeckState, theme: Theme, width: number): string {
   // Line 2 right: Work — derived from OpenSpec focus, never authored here.
-  // A fresh session keeps the slot with the accepted dim hint; pre-title
-  // publishers leave it silent (absent facts remove their slots).
+  // Width policy: the full tile from 56; 40–55 the attention/progress side
+  // yields first and the item count survives longest; below 40 the slot
+  // stays empty. A work slot without facts renders nothing — absent facts
+  // remove their slots, never sentinel dashes or narration.
+  if (width < 40) return '';
   const title = state.header?.title ?? null;
   if (!title) return '';
   const work = title.work;
-  if (!work) return color(theme, 'dim', '— no change owns the moment');
-  return deckWorkSegments(work)
+  if (!work) return '';
+  return deckWorkSegments(work, Date.now(), width < 56)
     .map((segment) => color(theme, segment.color, segment.text, segment.bold === true))
     .join('');
 }
@@ -754,7 +757,7 @@ export function renderHeaderDeck(
   // 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 titleRight = workTile(state, theme, boundedWidth);
   const focusLines = titleBandLines(state, boundedWidth, theme);
   const titleRows = [
     alignedSingleRow(focusLines[0] ?? '', titleRight, boundedWidth),

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

@@ -96,12 +96,7 @@ export type HeaderWork = {
   activityPath?: HeaderActivitySegment[];
 };
 
-export const HEADER_SELECTION_SOURCES = [
-  'openspec',
-  'session-work',
-  'subject',
-  'legacy',
-] as const;
+export const HEADER_SELECTION_SOURCES = ['openspec', 'subject', 'legacy'] as const;
 
 export type HeaderSelection = {
   source: (typeof HEADER_SELECTION_SOURCES)[number];

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

@@ -12,7 +12,9 @@
  * the legacy selection/activity rendering.
  */
 
-export const DECK_TITLE_STATE_VERSION = 1 as const;
+import { compactActivityAge } from './activity-age.ts';
+
+export const DECK_TITLE_STATE_VERSION = 2 as const;
 
 export const DECK_TITLE_ACTIVITY_CLASSES = [
   'editing',
@@ -38,16 +40,27 @@ const TASK_ID_MAX = 32;
 const SPAN_ID_MAX = 64;
 const WAIVER_ID_MAX = 64;
 const NOTICE_MAX = 180;
+const ARTIFACTS_MAX = 16;
 const TURN_TOKENS_MAX = 999_999_999;
 const TURN_ELAPSED_MAX = (99 * 60 + 59) * 1_000 + 999;
 
+export type DeckTitleArtifactState = {
+  id: string;
+  done: boolean;
+  items?: { done: number; total: number };
+};
+
 export type DeckTitleWorkState = {
   change: string;
   task?: string;
-  done?: number;
-  total?: number;
   schemaName?: string;
-  ladder?: { done: number; total: number; rung?: string };
+  artifacts?: DeckTitleArtifactState[];
+  /** The artifact the work is in — first not done, else last done. */
+  currentArtifact?: string;
+  /** Attention facts, derived from publisher-owned truth only. */
+  awaitingValidation?: boolean;
+  focusAt?: number;
+  focusStale?: boolean;
 };
 
 export type DeckTitleActivityState = {
@@ -121,46 +134,66 @@ function parseTitleWork(value: unknown): DeckTitleWorkState | null | undefined {
   if (!isRecord(value)) return undefined;
   const change = boundedText(value.change, IDENTIFIER_MAX);
   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;
   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 currentArtifact = boundedText(value.currentArtifact, TASK_ID_MAX, {
+    required: false,
+  });
+  if (currentArtifact === null) return undefined;
+  let artifacts: DeckTitleArtifactState[] | undefined;
+  if ('artifacts' in value) {
+    if (!Array.isArray(value.artifacts) || value.artifacts.length > ARTIFACTS_MAX) {
+      return undefined;
+    }
+    const parsed: DeckTitleArtifactState[] = [];
+    for (const entry of value.artifacts) {
+      if (!isRecord(entry)) return undefined;
+      const id = boundedText(entry.id, TASK_ID_MAX);
+      if (!id) return undefined;
+      if (typeof entry.done !== 'boolean') return undefined;
+      const artifactDone = entry.done;
+      let items: { done: number; total: number } | undefined;
+      if ('items' in entry) {
+        if (!isRecord(entry.items)) return undefined;
+        const done = boundedTotal(entry.items.done);
+        const total = boundedTotal(entry.items.total);
+        if (done === null || total === null) return undefined;
+        items = { done, total };
+      }
+      parsed.push({ id, done: artifactDone, ...(items ? { items } : {}) });
+    }
+    artifacts = parsed;
+  }
+  if ('awaitingValidation' in value && typeof value.awaitingValidation !== 'boolean') {
+    return undefined;
+  }
+  let focusAt: number | undefined;
+  if ('focusAt' in value) {
+    if (
+      typeof value.focusAt !== 'number' ||
+      !Number.isSafeInteger(value.focusAt) ||
+      value.focusAt < 0
+    ) {
+      return undefined;
+    }
+    focusAt = value.focusAt;
+  }
+  if ('focusStale' in value && typeof value.focusStale !== 'boolean') {
+    return undefined;
   }
-  const counts =
-    typeof boundedDone === 'number' && typeof boundedTotalValue === 'number'
-      ? { done: boundedDone, total: boundedTotalValue }
-      : {};
   const extras = {
     ...(schemaName ? { schemaName } : {}),
-    ...(ladder ? { ladder } : {}),
+    ...(artifacts ? { artifacts } : {}),
+    ...(currentArtifact ? { currentArtifact } : {}),
+    ...(value.awaitingValidation === true ? { awaitingValidation: true } : {}),
+    ...(focusAt !== undefined ? { focusAt } : {}),
+    ...(value.focusStale === true ? { focusStale: true } : {}),
   };
-  return task === undefined
-    ? { change, ...counts, ...extras }
-    : { change, task, ...counts, ...extras };
+  return task === undefined ? { change, ...extras } : { change, task, ...extras };
 }
 
 function parseTitleWaiver(value: unknown): DeckTitleWaiverState | null | undefined {
@@ -232,33 +265,66 @@ export function parseDeckTurnCost(value: unknown): DeckTurnCost | null {
 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.
+ * The Work label as colored segments — the truthful, de-duplicated tile:
+ * `execute 4/4 › 󰄱 12/15` — current artifact + artifact progress + the
+ * current artifact's file-truth item count. The change name lives on the
+ * subject side and never repeats here. Attention is derived, never authored:
+ * `⏸ awaiting you` (warning) replaces the whole tile; a stale focus fact
+ * (`⚠ focus <age> old`, dim, humanized at render time) replaces the artifact
+ * group. Unknown facts drop their segments — absent items never render as
+ * zeros. Compact width: the attention/progress side yields first, the item
+ * count survives longest. Separators are chrome with hard deck-wide colors —
+ * `›` accent like every minor separator.
  */
-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 });
+export function deckWorkSegments(
+  work: DeckTitleWorkState,
+  now: number = Date.now(),
+  compact = false,
+): DeckWorkSegment[] {
+  if (work.awaitingValidation) {
+    return compact ? [] : [{ text: '⏸ awaiting you', color: 'warning' }];
+  }
+  const segments: DeckWorkSegment[] = [];
+  const stale = work.focusStale === true && work.focusAt !== undefined;
+  if (!compact) {
+    if (stale) {
+      segments.push({
+        text: `⚠ focus ${compactActivityAge(Math.max(0, now - (work.focusAt ?? 0)))} old`,
+        color: 'dim',
+      });
+    } else {
+      const artifacts = work.artifacts;
+      const current = work.currentArtifact;
+      if (artifacts && artifacts.length > 0 && current) {
+        const done = artifacts.filter((artifact) => artifact.done).length;
+        const currentItems = artifacts.find(
+          (artifact) => artifact.id === current,
+        )?.items;
+        const itemsSettled =
+          currentItems === undefined ||
+          currentItems.total === 0 ||
+          currentItems.done >= currentItems.total;
+        // One hue per state: success only when the artifacts are done AND
+        // the current artifact's items are settled — otherwise work is open.
+        const complete = done === artifacts.length && itemsSettled;
+        segments.push({
+          text: `${current} ${done}/${artifacts.length}`,
+          color: complete ? 'success' : 'accent',
+        });
+      }
+    }
   }
-  if (work.done !== undefined && work.total !== undefined) {
-    segments.push({ text: ' › ', color: 'accent' });
+  const items = work.currentArtifact
+    ? work.artifacts?.find((artifact) => artifact.id === work.currentArtifact)?.items
+    : undefined;
+  if (items && items.total > 0) {
+    const complete = items.done >= items.total;
+    if (segments.length > 0) {
+      segments.push({ text: ' › ', color: 'accent' });
+    }
     segments.push({
-      text: `${complete ? '✔' : '󰄱'} ${work.done}/${work.total}`,
-      color: base,
+      text: `${complete ? '✔' : '󰄱'} ${items.done}/${items.total}`,
+      color: complete ? 'success' : 'accent',
       ...(complete ? { bold: true } : {}),
     });
   }

package/packages/status/README.md

@@ -90,10 +90,10 @@ branch entry. The agent-callable `openspec_focus` tool shares the command's `sta
 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.
+retired `work_focus`, `stage`, and `title` instruments are gone: stages
+derive from events and Taskflow phases, the focus row falls back to the
+native session name (named by `pi-title`) and then to legacy `session-subject`
+entries from old sessions, read defensively and 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