@aemonge-dev/pi-stardeck 0.11.0 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aemonge-dev/pi-stardeck",
-  "version": "0.11.0",
+  "version": "0.12.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/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/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

package/packages/status/index.ts

@@ -1,4 +1,3 @@
-import { StringEnum } from '@earendil-works/pi-ai';
 import type {
   ExtensionAPI,
   ExtensionCommandContext,
@@ -6,29 +5,15 @@ import type {
 } from '@earendil-works/pi-coding-agent';
 import { promises as fs, watch } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { Type } from 'typebox';
 import {
   formatActiveWorkTitle,
-  NO_OPEN_SPEC_FOCUS,
-  NO_SESSION_SUBJECT,
-  NO_SESSION_WORK_FOCUS,
-  OPEN_SPEC_FOCUS_ENTRY_TYPE,
   type OpenSpecFocus,
+  parseOpenSpecFocus,
   restoreOpenSpecFocus,
   restoreSessionSubject,
-  restoreSessionWorkFocus,
   sameOpenSpecFocus,
   sameSessionSubject,
-  sameSessionWorkFocus,
-  sameTaskFocus,
-  SESSION_SUBJECT_ENTRY_TYPE,
-  SESSION_WORK_FOCUS_ENTRY_TYPE,
   type SessionSubject,
-  type SessionWorkFocus,
-  sessionSubject,
-  taskflowRunFocus,
-  taskFocus,
-  titleFromPrompt,
 } from './src/active-work.ts';
 import { collectDiagnostics } from './src/diagnostics.ts';
 import { loadConfig } from './src/config.ts';
@@ -90,7 +75,6 @@ import type {
 
 type SessionContext = ExtensionContext | ExtensionCommandContext;
 type Domain = RuntimeErrorRecord['domain'];
-type OpenSpecFocusAction = 'status' | 'set' | 'replace' | 'validate' | 'clear';
 
 type StatusHealthCondition = {
   id: string;
@@ -187,10 +171,8 @@ class GalacticaStatusRuntime {
   private openSpecOverview: OpenSpecOverview | undefined;
   private openSpecProjectDetected: boolean | undefined;
   private focus: OpenSpecFocus;
-  private workFocus: SessionWorkFocus;
   private subject: SessionSubject;
   private sessionName: string | undefined;
-  private lastTitle: string | undefined;
   private diagnosticsPath: string | undefined;
   private orchestrationPath: string | undefined;
   private liveLifecycle: HeaderLifecycle;
@@ -218,7 +200,6 @@ class GalacticaStatusRuntime {
     ctx: SessionContext,
     publisher: FancyFooterPublisher,
     focus: OpenSpecFocus,
-    workFocus: SessionWorkFocus,
     subject: SessionSubject,
     sessionName: string | undefined,
   ) {
@@ -226,12 +207,10 @@ class GalacticaStatusRuntime {
     this.ctx = ctx;
     this.publisher = publisher;
     this.focus = focus;
-    this.workFocus = workFocus;
     this.subject = subject;
     this.sessionName = sessionName;
     const restoredAwaitingValidation =
-      (focus.mode === 'task' && focus.awaitingValidation) ||
-      workFocus.state === 'validation';
+      focus.mode === 'task' && focus.awaitingValidation;
     this.liveLifecycle = restoredAwaitingValidation ? 'waiting' : 'listening';
     this.liveActivity = restoredAwaitingValidation
       ? { kind: 'awaiting-validation' }
@@ -243,7 +222,6 @@ class GalacticaStatusRuntime {
     });
     const seededAt = Date.now();
     this.recordEvent({ type: 'focus/openspec', at: seededAt, focus });
-    this.recordEvent({ type: 'focus/work', at: seededAt, work: workFocus });
     this.recordEvent({ type: 'focus/subject', at: seededAt, subject });
   }
 
@@ -608,28 +586,19 @@ class GalacticaStatusRuntime {
     // the same object references), so output stays byte-identical while the
     // ledger becomes the feeding seam.
     const focus = this.cockpitFacts.openSpec;
-    const work = this.cockpitFacts.work;
     const subject = this.cockpitFacts.subject;
     const title = this.currentTitleState(snapshot);
     const focusedOpenSpec =
       focus.mode === 'task' && snapshot.openspec?.changeId === focus.change
         ? snapshot.openspec
         : null;
-    const visibleWorkFocus =
-      focus.mode === 'task' || (work.state === 'clear' && this.openSpecFeedback)
-        ? undefined
-        : work;
     const widgets = buildWidgetSnapshots(
       { ...snapshot, openspec: focusedOpenSpec },
       {
         focusedTaskId: focus.mode === 'task' ? focus.taskId : undefined,
-        openSpecFeedback:
-          focus.mode === 'none' && !visibleWorkFocus
-            ? this.openSpecFeedback
-            : undefined,
+        openSpecFeedback: focus.mode === 'none' ? this.openSpecFeedback : undefined,
         openSpecOverview: this.openSpecOverview,
         openSpecProjectDetected: this.openSpecProjectDetected,
-        workFocus: visibleWorkFocus,
       },
     );
     this.publisher.sync(widgets);
@@ -638,7 +607,6 @@ class GalacticaStatusRuntime {
       buildHeaderStatusEvent(widgets, {
         openSpec: focusedOpenSpec,
         focusedTaskId: focus.mode === 'task' ? focus.taskId : undefined,
-        workFocus: visibleWorkFocus,
         subject,
         orchestration: snapshot.orchestration,
         lifecycle: this.liveLifecycle,
@@ -655,20 +623,10 @@ class GalacticaStatusRuntime {
         diagnostics: snapshot.diagnostics,
       }),
     );
-    this.updateTitle(snapshot);
     this.publishStatusHealth();
   }
 
   private currentTitleState(snapshot = this.store.get()): TitleState {
-    return buildTitleState({
-      subject: this.cockpitFacts.subject,
-      focus: this.cockpitFacts.openSpec,
-      openspec: snapshot.openspec,
-      activity: this.titleActivity.current(),
-    });
-  }
-
-  private updateTitle(snapshot = this.store.get()): void {
     const facts = this.cockpitFacts;
     const focusedTaskId =
       facts.openSpec.mode === 'task' ? facts.openSpec.taskId : undefined;
@@ -680,18 +638,23 @@ class GalacticaStatusRuntime {
             (task) => task.id === focusedTaskId,
           )?.title
         : undefined;
-    const title = formatActiveWorkTitle({
+    // The band chip renders the fallback chain — task focus, native session
+    // name, legacy subject, directory. The terminal titlebar is pi-title's
+    // alone; this package never paints it (pure-renderer-split Slice 2).
+    const subjectTitle = formatActiveWorkTitle({
       focus: facts.openSpec,
-      workFocus: facts.work,
       subject: facts.subject,
       ...(taskTitle ? { taskTitle } : {}),
       ...(this.sessionName ? { sessionName: this.sessionName } : {}),
       projectRoot: snapshot.projectRoot,
       cwd: snapshot.cwd,
     });
-    if (title === this.lastTitle) return;
-    this.lastTitle = title;
-    this.ctx.ui.setTitle(title);
+    return buildTitleState({
+      subject: { state: 'set', title: subjectTitle },
+      focus: facts.openSpec,
+      openspec: snapshot.openspec,
+      activity: this.titleActivity.current(),
+    });
   }
 
   private recordEvent(event: LedgerEvent): void {
@@ -708,10 +671,6 @@ class GalacticaStatusRuntime {
     return this.focus;
   }
 
-  currentWorkFocus(): SessionWorkFocus {
-    return this.workFocus;
-  }
-
   currentSubject(): SessionSubject {
     return this.subject;
   }
@@ -735,27 +694,13 @@ class GalacticaStatusRuntime {
     this.store.clearOpenSpec();
     if (focus.mode === 'task' && focus.awaitingValidation) {
       this.setLiveProjection('waiting', { kind: 'awaiting-validation' });
-    } else if (focus.mode === 'none' && this.workFocus.state === 'clear') {
+    } else if (focus.mode === 'none') {
       this.setLiveProjection('listening');
     }
     this.publish();
     this.launch(this.refresh(false), 'openspec');
   }
 
-  setWorkFocus(focus: SessionWorkFocus): void {
-    if (sameSessionWorkFocus(this.workFocus, focus)) return;
-    this.workFocus = focus;
-    this.recordEvent({ type: 'focus/work', at: Date.now(), work: focus });
-    if (focus.state === 'validation') {
-      this.liveLifecycle = 'waiting';
-      this.liveActivity = { kind: 'awaiting-validation' };
-    } else if (focus.state === 'clear' && this.focus.mode === 'none') {
-      this.liveLifecycle = 'listening';
-      this.liveActivity = undefined;
-    }
-    this.publish();
-  }
-
   setSubject(subject: SessionSubject): void {
     if (sameSessionSubject(this.subject, subject)) return;
     this.subject = subject;
@@ -938,20 +883,16 @@ class GalacticaStatusRuntime {
       this.publish();
       return;
     }
-    if (this.focus.mode === 'task' || this.workFocus.state === 'validation') {
+    if (this.focus.mode === 'task') {
       this.setLiveProjection('waiting', { kind: 'awaiting-validation' });
       return;
     }
-    if (this.workFocus.state === 'active') {
-      this.setLiveProjection('waiting', { kind: 'awaiting-input' });
-      return;
-    }
     this.setLiveProjection('listening');
   }
 
   setSessionName(name: string | undefined): void {
     this.sessionName = name;
-    this.updateTitle();
+    this.publish();
   }
 
   async forceRefresh(): Promise<void> {
@@ -978,11 +919,6 @@ class GalacticaStatusRuntime {
           ? `OpenSpec focus: ${this.openSpecFeedback}`
           : 'OpenSpec focus: none',
     );
-    lines.push(
-      this.workFocus.state === 'clear'
-        ? 'Work: clear'
-        : `Work: ${this.workFocus.state} · ${this.workFocus.intent}`,
-    );
     lines.push(
       snapshot.diagnostics
         ? `Diagnostics: ${formatDiagnostics(snapshot.diagnostics)}`
@@ -1004,7 +940,6 @@ class GalacticaStatusRuntime {
         configPath: snapshot.configPath,
         configWarnings: snapshot.configWarnings,
         focus: this.focus,
-        workFocus: this.workFocus,
         openSpecFeedback: this.openSpecFeedback ?? null,
         openSpecOverview: this.openSpecOverview ?? null,
         detected: {
@@ -1055,123 +990,20 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
     }
   });
 
-  function persistAndApplyWorkFocus(focus: SessionWorkFocus): void {
-    pi.appendEntry(SESSION_WORK_FOCUS_ENTRY_TYPE, focus);
-    runtime?.setWorkFocus(focus);
-  }
-
-  function persistAndApplySubject(subject: SessionSubject): void {
-    pi.appendEntry(SESSION_SUBJECT_ENTRY_TYPE, subject);
-    runtime?.setSubject(subject);
-  }
-
-  function persistAndApplyFocus(focus: OpenSpecFocus): void {
-    if (
-      focus.mode === 'task' &&
-      (runtime?.currentWorkFocus() ?? NO_SESSION_WORK_FOCUS).state !== 'clear'
-    ) {
-      persistAndApplyWorkFocus(NO_SESSION_WORK_FOCUS);
-    }
-    pi.appendEntry(OPEN_SPEC_FOCUS_ENTRY_TYPE, focus);
+  // work-state owns focus writes and emits `focus-changed` after each
+  // successful one (pi.events); the renderer subscribes for immediate
+  // repaint (pure-renderer-split Slice 2).
+  const stopFocusRepaint = pi.events.on('focus-changed', (data: unknown) => {
+    const focus = parseOpenSpecFocus(data);
+    if (!focus) return;
     runtime?.setFocus(focus);
-  }
-
-  function subjectStatus(subject: SessionSubject): string {
-    return subject.state === 'clear' ? 'Title: clear' : `Title: ${subject.title}`;
-  }
-
-  function applyTitleAction(
-    action: 'status' | 'set',
-    title?: string,
-  ): { ok: boolean; message: string; subject: SessionSubject } {
-    const current = runtime?.currentSubject() ?? NO_SESSION_SUBJECT;
-
-    if (action === 'status') {
-      return { ok: true, message: subjectStatus(current), subject: current };
-    }
-
-    const next = sessionSubject('set', title);
-    if (!next || next.state !== 'set') {
-      return {
-        ok: false,
-        message: 'Title requires a non-empty title',
-        subject: current,
-      };
-    }
-    if (!sameSessionSubject(current, next)) persistAndApplySubject(next);
-    return { ok: true, message: subjectStatus(next), subject: next };
-  }
-
-  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: statusMessage(current), focus: current };
-    }
-    if (action === 'clear') {
-      persistAndApplyFocus(NO_OPEN_SPEC_FOCUS);
-      return {
-        ok: true,
-        message: 'OpenSpec focus cleared',
-        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) {
-      return {
-        ok: false,
-        message: 'OpenSpec focus requires non-empty change and task identifiers',
-        focus: current,
-      };
-    }
-    if (
-      action === 'set' &&
-      current.mode === 'task' &&
-      !sameTaskFocus(current, requested)
-    ) {
-      return {
-        ok: false,
-        message:
-          `OpenSpec focus is ${current.change} › ${current.taskId}; ` +
-          'use replace to change it deliberately',
-        focus: current,
-      };
-    }
-    if (!sameOpenSpecFocus(current, requested)) persistAndApplyFocus(requested);
-    return {
-      ok: true,
-      message: statusMessage(requested),
-      focus: requested,
-    };
-  }
+    runtime?.settle();
+  });
 
   pi.on('session_start', (_event, ctx) => {
     runtime?.stop();
     const branch = ctx.sessionManager.getBranch();
     const focus = restoreOpenSpecFocus(branch);
-    const workFocus = restoreSessionWorkFocus(branch);
     const subject = restoreSessionSubject(branch);
     const sessionName = pi.getSessionName() ?? ctx.sessionManager.getSessionName();
     runtime = new GalacticaStatusRuntime(
@@ -1179,7 +1011,6 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
       ctx,
       publisher,
       focus,
-      workFocus,
       subject,
       sessionName,
     );
@@ -1193,28 +1024,12 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
   pi.on('session_tree', (_event, ctx) => {
     const branch = ctx.sessionManager.getBranch();
     runtime?.setFocus(restoreOpenSpecFocus(branch));
-    runtime?.setWorkFocus(restoreSessionWorkFocus(branch));
     runtime?.setSubject(restoreSessionSubject(branch));
     runtime?.settle();
   });
 
-  pi.on('before_agent_start', (event) => {
+  pi.on('before_agent_start', () => {
     runtime?.beginTurn();
-    // Auto-title: the first real user prompt names the session while the
-    // subject is still clear — the agent's `title` call stays optional
-    // polish (every agent skipped the first-turn rule; verified
-    // systematically in simplify-session-focus-surface). Human- or
-    // agent-set titles and restored sessions are never overridden.
-    // The event fields are narrowed structurally: the registry-pinned
-    // @earendil-works/pi-coding-agent types predate messageType/prompt,
-    // while the runtime event carries both (extensions.md, before_agent_start).
-    const promptRun = event as { messageType?: unknown; prompt?: unknown };
-    if (promptRun.messageType !== 'user' || typeof promptRun.prompt !== 'string') {
-      return;
-    }
-    if ((runtime?.currentSubject() ?? NO_SESSION_SUBJECT).state !== 'clear') return;
-    const next = titleFromPrompt(promptRun.prompt);
-    if (next && next.state === 'set') persistAndApplySubject(next);
   });
 
   pi.on('tool_execution_start', (event) => {
@@ -1230,23 +1045,6 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
       );
       return;
     }
-    const requested = taskflowRunFocus(event.input);
-
-    if (requested) {
-      const current = runtime?.currentFocus() ?? NO_OPEN_SPEC_FOCUS;
-      if (current.mode === 'task' && !sameOpenSpecFocus(current, requested)) {
-        return {
-          block: true,
-          reason:
-            `OpenSpec focus is ${current.change} › ${current.taskId}; ` +
-            'use /openspec-focus clear or /openspec-focus replace <change> <task> before starting a conflicting run',
-        };
-      }
-      if (!sameOpenSpecFocus(current, requested)) {
-        persistAndApplyFocus(requested);
-      }
-    }
-
     const initialPhase = taskflowInitialHeaderPhase(event.input);
     if (initialPhase) {
       runtime?.setTaskflowPhase(initialPhase);
@@ -1312,117 +1110,7 @@ export default function galacticaStatus(pi: ExtensionAPI): void {
     runtime = undefined;
     publisher.removeAll();
     stopReady();
-  });
-
-  pi.registerTool({
-    name: 'title',
-    label: 'Session Title',
-    description:
-      'Show or set the sanitized session title that keeps the focus row populated beneath OpenSpec and Session Work. The session titles itself from the first real prompt; call this only to name or rename deliberately (at most 120 characters, never raw prompt text), revising 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(
-        Type.String({
-          description: 'Required only for set: the short sanitized subject title',
-        }),
-      ),
-    }),
-    async execute(_toolCallId, params) {
-      const result = applyTitleAction(params.action, params.title);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: result.ok ? result.message : `Error: ${result.message}`,
-          },
-        ],
-        details: {
-          ok: result.ok,
-          subject: result.subject,
-        },
-      };
-    },
-  });
-
-  pi.registerTool({
-    name: 'openspec_focus',
-    label: 'OpenSpec Focus',
-    description:
-      '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',
-    parameters: Type.Object({
-      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',
-        }),
-      ),
-      task: Type.Optional(
-        Type.String({
-          description: 'Required for set and replace: the exact OpenSpec Task ID',
-        }),
-      ),
-    }),
-    async execute(_toolCallId, params) {
-      const result = applyOpenSpecFocusAction(
-        params.action,
-        params.change,
-        params.task,
-      );
-      return {
-        content: [
-          {
-            type: 'text',
-            text: result.ok ? result.message : `Error: ${result.message}`,
-          },
-        ],
-        details: {
-          ok: result.ok,
-          focus: result.focus,
-        },
-      };
-    },
-  });
-
-  pi.registerCommand('openspec-focus', {
-    description: "Show, clear, or explicitly set this session's OpenSpec task focus",
-    handler: async (args, ctx) => {
-      const parts = args.trim().split(/\s+/u).filter(Boolean);
-      if (parts.length === 0) {
-        ctx.ui.notify(applyOpenSpecFocusAction('status').message, 'info');
-        return;
-      }
-
-      if (parts.length === 1 && parts[0]?.toLowerCase() === 'clear') {
-        const result = applyOpenSpecFocusAction('clear');
-        ctx.ui.notify(result.message, 'info');
-        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')
-        : 'set';
-      const identifiers = rawAction === action ? parts.slice(1) : parts;
-      if (identifiers.length !== 2) {
-        ctx.ui.notify(
-          'Usage: /openspec-focus [set|replace] <change> <task> | clear',
-          'warning',
-        );
-        return;
-      }
-
-      const result = applyOpenSpecFocusAction(action, identifiers[0], identifiers[1]);
-      ctx.ui.notify(result.message, result.ok ? 'info' : 'warning');
-    },
+    stopFocusRepaint();
   });
 
   pi.registerCommand('galactica-status', {