@aemonge-dev/pi-stardeck 0.13.0 → 0.15.0

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

@@ -1,13 +1,13 @@
-import type { OpenSpecFocus, SessionSubject } from './active-work.ts';
-import type { OpenSpecState } from './types.ts';
+import type { SessionSubject } from './active-work.ts';
+import type { RoomAim } from './room-aim.ts';
 
 /**
- * Title-state contract v1 (`deck-title-state`).
+ * Title-state contract v2 (`deck-title-state`).
  *
  * One authoritative object for the deck's upper half: `subject` is authored
- * once, `work` is derived from OpenSpec focus, `activity` is observed from
- * tool executions, and `waiver` suppresses one exact notice text. Rendering
- * code may never write any slot; it only parses defensively.
+ * once, `work` is the room aim's verbatim fields, `activity` is observed
+ * from tool executions, and `waiver` suppresses one exact notice text.
+ * Rendering code may never write any slot; it only parses defensively.
  */
 
 export const TITLE_STATE_VERSION = 2 as const;
@@ -28,34 +28,21 @@ export type TitleActivityClass = (typeof TITLE_ACTIVITY_CLASSES)[number];
  * 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;
-
 const SUBJECT_MAX = 180;
 const IDENTIFIER_MAX = 120;
 const TASK_ID_MAX = 32;
 const SPAN_ID_MAX = 64;
 const WAIVER_ID_MAX = 64;
 const NOTICE_MAX = 180;
-const ARTIFACTS_MAX = 16;
-
-export type TitleArtifactState = {
-  id: string;
-  done: boolean;
-  items?: { done: number; total: number };
-};
 
 export type TitleWorkState = {
   change: string;
+  /** Room-aim verbatim fields (observe-room-aim render law): printed
+   * as-is — the deck is a printer, not a translator. */
+  artifactName?: string;
+  artifactIdx?: string;
   task?: string;
-  schemaName?: string;
-  artifacts?: TitleArtifactState[];
-  /** 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;
+  nextStep?: string;
 };
 
 export type TitleActivityState = {
@@ -92,15 +79,6 @@ function boundedText(
   return points.join('');
 }
 
-function boundedTotal(value: unknown): number | null {
-  return typeof value === 'number' &&
-    Number.isInteger(value) &&
-    value >= 0 &&
-    value <= TITLE_TOTAL_MAX
-    ? value
-    : null;
-}
-
 function parseTitleActivity(value: unknown): TitleActivityState | null | undefined {
   if (value === null) return null;
   if (!isRecord(value)) return undefined;
@@ -126,66 +104,25 @@ function parseTitleWork(value: unknown): TitleWorkState | null | undefined {
   if (!isRecord(value)) return undefined;
   const change = boundedText(value.change, IDENTIFIER_MAX);
   if (!change) return undefined;
-  const task = boundedText(value.task, TASK_ID_MAX, { required: false });
-  if (task === null) return undefined;
-  const schemaName = boundedText(value.schemaName, IDENTIFIER_MAX, {
+  const artifactName = boundedText(value.artifactName, IDENTIFIER_MAX, {
     required: false,
   });
-  if (schemaName === null) return undefined;
-  const currentArtifact = boundedText(value.currentArtifact, TASK_ID_MAX, {
+  if (artifactName === null) return undefined;
+  const artifactIdx = boundedText(value.artifactIdx, TASK_ID_MAX, {
     required: false,
   });
-  if (currentArtifact === null) return undefined;
-  let artifacts: TitleArtifactState[] | undefined;
-  if ('artifacts' in value) {
-    if (!Array.isArray(value.artifacts) || value.artifacts.length > ARTIFACTS_MAX) {
-      return undefined;
-    }
-    const parsed: TitleArtifactState[] = [];
-    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 extras = {
-    ...(schemaName ? { schemaName } : {}),
-    ...(artifacts ? { artifacts } : {}),
-    ...(currentArtifact ? { currentArtifact } : {}),
-    ...(value.awaitingValidation === true ? { awaitingValidation: true } : {}),
-    ...(focusAt !== undefined ? { focusAt } : {}),
-    ...(value.focusStale === true ? { focusStale: true } : {}),
+  if (artifactIdx === null) return undefined;
+  const task = boundedText(value.task, TASK_ID_MAX, { required: false });
+  if (task === null) return undefined;
+  const nextStep = boundedText(value.nextStep, NOTICE_MAX, { required: false });
+  if (nextStep === null) return undefined;
+  return {
+    change,
+    ...(artifactName ? { artifactName } : {}),
+    ...(artifactIdx ? { artifactIdx } : {}),
+    ...(task ? { task } : {}),
+    ...(nextStep ? { nextStep } : {}),
   };
-  return task === undefined ? { change, ...extras } : { change, task, ...extras };
 }
 
 function parseTitleWaiver(value: unknown): TitleWaiverState | null | undefined {
@@ -199,8 +136,8 @@ function parseTitleWaiver(value: unknown): TitleWaiverState | null | undefined {
 
 /**
  * Defensive parser for incoming title-state payloads. Unknown versions,
- * malformed shapes, and out-of-bounds values (target > 120 characters,
- * totals > 999) reject the whole object with `null`; it never throws.
+ * malformed shapes, and out-of-bounds values (target > 120 characters)
+ * reject the whole object with `null`; it never throws.
  */
 export function parseTitleState(value: unknown): TitleState | null {
   try {
@@ -234,64 +171,35 @@ export function shortenTitleTarget(value: string): string {
 }
 
 /**
- * Derive the `work` slot from the OpenSpec focus and the focused snapshot.
- * A task focus owns its change; without a focus a passively collected change
- * still reports artifact facts, just without a task id. Counts live only on
- * artifact `items` — file truth; absent counts are absent, never zeros.
+ * The aimed work slot — the room aim's five fields, verbatim (render
+ * law). `change` is the keystone; every other field drops when missing,
+ * and the deck prints what remains exactly as the file wrote it.
  */
-export function deriveTitleWork(
-  focus: OpenSpecFocus,
-  openspec: OpenSpecState | null | undefined,
-  options: { focusAt?: number } = {},
-): TitleWorkState | null {
-  // Artifact facts come straight from the collector; nothing is invented
-  // here — absent facts simply drop out of the contract.
-  const extras = (state: OpenSpecState | undefined) => {
-    if (!state) return {};
-    return {
-      ...(state.schemaName ? { schemaName: state.schemaName } : {}),
-      ...(state.artifacts ? { artifacts: state.artifacts } : {}),
-      ...(state.currentArtifact ? { currentArtifact: state.currentArtifact } : {}),
-    };
+export function aimTitleWork(aim: RoomAim): TitleWorkState {
+  return {
+    change: aim.change,
+    ...(aim.artifactName ? { artifactName: aim.artifactName } : {}),
+    ...(aim.artifactIdx ? { artifactIdx: aim.artifactIdx } : {}),
+    ...(aim.task ? { task: aim.task } : {}),
+    ...(aim.nextStep ? { nextStep: aim.nextStep } : {}),
   };
-  if (focus.mode === 'task') {
-    const state = openspec && openspec.changeId === focus.change ? openspec : undefined;
-    const stale =
-      options.focusAt !== undefined &&
-      state?.changeModifiedAt !== undefined &&
-      state.changeModifiedAt > options.focusAt;
-    return {
-      change: focus.change,
-      task: focus.taskId,
-      ...extras(state),
-      ...(focus.awaitingValidation ? { awaitingValidation: true } : {}),
-      ...(options.focusAt !== undefined ? { focusAt: options.focusAt } : {}),
-      ...(stale ? { focusStale: true } : {}),
-    };
-  }
-  if (!openspec) return null;
-  return { change: openspec.changeId, ...extras(openspec) };
 }
 
 /**
- * Build the v1 title state from publisher-owned facts: the authored session
- * subject entry, the OpenSpec focus (plus its snapshot), and the newest
- * observed activity event. The waiver slot stays null until the notice slice.
+ * Build the title state from publisher-owned facts: the authored session
+ * subject entry, the room aim's verbatim work fields, and the newest
+ * observed activity event.
  */
 export function buildTitleState(options: {
   subject: SessionSubject;
-  focus: OpenSpecFocus;
-  openspec?: OpenSpecState | null;
+  /** The room aim — when present it owns the work slot outright. */
+  aim?: RoomAim | null;
   activity?: TitleActivityState | null;
-  /** Publisher-owned timestamp of the current focus fact. */
-  focusAt?: number;
 }): TitleState {
   return {
     v: TITLE_STATE_VERSION,
     subject: options.subject.state === 'set' ? options.subject.title : null,
-    work: deriveTitleWork(options.focus, options.openspec, {
-      focusAt: options.focusAt,
-    }),
+    work: options.aim ? aimTitleWork(options.aim) : null,
     activity: options.activity ?? null,
     waiver: null,
   };

package/packages/status/src/types.ts

@@ -21,7 +21,6 @@ export interface GalacticaStatusConfig {
   enabled: boolean;
   openspec: {
     enabled: boolean;
-    change: string | null;
   };
   diagnostics: {
     enabled: boolean;
@@ -91,9 +90,12 @@ export interface OpenSpecState {
   changeId: string;
   title: string;
   phase: string;
-  completedTasks: number;
-  totalTasks: number;
-  progressPercent: number;
+  /** File-truth counts — checkbox tasks first, then done/total
+   *  artifacts. Absent when neither is readable: absence never becomes
+   *  zero (truthful-rendered-state). */
+  completedTasks?: number;
+  totalTasks?: number;
+  progressPercent?: number;
   pendingTasks: OpenSpecTask[];
   allTasks?: OpenSpecTask[];
   tasksPath?: string;
@@ -205,10 +207,7 @@ export type StageValue =
   | 'listening'
   | 'aborted';
 
-export type SelectionState =
-  | { kind: 'openspec-task'; change: string; task: string }
-  | { kind: 'subject'; title: string }
-  | { kind: 'none' };
+export type SelectionState = { kind: 'subject'; title: string } | { kind: 'none' };
 
 export type RunSpan = {
   id: string;

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/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,
-        },
-      };
-    },
-  });
-}