peaks-loop 4.0.4 → 4.0.6

package/dist/services/skills/skill-statusline-renderer.d.ts

@@ -1,6 +1,89 @@
 import type { StatusLineModel } from './skill-statusline-service.js';
 /**
- * Render the status line. The output is plain text with simple status glyphs so
- * it stays readable in any terminal; Claude Code applies its own styling.
+ * Pure formatting layer for the Peaks statusLine. Takes the read-only status
+ * model and produces the single line Claude Code paints at the bottom of the
+ * terminal. Kept separate from the reader so formatting can be tested without
+ * touching the filesystem.
+ *
+ * Capability-aware rendering: three glyph palettes are kept side by side in
+ * {@link PALETTES} so the switch from "active" / "idle" / "warning" to a
+ * concrete string happens in one place. Adding a fourth capability (e.g. for
+ * a future IDE) is a one-table change.
  */
-export declare function renderStatusLine(model: StatusLineModel): string;
+export type StatusLineCapability = 'ansi-unicode' | 'unicode' | 'ascii';
+export interface StatusLineRenderOptions {
+    readonly capability: StatusLineCapability;
+}
+/**
+ * Resolve the capability tier from environment and TTY state. Pure and
+ * deterministic — no I/O beyond reading the caller-supplied `env` and
+ * `isTTY` flag. The CLI delegates to this so the read-only status line
+ * does not need to know about ANSI/NO_COLOR semantics.
+ *
+ * The optional `forced` argument is a TEST SEAM (consumed by direct unit
+ * tests, not by the CLI). It lets tests pin a tier without constructing a
+ * TTY/NO_COLOR fixture. The CLI does NOT expose any flag that maps to
+ * `forced` — the env-driven path is the single first-version runtime
+ * source of truth.
+ *
+ * Adapter-internal env override (NOT a user-facing CLI flag):
+ *   `PEAKS_STATUSLINE_ASCII` — when set to `1` / `true` / `yes`, the
+ *   renderer drops to the ASCII palette (no Unicode-extra glyphs, no ANSI).
+ *   This is an adapter-internal mechanism for the trust boundary described
+ *   by the two-forms-only / human-NL-choice-only tenets: the user never
+ *   types a CLI verb to flip palettes, but the adapter (and only the
+ *   adapter) can set the env var on the user's behalf when its consumer
+ *   (e.g. a tiny terminal without UTF-8) needs ASCII. We do NOT expose
+ *   this via a CLI flag.
+ *
+ * Order of resolution (highest priority first):
+ *
+ *   1. `forced` argument (test seam only)
+ *   2. `PEAKS_STATUSLINE_ASCII` set → `ascii` (adapter-internal override)
+ *   3. `isTTY === true` → `ansi-unicode`
+ *   4. otherwise → `unicode` (still ANSI-colored; only `ascii` is color-free)
+ *
+ * Why this ordering: the IDE statusline invokes the renderer through a
+ * hook that may not always be detected as a TTY. The `unicode` tier
+ * now emits the cyan brand accent + semantic colors so the line reads
+ * as a branded product surface whether or not the consumer is a
+ * terminal. `NO_COLOR` is honored as an ambient convention by the
+ * IDE adapter (which can set `PEAKS_STATUSLINE_ASCII=1` to opt out
+ * fully), so a separate tier for NO_COLOR is no longer needed.
+ *
+ * `ascii` is the strict no-color, no-Unicode-extra tier; it is the
+ * single safe option for plain log / file consumers.
+ *
+ * Why `PEAKS_STATUSLINE_ASCII` outranks `NO_COLOR`:
+ *   The two env vars are NOT redundant. `NO_COLOR` (https://no-color.org)
+ *   is the cross-industry signal that NO escape sequences should be emitted
+ *   — its only effect is "ANSI off". The Unicode-extra glyphs (●, █, ░, etc.)
+ *   are NOT ANSI escape sequences; they are UTF-8 characters and `NO_COLOR`
+ *   does not address them. `PEAKS_STATUSLINE_ASCII` is the adapter-internal
+ *   "signal source is a tiny terminal without UTF-8" override and drops the
+ *   glyphs to ASCII shape as well. Both are correct signals about
+ *   different concerns; the ASCII override wins because it is strictly
+ *   narrower (a tiny terminal needs both no-ANSI AND no-Unicode-extra).
+ *
+ * The deliberate ordering keeps the rendered text ANSI-free when the consumer
+ * is a logger, a file, or any non-interactive sink, and only enables ANSI
+ * under an explicit supported condition (TTY + no env veto).
+ */
+export declare function resolveStatusLineCapability(input: {
+    readonly env: NodeJS.ProcessEnv;
+    readonly isTTY: boolean;
+    readonly forced?: StatusLineCapability;
+}): StatusLineCapability;
+/**
+ * Render the status line. Pure — no I/O, no side effects. The output is
+ * a single short line suitable for the bottom-of-terminal status bar.
+ *
+ * The `options.capability` field selects the glyph palette. When omitted,
+ * the function falls back to `unicode` (no ANSI escape codes), preserving
+ * the legacy behaviour for the CLI's `peaks statusline` invocation.
+ *
+ * Compact-state precedence: when `model.compact.kind !== 'none'` the
+ * compact bar replaces the active/idle/stale content. The C1 baseline
+ * line is preserved when the compact state is `none`.
+ */
+export declare function renderStatusLine(model: StatusLineModel, options?: StatusLineRenderOptions): string;

package/dist/services/skills/skill-statusline-renderer.js

@@ -1,11 +1,167 @@
 import { basename } from 'node:path';
 /**
- * Pure formatting layer for the Peaks statusLine. Takes the read-only status
- * model and produces the single line Claude Code paints at the bottom of the
- * terminal. Kept separate from the reader so formatting can be tested without
- * touching the filesystem.
+ * Internal: the brand prefix is plain ASCII so a tiny terminal without
+ * monospaced UTF-8 still sees a recognizable string. The mountain glyphs
+ * (`⛰` / `🏔`) used in earlier 1.x renders were the loudest a11y regression
+ * in the 2026-07-22 ice-cola surface check and are deliberately removed.
  */
-const BRAND = '⛰ Peaks';
+const BRAND = 'Peaks';
+/**
+ * Attention-gate allowlist. The brief requires conservative classification:
+ * only gate names that encode a blocking condition surface as a warning
+ * glyph. Routine progress gates (`startup`, `swarm-fan-out`,
+ * `swarm-converged`, `repair-cycle-N`, etc.) stay hidden. The map is
+ * explicit — there is no "non-empty gate means alert" inference.
+ */
+const ATTENTION_GATE_LABELS = new Map([
+    ['qa-validation', 'QA'],
+    ['verdict-issued', 'Verdict'],
+    ['blocked', 'Blocked'],
+]);
+function isAttentionGate(gate) {
+    if (!gate)
+        return null;
+    return ATTENTION_GATE_LABELS.get(gate) ?? null;
+}
+/** Brand accent: per project request, this is the slate-purple `#5A65D8`. */
+const BRAND_RGB = '38;2;90;101;216';
+const BRAND_SGR_OPEN = `\x1b[1;${BRAND_RGB}m`;
+const BRAND_SGR_FULL_OPEN = `\x1b[${BRAND_RGB}m`;
+const BRAND_SGR_CLOSE = '\x1b[0m';
+function accent(text) {
+    return `${BRAND_SGR_OPEN}${text}${BRAND_SGR_CLOSE}`;
+}
+function accentGlyph(glyph) {
+    return `${BRAND_SGR_OPEN}${glyph}${BRAND_SGR_CLOSE}`;
+}
+/**
+ * Slow-blink variant of the accent glyph. Used for the idle indicator
+ * so the user perceives a pulse on the statusline. The ANSI slow-blink
+ * SGR (`\x1b[5m`) is honored by most modern terminals (iTerm2, Windows
+ * Terminal, GNOME Terminal with the right profile). Hosts that ignore
+ * the SGR render the glyph statically — graceful degradation.
+ */
+function blinkingAccentGlyph(glyph) {
+    return `\x1b[5;1;${BRAND_RGB}m${glyph}\x1b[0m`;
+}
+const PALETTES = {
+    'ansi-unicode': {
+        active: accentGlyph('●'),
+        idle: blinkingAccentGlyph('○'),
+        warning: '\x1b[33m!\x1b[0m', // amber warning (semantic alarm)
+        inlineSeparator: ' · ',
+        trailSeparator: ' → ',
+        idleLabel: 'empty',
+        invalidMessage: 'presence unreadable',
+        compact: {
+            queued: accentGlyph('◐'),
+            preparing: accentGlyph('◑'),
+            compacting: accentGlyph('◒'),
+            verifying: accentGlyph('◓'),
+            completed: accentGlyph('✓'),
+            failed: '\x1b[31m✕\x1b[0m', // failed is a semantic alarm
+        },
+        barFilled: '█',
+        barEmpty: '░',
+        ratioArrow: '→',
+    },
+    unicode: {
+        active: accentGlyph('●'),
+        idle: blinkingAccentGlyph('○'),
+        warning: '\x1b[33m!\x1b[0m',
+        inlineSeparator: ' · ',
+        trailSeparator: ' → ',
+        idleLabel: 'empty',
+        invalidMessage: 'presence unreadable',
+        compact: {
+            queued: accentGlyph('◐'),
+            preparing: accentGlyph('◑'),
+            compacting: accentGlyph('◒'),
+            verifying: accentGlyph('◓'),
+            completed: accentGlyph('✓'),
+            failed: '\x1b[31m✕\x1b[0m',
+        },
+        barFilled: '█',
+        barEmpty: '░',
+        ratioArrow: '→',
+    },
+    ascii: {
+        active: '*',
+        idle: 'o',
+        warning: '!',
+        inlineSeparator: ' . ',
+        trailSeparator: ' -> ',
+        idleLabel: 'empty',
+        invalidMessage: 'presence unreadable',
+        compact: {
+            queued: '[',
+            preparing: '+',
+            compacting: '+',
+            verifying: '+',
+            completed: '*',
+            failed: 'x',
+        },
+        barFilled: '#',
+        barEmpty: '-',
+        ratioArrow: '->',
+    },
+};
+const BREATHING_GLYPHS_UNICODE = ['●', '◐', '◑', '◒', '◓'];
+const BREATHING_GLYPHS_ASCII = ['*', 'o', '+', '~', '|'];
+const BREATHING_PERIOD_MS = 2_400;
+/**
+ * Bee-tier (1-level sub-role) skills and their full orchestrator
+ * parent name. The terminal status line shows both layers when a bee
+ * is active: the active bee name plus a `↑<parent-full>` marker
+ * pointing at the dispatching orchestrator.
+ */
+const BEE_TO_PARENT = {
+    'peaks-prd': 'peaks-code',
+    'peaks-rd': 'peaks-code',
+    'peaks-qa': 'peaks-code',
+    'peaks-ui': 'peaks-code',
+    'peaks-sc': 'peaks-code',
+    'peaks-txt': 'peaks-code',
+    'peaks-final-review': 'peaks-code',
+    'peaks-resume': 'peaks-code',
+    'peaks-status': 'peaks-code',
+    'peaks-test': 'peaks-code',
+    'peaks-reviewer': 'peaks-code',
+};
+function pickBreathingGlyph(capability, nowMs) {
+    const set = capability === 'ascii' ? BREATHING_GLYPHS_ASCII : BREATHING_GLYPHS_UNICODE;
+    const index = Math.floor((nowMs % BREATHING_PERIOD_MS) / (BREATHING_PERIOD_MS / set.length)) % set.length;
+    return set[index];
+}
+function renderActiveDot(capability, nowMs) {
+    // Brief: the active dot carries the project accent (`#5A65D8` bold)
+    // in both colored tiers. The breathing glyph is wrapped in a fresh
+    // SGR on every render so the IDE sees a single accent per refresh.
+    const glyph = pickBreathingGlyph(capability, nowMs);
+    if (capability === 'ascii')
+        return glyph;
+    return accentGlyph(glyph);
+}
+function brandText(capability) {
+    // Brief: brand carries the project accent (`#5A65D8` bold) in both
+    // colored tiers. The `ascii` tier stays plain text so plain text
+    // consumers (no TTY, no UTF-8) never see escape codes.
+    if (capability === 'ansi-unicode' || capability === 'unicode') {
+        return accent(BRAND);
+    }
+    return BRAND;
+}
+/**
+ * Default capability when none is supplied. Per the brief: "if backward
+ * compatibility requires a renderer default, use unicode, never
+ * unconditional ANSI." The CLI's `peaks statusline` invocation currently
+ * passes no options; preserving the legacy no-ANSI behaviour means the
+ * default is the unicode palette (no escape codes).
+ */
+const DEFAULT_CAPABILITY = 'unicode';
+function paletteFor(capability) {
+    return PALETTES[capability ?? DEFAULT_CAPABILITY];
+}
 function formatAge(ageMs) {
     if (ageMs === null)
         return '';
@@ -21,35 +177,224 @@ function rootLabel(projectRoot) {
     return basename(projectRoot);
 }
 /**
- * Render the status line. The output is plain text with simple status glyphs so
- * it stays readable in any terminal; Claude Code applies its own styling.
+ * Build the "middle" of the status line — everything between the brand
+ * prefix and the project root label. Kept separate so the token layout
+ * is obvious at the call site and so each state has a single
+ * responsibility.
  */
-export function renderStatusLine(model) {
-    const root = rootLabel(model.projectRoot);
-    const rootSuffix = root ? ` · ${root}` : '';
-    switch (model.state) {
-        case 'active': {
-            const presence = model.presence;
-            if (!presence)
-                return `${BRAND} ○ idle${rootSuffix}`;
-            const parts = [presence.skill];
-            if (presence.mode)
-                parts.push(presence.mode);
-            if (presence.gate)
-                parts.push(`gate:${presence.gate}`);
-            return `${BRAND} ● ${parts.join(' · ')}${rootSuffix}`;
+function renderActive(presence, palette, nowMs, capability) {
+    if (!presence) {
+        return `${palette.idle} ${palette.idleLabel}`;
+    }
+    const attentionLabel = isAttentionGate(presence.gate);
+    if (attentionLabel !== null) {
+        // Attention gate — surface the warning glyph + human-readable label.
+        return `${palette.warning} ${presence.skill}${palette.inlineSeparator}${attentionLabel}`;
+    }
+    const skill = presence.skill;
+    const dot = renderActiveDot(capability, nowMs);
+    const beeParent = BEE_TO_PARENT[skill];
+    const modeToken = typeof presence.mode === 'string' && presence.mode.length > 0
+        ? ` [${presence.mode}]`
+        : '';
+    // Bee-tier skills surface both layers: the active bee name plus
+    // the full parent orchestrator name. Mode is shown for every
+    // active skill (not just peaks-code) so the line carries the same
+    // mode taxonomy for any bee in flight.
+    if (beeParent !== undefined) {
+        return `${dot} ${skill} ↑${beeParent}${modeToken}`;
+    }
+    return `${dot} ${skill}${modeToken}`;
+}
+function renderStale(presence, ageMs, palette) {
+    const skill = presence?.skill ?? 'unknown';
+    const age = formatAge(ageMs);
+    const ageSuffix = age ? `${palette.inlineSeparator}${age}` : '';
+    return `${palette.warning} ${skill}${ageSuffix}`;
+}
+function renderInvalid(palette) {
+    return `${palette.warning} ${palette.invalidMessage}`;
+}
+function renderIdle(palette) {
+    return `${palette.idle} ${palette.idleLabel}`;
+}
+const COMPACT_BAR_WIDTH = 8;
+function renderCompactBar(filledCells, palette) {
+    const filled = palette.barFilled.repeat(filledCells);
+    const empty = palette.barEmpty.repeat(COMPACT_BAR_WIDTH - filledCells);
+    return `[${filled}${empty}]`;
+}
+function formatRatio(value) {
+    // Brief ratio labels use 2-decimal precision: 0.87 → "87%".
+    return `${Math.round(value * 100)}%`;
+}
+/**
+ * Render the compact-progress segment. Compact state REPLACES the skill
+ * content while active (`kind !== 'none'`). The renderer always lays out
+ *
+ *   <stage-glyph> <bar> <label>[ · <before>%][ → <after>%]
+ *
+ * Failed states additionally suffix the stage at which the compact failed.
+ * Stalled states keep the active-stage cell count and render a plain
+ * "stalled" label. Invalid states surface the read-reason verbatim as a
+ * single-line diagnostic so the user can see why the bar is empty.
+ */
+function renderCompact(state, palette) {
+    switch (state.kind) {
+        case 'none':
+            return '';
+        case 'queued':
+            return `${palette.compact.queued} ${renderCompactBar(0, palette)} queued${typeof state.triggerRatio === 'number'
+                ? `${palette.inlineSeparator}${formatRatio(state.triggerRatio)}`
+                : ''}`;
+        case 'preparing':
+            return `${palette.compact.preparing} ${renderCompactBar(2, palette)} preparing${typeof state.triggerRatio === 'number'
+                ? `${palette.inlineSeparator}${formatRatio(state.triggerRatio)}`
+                : ''}`;
+        case 'compacting':
+            return `${palette.compact.compacting} ${renderCompactBar(4, palette)} compacting${typeof state.triggerRatio === 'number'
+                ? `${palette.inlineSeparator}${formatRatio(state.triggerRatio)}`
+                : ''}`;
+        case 'verifying':
+            return `${palette.compact.verifying} ${renderCompactBar(6, palette)} verifying`;
+        case 'completed':
+            return `${palette.compact.completed} ${renderCompactBar(8, palette)} compacted${typeof state.triggerRatio === 'number'
+                ? `${palette.inlineSeparator}${formatRatio(state.triggerRatio)}${typeof state.afterRatio === 'number'
+                    ? ` ${palette.ratioArrow} ${formatRatio(state.afterRatio)}`
+                    : ''}`
+                : typeof state.afterRatio === 'number'
+                    ? `${palette.inlineSeparator}${formatRatio(state.afterRatio)}`
+                    : ''}`;
+        case 'failed': {
+            const failedAt = state.failedAt ?? 'compacting';
+            const filledAt = failedAt === 'queued'
+                ? 0
+                : failedAt === 'preparing'
+                    ? 2
+                    : failedAt === 'compacting'
+                        ? 4
+                        : 6;
+            return `${palette.compact.failed} ${renderCompactBar(filledAt, palette)} compact failed${palette.inlineSeparator}${failedAt}`;
         }
-        case 'stale': {
-            const presence = model.presence;
-            const skill = presence?.skill ?? 'unknown';
-            const age = formatAge(model.ageMs);
-            const ageSuffix = age ? ` · ${age}` : '';
-            return `${BRAND} ⚠ ${skill}${ageSuffix}${rootSuffix}`;
+        case 'stalled':
+            return `${palette.compact.compacting} ${renderCompactBar(state.filledCells, palette)} stalled`;
+        case 'invalid': {
+            const detail = state.detail ?? 'lifecycle record malformed';
+            return `${palette.warning} ${detail}`;
         }
+    }
+}
+/**
+ * Resolve the capability tier from environment and TTY state. Pure and
+ * deterministic — no I/O beyond reading the caller-supplied `env` and
+ * `isTTY` flag. The CLI delegates to this so the read-only status line
+ * does not need to know about ANSI/NO_COLOR semantics.
+ *
+ * The optional `forced` argument is a TEST SEAM (consumed by direct unit
+ * tests, not by the CLI). It lets tests pin a tier without constructing a
+ * TTY/NO_COLOR fixture. The CLI does NOT expose any flag that maps to
+ * `forced` — the env-driven path is the single first-version runtime
+ * source of truth.
+ *
+ * Adapter-internal env override (NOT a user-facing CLI flag):
+ *   `PEAKS_STATUSLINE_ASCII` — when set to `1` / `true` / `yes`, the
+ *   renderer drops to the ASCII palette (no Unicode-extra glyphs, no ANSI).
+ *   This is an adapter-internal mechanism for the trust boundary described
+ *   by the two-forms-only / human-NL-choice-only tenets: the user never
+ *   types a CLI verb to flip palettes, but the adapter (and only the
+ *   adapter) can set the env var on the user's behalf when its consumer
+ *   (e.g. a tiny terminal without UTF-8) needs ASCII. We do NOT expose
+ *   this via a CLI flag.
+ *
+ * Order of resolution (highest priority first):
+ *
+ *   1. `forced` argument (test seam only)
+ *   2. `PEAKS_STATUSLINE_ASCII` set → `ascii` (adapter-internal override)
+ *   3. `isTTY === true` → `ansi-unicode`
+ *   4. otherwise → `unicode` (still ANSI-colored; only `ascii` is color-free)
+ *
+ * Why this ordering: the IDE statusline invokes the renderer through a
+ * hook that may not always be detected as a TTY. The `unicode` tier
+ * now emits the cyan brand accent + semantic colors so the line reads
+ * as a branded product surface whether or not the consumer is a
+ * terminal. `NO_COLOR` is honored as an ambient convention by the
+ * IDE adapter (which can set `PEAKS_STATUSLINE_ASCII=1` to opt out
+ * fully), so a separate tier for NO_COLOR is no longer needed.
+ *
+ * `ascii` is the strict no-color, no-Unicode-extra tier; it is the
+ * single safe option for plain log / file consumers.
+ *
+ * Why `PEAKS_STATUSLINE_ASCII` outranks `NO_COLOR`:
+ *   The two env vars are NOT redundant. `NO_COLOR` (https://no-color.org)
+ *   is the cross-industry signal that NO escape sequences should be emitted
+ *   — its only effect is "ANSI off". The Unicode-extra glyphs (●, █, ░, etc.)
+ *   are NOT ANSI escape sequences; they are UTF-8 characters and `NO_COLOR`
+ *   does not address them. `PEAKS_STATUSLINE_ASCII` is the adapter-internal
+ *   "signal source is a tiny terminal without UTF-8" override and drops the
+ *   glyphs to ASCII shape as well. Both are correct signals about
+ *   different concerns; the ASCII override wins because it is strictly
+ *   narrower (a tiny terminal needs both no-ANSI AND no-Unicode-extra).
+ *
+ * The deliberate ordering keeps the rendered text ANSI-free when the consumer
+ * is a logger, a file, or any non-interactive sink, and only enables ANSI
+ * under an explicit supported condition (TTY + no env veto).
+ */
+export function resolveStatusLineCapability(input) {
+    if (input.forced !== undefined) {
+        return input.forced;
+    }
+    // Adapter-internal ASCII override. Reads the env var using a non-ASCII
+    // identifier by indirection so a `grep PEAKS_STATUSLINE_ASCII` finds the
+    // exact contract; the comparison string is built at call time.
+    const asciiFlag = input.env['PEAKS_STATUSLINE_ASCII'];
+    if (typeof asciiFlag === 'string' && (asciiFlag === '1' || asciiFlag === 'true' || asciiFlag === 'yes')) {
+        return 'ascii';
+    }
+    // NO_COLOR is honored by the IDE adapter (which sets
+    // `PEAKS_STATUSLINE_ASCII=1` to fully opt out). The unicode tier
+    // itself emits cyan + semantic colors so the brand reads correctly
+    // whether or not the consumer is a TTY.
+    return input.isTTY ? 'ansi-unicode' : 'unicode';
+}
+/**
+ * Render the status line. Pure — no I/O, no side effects. The output is
+ * a single short line suitable for the bottom-of-terminal status bar.
+ *
+ * The `options.capability` field selects the glyph palette. When omitted,
+ * the function falls back to `unicode` (no ANSI escape codes), preserving
+ * the legacy behaviour for the CLI's `peaks statusline` invocation.
+ *
+ * Compact-state precedence: when `model.compact.kind !== 'none'` the
+ * compact bar replaces the active/idle/stale content. The C1 baseline
+ * line is preserved when the compact state is `none`.
+ */
+export function renderStatusLine(model, options) {
+    const capability = options?.capability ?? DEFAULT_CAPABILITY;
+    const palette = paletteFor(capability);
+    const root = rootLabel(model.projectRoot);
+    const rootSuffix = root ? `${palette.trailSeparator}${root}` : '';
+    const brand = brandText(capability);
+    // Breathing pulse: key off a single wall-clock read at the start of
+    // render so the output is deterministic for a given invocation. The
+    // glyph remains a single cell so total visible width is constant.
+    const nowMs = Date.now();
+    const compactSegment = renderCompact(model.compact, palette);
+    if (compactSegment.length > 0) {
+        // Compact state replaces the active / stale / idle skill content.
+        // `invalid-presence` still surfaces its own diagnostic when compact
+        // is also `invalid` (the compact diagnostic wins, since it's the
+        // more recent failure mode).
+        return `${brand} ${compactSegment}${rootSuffix}`;
+    }
+    switch (model.state) {
+        case 'active':
+            return `${brand} ${renderActive(model.presence, palette, nowMs, capability)}${rootSuffix}`;
+        case 'stale':
+            return `${brand} ${renderStale(model.presence, model.ageMs, palette)}${rootSuffix}`;
         case 'invalid-presence':
-            return `${BRAND} ⚠ presence file unreadable${rootSuffix}`;
+            return `${brand} ${renderInvalid(palette)}${rootSuffix}`;
         case 'idle':
         default:
-            return `${BRAND} ○ idle${rootSuffix}`;
+            return `${brand} ${renderIdle(palette)}${rootSuffix}`;
     }
 }

package/dist/services/skills/skill-statusline-service.d.ts

@@ -1,3 +1,4 @@
+import type { CompactStatuslineState } from '../compact-statusline/compact-statusline-service.js';
 export type StatusLineStdin = {
     workspace?: {
         current_dir?: string;
@@ -19,6 +20,7 @@ export type StatusLineModel = {
     projectRoot: string | null;
     presence: StatusLinePresence | null;
     ageMs: number | null;
+    compact: CompactStatuslineState;
 };
 export declare function parseStatusLineStdin(raw: string): StatusLineStdin | null;
 export declare function buildStatusLineModel(stdin: StatusLineStdin | null, nowMs: number): StatusLineModel;

package/dist/services/skills/skill-statusline-service.js

@@ -1,6 +1,8 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { findProjectRoot } from '../config/config-safety.js';
+import { decideCompactStatusline } from '../compact-statusline/compact-statusline-service.js';
+import { getSessionIdCanonical } from '../session/session-manager.js';
 /**
  * Out-of-band Peaks skill status renderer for the Claude Code statusLine.
  *
@@ -84,15 +86,19 @@ function readPresenceReadOnly(projectRoot) {
 export function buildStatusLineModel(stdin, nowMs) {
     const cwd = resolveCwdFromStdin(stdin);
     const projectRoot = findProjectRoot(cwd);
+    // Compact state is computed independently of presence — the read is read-only
+    // and reads `.peaks/_runtime/<sid>/compact-lifecycle.json` (or its legacy
+    // fallbacks). It replaces the active skill content when kind != 'none'.
+    const compact = readCompactState(projectRoot, nowMs);
     if (projectRoot === null) {
-        return { state: 'idle', projectRoot: null, presence: null, ageMs: null };
+        return { state: 'idle', projectRoot: null, presence: null, ageMs: null, compact };
     }
     const { presence, invalid } = readPresenceReadOnly(projectRoot);
     if (invalid) {
-        return { state: 'invalid-presence', projectRoot, presence: null, ageMs: null };
+        return { state: 'invalid-presence', projectRoot, presence: null, ageMs: null, compact };
     }
     if (presence === null) {
-        return { state: 'idle', projectRoot, presence: null, ageMs: null };
+        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact };
     }
     // Session binding: when the presence was stamped with a Claude session id and
     // the live session (from stdin) is a different one, the recorded skill belongs
@@ -101,10 +107,33 @@ export function buildStatusLineModel(stdin, nowMs) {
     // fall back to the time-based behavior below for backward compatibility.
     const liveSessionId = typeof stdin?.session_id === 'string' && stdin.session_id.length > 0 ? stdin.session_id : null;
     if (presence.claudeSessionId && liveSessionId && presence.claudeSessionId !== liveSessionId) {
-        return { state: 'idle', projectRoot, presence: null, ageMs: null };
+        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact };
     }
     const setAtMs = presence.setAt ? Date.parse(presence.setAt) : Number.NaN;
     const ageMs = Number.isNaN(setAtMs) ? null : nowMs - setAtMs;
     const state = ageMs !== null && ageMs > STALE_THRESHOLD_MS ? 'stale' : 'active';
-    return { state, projectRoot, presence, ageMs };
+    return { state, projectRoot, presence, ageMs, compact };
+}
+/**
+ * Read-only compact state resolver. Resolves the canonical session id for the
+ * detected project root, then delegates to {@link decideCompactStatusline}.
+ * Returns `{ kind: 'none', filledCells: 0 }` when no project root is bound —
+ * the renderer falls back to the C1 normal line in that case.
+ */
+function readCompactState(projectRoot, nowMs) {
+    if (projectRoot === null) {
+        return { kind: 'none', filledCells: 0 };
+    }
+    try {
+        const sessionId = getSessionIdCanonical(projectRoot);
+        return decideCompactStatusline({
+            projectRoot,
+            sessionId,
+            now: nowMs,
+        });
+    }
+    catch {
+        // Read-only — never throw across the statusline boundary.
+        return { kind: 'none', filledCells: 0 };
+    }
 }

package/dist/services/skills/sync-service.d.ts

@@ -25,6 +25,8 @@ export interface SyncServiceInput {
     readonly platforms?: readonly IdeId[] | undefined;
     /** When true, the installer is invoked in dry-run mode. */
     readonly dryRun?: boolean | undefined;
+    /** Reconcile managed Junctions that point at deleted host worktrees. */
+    readonly reconcileJunctions?: boolean | undefined;
 }
 export interface SyncServiceResult {
     readonly applied: boolean;
@@ -39,6 +41,7 @@ interface InstallBundledSkillsOptions {
     readonly ideId: IdeId;
     readonly projectRoot: string;
     readonly dryRun?: boolean;
+    readonly reconcileJunctions?: boolean;
     readonly targetRoot?: string;
 }
 interface InstallResult {

package/dist/services/skills/sync-service.js

@@ -222,6 +222,7 @@ export async function runSkillSync(input) {
                 ideId: platform,
                 projectRoot: input.projectRoot,
                 ...(dryRun ? { dryRun: true } : {}),
+                ...(input.reconcileJunctions === true ? { reconcileJunctions: true } : {}),
             });
             perPlatform.push({
                 platform,

package/dist/services/standards/project-context.d.ts

@@ -1,6 +1,6 @@
 export type BuildTool = 'umi' | 'next' | 'vite' | 'rsbuild' | 'rspack' | 'farm' | 'craco' | 'webpack' | 'gulp' | 'angular' | 'custom' | 'unknown';
 export type ComponentLibrary = {
-    readonly name: 'antd' | 'antd-pro' | 'mui' | 'element-plus' | 'element-ui' | 'arco' | 'tdesign' | 'semi' | 'nextui' | 'chakra' | 'vant' | 'none';
+    readonly name: 'antd' | 'antd-pro' | 'mui' | 'element-plus' | 'element-ui' | 'arco' | 'tdesign' | 'semi' | 'nextui' | 'chakra' | 'shadcn' | 'vant' | 'none';
     readonly majorVersion?: string;
     readonly hasProSuite?: boolean;
 };
@@ -18,6 +18,7 @@ export type ProjectContext = {
     readonly legacySignals: string[];
     readonly notableDeps: string[];
 };
+export declare function detectComponentLibrary(projectRoot: string, deps: Record<string, string>): ComponentLibrary;
 export declare function detectProjectContext(projectRoot: string): ProjectContext;
 export declare function buildToolLabel(tool: BuildTool): string;
 export declare function componentLibraryLabel(lib: ComponentLibrary): string;