@aemonge-dev/pi-stardeck 0.14.0 → 0.15.0

package/packages/status/src/publisher.ts

@@ -23,7 +23,6 @@ export const GALACTICA_HEADER_CHANNEL = 'galactica-status:header';
 
 const OPEN_SPEC_WIDGET_ID = 'galactica.openspec';
 const OPEN_SPEC_SCOPE_SEPARATOR_WIDGET_ID = 'galactica.openspec-scope-separator';
-const OPEN_SPEC_PROGRESS_WIDGET_ID = 'galactica.openspec-progress';
 const DIAGNOSTICS_WIDGET_ID = 'galactica.diagnostics';
 const ORCHESTRATION_WIDGET_ID = 'galactica.orchestration';
 
@@ -48,17 +47,6 @@ function compactChangeTitle(title: string, maximum: number): string {
   return shorten(normalizeChangeTitle(title), maximum);
 }
 
-function focusedTaskText(
-  task: { id: string; title: string },
-  compact: boolean,
-): string {
-  const title = normalizeInline(task.title);
-  const step = title.match(/^(?:Step|Task)\s+(\d+(?:\.\d+)*)(?:[.:])?\s+(.+)$/iu);
-  const id = step?.[1] ?? task.id;
-  const body = step?.[2] ?? title;
-  return `${id} ${compact ? shorten(body, 14) : body}`;
-}
-
 function formatDuration(ms: number | undefined): string | undefined {
   if (ms === undefined || ms < 0) return undefined;
   if (ms < 60_000) return `${Math.max(1, Math.round(ms / 1_000))}s`;
@@ -94,11 +82,7 @@ export function formatOpenSpecOverview(overview: OpenSpecOverview): string {
   );
 }
 
-export function formatOpenSpec(
-  state: OpenSpecState,
-  focusedTaskId: string | null,
-  compact = false,
-): string {
+export function formatOpenSpec(state: OpenSpecState, compact = false): string {
   // File-truth counts only — absent counts render no progress prefix at
   // all (absence never becomes zero, truthful-rendered-state).
   const progress =
@@ -115,13 +99,6 @@ export function formatOpenSpec(
 
   if (state.phase === 'complete') return `${lead}${title}${stale}`;
 
-  const activeTask = focusedTaskId
-    ? (state.allTasks ?? state.pendingTasks).find((task) => task.id === focusedTaskId)
-    : undefined;
-  if (activeTask) {
-    return `${lead}▶ ${focusedTaskText(activeTask, compact)}${stale}`;
-  }
-
   return `${lead}${title}${stale}`;
 }
 
@@ -203,7 +180,6 @@ export function buildWidgetSnapshots(
   options: {
     compact?: boolean;
     now?: number;
-    focusedTaskId?: string;
     openSpecFeedback?: OpenSpecFeedback;
     openSpecOverview?: OpenSpecOverview;
     openSpecProjectDetected?: boolean;
@@ -212,7 +188,6 @@ export function buildWidgetSnapshots(
   const compact = options.compact ?? false;
   const now = options.now ?? Date.now();
   const widgets: FancyFooterWidget[] = [];
-
   if (options.openSpecOverview || options.openSpecProjectDetected === false) {
     widgets.push({
       id: OPEN_SPEC_SCOPE_SEPARATOR_WIDGET_ID,
@@ -231,29 +206,8 @@ export function buildWidgetSnapshots(
     });
   }
 
-  if (options.openSpecOverview && options.focusedTaskId) {
-    const overview = options.openSpecOverview;
-    const complete =
-      overview.totalPlans > 0 &&
-      overview.completedPlans >= overview.totalPlans &&
-      (overview.totalTasks === 0 || overview.completedTasks >= overview.totalTasks);
-    const color: WidgetColor =
-      overview.totalPlans === 0 ? 'dim' : complete ? 'success' : 'accent';
-    widgets.push({
-      id: OPEN_SPEC_PROGRESS_WIDGET_ID,
-      label: 'OpenSpec progress',
-      description: 'Aggregate completion across OpenSpec Plans and their Tasks',
-      content: { type: 'text', text: formatOpenSpecOverview(overview) },
-      icon: {
-        glyphs: { nerd: '', emoji: '📋', unicode: '▤', ascii: 'P' },
-        color,
-      },
-      style: { textColor: color },
-      layout: { row: 0, position: 0, align: 'right', fill: 'none', minWidth: 8 },
-    });
-  }
-  // Frozen contract: without an OpenSpec focus there is no progress surface —
-  // no aggregate overview, no 'no OpenSpec' narration.
+  // Frozen contract: without a task focus there is no aggregate progress
+  // surface — no overview widget, no 'no OpenSpec' narration.
 
   if (!snapshot.openspec && options.openSpecFeedback) {
     const unavailable = options.openSpecFeedback === 'unavailable';
@@ -303,7 +257,7 @@ export function buildWidgetSnapshots(
       description: 'Focused OpenSpec change, task progress, and pending work',
       content: {
         type: 'text',
-        text: formatOpenSpec(snapshot.openspec, options.focusedTaskId ?? null, compact),
+        text: formatOpenSpec(snapshot.openspec, compact),
       },
       icon: {
         glyphs: {
@@ -477,34 +431,18 @@ export type HeaderStatusEvent = {
   progress: { icon: string; completed: number; total: number; color: WidgetColor }[];
 };
 
-function narrativeTaskTitle(title: string): string {
-  return normalizeInline(title).replace(
-    /^(?:Step|Task)\s+\d+(?:\.\d+)*(?:[.:])?\s+/iu,
-    '',
-  );
-}
-
-function selectedOpenSpecTitles(
-  state: OpenSpecState,
-  focusedTaskId: string | undefined,
-): string[] {
-  const activeTask = focusedTaskId
-    ? (state.allTasks ?? state.pendingTasks).find((task) => task.id === focusedTaskId)
-    : undefined;
-  return activeTask
-    ? [normalizeInline(state.title), narrativeTaskTitle(activeTask.title)]
-    : [normalizeInline(state.changeId), normalizeInline(focusedTaskId ?? 'no focus')];
+function selectedOpenSpecTitles(state: OpenSpecState): string[] {
+  return [normalizeInline(state.changeId)];
 }
 
 export function headerSelection(options: {
   openSpec?: OpenSpecState | null;
-  focusedTaskId?: string;
   subject?: SessionSubject;
 }): HeaderSelection | null {
   if (options.openSpec) {
     return {
       source: 'openspec',
-      titles: selectedOpenSpecTitles(options.openSpec, options.focusedTaskId),
+      titles: selectedOpenSpecTitles(options.openSpec),
       color: openSpecColor(options.openSpec),
     };
   }
@@ -827,7 +765,6 @@ export function buildHeaderStatusEvent(
   widgets: readonly FancyFooterWidget[],
   options: {
     openSpec?: OpenSpecState | null;
-    focusedTaskId?: string;
     subject?: SessionSubject;
     orchestration?: OrchestrationState | null;
     lifecycle?: HeaderLifecycle;
@@ -899,7 +836,7 @@ export function buildHeaderStatusEvent(
     const state = options.openSpec;
     work = {
       lifecycle,
-      titles: selectedOpenSpecTitles(state, options.focusedTaskId),
+      titles: selectedOpenSpecTitles(state),
       color: openSpecColor(state),
       ...projectedActivity,
     };
@@ -979,13 +916,6 @@ export function buildHeaderStatusEvent(
       ...(options.openSpec?.hierarchy
         ? { tasks: options.openSpec.hierarchy.tasks }
         : {}),
-      ...(options.openSpec?.hierarchy &&
-      options.focusedTaskId &&
-      options.openSpec.hierarchy.stepsByTask[options.focusedTaskId]
-        ? {
-            steps: options.openSpec.hierarchy.stepsByTask[options.focusedTaskId],
-          }
-        : {}),
       ...(orchestration?.completedFiles === undefined ||
       orchestration.totalFiles === undefined
         ? {}

package/packages/status/src/reducer.ts

@@ -1,5 +1,5 @@
 import type { LedgerEvent } from './ledger.ts';
-import type { OpenSpecFocus, SessionSubject } from './active-work.ts';
+import type { SessionSubject } from './active-work.ts';
 import type {
   CockpitSnapshot,
   ProgressFact,
@@ -18,7 +18,6 @@ import type {
  */
 
 export type ReducerFacts = {
-  openSpec: OpenSpecFocus;
   subject: SessionSubject;
   runs: ReadonlyMap<string, RunSpan>;
   progress: ProgressFact | null;
@@ -28,7 +27,6 @@ export const NO_SELECTION: SelectionState = { kind: 'none' };
 
 export function emptyFacts(): ReducerFacts {
   return {
-    openSpec: { mode: 'none' },
     subject: { state: 'clear' },
     runs: new Map(),
     progress: null,
@@ -36,17 +34,7 @@ export function emptyFacts(): ReducerFacts {
 }
 
 /** The single selection resolver. Priority order is contract-frozen. */
-export function resolveSelection(facts: {
-  openSpec: OpenSpecFocus;
-  subject: SessionSubject;
-}): SelectionState {
-  if (facts.openSpec.mode === 'task') {
-    return {
-      kind: 'openspec-task',
-      change: facts.openSpec.change,
-      task: facts.openSpec.taskId,
-    };
-  }
+export function resolveSelection(facts: { subject: SessionSubject }): SelectionState {
   if (facts.subject.state === 'set') {
     return { kind: 'subject', title: facts.subject.title };
   }
@@ -61,8 +49,6 @@ function applyStageRule(span: RunSpan, stage: StageValue, declared: boolean): Ru
 
 export function applyEvent(facts: ReducerFacts, event: LedgerEvent): ReducerFacts {
   switch (event.type) {
-    case 'focus/openspec':
-      return { ...facts, openSpec: event.focus };
     case 'focus/subject':
       return { ...facts, subject: event.subject };
     case 'run/start': {
@@ -129,23 +115,3 @@ export function rootRun(snapshot: CockpitSnapshot): RunSpan | undefined {
 export function derivedStage(snapshot: CockpitSnapshot): StageValue {
   return rootRun(snapshot)?.stage ?? 'listening';
 }
-
-/**
- * Derived terminal title. `title = f(selection, stage, progress)` — never stored,
- * never updated independently, never a placeholder.
- */
-export function deriveTitle(snapshot: CockpitSnapshot): string {
-  const selection = snapshot.selection;
-  let detail: string;
-  switch (selection.kind) {
-    case 'openspec-task':
-      detail = `${selection.change} › ${selection.task}`;
-      break;
-    case 'subject':
-      detail = selection.title;
-      break;
-    default:
-      detail = '';
-  }
-  return detail ? `π ${detail}` : 'π';
-}

package/packages/status/src/room-aim.ts

@@ -0,0 +1,151 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+/**
+ * The room aim — `openspec/.focus`, the Human's standing word for the
+ * room. Render law (observe-room-aim 2026-11-11): the deck reads it
+ * as-is and prints it as-is — a printer, not a translator. Five flat
+ * YAML fields; a missing field drops its segment and the separator that
+ * led it; absence never becomes zero; `change` is the keystone — no
+ * change, no aim.
+ */
+export type RoomAim = {
+  change: string;
+  artifactName?: string;
+  artifactIdx?: string;
+  task?: string;
+  nextStep?: string;
+  /** The aim file's mtime — cache key only, never rendered. */
+  mtimeMs: number;
+};
+
+const CHANGE_MAX = 120;
+const ARTIFACT_NAME_MAX = 120;
+const COUNT_MAX = 32;
+const NEXT_STEP_MAX = 180;
+const WALK_LIMIT = 40;
+const ABSENT_TTL_MS = 30_000;
+const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/gu;
+
+const AIM_FIELDS = new Set([
+  'change',
+  'artifact-name',
+  'artifact-idx',
+  'task',
+  'next-step',
+]);
+
+/** Collapse control characters to spaces and trim — the one cleanliness a
+ * terminal printer owes; honest content passes untouched. A symmetric
+ * YAML quote pair is syntax, not content: `"…"` and '…' unwrap before the
+ * emptiness check, so `task: ""` drops its segment like any missing
+ * field. */
+function printable(value: string): string {
+  const text = value.replace(CONTROL_CHARACTERS, ' ').trim();
+  if (
+    text.length >= 2 &&
+    ((text.startsWith('"') && text.endsWith('"')) ||
+      (text.startsWith("'") && text.endsWith("'")))
+  ) {
+    return text.slice(1, -1).trim();
+  }
+  return text;
+}
+
+/** Over-bound or empty values drop their field — absence, never a
+ * mid-token ellipsis; the Human re-aims rather than the deck inventing. */
+function field(value: string | undefined, maximum: number): string | undefined {
+  if (value === undefined) return undefined;
+  const text = printable(value);
+  if (text.length === 0 || Array.from(text).length > maximum) return undefined;
+  return text;
+}
+
+/**
+ * Parse the aim text into its five fields. Garbage lines are ignored;
+ * duplicate keys — last one wins; empty or comment-only values count as
+ * missing. An aim without `change` is not an aim.
+ */
+export function parseRoomAim(text: string, mtimeMs: number): RoomAim | undefined {
+  const values = new Map<string, string>();
+  for (const line of text.split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith('#')) continue;
+    const colon = trimmed.indexOf(':');
+    if (colon <= 0) continue;
+    const key = trimmed.slice(0, colon).trim();
+    if (!AIM_FIELDS.has(key)) continue;
+    values.set(key, trimmed.slice(colon + 1).trim());
+  }
+  const change = field(values.get('change'), CHANGE_MAX);
+  if (!change) return undefined;
+  const artifactName = field(values.get('artifact-name'), ARTIFACT_NAME_MAX);
+  const artifactIdx = field(values.get('artifact-idx'), COUNT_MAX);
+  const task = field(values.get('task'), COUNT_MAX);
+  const nextStep = field(values.get('next-step'), NEXT_STEP_MAX);
+  return {
+    change,
+    ...(artifactName ? { artifactName } : {}),
+    ...(artifactIdx ? { artifactIdx } : {}),
+    ...(task ? { task } : {}),
+    ...(nextStep ? { nextStep } : {}),
+    mtimeMs,
+  };
+}
+
+function findOpenspecRoot(cwd: string): string | undefined {
+  let dir = resolve(cwd);
+  for (let step = 0; step < WALK_LIMIT; step += 1) {
+    if (existsSync(join(dir, 'openspec'))) return join(dir, 'openspec');
+    const parent = dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+  return undefined;
+}
+
+type Cache =
+  | { path: string; mtimeMs: number; aim: RoomAim | undefined }
+  | { path: string; absentAt: number };
+
+let cache: Cache | undefined;
+
+/**
+ * Read the room aim for `cwd`. One `stat` per refresh — the file is only
+ * re-read when the mtime moves; an absent file is remembered for
+ * ABSENT_TTL_MS so a missing aim costs no per-render stat storm.
+ */
+export function readRoomAim(
+  cwd: string,
+  now: number = Date.now(),
+): RoomAim | undefined {
+  const root = findOpenspecRoot(cwd);
+  if (!root) return undefined;
+  const file = join(root, '.focus');
+  let mtimeMs: number;
+  try {
+    mtimeMs = statSync(file).mtimeMs;
+  } catch {
+    if (
+      cache &&
+      'absentAt' in cache &&
+      cache.path === file &&
+      now - cache.absentAt < ABSENT_TTL_MS
+    ) {
+      return undefined;
+    }
+    cache = { path: file, absentAt: now };
+    return undefined;
+  }
+  if (cache && 'aim' in cache && cache.path === file && cache.mtimeMs === mtimeMs) {
+    return cache.aim;
+  }
+  let aim: RoomAim | undefined;
+  try {
+    aim = parseRoomAim(readFileSync(file, 'utf8'), mtimeMs);
+  } catch {
+    aim = undefined;
+  }
+  cache = { path: file, mtimeMs, aim };
+  return aim;
+}

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,37 +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;
-const GATE_ACT_MAX = 180;
-
-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;
-  /** The gate's relayed act line — dim commentary in the optional slot. */
-  gateAct?: string;
+  nextStep?: string;
 };
 
 export type TitleActivityState = {
@@ -95,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;
@@ -129,69 +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 gateAct = boundedText(value.gateAct, GATE_ACT_MAX, { required: false });
-  if (gateAct === null) return undefined;
-  const extras = {
-    ...(schemaName ? { schemaName } : {}),
-    ...(artifacts ? { artifacts } : {}),
-    ...(currentArtifact ? { currentArtifact } : {}),
-    ...(value.awaitingValidation === true ? { awaitingValidation: true } : {}),
-    ...(focusAt !== undefined ? { focusAt } : {}),
-    ...(value.focusStale === true ? { focusStale: true } : {}),
-    ...(gateAct ? { gateAct } : {}),
+  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 {
@@ -205,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 {
@@ -240,72 +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; gateAct?: string } = {},
-): 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 } : {}),
-    };
-  };
-  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 } : {}),
-      ...(options.gateAct ? { gateAct: options.gateAct } : {}),
-    };
-  }
-  if (!openspec) return null;
+export function aimTitleWork(aim: RoomAim): TitleWorkState {
   return {
-    change: openspec.changeId,
-    ...extras(openspec),
-    ...(options.gateAct ? { gateAct: options.gateAct } : {}),
+    change: aim.change,
+    ...(aim.artifactName ? { artifactName: aim.artifactName } : {}),
+    ...(aim.artifactIdx ? { artifactIdx: aim.artifactIdx } : {}),
+    ...(aim.task ? { task: aim.task } : {}),
+    ...(aim.nextStep ? { nextStep: aim.nextStep } : {}),
   };
 }
 
 /**
- * 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;
-  /** The gate's relayed act line for the focused change, if resolved. */
-  gateAct?: string;
 }): TitleState {
   return {
     v: TITLE_STATE_VERSION,
     subject: options.subject.state === 'set' ? options.subject.title : null,
-    work: deriveTitleWork(options.focus, options.openspec, {
-      focusAt: options.focusAt,
-      ...(options.gateAct ? { gateAct: options.gateAct } : {}),
-    }),
+    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;
@@ -208,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;