@aemonge-dev/pi-stardeck 0.13.0 → 0.14.0

package/package.json

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

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

@@ -163,10 +163,6 @@ function wrapFocus(text: string, width: number, maximumLines: number): string[]
   return lines.slice(0, maximumLines);
 }
 
-function mirrorKey(value: string): string {
-  return value.toLowerCase().replace(/[^a-z0-9]/gu, '');
-}
-
 function bandWrap(
   content: string,
   width: number,
@@ -191,12 +187,10 @@ function titleBandLines(state: HeaderDeckState, width: number, theme: Theme): st
       // moment` — never an empty band while the session talks.
       return bandWrap('— no subject', width, theme, 'dim');
     }
-    // When the subject mirrors the focused change (the gate law's
-    // "subject mirrors its title"), it renders success-green like the
-    // PWD — the mirror visible at a glance.
-    const work = title.work;
-    const mirrorsFocus = work !== null && mirrorKey(subject) === mirrorKey(work.change);
-    return bandWrap(subject, width, theme, mirrorsFocus ? 'success' : 'accent');
+    // Human layout law 2026-11-10: the left band is Human-owned title —
+    // it can never mirror openspec, so the mirror coloring is gone and
+    // the band renders accent unconditionally.
+    return bandWrap(subject, width, theme, 'accent');
   }
   // Pre-title publishers: the legacy selection keeps the band alive.
   const selection = state.header?.selection;

package/packages/pi-stardeck/src/title-state.ts

@@ -41,6 +41,7 @@ const SPAN_ID_MAX = 64;
 const WAIVER_ID_MAX = 64;
 const NOTICE_MAX = 180;
 const ARTIFACTS_MAX = 16;
+const GATE_ACT_MAX = 180;
 const TURN_TOKENS_MAX = 999_999_999;
 const TURN_ELAPSED_MAX = (99 * 60 + 59) * 1_000 + 999;
 
@@ -61,6 +62,8 @@ export type DeckTitleWorkState = {
   awaitingValidation?: boolean;
   focusAt?: number;
   focusStale?: boolean;
+  /** The gate's relayed act line — dim commentary in the optional slot. */
+  gateAct?: string;
 };
 
 export type DeckTitleActivityState = {
@@ -185,6 +188,8 @@ function parseTitleWork(value: unknown): DeckTitleWorkState | null | undefined {
   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 } : {}),
@@ -192,6 +197,7 @@ function parseTitleWork(value: unknown): DeckTitleWorkState | null | undefined {
     ...(value.awaitingValidation === true ? { awaitingValidation: true } : {}),
     ...(focusAt !== undefined ? { focusAt } : {}),
     ...(value.focusStale === true ? { focusStale: true } : {}),
+    ...(gateAct ? { gateAct } : {}),
   };
   return task === undefined ? { change, ...extras } : { change, task, ...extras };
 }
@@ -265,10 +271,13 @@ export function parseDeckTurnCost(value: unknown): DeckTurnCost | null {
 export type DeckWorkSegment = { text: string; color: string; bold?: boolean };
 
 /**
- * The Work label as colored segments — the truthful, de-duplicated tile:
- * `execute 4/4 › 󰄱 12/15` — current artifact + artifact progress + the
- * current artifact's file-truth item count. The change name lives on the
- * subject side and never repeats here. Attention is derived, never authored:
+ * The Work label as colored segments — the truthful, de-duplicated tile
+ * under the layout law (truthful-rendered-state 2026-11-10):
+ * `<slug> › <artifact> <done/total> › gate: <act> › 󰄱 <items>` — the
+ * slug leads because openspec identity renders exclusively on the right
+ * (the left band is Human-owned title), then current artifact + artifact
+ * progress, the gate's relayed act dim in the optional slot, and the
+ * current artifact's file-truth item count. Attention is derived, never authored:
  * `⏸ awaiting you` (warning) replaces the whole tile; a stale focus fact
  * (`⚠ focus <age> old`, dim, humanized at render time) replaces the artifact
  * group. Unknown facts drop their segments — absent items never render as
@@ -284,10 +293,15 @@ export function deckWorkSegments(
   if (work.awaitingValidation) {
     return compact ? [] : [{ text: '⏸ awaiting you', color: 'warning' }];
   }
-  const segments: DeckWorkSegment[] = [];
+  // The slug leads the right side — openspec identity renders exclusively
+  // here (Human layout law 2026-11-10); the left band is Human-owned.
+  const segments: DeckWorkSegment[] = [
+    { text: work.change, color: 'success', bold: true },
+  ];
   const stale = work.focusStale === true && work.focusAt !== undefined;
   if (!compact) {
     if (stale) {
+      segments.push({ text: ' › ', color: 'accent' });
       segments.push({
         text: `⚠ focus ${compactActivityAge(Math.max(0, now - (work.focusAt ?? 0)))} old`,
         color: 'dim',
@@ -307,12 +321,23 @@ export function deckWorkSegments(
         // One hue per state: success only when the artifacts are done AND
         // the current artifact's items are settled — otherwise work is open.
         const complete = done === artifacts.length && itemsSettled;
-        segments.push({
-          text: `${current} ${done}/${artifacts.length}`,
-          color: complete ? 'success' : 'accent',
-        });
+        segments.push(
+          { text: ' › ', color: 'accent' },
+          {
+            text: `${current} ${done}/${artifacts.length}`,
+            color: complete ? 'success' : 'accent',
+          },
+        );
       }
     }
+    // The {optional} slot: the gate's relayed act — dim commentary that
+    // yields first on narrow frames.
+    if (work.gateAct) {
+      segments.push(
+        { text: ' › ', color: 'accent' },
+        { text: `gate: ${work.gateAct}`, color: 'dim' },
+      );
+    }
   }
   const items = work.currentArtifact
     ? work.artifacts?.find((artifact) => artifact.id === work.currentArtifact)?.items

package/packages/status/index.ts

@@ -17,6 +17,7 @@ import {
 } from './src/active-work.ts';
 import { collectDiagnostics } from './src/diagnostics.ts';
 import { loadConfig } from './src/config.ts';
+import { resolveGateAct } from './src/gate-act.ts';
 import { collectOpenSpec, collectOpenSpecOverview } from './src/openspec.ts';
 import { collectOrchestration } from './src/orchestration.ts';
 import {
@@ -175,6 +176,10 @@ class GalacticaStatusRuntime {
    *  construction, refreshed on every accepted focus change; staleness
    *  compares it against the change directory's file truth. */
   private focusAt: number | undefined;
+  /** The gate's relayed act line for the focused change — commentary
+   *  beside the declared focus, never a replacement; cleared whenever
+   *  the focus moves so stale gate truth never survives a switch. */
+  private gateAct: { change: string; line?: string } | undefined;
   private subject: SessionSubject;
   private sessionName: string | undefined;
   private diagnosticsPath: string | undefined;
@@ -459,6 +464,19 @@ class GalacticaStatusRuntime {
     ) {
       return;
     }
+    // The gate act is focus-owned commentary: resolved only for a task
+    // focus inside an OpenSpec project, after the commit guard, so a
+    // superseded refresh never spends a probe on stale truth.
+    if (focus.mode === 'task' && hasOpenSpecProject) {
+      this.gateAct = {
+        change: focus.change,
+        line: await resolveGateAct({
+          change: focus.change,
+          projectRoot,
+          runner: this.runner,
+        }),
+      };
+    }
     const previous = this.store.get();
     this.updateRefreshHealth(
       'openspec',
@@ -633,23 +651,15 @@ class GalacticaStatusRuntime {
 
   private currentTitleState(snapshot = this.store.get()): TitleState {
     const facts = this.cockpitFacts;
-    const focusedTaskId =
-      facts.openSpec.mode === 'task' ? facts.openSpec.taskId : undefined;
-    const taskTitle =
-      facts.openSpec.mode === 'task' &&
-      snapshot.openspec?.changeId === facts.openSpec.change &&
-      !snapshot.openspec.meta.stale
-        ? (snapshot.openspec.allTasks ?? snapshot.openspec.pendingTasks).find(
-            (task) => task.id === focusedTaskId,
-          )?.title
+    // The left title is Human-owned — session name, subject, directory —
+    // never openspec text (truthful-rendered-state law 2026-11-10); the
+    // gate act rides the work slot for the right-side tile.
+    const gateAct =
+      facts.openSpec.mode === 'task' && this.gateAct?.change === facts.openSpec.change
+        ? this.gateAct.line
         : undefined;
-    // 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,
       subject: facts.subject,
-      ...(taskTitle ? { taskTitle } : {}),
       ...(this.sessionName ? { sessionName: this.sessionName } : {}),
       projectRoot: snapshot.projectRoot,
       cwd: snapshot.cwd,
@@ -660,6 +670,7 @@ class GalacticaStatusRuntime {
       openspec: snapshot.openspec,
       activity: this.titleActivity.current(),
       focusAt: this.focusAt,
+      ...(gateAct ? { gateAct } : {}),
     });
   }
 
@@ -697,6 +708,9 @@ class GalacticaStatusRuntime {
     if (sameOpenSpecFocus(this.focus, focus)) return;
     this.focus = focus;
     this.focusAt = Date.now();
+    if (focus.mode !== 'task' || this.gateAct?.change !== focus.change) {
+      this.gateAct = undefined;
+    }
     this.recordEvent({ type: 'focus/openspec', at: Date.now(), focus });
     this.store.clearOpenSpec();
     if (focus.mode === 'task' && focus.awaitingValidation) {

package/packages/status/src/active-work.ts

@@ -20,7 +20,6 @@ export const NO_SESSION_SUBJECT: SessionSubject = { state: 'clear' };
 
 const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/gu;
 const MAX_TITLE_POINTS = 180;
-const MAX_TASK_TITLE_POINTS = 72;
 const MAX_SUBJECT_POINTS = 120;
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -160,34 +159,26 @@ export function sameSessionSubject(
   );
 }
 
+/**
+ * The Human-owned left title: session name, subject, then the directory
+ * fallbacks. Layout law 2026-11-10 (truthful-rendered-state): openspec
+ * identity renders exclusively on the right work tile — this chain never
+ * carries change, task, or gate text.
+ */
 export function formatActiveWorkTitle(options: {
-  focus: OpenSpecFocus;
   subject?: SessionSubject;
-  taskTitle?: string;
   sessionName?: string;
   projectRoot?: string;
   cwd: string;
 }): string {
-  let detail: string;
-  if (options.focus.mode === 'task') {
-    const taskTitle = options.taskTitle
-      ? shorten(normalizeTitlePart(options.taskTitle), MAX_TASK_TITLE_POINTS)
-      : '';
-    detail = `${options.focus.change} › ${options.focus.taskId}${taskTitle ? ` ${taskTitle}` : ''}`;
-  } else if (normalizeTitlePart(options.sessionName ?? '')) {
-    detail = normalizeTitlePart(options.sessionName ?? '');
-  } else if (options.subject && options.subject.state === 'set') {
-    detail = options.subject.title;
-  } else {
-    detail =
-      normalizeTitlePart(options.sessionName ?? '') ||
-      normalizeTitlePart(basename(options.projectRoot ?? '')) ||
-      normalizeTitlePart(basename(options.cwd)) ||
-      'pi';
-  }
-
-  // Bare text — line 2 carries no chrome (frozen amendment): the session
-  // name, change, and task stand naked, and pi-title's naming is quoted,
-  // never re-decorated.
-  return shorten(normalizeTitlePart(detail), MAX_TITLE_POINTS);
+  const detail =
+    normalizeTitlePart(options.sessionName ?? '') ||
+    (options.subject && options.subject.state === 'set' ? options.subject.title : '') ||
+    normalizeTitlePart(basename(options.projectRoot ?? '')) ||
+    normalizeTitlePart(basename(options.cwd)) ||
+    'pi';
+
+  // Bare text — line 2 carries no chrome (frozen amendment): the title
+  // stands naked, and pi-title's naming is quoted, never re-decorated.
+  return shorten(detail, MAX_TITLE_POINTS);
 }

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

@@ -0,0 +1,85 @@
+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/status/src/openspec.ts

@@ -517,7 +517,6 @@ export async function collectOpenSpec(options: {
 
   let tasks: OpenSpecTask[] = [];
   let tasksPath: string | undefined;
-  let instructionProgress: ApplyInstructionsResult['progress'];
   let hierarchy: OpenSpecHierarchyProgress | undefined;
   try {
     const instructions = parseApplyInstructions(
@@ -530,7 +529,6 @@ export async function collectOpenSpec(options: {
     );
     tasks = instructions.tasks;
     tasksPath = instructions.tasksPath;
-    instructionProgress = instructions.progress;
 
     if (tasksPath) {
       try {
@@ -552,28 +550,38 @@ export async function collectOpenSpec(options: {
   // tile at 0/N (simplify-deck-defaults). CLI progress and list counts
   // remain fallbacks; the blocked-apply zero-guard stays for the
   // no-tasks case.
+  // File-truth ladder: checkbox tasks first, then done/total artifacts
+  // (file presence via `openspec status`) — CLI task opinion cannot count
+  // custom schemas and pins 0/N (truthful-rendered-state). With neither
+  // readable, counts stay absent — absence never becomes zero.
+  const artifactCounts = artifacts
+    ? {
+        done: artifacts.filter((artifact) => artifact.done).length,
+        total: artifacts.length,
+      }
+    : undefined;
   const completedTasks =
-    tasks.length > 0
-      ? tasks.filter((task) => task.done).length
-      : Math.max(0, Math.trunc(instructionProgress?.complete ?? change.completedTasks));
-  const totalTasks =
-    tasks.length > 0
-      ? tasks.length
-      : Math.max(0, Math.trunc(instructionProgress?.total ?? change.totalTasks));
+    tasks.length > 0 ? tasks.filter((task) => task.done).length : artifactCounts?.done;
+  const totalTasks = tasks.length > 0 ? tasks.length : artifactCounts?.total;
   const complete =
-    change.status === 'complete' || (totalTasks > 0 && completedTasks >= totalTasks);
+    change.status === 'complete' ||
+    (totalTasks !== undefined && totalTasks > 0 && (completedTasks ?? 0) >= totalTasks);
 
   return {
     projectRoot,
     changeId: change.name,
     title,
     phase: complete ? 'complete' : change.status,
-    completedTasks,
-    totalTasks,
-    progressPercent:
-      totalTasks > 0
-        ? Math.max(0, Math.min(100, Math.round((completedTasks / totalTasks) * 100)))
-        : 0,
+    ...(completedTasks !== undefined ? { completedTasks } : {}),
+    ...(totalTasks !== undefined ? { totalTasks } : {}),
+    ...(totalTasks !== undefined && totalTasks > 0
+      ? {
+          progressPercent: Math.max(
+            0,
+            Math.min(100, Math.round(((completedTasks ?? 0) / totalTasks) * 100)),
+          ),
+        }
+      : {}),
     pendingTasks: tasks.filter((task) => !task.done),
     allTasks: tasks,
     ...(tasksPath ? { tasksPath } : {}),

package/packages/status/src/publisher.ts

@@ -99,7 +99,13 @@ export function formatOpenSpec(
   focusedTaskId: string | null,
   compact = false,
 ): string {
-  const progress = `${state.completedTasks}/${state.totalTasks}`;
+  // File-truth counts only — absent counts render no progress prefix at
+  // all (absence never becomes zero, truthful-rendered-state).
+  const progress =
+    state.totalTasks !== undefined
+      ? `${state.completedTasks ?? 0}/${state.totalTasks}`
+      : '';
+  const lead = progress ? `${progress}  ` : '';
   const title = compact
     ? compactChangeTitle(state.title, 26)
     : normalizeChangeTitle(state.title);
@@ -107,16 +113,16 @@ export function formatOpenSpec(
     ? `  stale ${ageText(state.meta.updatedAt, Date.now()) ?? ''}`.trimEnd()
     : '';
 
-  if (state.phase === 'complete') return `${progress}  ${title}${stale}`;
+  if (state.phase === 'complete') return `${lead}${title}${stale}`;
 
   const activeTask = focusedTaskId
     ? (state.allTasks ?? state.pendingTasks).find((task) => task.id === focusedTaskId)
     : undefined;
   if (activeTask) {
-    return `${progress}  ▶ ${focusedTaskText(activeTask, compact)}${stale}`;
+    return `${lead}▶ ${focusedTaskText(activeTask, compact)}${stale}`;
   }
 
-  return `${progress}  ${title}${stale}`;
+  return `${lead}${title}${stale}`;
 }
 
 function diagnosticsColor(state: DiagnosticsState, now: number): WidgetColor {
@@ -917,16 +923,19 @@ export function buildHeaderStatusEvent(
       ...projectedActivity,
     };
   }
-  const progress = options.openSpec?.totalTasks
-    ? [
-        {
-          icon: '󰘬',
-          completed: options.openSpec.completedTasks,
-          total: options.openSpec.totalTasks,
-          color: openSpecColor(options.openSpec),
-        },
-      ]
-    : [];
+  const openSpec = options.openSpec;
+  const progress =
+    typeof openSpec?.totalTasks === 'number' &&
+    typeof openSpec.completedTasks === 'number'
+      ? [
+          {
+            icon: '󰘬',
+            completed: openSpec.completedTasks,
+            total: openSpec.totalTasks,
+            color: openSpecColor(openSpec),
+          },
+        ]
+      : [];
 
   return {
     protocol: 1,

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

@@ -38,6 +38,7 @@ 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;
@@ -56,6 +57,8 @@ export type TitleWorkState = {
   awaitingValidation?: boolean;
   focusAt?: number;
   focusStale?: boolean;
+  /** The gate's relayed act line — dim commentary in the optional slot. */
+  gateAct?: string;
 };
 
 export type TitleActivityState = {
@@ -177,6 +180,8 @@ function parseTitleWork(value: unknown): TitleWorkState | null | undefined {
   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 } : {}),
@@ -184,6 +189,7 @@ function parseTitleWork(value: unknown): TitleWorkState | null | undefined {
     ...(value.awaitingValidation === true ? { awaitingValidation: true } : {}),
     ...(focusAt !== undefined ? { focusAt } : {}),
     ...(value.focusStale === true ? { focusStale: true } : {}),
+    ...(gateAct ? { gateAct } : {}),
   };
   return task === undefined ? { change, ...extras } : { change, task, ...extras };
 }
@@ -242,7 +248,7 @@ export function shortenTitleTarget(value: string): string {
 export function deriveTitleWork(
   focus: OpenSpecFocus,
   openspec: OpenSpecState | null | undefined,
-  options: { focusAt?: number } = {},
+  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.
@@ -267,10 +273,15 @@ export function deriveTitleWork(
       ...(focus.awaitingValidation ? { awaitingValidation: true } : {}),
       ...(options.focusAt !== undefined ? { focusAt: options.focusAt } : {}),
       ...(stale ? { focusStale: true } : {}),
+      ...(options.gateAct ? { gateAct: options.gateAct } : {}),
     };
   }
   if (!openspec) return null;
-  return { change: openspec.changeId, ...extras(openspec) };
+  return {
+    change: openspec.changeId,
+    ...extras(openspec),
+    ...(options.gateAct ? { gateAct: options.gateAct } : {}),
+  };
 }
 
 /**
@@ -285,12 +296,15 @@ export function buildTitleState(options: {
   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 } : {}),
     }),
     activity: options.activity ?? null,
     waiver: null,

package/packages/status/src/types.ts

@@ -91,9 +91,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;