@aemonge-dev/pi-stardeck 0.8.0 → 0.9.1

package/package.json

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

package/packages/footer/index.ts

@@ -1,17 +1,21 @@
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
 
 import { activeQuotaProviders } from './src/quota.ts';
+import { startZaiQuotaProvider } from './src/quota-zai.ts';
 import { FOOTER_TELEMETRY_CHANNEL } from './src/protocol.ts';
 import { buildFooterTelemetryMessage, collectTotalCost } from './src/telemetry.ts';
 
 /**
  * Footer telemetry producer for the pi-stardeck deck. Renders nothing,
- * configures nothing, polls nothing: it walks the session branch for usage
- * cost and publishes deck-consumable snapshots on the footer-telemetry
- * channel after the events that can change them.
+ * configures nothing: it walks the session branch for usage cost and
+ * publishes deck-consumable snapshots on the footer-telemetry channel
+ * after the events that can change them. The z.ai quota provider rides
+ * the same cadence — session start, model change, and its own 5-minute
+ * interval — with snapshots cached between ticks.
  */
 export default function footerTelemetry(pi: ExtensionAPI): void {
   let context: ExtensionContext | undefined;
+  const zai = startZaiQuotaProvider();
 
   const publish = () => {
     if (!context) return;
@@ -24,14 +28,26 @@ export default function footerTelemetry(pi: ExtensionAPI): void {
     );
   };
 
+  // Fire-and-forget refresh then republish: the fetch resolves between
+  // events, and the publish lands the lit gauge without waiting for the
+  // next message.
+  const refreshQuota = () => {
+    void zai.refresh().then(() => publish());
+  };
+
   pi.on('session_start', (_event, ctx) => {
     context = ctx;
+    refreshQuota();
     publish();
   });
   pi.on('message_end', publish);
-  pi.on('model_select', publish);
+  pi.on('model_select', () => {
+    refreshQuota();
+    publish();
+  });
   pi.on('session_compact', publish);
   pi.on('session_shutdown', () => {
     context = undefined;
+    zai.stop();
   });
 }

package/packages/footer/src/protocol.ts

@@ -1,3 +1,5 @@
+import type { QuotaWindow } from './quota.ts';
+
 export const FOOTER_TELEMETRY_PROTOCOL_VERSION = 1 as const;
 
 export const FOOTER_TELEMETRY_CHANNEL = 'pi-stardeck:footer-telemetry/v1';
@@ -7,4 +9,6 @@ export interface FooterTelemetryMessage {
   type: 'snapshot';
   totalCost: number;
   quotaPercent?: number;
+  /** Windowed quota usage (5h/7d); additive, protocol stays 1. */
+  quotaWindows?: QuotaWindow[];
 }

package/packages/footer/src/quota-zai.ts

@@ -0,0 +1,228 @@
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+  registerQuotaProvider,
+  type QuotaSnapshot,
+  type QuotaWindow,
+} from './quota.ts';
+
+/**
+ * z.ai/GLM coding-plan QuotaProvider — the first registration on the
+ * quota seam. Clean-room envelope facts (recovered from git history,
+ * not copied): Bearer-authenticated GET on the quota-limit endpoint,
+ * `{ data: { limits: [...] } }` with usage as `percentage` or
+ * `usage`+`currentValue`, `nextResetTime` in unix seconds, and `TIME*`
+ * limits being the monthly MCP allowance (skipped — the token/credit
+ * pair gates coding sessions).
+ *
+ * Fail-soft contract: no key, unreachable API, or malformed envelope →
+ * `snapshot()` returns `undefined` and the deck stays dark. The last
+ * successful snapshot is cached between ticks so a transient failure
+ * never blanks a lit gauge; at most one debug line per distinct failure
+ * mode.
+ */
+
+const ZAI_QUOTA_ENDPOINT = 'https://api.z.ai/api/monitor/usage/quota/limit';
+const REFRESH_INTERVAL_MS = 5 * 60 * 1000;
+const SECONDS_PER_HOUR = 3600;
+
+export interface ZaiQuotaOptions {
+  /** Injectable for tests; defaults to global fetch. */
+  fetchImpl?: typeof fetch;
+  /** Injectable for tests; defaults to ~/.pi/agent/auth.json. */
+  authPath?: string;
+  /** Injectable for tests; unix seconds. */
+  now?: () => number;
+  /** Debug sink; at most one line per distinct failure mode. */
+  debug?: (message: string) => void;
+}
+
+export interface ZaiQuotaHandle {
+  readonly id: 'zai';
+  refresh(): Promise<void>;
+  stop(): void;
+}
+
+const AUTH_REFERENCE_PATTERN = /^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/;
+
+/**
+ * pi auth convention: a key is either a literal or a `${ENV}` reference.
+ * Unresolvable references yield undefined (fail-soft, no guesses).
+ */
+export function expandAuthReference(value: string): string | undefined {
+  const match = AUTH_REFERENCE_PATTERN.exec(value.trim());
+  if (match === null) return value;
+  const expanded = process.env[match[1]];
+  return typeof expanded === 'string' && expanded.length > 0 ? expanded : undefined;
+}
+
+/** Reads the z.ai key from the pi auth file: `{ zai: { key } }`. */
+export async function readZaiKey(
+  authPath: string,
+  readFileImpl: typeof readFile = readFile,
+): Promise<string | undefined> {
+  let text: string;
+  try {
+    text = await readFileImpl(authPath, 'utf8');
+  } catch {
+    return undefined;
+  }
+  try {
+    const parsed = JSON.parse(text) as { zai?: { key?: unknown } };
+    const key = parsed?.zai?.key;
+    return typeof key === 'string' && key.length > 0
+      ? expandAuthReference(key)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+interface ZaiLimitLike {
+  type?: unknown;
+  percentage?: unknown;
+  usage?: unknown;
+  currentValue?: unknown;
+  nextResetTime?: unknown;
+}
+
+function clampPercent(value: number): number {
+  return Math.min(100, Math.max(0, value));
+}
+
+function windowLabel(resetAt: number, nowSeconds: number): string {
+  const hours = (resetAt - nowSeconds) / SECONDS_PER_HOUR;
+  if (hours <= 48) return '5h';
+  if (hours <= 360) return '7d';
+  return `${Math.max(1, Math.ceil(hours / 24))}d`;
+}
+
+/**
+ * Normalizes the z.ai envelope into reset-sorted windows: nearest reset
+ * is the coding window (`5h`), next the weekly cap (`7d`), labels fall
+ * back by reset distance. Returns undefined when nothing usable remains.
+ */
+export function normalizeZaiEnvelope(
+  envelope: unknown,
+  nowSeconds: number,
+): QuotaWindow[] | undefined {
+  const limits = (envelope as { data?: { limits?: unknown } })?.data?.limits;
+  if (!Array.isArray(limits) || limits.length === 0) return undefined;
+  const windows: Array<QuotaWindow & { resetAt: number }> = [];
+  for (const raw of limits as ZaiLimitLike[]) {
+    if (typeof raw !== 'object' || raw === null) continue;
+    // TIME* limits are the monthly MCP allowance — not coding sessions.
+    if (typeof raw.type === 'string' && raw.type.startsWith('TIME')) continue;
+    let percent: number | undefined;
+    if (typeof raw.percentage === 'number' && Number.isFinite(raw.percentage)) {
+      percent = clampPercent(raw.percentage);
+    } else if (
+      typeof raw.usage === 'number' &&
+      Number.isFinite(raw.usage) &&
+      raw.usage > 0 &&
+      typeof raw.currentValue === 'number' &&
+      Number.isFinite(raw.currentValue)
+    ) {
+      percent = clampPercent((raw.currentValue / raw.usage) * 100);
+    }
+    if (percent === undefined) continue;
+    if (
+      typeof raw.nextResetTime !== 'number' ||
+      !Number.isFinite(raw.nextResetTime) ||
+      raw.nextResetTime <= 0
+    ) {
+      continue; // sort and labels ride on the reset deadline
+    }
+    // Live envelope correction (2026-10-19, real key): z.ai reports
+    // nextResetTime in MILLISECONDS — seconds values ride an order of
+    // magnitude lower, so anything above 1e11 is ms and gets floored
+    // to seconds. Both epochs keep working.
+    const resetRaw =
+      raw.nextResetTime > 1e11
+        ? Math.floor(raw.nextResetTime / 1000)
+        : Math.floor(raw.nextResetTime);
+    const resetAt = resetRaw;
+    windows.push({ label: windowLabel(resetAt, nowSeconds), percent, resetAt });
+  }
+  if (windows.length === 0) return undefined;
+  windows.sort((a, b) => a.resetAt - b.resetAt);
+  return windows;
+}
+
+let started: ZaiQuotaHandle | undefined;
+let cached: QuotaSnapshot | undefined;
+
+// Registered once per process; reads module state so a stop/restart
+// cycle never leaves the registry holding a dead closure.
+registerQuotaProvider({ id: 'zai', snapshot: () => cached });
+
+/**
+ * Registers the z.ai provider and starts the cadence: refresh on start,
+ * on every `refresh()` call (the footer triggers session start and model
+ * change), and on a 5-minute interval. Idempotent per process.
+ */
+export function startZaiQuotaProvider(options: ZaiQuotaOptions = {}): ZaiQuotaHandle {
+  if (started !== undefined) return started;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const authPath = options.authPath ?? join(homedir(), '.pi', 'agent', 'auth.json');
+  const now = options.now ?? (() => Math.floor(Date.now() / 1000));
+  const reported = new Set<string>();
+  const debug = (mode: string) => {
+    if (reported.has(mode)) return;
+    reported.add(mode);
+    options.debug?.(`zai quota: ${mode}`);
+  };
+
+  const refresh = async (): Promise<void> => {
+    const key = await readZaiKey(authPath);
+    if (key === undefined) {
+      debug('no key in ~/.pi/agent/auth.json (zai.key)');
+      return;
+    }
+    let response: Response;
+    try {
+      response = await fetchImpl(ZAI_QUOTA_ENDPOINT, {
+        headers: { authorization: `Bearer ${key}` },
+      });
+    } catch {
+      debug('unreachable');
+      return;
+    }
+    if (!response.ok) {
+      debug(`http ${response.status}`);
+      return;
+    }
+    let envelope: unknown;
+    try {
+      envelope = await response.json();
+    } catch {
+      debug('unparseable envelope');
+      return;
+    }
+    const windows = normalizeZaiEnvelope(envelope, now());
+    if (windows === undefined) {
+      debug('no usable windows');
+      return;
+    }
+    reported.clear(); // a success re-arms distinct-mode reporting
+    cached = { percent: windows[0]!.percent, windows };
+  };
+
+  void refresh();
+  const timer = setInterval(() => void refresh(), REFRESH_INTERVAL_MS);
+  timer.unref?.();
+
+  started = {
+    id: 'zai',
+    refresh,
+    stop() {
+      clearInterval(timer);
+      cached = undefined;
+      reported.clear();
+      started = undefined;
+    },
+  };
+  return started;
+}

package/packages/footer/src/quota.ts

@@ -1,12 +1,26 @@
 /**
- * Quota seam. The provider ships with no implementations: every quota source
- * this cockpit had (Codex OAuth, Claude OAuth, z.ai coding plan) is gone with
- * the previous footer module. A future slice registers a provider here
- * and the deck row gains its gauge back without any renderer change.
+ * Quota seam. The registry ships empty by design: providers land here as
+ * sibling registrations (z.ai first; Codex/Claude later) and the deck row
+ * gains its gauge back without any renderer change.
  */
+export interface QuotaWindow {
+  /** Human label for the window, e.g. `5h`, `7d`. */
+  label: string;
+  /** Window usage, 0–100. */
+  percent: number;
+  /** Reset deadline, unix seconds, when the source reports one. */
+  resetAt?: number;
+}
+
 export interface QuotaSnapshot {
   /** Whole-session quota usage, 0–100. */
   percent: number;
+  /**
+   * Windowed usage when the source distinguishes them (z.ai: the 5h
+   * coding window and the 7d weekly cap). Additive and optional: the
+   * deck keeps rendering `percent` alone when absent.
+   */
+  windows?: readonly QuotaWindow[];
 }
 
 export interface QuotaProvider {

package/packages/footer/src/telemetry.ts

@@ -1,6 +1,6 @@
 import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
 
-import type { QuotaSnapshot } from './quota.ts';
+import type { QuotaSnapshot, QuotaWindow } from './quota.ts';
 import {
   FOOTER_TELEMETRY_PROTOCOL_VERSION,
   type FooterTelemetryMessage,
@@ -36,6 +36,31 @@ export function collectTotalCost(ctx: ExtensionContext): number {
   return totalCostFromEntries(ctx.sessionManager.getBranch());
 }
 
+function boundedPercent(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value)
+    ? Math.min(100, Math.max(0, value))
+    : undefined;
+}
+
+function sanitizeWindow(value: unknown): QuotaWindow | undefined {
+  if (typeof value !== 'object' || value === null) return undefined;
+  const { label, percent, resetAt } = value as {
+    label?: unknown;
+    percent?: unknown;
+    resetAt?: unknown;
+  };
+  if (typeof label !== 'string' || label.length === 0) return undefined;
+  const bounded = boundedPercent(percent);
+  if (bounded === undefined) return undefined;
+  const deadline =
+    typeof resetAt === 'number' && Number.isFinite(resetAt) && resetAt > 0
+      ? Math.floor(resetAt)
+      : undefined;
+  return deadline === undefined
+    ? { label, percent: bounded }
+    : { label, percent: bounded, resetAt: deadline };
+}
+
 export function buildFooterTelemetryMessage(
   totalCost: number,
   quota?: QuotaSnapshot,
@@ -44,16 +69,15 @@ export function buildFooterTelemetryMessage(
     typeof totalCost === 'number' && Number.isFinite(totalCost)
       ? Math.max(0, totalCost)
       : 0;
-  const percent =
-    quota !== undefined &&
-    typeof quota.percent === 'number' &&
-    Number.isFinite(quota.percent)
-      ? Math.min(100, Math.max(0, quota.percent))
-      : undefined;
+  const percent = quota === undefined ? undefined : boundedPercent(quota.percent);
+  const windows = quota?.windows
+    ?.map(sanitizeWindow)
+    .filter((window): window is QuotaWindow => window !== undefined);
   return {
     protocol: FOOTER_TELEMETRY_PROTOCOL_VERSION,
     type: 'snapshot',
     totalCost: cost,
     ...(percent !== undefined ? { quotaPercent: percent } : {}),
+    ...(windows !== undefined && windows.length > 0 ? { quotaWindows: windows } : {}),
   };
 }

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

@@ -173,7 +173,12 @@ function titleBandLines(state: HeaderDeckState, width: number, theme: Theme): st
   const title = state.header?.title ?? null;
   if (title) {
     const subject = safeText(title.subject ?? '');
-    if (!subject) return [clock];
+    if (!subject) {
+      // Human amendment 2026-10-19: the empty slot renders its dim
+      // placeholder — mirroring the Work side's `— no change owns the
+      // moment` — instead of leaving the clock leading alone.
+      return focusWrapLines('— no subject', clock, width, theme, 'dim');
+    }
     return focusWrapLines(subject, clock, width, theme, 'accent');
   }
   // Pre-title publishers: the legacy selection keeps the band alive.
@@ -182,7 +187,15 @@ function titleBandLines(state: HeaderDeckState, width: number, theme: Theme): st
     .map((value) => safeText(value))
     .filter(Boolean);
   if (!selection || titles.length === 0) {
-    return [clock]; // frozen contract: no selection means no slot, clock stays
+    if (!state.header) {
+      // Frozen contract: a publisher that reports nothing at all keeps
+      // the collapsed frame — clock alone, no placeholder dashes.
+      return [clock];
+    }
+    // Amendment: a live session (header present, Work rendering) that
+    // simply has no subject gets the dim placeholder — the title slot
+    // never renders empty when the session is talking to us.
+    return focusWrapLines('— no subject', clock, width, theme, 'dim');
   }
   const selectionColor = ['accent', 'success'].includes(selection.color)
     ? 'accent'
@@ -385,40 +398,73 @@ function globalLeft(state: HeaderDeckState, theme: Theme): string {
   return `${color(theme, 'accent', `󰚩 ${safeText(state.model, 80)}`)} ${minorSeparator(theme)} ${color(theme, state.thinking ? 'thinkingHigh' : 'dim', safeText(state.thinking || 'off', 16))}`;
 }
 
-function projectDeckLeft(state: HeaderDeckState, theme: Theme, width: number): string {
-  // Line 1 left: the path; the git segment yields below 79 columns before
-  // the path does. The devbox marker moved to the line-1 corner with the
-  // companion chips (deck-machine-corner); the identity cluster never
-  // drops, so the path never carries it again.
-  const path = color(theme, 'success', ` \u{F07B} ${safeText(state.cwd)}`);
+function projectDeckLeft(
+  state: HeaderDeckState,
+  theme: Theme,
+  width: number,
+  identity: { text: string; trailingBare: boolean },
+): string {
+  // Line 1 left (deck-reshape): the identity cluster LEADS —
+  // `identity ⟩ path › git` — never the reverse; the cluster never
+  // drops, so truncation eats the git segment first, then the path.
+  const path = color(theme, 'success', `\u{F07B} ${safeText(state.cwd)}`);
   const gitSegment =
     width >= 79 ? truncateToWidth(gitRight(state, theme), 52, '…') : '';
-  return gitSegment ? `${path} ${semanticSeparator(theme)} ${gitSegment}` : path;
+  const left = gitSegment ? `${path} ${semanticSeparator(theme)} ${gitSegment}` : path;
+  return `${identity.text} ${semanticSeparator(theme)} ${left}`;
 }
 
 type CompanionSpec = {
   keys: readonly string[];
   icons: readonly string[];
-  /** Render the chip bracketed even at one icon (engram identity). */
-  bracket?: boolean;
 };
 
+// Human icon swap 2026-10-19: every chip is a Nerd Font PUA glyph with
+// identical single-cell metrics (verified via font cmap + advance in two
+// NF families) — the base-font symbols (↻ ⌬ ⛨) rendered two cells in
+// some terminals and no spacing rule could compensate. md-sync keeps
+// engram's loop semantics; md-graph reads knowledge-graph; md-shield
+// keeps appa's shield — all md- family, matching visual weight.
 const KNOWN_COMPANION_ICONS: ReadonlyArray<CompanionSpec> = [
-  { keys: ['engram'], icons: ['\u{21BB}'], bracket: true },
-  { keys: ['graphify'], icons: ['\u{232C}'] },
-  { keys: ['appa', 'openappa'], icons: ['\u{26E8}'] },
+  { keys: ['engram'], icons: ['\u{F04E6}'] },
+  { keys: ['graphify'], icons: ['\u{F1049}'] },
+  { keys: ['appa', 'openappa'], icons: ['\u{F0498}'] },
 ];
 
-const COMPANION_WARNING_PATTERN =
-  /(warn|error|stale|unreachable|down|fail|update recommended|needs attention|unhealthy)/iu;
+// Severity-shaped chips: shape is the grayscale-proof channel — [] wraps
+// error-or-off, () wraps degraded, bare is healthy — while color keeps the
+// fine grain underneath (off muted, degraded warning, error error,
+// healthy accent/success). Mnemonic: the more enclosed, the worse.
+const COMPANION_DEGRADE_PATTERN = /(warn|stale|update recommended|needs attention)/iu;
+const COMPANION_ERROR_PATTERN = /(error|fail|down|unreachable|unhealthy)/iu;
+
+type ChipSeverity = 'healthy' | 'degraded' | 'error' | 'off';
 
-function companionIconColor(text: string | undefined, active: boolean): string {
-  // Color is the only state signal: symbols never hide.
-  // On = accent, warn/error = warning, off = muted (visible gray).
-  if (!active) return 'muted';
-  return text !== undefined && COMPANION_WARNING_PATTERN.test(text)
-    ? 'warning'
-    : 'accent';
+function companionSeverity(text: string | undefined): ChipSeverity {
+  // Error-grade words outrank degrade-grade when both appear.
+  if (text === undefined) return 'off';
+  if (COMPANION_ERROR_PATTERN.test(text)) return 'error';
+  if (COMPANION_DEGRADE_PATTERN.test(text)) return 'degraded';
+  return 'healthy';
+}
+
+function renderChip(
+  theme: Theme,
+  severity: ChipSeverity,
+  healthyColor: string,
+  icons: string,
+): string {
+  // Human verdict 2026-10-19 — variant C of scripts/chips-preview.mjs:
+  // bold foreground colors alone. No enclosures, no reverse-video.
+  // Blue = healthy/OK, yellow = degraded, red = error/off/KO; the
+  // notice slot carries the why (off vs error read identically here).
+  const name =
+    severity === 'healthy'
+      ? healthyColor
+      : severity === 'degraded'
+        ? 'warning'
+        : 'error';
+  return color(theme, name, icons, true);
 }
 
 function identityCluster(
@@ -435,39 +481,32 @@ function identityCluster(
     if (item.key === 'goal' || texts.has(item.key)) continue;
     texts.set(item.key, item.text);
   }
-  const parts: Array<{ bare: boolean; text: string }> = [];
-  if (state.devbox) {
-    // Corner lead chip (deck-machine-corner): the devbox marker joins
-    // the identity cluster ahead of the companions, success-colored as
-    // it was as a path prefix.
-    parts.push({ bare: false, text: color(theme, 'success', '[\u{F01A7}]', true) });
+  const parts: string[] = [];
+  {
+    // Human amendment 2026-10-19: the devbox chip never appears or
+    // disappears — in-devbox renders bold blue OK, outside renders
+    // bold red KO. DEVBOX_PROJECT_ROOT at pi launch decides.
+    parts.push(
+      renderChip(theme, state.devbox ? 'healthy' : 'error', 'accent', '\u{F01A7}'),
+    );
   }
   for (const companion of KNOWN_COMPANION_ICONS) {
     const published = companion.keys
       .map((key) => texts.get(key))
       .find((text) => text !== undefined);
     for (const key of companion.keys) texts.delete(key);
-    const joined = companion.icons.join(' ');
-    const bracketed = companion.bracket === true || companion.icons.length > 1;
-    const chip = bracketed ? `[${joined}]` : joined;
-    parts.push({
-      bare: !bracketed,
-      text: color(
+    parts.push(
+      renderChip(
         theme,
-        companionIconColor(published, published !== undefined),
-        chip,
-        true,
+        companionSeverity(published),
+        'accent',
+        companion.icons.join(' '),
       ),
-    });
-  }
-  let text = '';
-  let trailingBare = false;
-  for (const part of parts) {
-    text +=
-      text === '' ? part.text : `${trailingBare && part.bare ? '  ' : ' '}${part.text}`;
-    trailingBare = part.bare;
+    );
   }
-  return { text, trailingBare };
+  // Uniform single-cell icons: plain single-space join, single gap
+  // before the major separator (trailingBare false).
+  return { text: parts.join(' '), trailingBare: false };
 }
 
 const BLOCKED_NOTICE = '\u26d4 blocked';
@@ -486,7 +525,8 @@ function companionWarningTexts(state: HeaderDeckState): string[] {
     const published = companion.keys
       .map((key) => texts.get(key))
       .find((text) => text !== undefined);
-    if (published !== undefined && COMPANION_WARNING_PATTERN.test(published)) {
+    const severity = companionSeverity(published);
+    if (published !== undefined && (severity === 'degraded' || severity === 'error')) {
       warnings.push(safeText(published, 180));
     }
   }
@@ -521,42 +561,40 @@ export function collectDeckNotices(state: HeaderDeckState): string[] {
 
 function noticeTile(state: HeaderDeckState, theme: Theme): string {
   const notices = collectDeckNotices(state);
-  if (notices.length === 0) return '';
+  // Healthy sentinel (Human-directed 2026-10-19, reversing the retirement):
+  // when the ladder is silent the dim ladybug holds the right end — the
+  // deck's signature glyph and a reserved one (safeText strips 󰠭 from
+  // published text), so the status row always speaks: ⚠ with notices,
+  // the quiet ladybug when all is well.
+  if (notices.length === 0) return color(theme, 'dim', '󰠭');
   // Blocked carries the error severity it wore on the deleted lifecycle
   // tile; every other notice renders at warning.
   const semantic = notices.includes(BLOCKED_NOTICE) ? 'error' : 'warning';
   return color(theme, semantic, `⚠ ${notices.join(' · ')}`);
 }
 
-function telemetryRowLeft(state: HeaderDeckState, theme: Theme): string {
-  // Line 4 left (deck-corner-context amendment): the global group —
-  // engine › thinking, then the long-horizon quota — owns the row's left
-  // end; the notice slot owns the right end (Task 3). Context and
-  // compaction live in the line-1 corner now.
-  return modelGroupLeft(state, theme);
-}
-
 export function machineCornerSegments(
   state: HeaderDeckState,
   theme: Theme,
   nowMs = Date.now(),
-): string[] {
-  // Machine corner (deck-machine-corner; deck-corner-context): icon-led
-  // machine readings for the line-1 corner — coding quota flame with its
-  // countdown, CPU, memory, MCP availability, context percent, summary
-  // (compaction) count, global cost — in that frozen order, joined by
-  // minor separators. Segments yield right-to-left on narrow frames.
-  const segments: string[] = [];
+): string[][] {
+  // Machine tail (deck-machine-corner; deck-corner-context; swap
+  // amendment): GROUPED icon-led readings — quota (flame + countdown),
+  // process (cpu › mem › mcp), context (ctx › sums), cost — minor
+  // separators inside a group, big separators between groups; groups
+  // yield right-to-left on narrow frames.
+  const quotaGroup: string[] = [];
   const flame = windowQuotaTiles(state, theme, nowMs);
-  if (flame !== '') segments.push(flame);
+  if (flame !== '') quotaGroup.push(flame);
+  const processGroup: string[] = [];
   const resources = state.resources;
   if (resources) {
     const resourceColor =
       resources.cpuWarning || resources.memoryWarning ? 'warning' : 'accent';
-    segments.push(
+    processGroup.push(
       color(theme, resourceColor, `\u{F035B} ${formatDeckCpu(resources.cpuPercent)}`),
     );
-    segments.push(
+    processGroup.push(
       color(
         theme,
         resourceColor,
@@ -565,9 +603,12 @@ export function machineCornerSegments(
     );
   }
   if (state.mcp) {
-    segments.push(color(theme, 'accent', `${state.mcp.healthy}/${state.mcp.total}`));
+    processGroup.push(
+      color(theme, 'accent', `${state.mcp.healthy}/${state.mcp.total}`),
+    );
   }
-  // deck-corner-context: context and summary counts ride the corner.
+  const contextGroup: string[] = [];
+  // deck-corner-context: context and summary counts ride together.
   // Context wears warning at ≥ 85% (the threshold it carried engine-left);
   // the summary count follows the context color as before.
   const ctxColor =
@@ -577,45 +618,51 @@ export function machineCornerSegments(
         ? 'dim'
         : 'accent';
   if (state.contextPercent !== undefined) {
-    segments.push(
+    contextGroup.push(
       color(theme, ctxColor, `\u{F0F86} ${formatDeckPercent(state.contextPercent)}`),
     );
   }
   if (state.compactionCount > 0) {
-    segments.push(color(theme, ctxColor, `\u{F039E} ${state.compactionCount}`));
+    contextGroup.push(color(theme, ctxColor, `\u{F039E} ${state.compactionCount}`));
   }
+  const costGroup: string[] = [];
   const cost = costTile(state, theme);
-  if (cost !== '') segments.push(cost);
-  return segments;
+  if (cost !== '') costGroup.push(cost);
+  return [quotaGroup, processGroup, contextGroup, costGroup].filter(
+    (group) => group.length > 0,
+  );
+}
+
+function deckCornerRight(state: HeaderDeckState, theme: Theme, width: number): string {
+  // Line 1 right corner (deck-reshape, swap amendment): the ENGINE
+  // group — short and predictable (`󰚩 model › thinking › 󰃰 weekly?`) —
+  // so a growing PWD/branch never fights the long machine tail for
+  // width. It fits beside the path floor or yields wholesale. The
+  // machine tail lives on the bottom row now; the identity cluster
+  // leads line 1 LEFT and never yields.
+  const engine = modelGroupLeft(state, theme);
+  if (engine === '') return '';
+  return width - visibleWidth(engine) - 1 >= 20 ? engine : '';
 }
 
-function deckCornerRight(
+function machineCornerLadder(
   state: HeaderDeckState,
   theme: Theme,
   width: number,
   nowMs = Date.now(),
 ): string {
-  // Line 1 corner: the identity cluster (devbox lead, companion chips)
-  // split from the machine group by one major separator. A bare trailing
-  // chip keeps the wide gap before the separator (0.7.1 amendment);
-  // machine segments yield right-to-left (cost first) before the path
-  // truncates below a 20-column floor; the identity cluster never drops
-  // (always-visible contract).
-  const identity = identityCluster(state, theme);
-  const segments = machineCornerSegments(state, theme, nowMs);
-  const pathFloor = 20;
-  const cornerGap = identity.trailingBare ? '  ' : ' ';
-  for (let keep = segments.length; keep >= 0; keep -= 1) {
-    const tail = segments.slice(0, keep).join(` ${minorSeparator(theme)} `);
-    const corner =
-      tail === ''
-        ? identity.text
-        : `${identity.text}${cornerGap}${semanticSeparator(theme)} ${tail}`;
-    if (keep === 0 || width - visibleWidth(corner) - 1 >= pathFloor) {
-      return corner;
-    }
+  // Bottom row left (deck-reshape, swap amendment): the machine tail
+  // yields right-to-left (cost first) into whatever width remains
+  // beside the status right end.
+  const groups = machineCornerSegments(state, theme, nowMs);
+  for (let keep = groups.length; keep >= 1; keep -= 1) {
+    const tail = groups
+      .slice(0, keep)
+      .map((group) => group.join(` ${minorSeparator(theme)} `))
+      .join(` ${semanticSeparator(theme)} `);
+    if (visibleWidth(tail) <= width) return tail;
   }
-  return identity.text;
+  return '';
 }
 
 function modelGroupLeft(state: HeaderDeckState, theme: Theme): string {
@@ -646,7 +693,7 @@ function simpleQuotaTile(state: HeaderDeckState, theme: Theme): string {
   return color(
     theme,
     calendar.percent >= 80 ? 'error' : calendar.percent >= 60 ? 'warning' : 'accent',
-    `󰃰 ${formatDeckPercent(calendar.percent)}`,
+    `󰃰 ${calendar.label} ${formatDeckPercent(calendar.percent)}`,
   );
 }
 
@@ -809,31 +856,31 @@ export function renderHeaderDeck(
   // Activity, and the spans rows are their replacements. The spans rows
   // keep their home directly beneath this line.
   const activityRow = alignedSingleRow(
-    ` ${activityTile(state, theme)}`,
+    activityTile(state, theme),
     turnCostTile(state, theme),
     boundedWidth,
   );
-  // Line 4 (deck-machine-corner amendment): the engine group holds the
-  // row's left end; the right end is notice-only. The machine group moved
-  // to the line-1 corner, so notices can no longer starve machine
-  // readings — the old wholesale yield is gone with the group itself.
-  // 0.7.1 amendment: a clean notice slot renders the dim `healthy`
-  // placeholder instead of trailing silence — it yields like a notice
-  // when the engine group needs the width.
-  const engineGroup = telemetryRowLeft(state, theme);
-  const noticeGroup = noticeTile(state, theme);
-  const rightGroup = noticeGroup !== '' ? noticeGroup : color(theme, 'dim', 'healthy');
-  const telemetryRow =
-    visibleWidth(engineGroup) + 1 + visibleWidth(rightGroup) <= boundedWidth
-      ? alignedSingleRow(engineGroup, rightGroup, boundedWidth)
-      : fit(engineGroup, boundedWidth);
+  // deck-reshape, swap amendment: the bottom row carries the MACHINE
+  // tail on the left (yielding right-to-left into whatever width the
+  // status leaves) and the status on the right — which always speaks
+  // now: ⚠ notices or the dim ladybug sentinel when clean. The engine
+  // group moved to line 1 right.
+  const statusRight = noticeTile(state, theme);
+  const machineRow = machineCornerLadder(
+    state,
+    theme,
+    statusRight === '' ? boundedWidth : boundedWidth - visibleWidth(statusRight) - 1,
+  );
+  const engineRow =
+    statusRight === '' && machineRow === ''
+      ? ''
+      : alignedSingleRow(machineRow, statusRight, boundedWidth);
 
   // Band adjacency (Human-directed, accepted mockups; third 2.4
   // amendment): the deck opens with a full ─ rule directly beneath the
-  // line-1 strip and ends at the telemetry row — nothing renders beneath
-  // line 4; pi's own prompt chrome below closes the visual block — while
-  // the internal seams stay dotted ┈ between lines 2 and 3 and between
-  // line 3 (spans rows included) and line 4.
+  // line-1 strip; the internal seams stay dotted ┈ between lines 2 and
+  // 3 and between line 3 (spans rows included) and the status row.
+  const identity = identityCluster(state, theme);
   const corner = deckCornerRight(state, theme, boundedWidth);
   const alert = statusAlertTile(
     state,
@@ -843,7 +890,7 @@ export function renderHeaderDeck(
   );
   const rows = [
     alignedSingleRow(
-      projectDeckLeft(state, theme, boundedWidth),
+      projectDeckLeft(state, theme, boundedWidth, identity),
       alert ? `${alert} ${corner}` : corner,
       boundedWidth,
     ),
@@ -853,8 +900,7 @@ export function renderHeaderDeck(
     dottedRule,
     activityRow,
     ...spanTreeRows(state, boundedWidth, theme),
-    dottedRule,
-    telemetryRow,
+    ...(engineRow.trim() !== '' ? [dottedRule, engineRow] : []),
   ];
   return rows.map((line) => fitWithoutDanglingSeparator(line, boundedWidth));
 }