@aemonge-dev/pi-stardeck 0.14.0 → 0.15.0

package/src/index.ts

@@ -1,7 +1,6 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 
 import galacticaContextHeader from '../packages/pi-stardeck/index.js';
-import workState from '../packages/work-state/index.js';
 import galacticaStatus from '../packages/status/index.js';
 import footerTelemetry from '../packages/footer/index.js';
 import { registerStardeckHealth } from './health.js';
@@ -20,7 +19,6 @@ export const COCKPIT_COMPOSITION = [
 export default function piStardeck(pi: ExtensionAPI): void {
   registerPiStatus(pi);
   footerTelemetry(pi);
-  workState(pi);
   galacticaStatus(pi);
   galacticaContextHeader(pi, {
     surface: COCKPIT_SURFACES.contextHeader,

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

@@ -1,184 +0,0 @@
-import { visibleWidth } from '@earendil-works/pi-tui';
-
-export const WIDE_ACTIVITY_AGE_CELLS = 6;
-export const STANDARD_ACTIVITY_AGE_CELLS = 4;
-export const COMPACT_ACTIVITY_AGE_CELLS = 3;
-export const RAIL_CHRONOMETER_CELLS = 8;
-export const RUNTIME_STATUS_WIDGET_ID = 'galactica.runtime-state';
-export const RUNTIME_SCOPE_SEPARATOR_WIDGET_ID = 'galactica.runtime-scope-separator';
-
-export type ActivityAgeSize = 6 | 4 | 3;
-
-const ACTIVITY_AGE_SIZES: readonly ActivityAgeSize[] = [
-  WIDE_ACTIVITY_AGE_CELLS,
-  STANDARD_ACTIVITY_AGE_CELLS,
-  COMPACT_ACTIVITY_AGE_CELLS,
-];
-
-function boundedAge(ageMs: number): number {
-  return Number.isFinite(ageMs) ? Math.max(0, Math.floor(ageMs)) : 0;
-}
-
-function activityHeartbeat(ageMs: number): string {
-  return Math.floor(boundedAge(ageMs) / 500) % 2 === 0 ? '·' : '•';
-}
-
-function wideActivityAge(ageMs: number): string {
-  const age = boundedAge(ageMs);
-  if (age < 100) return `${age}ms`;
-  if (age < 60_000) {
-    return `${Math.min(59.9, Math.floor(age / 100) / 10).toFixed(1)}s`;
-  }
-
-  const seconds = Math.floor(age / 1_000);
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 60) {
-    return `${minutes}m${String(seconds % 60).padStart(2, '0')}s`;
-  }
-
-  const hours = Math.floor(minutes / 60);
-  const heartbeat = activityHeartbeat(age);
-  if (hours < 10) {
-    return `${hours}h${String(minutes % 60).padStart(2, '0')}m${heartbeat}`;
-  }
-  if (hours < 100) {
-    return `${hours}:${String(minutes % 60).padStart(2, '0')}${heartbeat}`;
-  }
-
-  const days = Math.min(99, Math.floor(hours / 24));
-  if (days < 10) {
-    return `${days}d${String(hours % 24).padStart(2, '0')}h${heartbeat}`;
-  }
-  return `${days}d${String(hours % 24).padStart(2, '0')}${heartbeat}`;
-}
-
-function standardActivityAge(ageMs: number): string {
-  const age = boundedAge(ageMs);
-  if (age < 100) return `${age}ms`;
-  if (age < 10_000) return `${Math.min(9.9, age / 1_000).toFixed(1)}s`;
-
-  const seconds = Math.floor(age / 1_000);
-  if (seconds < 100) return `${seconds}s`;
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 100) return `${minutes}m`;
-  const hours = Math.floor(minutes / 60);
-  if (hours < 100) return `${hours}h`;
-  return `${Math.min(99, Math.floor(hours / 24))}d`;
-}
-
-export function compactActivityAge(ageMs: number): string {
-  const age = boundedAge(ageMs);
-  const seconds = Math.floor(age / 1_000);
-  if (seconds < 100) return `${seconds}s`;
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 100) return `${minutes}m`;
-  const hours = Math.floor(minutes / 60);
-  if (hours < 100) return `${hours}h`;
-  return `${Math.min(99, Math.floor(hours / 24))}d`;
-}
-
-export function formatActivityAge(ageMs: number, size: ActivityAgeSize): string {
-  const text =
-    size === WIDE_ACTIVITY_AGE_CELLS
-      ? wideActivityAge(ageMs)
-      : size === STANDARD_ACTIVITY_AGE_CELLS
-        ? standardActivityAge(ageMs)
-        : compactActivityAge(ageMs);
-  return `${' '.repeat(Math.max(0, size - visibleWidth(text)))}${text}`;
-}
-
-export function passiveActivityStatus(
-  lifecycle: string,
-  size: ActivityAgeSize,
-): string {
-  const normalized = lifecycle.trim().toLowerCase();
-  const full =
-    normalized === 'listening'
-      ? 'idle'
-      : normalized === 'blocked'
-        ? 'hold'
-        : normalized === 'aborted'
-          ? 'stop'
-          : 'wait';
-  if (size !== COMPACT_ACTIVITY_AGE_CELLS) {
-    return `${' '.repeat(Math.max(0, size - visibleWidth(full)))}${full}`;
-  }
-  const compact =
-    full === 'idle' ? '—' : full === 'hold' ? '!' : full === 'stop' ? '×' : '…';
-  return `${' '.repeat(size - visibleWidth(compact))}${compact}`;
-}
-
-export function formatRailChronometer(ageMs: number | null): string {
-  if (ageMs === null) return "00:00'00";
-
-  const centiseconds = Math.floor(boundedAge(ageMs) / 10);
-  const minutes = Math.floor(centiseconds / 6_000);
-  if (minutes < 100) {
-    const seconds = Math.floor(centiseconds / 100) % 60;
-    const remainder = centiseconds % 100;
-    return `${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}'${String(remainder).padStart(2, '0')}`;
-  }
-
-  const totalSeconds = Math.floor(centiseconds / 100);
-  const hours = Math.floor(totalSeconds / 3_600);
-  if (hours < 100) {
-    const remainderMinutes = Math.floor(totalSeconds / 60) % 60;
-    const seconds = totalSeconds % 60;
-    return `${String(hours).padStart(2, '0')}h${String(remainderMinutes).padStart(2, '0')}'${String(seconds).padStart(2, '0')}`;
-  }
-
-  const days = Math.min(99, Math.floor(hours / 24));
-  const remainderHours = hours % 24;
-  const remainderMinutes = Math.floor(totalSeconds / 60) % 60;
-  return `${String(days).padStart(2, '0')}d${String(remainderHours).padStart(2, '0')}'${String(remainderMinutes).padStart(2, '0')}`;
-}
-
-export function activityAgeCandidates(
-  ageMs: number | null,
-  lifecycle = 'listening',
-): ReadonlyArray<{ size: ActivityAgeSize; age: string }> {
-  return ACTIVITY_AGE_SIZES.map((size) => ({
-    size,
-    age:
-      ageMs === null
-        ? passiveActivityStatus(lifecycle, size)
-        : formatActivityAge(ageMs, size),
-  }));
-}
-
-export function buildRuntimeFooterWidgets(status: string, active = false) {
-  return [
-    {
-      protocol: 1,
-      type: 'upsert',
-      widget: {
-        id: RUNTIME_STATUS_WIDGET_ID,
-        label: 'Runtime state',
-        description: 'Time since foreground activity or the settled runtime state',
-        content: { type: 'text', text: status },
-        icon: false,
-        style: { textColor: active ? 'accent' : 'dim' },
-        layout: {
-          row: 1,
-          position: 4,
-          align: 'left',
-          fill: 'none',
-          minWidth: RAIL_CHRONOMETER_CELLS,
-        },
-      },
-    },
-    {
-      protocol: 1,
-      type: 'upsert',
-      widget: {
-        id: RUNTIME_SCOPE_SEPARATOR_WIDGET_ID,
-        label: 'Runtime scope separator',
-        description: 'Separates the active LLM from runtime state',
-        content: { type: 'text', text: '⟩' },
-        icon: false,
-        style: { textColor: 'thinkingHigh' },
-        layout: { row: 1, position: 3, align: 'left', fill: 'none' },
-      },
-    },
-  ] as const;
-}

package/packages/status/src/gate-act.ts

@@ -1,85 +0,0 @@
-import { promises as fs } from 'node:fs';
-import { resolve, sep } from 'node:path';
-import type { CommandRunner } from './types.ts';
-
-/** Relay budget: the gate's act line is cockpit commentary — a slow or
- *  absent gate must cost less than a refresh, never block one. */
-const GATE_PROBE_TIMEOUT_MS = 2_000;
-/** Re-probe cadence when the meta file cannot be statted at all — time
- *  is the only cache key left, so it steps lightly. */
-const ABSENT_META_TTL_MS = 30_000;
-
-const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/gu;
-
-interface GateActCacheEntry {
-  mtimeMs?: number;
-  at: number;
-  line: string | undefined;
-}
-
-/** mtime-keyed relay cache: one probe per meta mtime, negatives cached
- *  exactly like hits — a missing or refusing gate must never become a
- *  per-render spawn storm. Keyed by contained change root, not slug. */
-const gateActCache = new Map<string, GateActCacheEntry>();
-
-function containedChangeRoot(projectRoot: string, change: string): string | undefined {
-  const changesRoot = resolve(projectRoot, 'openspec', 'changes');
-  const changeRoot = resolve(changesRoot, change);
-  if (changeRoot === changesRoot || !changeRoot.startsWith(`${changesRoot}${sep}`)) {
-    return undefined;
-  }
-  return changeRoot;
-}
-
-/**
- * The gate's teaching line for one change, relayed verbatim:
- * `pios-gate <slug>` — the aim — owns truth and words; this module owns
- * only placement and cost. Any non-zero exit (unknown changes error),
- * timeout kill, spawn failure, or empty output yields `undefined` —
- * declared focus renders alone, quietly. The meta file is never parsed:
- * its mtime only keys the cache.
- */
-export async function resolveGateAct(options: {
-  change: string;
-  projectRoot: string;
-  runner: CommandRunner;
-  now?: number;
-}): Promise<string | undefined> {
-  const changeRoot = containedChangeRoot(options.projectRoot, options.change);
-  if (!changeRoot) return undefined;
-  const now = options.now ?? Date.now();
-
-  let mtimeMs: number | undefined;
-  try {
-    mtimeMs = (await fs.stat(resolve(changeRoot, '.openspec.yaml'))).mtimeMs;
-  } catch {
-    mtimeMs = undefined;
-  }
-
-  const cached = gateActCache.get(changeRoot);
-  if (
-    cached &&
-    (cached.mtimeMs !== undefined
-      ? cached.mtimeMs === mtimeMs
-      : mtimeMs === undefined && now - cached.at < ABSENT_META_TTL_MS)
-  ) {
-    return cached.line;
-  }
-
-  let line: string | undefined;
-  try {
-    const result = await options.runner('pios-gate', [options.change], {
-      cwd: options.projectRoot,
-      timeoutMs: GATE_PROBE_TIMEOUT_MS,
-    });
-    if (result.code === 0 && !result.killed) {
-      const firstLine = String(result.stdout).split('\n', 1)[0] ?? '';
-      const cleaned = firstLine.replace(CONTROL_CHARACTERS, ' ').trim();
-      if (cleaned) line = cleaned;
-    }
-  } catch {
-    // Missing binary, spawn refusal, whatever went wrong: no gate line.
-  }
-  gateActCache.set(changeRoot, { mtimeMs, at: now, line });
-  return line;
-}

package/packages/work-state/README.md

@@ -1,33 +0,0 @@
-# work-state
-
-Owns the branch-local OpenSpec Task focus for the pi-stardeck cockpit: the
-`openspec_focus` tool, the `galactica-status.openspec-focus.v1` session entry
-write path, and the taskflow conflict guard.
-
-## Entry contract
-
-The session entry name `galactica-status.openspec-focus.v1` is an
-**interface, not an ownership mark**: it predates this package and must stay
-byte-identical for existing sessions and external readers. A contract test
-(`test/contract.test.ts`) asserts byte-identity against the renderer's copy —
-runtime code never imports across packages; the suites enforce the name.
-
-External readers:
-
-- **`pi-openspec-gate`** (separate repository) — parses latest-wins
-  `galactica-status.openspec-focus.v1` entries, with explicit clears. Do not
-  change the entry shape or name.
-
-## Focus changes
-
-After each successful focus write this package emits the `pi.events` event
-`focus-changed` carrying the new focus data. The status renderer subscribes
-and repaints; no other consumer is required, and the package fails soft when
-nothing listens.
-
-## No slash command
-
-Focus is set only through the `openspec_focus` tool, on explicit Human
-direction or an exact declared OpenSpec Task handoff — never inferred. There
-is deliberately **no slash command**; clears and replacements happen through
-the tool's `clear` / `replace` actions under the same policy.

package/packages/work-state/index.ts

@@ -1,160 +0,0 @@
-import { StringEnum } from '@earendil-works/pi-ai';
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-import { Type } from 'typebox';
-import {
-  NO_OPEN_SPEC_FOCUS,
-  OPEN_SPEC_FOCUS_ENTRY_TYPE,
-  type OpenSpecFocus,
-  restoreOpenSpecFocus,
-  sameOpenSpecFocus,
-  sameTaskFocus,
-  taskflowRunFocus,
-  taskFocus,
-} from './src/focus.ts';
-
-const FOCUS_CHANGED_EVENT = 'focus-changed';
-
-type OpenSpecFocusAction = 'status' | 'set' | 'replace' | 'validate' | 'clear';
-
-export default function workState(pi: ExtensionAPI): void {
-  let currentFocus: OpenSpecFocus = NO_OPEN_SPEC_FOCUS;
-
-  pi.on('session_start', (_event, ctx) => {
-    currentFocus = restoreOpenSpecFocus(ctx.sessionManager.getBranch());
-  });
-
-  pi.on('session_tree', (_event, ctx) => {
-    currentFocus = restoreOpenSpecFocus(ctx.sessionManager.getBranch());
-  });
-
-  function persistAndApplyFocus(focus: OpenSpecFocus): void {
-    pi.appendEntry(OPEN_SPEC_FOCUS_ENTRY_TYPE, focus);
-    currentFocus = focus;
-    pi.events.emit(FOCUS_CHANGED_EVENT, focus);
-  }
-
-  function applyOpenSpecFocusAction(
-    action: OpenSpecFocusAction,
-    change?: string,
-    taskId?: string,
-  ): { ok: boolean; message: string; focus: OpenSpecFocus } {
-    const current = currentFocus;
-    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,
-    };
-  }
-
-  pi.on('tool_call', (event) => {
-    if (event.toolName !== 'taskflow') return;
-    const requested = taskflowRunFocus(event.input);
-
-    if (requested) {
-      if (currentFocus.mode === 'task' && !sameOpenSpecFocus(currentFocus, requested)) {
-        return {
-          block: true,
-          reason:
-            `OpenSpec focus is ${currentFocus.change} › ${currentFocus.taskId}; ` +
-            'clear or replace the OpenSpec focus (explicit Human direction) before starting a conflicting run',
-        };
-      }
-      if (!sameOpenSpecFocus(currentFocus, requested)) {
-        persistAndApplyFocus(requested);
-      }
-    }
-  });
-
-  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,
-        },
-      };
-    },
-  });
-}

package/packages/work-state/package.json

@@ -1,33 +0,0 @@
-{
-  "name": "work-state",
-  "version": "1.0.0",
-  "private": true,
-  "description": "OpenSpec focus entry owner for the pi-stardeck cockpit",
-  "type": "module",
-  "keywords": [
-    "pi-package",
-    "pi-extension",
-    "work-state",
-    "openspec"
-  ],
-  "engines": {
-    "node": ">=22.19.0"
-  },
-  "scripts": {
-    "format": "prettier --write \"**/*.{js,jsx,ts,tsx,mjs,cjs,mts,cts}\" --ignore-path .prettierignore",
-    "format:check": "prettier --check \"**/*.{js,jsx,ts,tsx,mjs,cjs,mts,cts}\" --ignore-path .prettierignore",
-    "typecheck": "tsc --noEmit",
-    "test": "node --test --experimental-strip-types test/*.test.ts",
-    "check": "npm run format:check && npm run typecheck && npm test"
-  },
-  "pi": {
-    "extensions": [
-      "./index.ts"
-    ]
-  },
-  "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
-    "typebox": "*"
-  }
-}

package/packages/work-state/src/focus.ts

@@ -1,100 +0,0 @@
-export const OPEN_SPEC_FOCUS_ENTRY_TYPE = 'galactica-status.openspec-focus.v1';
-
-export type TaskOpenSpecFocus = {
-  mode: 'task';
-  change: string;
-  taskId: string;
-  awaitingValidation: boolean;
-};
-
-export type OpenSpecFocus = { mode: 'none' } | TaskOpenSpecFocus;
-
-export const NO_OPEN_SPEC_FOCUS: OpenSpecFocus = { mode: 'none' };
-
-const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/gu;
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-export function normalizeTitlePart(value: string): string {
-  return value.replace(CONTROL_CHARACTERS, ' ').replace(/\s+/gu, ' ').trim();
-}
-
-function explicitId(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const normalized = normalizeTitlePart(value);
-  return normalized || 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,
-    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, value.awaitingValidation);
-}
-
-export function restoreOpenSpecFocus(entries: readonly unknown[]): OpenSpecFocus {
-  for (let index = entries.length - 1; index >= 0; index -= 1) {
-    const entry = entries[index];
-    if (
-      !isRecord(entry) ||
-      entry.type !== 'custom' ||
-      entry.customType !== OPEN_SPEC_FOCUS_ENTRY_TYPE
-    ) {
-      continue;
-    }
-    const focus = parseOpenSpecFocus(entry.data);
-    if (focus) return focus;
-  }
-  return NO_OPEN_SPEC_FOCUS;
-}
-
-export function taskflowRunFocus(input: unknown): TaskOpenSpecFocus | undefined {
-  if (!isRecord(input) || input.action !== 'run' || !isRecord(input.args)) {
-    return undefined;
-  }
-  const focus = taskFocus(input.args.change, input.args.task);
-  return focus && focus.change !== 'none' && focus.taskId !== 'none'
-    ? focus
-    : undefined;
-}
-
-/** 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' ||
-    (right.mode === 'task' &&
-      left.change === right.change &&
-      left.taskId === right.taskId)
-  );
-}
-
-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)
-  );
-}