@aemonge-dev/pi-stardeck 0.9.3 → 0.10.0

package/package.json

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

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

@@ -357,32 +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 {
-  // Activity lane right: the turn cluster — liveness icon, turn time,
-  // and tokens in one aligned group (Human amendment 2026-10-23: the
-  // deck's only timer). Idle keeps the accepted dim `— · 0 tok`; the
-  // quiet-activity-row contract depends on it.
+  // 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(theme, 'customMessageLabel', '󰠭')} ${color(
+  return `${color(theme, 'warning', formatDeckElapsed(turn.elapsedMs), true)} ${color(
     theme,
-    'warning',
-    formatTurnElapsed(turn.elapsedMs),
-    true,
-  )} ${color(theme, 'dim', '·')} ${color(theme, 'warning', formatTokens(turn.tokens))}`;
+    'dim',
+    '·',
+  )} ${color(theme, 'warning', formatTokens(turn.tokens))}`;
 }
 
 function gitRight(state: HeaderDeckState, theme: Theme): string {

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;

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,12 +20,12 @@ import {
   sameOpenSpecFocus,
   sameSessionSubject,
   sameSessionWorkFocus,
+  sameTaskFocus,
   SESSION_SUBJECT_ENTRY_TYPE,
   SESSION_WORK_FOCUS_ENTRY_TYPE,
   type SessionSubject,
   type SessionWorkFocus,
   sessionSubject,
-  sessionWorkFocus,
   taskflowRunFocus,
   taskFocus,
 } from './src/active-work.ts';
@@ -77,7 +77,6 @@ import {
 } from './src/reducer.ts';
 import type {
   CockpitSnapshot,
-  StageValue,
   CommandRunner,
   DiagnosticsState,
   LoadedConfig,
@@ -90,7 +89,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 +228,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 +732,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 +762,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 +1075,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 +1093,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 +1101,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 +1124,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 +1148,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 +1161,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,
     };
   }
@@ -1360,80 +1299,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',
+    name: 'title',
+    label: 'Session Title',
     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',
-    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. Call this at the first conversational turn with a short sanitized title (at most 120 characters, never raw prompt text) and revise it only 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 +1313,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 +1333,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 +1370,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 +1385,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(
@@ -162,7 +169,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 +181,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/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;
@@ -165,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 {