@groeponline/pi-wishcraft 1.4.17 → 1.8.0

package/CHANGELOG.md

@@ -2,16 +2,28 @@
 
 ## [Unreleased]
 
+## [1.8.0] - 2026-09-12
+
+### Fixed
+- Deck dashboard focus model: the focused pane is now marked with ◉/○ so ↓ on the skills workbench no longer looks like it "goes right" — ↑↓ moves the focused pane, ←/tab focuses NAVIGATION, → returns to the list, and the footer advertises both. List cursors clamp from the current position, so a stale cursor after filtering/refresh moves one row instead of sticking.
+
 ## [1.4.17] - 2026-09-07
 
 ### Added
 - Bash forward-mode privacy notice (issue #71): the first keystroke forwarded to a running command raises an info notice that typed input may echo into the transcript; documented in `docs/bash-mode.md`.
 - Managed PTY suite is now script-gated (issue #73): PTY-core tests skip when `script(1)` is missing instead of silently passing in degraded pipe mode, the basic run asserts a real PTY transport, and the explicit pipe-mode tests still cover the fallback.
 
+### Changed
+- Signal rail is now a compact single-line state surface. `ready` is stable and costs no animation frames; thinking, streaming, tools, and compaction use a bounded directional trail without expanding the footer to three rows.
+- Chef preset now includes session age, generated-token throughput, and cache-read information when present. The port counter names its protocol (`tcp` or `tcp+udp`) instead of displaying an ambiguous bare count.
+
 ### Fixed
 - Bash paste-while-running (issue #72): a bracketed paste performed while a command runs is stripped of its markers and forwarded to the child stdin — including split delivery across input chunks — instead of silently queuing in the editor buffer behind the command.
 - PTY/transcript memory bounds (from jan `fix/runtime-pty-bounds`): a single unterminated output line is capped at a 64 KiB UTF-8 tail with a one-time notice, the partial-escape tail is bounded, and the active transcript command trims head lines/bytes within limits instead of growing unbounded.
 - Segment-options spread hygiene (CodeFactor #86–89): `normalizeSegmentOptions` assigns fields imperatively instead of spreading conditional empty objects.
+- Motion frames that contain multiple terminal columns no longer expand a rail cell and shift the footer layout while they animate.
+- Idle rail no longer samples `Date.now()` without a corresponding repaint clock, eliminating stale or apparently random idle frames.
+- TPS now reports `--` until a live two-sample rate exists, rather than falsely presenting idle telemetry as `0`; the existing `both`/`out`/`in` setting is validated and honored.
 
 ## [1.4.16] - 2026-09-05
 

package/README.md

@@ -1,43 +1,54 @@
-<p>
-  <img src="https://raw.githubusercontent.com/GroepOnline/pi-wishcraft/main/banner.png" alt="pi-wishcraft" width="1100">
+<p align="center">
+  <img src="https://raw.githubusercontent.com/GroepOnline/pi-wishcraft/main/banner.png" alt="Pi Wishcraft" width="100%">
 </p>
 
-<p>
+<h1 align="center">Pi Wishcraft</h1>
+
+<p align="center"><strong>Your operator cockpit for Pi.</strong><br>See what the session is doing, park ideas without interrupting it, search skills, switch into Bash, and keep the important controls one keypress away.</p>
+
+<p align="center">
   <a href="https://www.npmjs.com/package/@groeponline/pi-wishcraft"><img src="https://img.shields.io/npm/v/@groeponline/pi-wishcraft.svg" alt="npm version"></a>
   <a href="https://www.npmjs.com/package/@groeponline/pi-wishcraft"><img src="https://img.shields.io/npm/dm/@groeponline/pi-wishcraft.svg?label=downloads" alt="npm downloads"></a>
   <a href="https://pi.dev/packages/@groeponline/pi-wishcraft"><img src="https://img.shields.io/badge/Pi-package-9b59b6.svg" alt="Pi package"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-555.svg" alt="MIT license"></a>
 </p>
 
-# pi-wishcraft
+<p align="center"><img src="https://raw.githubusercontent.com/GroepOnline/pi-wishcraft/main/docs/images/wishcraft-cockpit-map.svg" alt="Wishcraft cockpit map showing Signal, Deck, idea capture, skills, managed shell and local guardrails around Pi" width="100%"><br><sub>A map of the shipped operator surfaces. Pi remains the agent runtime.</sub></p>
 
-Cockpit and harness for the [pi](https://github.com/badlogic/pi-mono) coding agent: a live status bar, overlay menus, skills, an idea inbox, sticky bash, hooks, and tool-input repairs. Stock pi stays the engine. This package is the operator layer.
-Kongming lanterns started as battlefield signals and later carried wishes. Wishcraft is that split in a coding session: telemetry on the bar, thoughts you can park without interrupting the run.
+## Start in 10 seconds
 
-Install `@groeponline/pi-wishcraft`. It is listed on the [Pi package catalog](https://pi.dev/packages/@groeponline/pi-wishcraft). Grew out of [`nicobailon/pi-powerline-footer`](https://github.com/nicobailon/pi-powerline-footer). Maintained by [GroepOnline](https://github.com/GroepOnline).
+```bash
+pi install npm:@groeponline/pi-wishcraft
+```
 
-Guides live in [`docs/`](docs/index.md). This is the Pi extension contract: what ships, how to install it, and what can fail.
+Reload Pi, then press `alt+p` to open the Deck.
 
-## Quick start tutorial
+Try the two flows that make Wishcraft click fastest:
 
-Install, restart Pi (or run `/reload`), then press `alt+p` for the Deck. Try `/signal menu`, `/skills`, `/ideas`, and `ctrl+shift+b`. Full setup: [docs/configuration.md](docs/configuration.md).
-**Portfolio boundary:** Wishcraft owns the operator cockpit and lightweight idea capture. Promote durable work to [`pi-missions`](https://github.com/GroepOnline/pi-missions), then use [`pi-agent-orchestrator`](https://github.com/GroepOnline/pi-agent-orchestrator) when parallel/isolated execution adds value: `idea -> mission -> orchestration run`.
+```text
+# remember to benchmark the new provider path
+/ideas
+```
 
-## Install
+The `#` line is captured as an idea instead of being sent as a prompt. Your active run keeps going.
 
-Pi package manager (usual path):
+Then open the skill picker:
 
-```bash
-pi install npm:@groeponline/pi-wishcraft
+```text
+/skills
 ```
 
-For a local checkout or CI environment, run the repository bootstrap script with Bash:
+Search, inspect and insert a skill without leaving the session.
 
-```bash
-bash ./scripts/install.sh
-```
+## Why Wishcraft
+
+Pi stays the engine. Wishcraft adds the operator layer around it: live status, overlays, idea capture, skill search, sticky Bash, hooks, policy controls and session UX.
+
+Kongming lanterns started as battlefield signals and later carried wishes. Wishcraft keeps both ideas in one place: telemetry while the work is moving, and thoughts you can park until you are ready for them.
+
+**Portfolio boundary:** Wishcraft owns the operator cockpit and lightweight idea capture. Promote durable work to [`pi-missions`](https://github.com/GroepOnline/pi-missions), then use [`pi-agent-orchestrator`](https://github.com/GroepOnline/pi-agent-orchestrator) when parallel or isolated execution adds value: `idea -> mission -> orchestration run`.
 
-Then restart Pi or `/reload`. Pi host packages are declared as `peerDependencies: "*"`, matching the Pi package contract.
+Guides live in [`docs/`](docs/index.md).
 
 ## What you get
 
@@ -80,12 +91,6 @@ Activates on load. `/signal` toggles it. `/signal <preset>` switches the informa
 /vibe star trek       themed working messages
 ```
 
-Queue:
-
-- `# <text>` current project; `# @global`, `# @current`, `# @alias`
-- `/idea`, `/ideas`, `/queue` for capture, send, retry, clear, archive
-- `/ideas` overlay: `reviewStatus` (`idea` / `in-progress` / `done`), tags, Run with skill X
-
 Keybinds (`powerlineShortcuts`, applied after `/reload`; `null` disables):
 
 ```json
@@ -114,10 +119,6 @@ Keybinds (`powerlineShortcuts`, applied after `/reload`; `null` disables):
 
 `chef` is muted colors, slash separators, live TPS in/out, and TCP port count. Built-in presets: `default`, `minimal`, `compact`, `full`, `nerd`, `ascii`, `chef`. Custom segments, labels, layout, and presets are documented in [docs/configuration.md](docs/configuration.md). For every setting at its default, see [`examples/settings.example.json`](examples/settings.example.json).
 
-Nerd Fonts auto-detect for iTerm, WezTerm, Kitty, Ghostty, and Alacritty; ASCII otherwise. `POWERLINE_NERD_FONTS=0` forces ASCII.
-
-Context turns warning above 70% and error above 90%. TPS is tokens in the last ~1s, not a session average. `/tps` reads that ring; it does not start a second sampler.
-
 Daily token budget (never blocks a turn):
 
 ```json
@@ -233,7 +234,6 @@ Privacy/network boundary: ideas, settings, usage ledgers, and normal cockpit sta
 ## vNext Direction
 
 Wishcraft is Pi's animated operator layer. See the [release plan](docs/design/vnext-release-plan.md) and [design corpus](docs/index.md#design-system--vnext-specifications).
-
 ## Docs
 
 - [Commands](docs/commands.md)

package/docs/commands.md

@@ -86,7 +86,7 @@ You can also set it in the agent settings file (`~/.pi/agent/settings.json` by d
 | `full` | Everything: hostname, model, path (abbreviated), full git incl commit + ↑/↓, totals, context total, elapsed + clock |
 | `nerd` | Maximum detail for Nerd Font users: qualified model, full tokens + cache, commit, totals, seconds clock |
 | `ascii` | Safe for any terminal: branch + short commit + ↑/↓, tokens, cost, context% (no Nerd glyphs) |
-| `chef` | Fork default: muted colors, slash separators, live TPS in/out + open-ports + subagent-cost segments |
+| `chef` | Fork default: muted colors, slash separators, compact live state rail, session age, TPS in/out, protocol-labelled open ports, generated tokens, cache, subagent cost |
 
 **Environment:** `POWERLINE_NERD_FONTS=1` to force Nerd Fonts, `=0` for ASCII.
 

package/docs/segments.md

@@ -4,8 +4,8 @@
 
 `preset: "chef"` is the GroepOnline fork's default look: muted colors (no rainbow), slash separators, and two extra right-side segments:
 
-- `tps`: live tokens/sec over a rolling 1-second window (EMA-free, no spikes), now reporting **output and input** rates separately (`⇡out ⇣in`) so you can see generation speed and incoming prompt tokens at a glance. A rocket/bolt icon lights up while streaming (override with env `POWERLINE_TPS`).
-- `open_ports`: count of unique **TCP** listening ports (`ss` → `netstat` → `/proc/net` fallback, dedupes IPv4/IPv6). Set `segmentOptions.openPorts.includeUdp: true` to include noisy UDP (mDNS/DHCP/ephemeral).
+- `tps`: live tokens/sec over a rolling 1-second window (EMA-free, no spikes), reporting **output and input** rates separately (`⇡out ⇣in`) so you can see generation speed and incoming prompt tokens at a glance. It shows `--` until two live samples exist, rather than pretending an idle session runs at zero. Set `segmentOptions.tps.mode` to `both`, `out`, or `in`; override with `POWERLINE_TPS` when needed.
+- `open_ports`: count of unique **TCP** listening ports (`ss` → `netstat` → `/proc/net` fallback, dedupes IPv4/IPv6) rendered as `21 tcp`. Set `segmentOptions.openPorts.includeUdp: true` to include noisy UDP (mDNS/DHCP/ephemeral), rendered as `tcp+udp`.
 
 ### Open-port process owners
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groeponline/pi-wishcraft",
-  "version": "1.4.17",
+  "version": "1.8.0",
   "description": "Operator cockpit for Pi: live powerline status, searchable skills, idea queue, sticky Bash, hooks, policy controls, and session UX.",
   "type": "module",
   "files": [

package/src/config/presets.ts

@@ -358,9 +358,19 @@ export const PRESETS: Record<StatusLinePreset, PresetDef> = {
       "shell_mode",
       "path",
       "git",
+      "session",
       "queue",
     ],
-    rightSegments: ["tps", "open_ports", "subagents", "cost", "context_pct", "time"],
+    rightSegments: [
+      "tps",
+      "open_ports",
+      "token_out",
+      "cache_read",
+      "subagents",
+      "cost",
+      "context_pct",
+      "time",
+    ],
     separator: "slash",
     colors: CHEF_COLORS,
     segmentOptions: {

package/src/config/segment-options.ts

@@ -139,6 +139,9 @@ export function normalizeSegmentOptions(
     if (typeof raw.tps.windowMs === "number" && Number.isFinite(raw.tps.windowMs)) {
       tps.windowMs = Math.min(5000, Math.max(500, Math.floor(raw.tps.windowMs)));
     }
+    if (raw.tps.mode === "both" || raw.tps.mode === "out" || raw.tps.mode === "in") {
+      tps.mode = raw.tps.mode;
+    }
     options.tps = tps;
   }
 

package/src/config/types.ts

@@ -325,6 +325,8 @@ export interface StatusLineSegmentOptions {
   tps?: SegmentFormatOption & {
     /** Sliding rate window length in ms (default 1000; wider = smoother, e.g. 2000 for fast models). */
     windowMs?: number;
+    /** Show both rates, generated tokens only, or prompt/input throughput only. */
+    mode?: "both" | "out" | "in";
   };
 }
 

package/src/extension/ui/deck/component.ts

@@ -168,16 +168,24 @@ export function createDeckComponent(
         return;
       }
 
-      // ←/tab returns focus to the NAVIGATION column in one press; from there
-      // ↑↓ moves the nav selection and any other key drops back into the list.
+      // ←/tab moves focus to the NAVIGATION column in one press; from there
+      // ↑↓ walks the routes and → (or any other key) drops back into the
+      // list. The focused pane is highlighted in the frame (◉/○ markers)
+      // so ↑↓ never appears to "go right" while the list has focus.
       if (
         !state.composerOpen &&
         !state.skillCreate &&
-        (matchesKey(data, "left") || matchesKey(data, "tab"))
+        (matchesKey(data, "left") ||
+          matchesKey(data, "tab") ||
+          matchesKey(data, "shift+tab"))
       ) {
         state = { ...state, navMode: true };
         return;
       }
+      if (state.navMode && matchesKey(data, "right")) {
+        state = { ...state, navMode: false };
+        return;
+      }
       if (state.navMode) {
         if (matchesKey(data, "up") || matchesKey(data, "down")) {
           // fall through to the nav handlers at the bottom
@@ -313,12 +321,16 @@ export function createDeckComponent(
     length: number,
   ): boolean {
     if (length <= 0) return false;
+    // Clamp first: the catalog can shrink (filter/refresh) while the stored
+    // cursor still points past the end. Without this, ↑ from a stale cursor
+    // lands out of range and the highlight appears stuck.
+    const cursor = Math.min(Math.max(0, state[key]), length - 1);
     if (matchesKey(data, "up")) {
-      state = { ...state, [key]: Math.max(0, state[key] - 1) };
+      state = { ...state, [key]: Math.max(0, cursor - 1) };
       return true;
     }
     if (matchesKey(data, "down")) {
-      state = { ...state, [key]: Math.min(length - 1, state[key] + 1) };
+      state = { ...state, [key]: Math.min(length - 1, cursor + 1) };
       return true;
     }
     return false;

package/src/extension/ui/deck/render.ts

@@ -29,15 +29,18 @@ export function deckFooter(state: DeckNavState): string {
   if (state.searchOpen) return `/ ${state.searchQuery}_`;
   if (state.composerOpen) return "←→ nudge · ↑↓ field · enter apply · esc back";
   if (state.skillCreate) return "type a name · enter create · esc cancel";
+  // Nav column has focus: ↑↓ walks routes, → jumps back into the list.
+  if (state.navMode)
+    return "↑↓ route · → list · / Search · g h Home · Esc Close";
   switch (state.route) {
     case "appearance":
-      return "↑↓ select base · enter apply · ←/tab nav · / Search · g h Home · Esc Close";
+      return "↑↓ select base · enter apply · ←/tab nav · → list · / Search · g h Home · Esc Close";
     case "motion":
-      return "↑↓ motion · t event · e composer · enter apply · ←/tab nav · Esc Close";
+      return "↑↓ motion · t event · e composer · enter apply · ←/tab nav · → list · Esc Close";
     case "skills":
-      return "↑↓ skill · enter insert · n new · / filter · ←/tab nav · Esc Close";
+      return "↑↓ skill · enter insert · n new · / filter · ←/tab nav · → list · Esc Close";
     case "ideas":
-      return "↑↓ idea · / Search · ←/tab nav · g h Home · Esc Close";
+      return "↑↓ idea · / Search · ←/tab nav · → list · g h Home · Esc Close";
     default:
       return "/ Search   g h Home   g s Signal   g i Ideas   ? Help   Esc Close";
   }
@@ -67,7 +70,7 @@ export function renderDeckFrame(
   lines.push(wrap(theme.fg("accent", theme.bold(truncateToWidth(header, inner, "…", true)))));
   lines.push(border(`├${"─".repeat(inner)}┤`));
 
-  const nav = navLines(snapshot, state, theme, leftW);
+  const nav = navLines(snapshot, state, theme, leftW, state.navMode);
   const center = centerRouteBody(snapshot, state, theme, centerW, shortcuts, composer, tick);
   const right = rightRail(snapshot, theme, rightW);
 
@@ -91,8 +94,14 @@ function navLines(
   state: DeckNavState,
   theme: Theme,
   width: number,
+  focused: boolean,
 ): string[] {
-  const lines: string[] = [theme.fg("accent", "NAVIGATION")];
+  // Focus marker: ◉ = ↑↓ walks this column, ○ = ↑↓ moves the center list.
+  // Without this the cursor appears to "go right" on ↓ while list-focused.
+  const header = focused
+    ? theme.fg("accent", theme.bold("◉ NAVIGATION"))
+    : theme.fg("muted", "○ NAVIGATION");
+  const lines: string[] = [header];
   for (const route of DECK_ROUTE_DEFS) {
     const active = route.id === state.route;
     const marker = active ? "◉" : "◇";
@@ -118,7 +127,17 @@ function centerRouteBody(
   composer: ComposerDraft | null = null,
   tick = Date.now(),
 ): string[] {
-  const title = theme.fg("accent", `ACTIVE ROUTE: ${routeTitle(state.route).toUpperCase()}`);
+  const listFocused =
+    !state.navMode && !state.searchOpen && !state.composerOpen;
+  const title = listFocused
+    ? theme.fg(
+        "accent",
+        theme.bold(`◉ ACTIVE ROUTE: ${routeTitle(state.route).toUpperCase()}`),
+      )
+    : theme.fg(
+        "muted",
+        `○ ACTIVE ROUTE: ${routeTitle(state.route).toUpperCase()}`,
+      );
   const body: string[] = [title, ""];
   switch (state.route) {
     case "home":

package/src/render/motion-rail.ts

@@ -1,17 +1,25 @@
 /**
- * Motion rail (v2). Renders the Signal activity rail — the animated
- * sweep/compact rail plus activity label — as a first-class layout segment.
- * Extracted from the legacy v1 Signal renderer (src/signal/render.ts,
- * deleted in the U12 cutover); rail semantics are unchanged: idle = flat
- * rail, streaming = travelling head + trail, compacting = inward heads.
+ * Compact Signal rail. It is deliberately a single terminal row: the rail
+ * reports agent state, it never displaces the footer while a response streams.
+ * Idle has no scheduler consumer; active work leases the shared scheduler.
  */
 
-import { defaultMotionFor, getMotion } from "../motion/catalog.ts";
-import { frameAt, framesOf, sweepPosition, trailGlyph } from "../motion/frames.ts";
+import { getMotion } from "../motion/catalog.ts";
+import { frameAt, sweepPosition, trailGlyph } from "../motion/frames.ts";
 import type { SignalRuntime } from "../signal/controller.ts";
 import type { SignalSpec } from "../config/types.ts";
 import { ansi, colorEnabled, getFgAnsiCode } from "../theme/colors.ts";
-import { lanternSigil } from "./motion-candidates.ts";
+
+function paint(text: string, color: string): string {
+  if (!color || !colorEnabled()) return text;
+  return `${color}${text}${ansi.reset}`;
+}
+
+/** Generators such as writing-reveal may contain several columns. A rail cell
+ * must always occupy exactly one column or its layout drifts under animation. */
+function cellGlyph(value: string, fallback: string): string {
+  return Array.from(value)[0] ?? fallback;
+}
 
 export function renderActivity(
   runtime: SignalRuntime,
@@ -20,134 +28,82 @@ export function renderActivity(
   width = 80,
 ): string {
   const label = runtime.activity || "ready";
-  const open = spec.caps.leftOpen ?? "";
-  const close = spec.caps.leftClose ?? "";
   const dim = getFgAnsiCode("sep");
   const hot = getFgAnsiCode("accent");
-  const reset = colorEnabled() ? ansi.reset : "";
-  // Adaptive rail width: ~20% of terminal, clamped [16, 40]. Wider
-  // terminals get a longer sweep so the motion reads at a glance.
-  const RAIL_WIDTH = Math.max(16, Math.min(40, Math.round(width * 0.2)));
+  const model = getFgAnsiCode("model");
+  const path = getFgAnsiCode("path");
   const track = ascii ? "-" : "─";
-  const head = ascii ? "o" : "●";
-  const railColor = runtime.active ? hot : dim;
+  // A footer rail is state indication, not a hero animation. Keep it readable
+  // on wide terminals and leave enough room for actual operational segments.
+  const railWidth = Math.max(12, Math.min(22, Math.round(width * 0.1)));
   const def = getMotion(runtime.motionId);
-  // The head glyph is the chosen motion's own frame — so ember-relay
-  // sweeps a ◇→◈→◆ sequence and hex-relay carries #-density, instead of
-  // every motion wearing the same generic comet. The trail reuses the
-  // motion's own past frames too, so each motion leaves its own wake.
-  // ASCII terminals fall back to the clean box-drawing comet — motion
-  // frames are a color-font feature.
+  const direction = def?.generator?.direction === "reverse" ? "reverse" : "forward";
+  const trailDepth = Math.max(2, Math.min(6, def?.generator?.trail ?? 4));
+  const headFallback = ascii ? "o" : "●";
   const headGlyph = (tick: number, distance: number) => {
-    if (def && !ascii) return frameAt(def, Math.max(0, tick - distance), false);
-    return distance === 0 ? head : trailGlyph(distance, ascii);
+    if (ascii) return distance === 0 ? headFallback : trailGlyph(distance, true);
+    return def ? cellGlyph(frameAt(def, tick - distance), headFallback) : headFallback;
   };
-  const trailDepth = def?.generator?.trail ?? 4;
-  // Per-cell color gradient: hot head fading to dim through the palette.
-  // Distance 0 = accent, then model → path → sep so the wake cools off.
-  const cellColor = (distance: number): string => {
-    if (!colorEnabled()) return "";
-    if (distance <= 0) return hot;
-    if (distance <= 1) return getFgAnsiCode("model");
-    if (distance <= 2) return getFgAnsiCode("path");
+  const cellColor = (distance: number) => {
+    if (distance === 0) return hot;
+    if (distance === 1) return model;
+    if (distance === 2) return path;
     return dim;
   };
-  let railBlock: string;
+
+  let rail: string;
   if (!runtime.active) {
-    // Idle: a frozen breathing wave of the ambient motion (wisp) frames.
-    // No animation consumer at idle, but a sine-sampled wave reads as
-    // "resting, not dead" — calmer than a full sweep, warmer than a flat track.
-    const ambient = getMotion(defaultMotionFor("idle"));
-    const ambientFrames = ambient ? framesOf(ambient) : null;
-    if (ambientFrames && colorEnabled()) {
-      const phase = Date.now() % 4000 / 4000;
-      const built: string[] = [];
-      for (let i = 0; i < RAIL_WIDTH; i++) {
-        const wave = Math.sin((i / RAIL_WIDTH) * Math.PI * 2 + phase * Math.PI * 2);
-        const frameIdx = Math.floor(((wave + 1) / 2) * ambientFrames.length) % ambientFrames.length;
-        const color = wave > 0.3 ? hot : dim;
-        built.push(`${color}${ambientFrames[frameIdx]}${reset}`);
-      }
-      railBlock = built.join("");
-    } else {
-      railBlock = track.repeat(RAIL_WIDTH);
-    }
-  } else if (runtime.activity === "compacting") {
-    railBlock = renderCompactRail(runtime.tick, RAIL_WIDTH, ascii, headGlyph, cellColor);
+    // Do not derive idle state from Date.now(): there is intentionally no idle
+    // animation clock, so a clock-derived rail otherwise changes only when an
+    // unrelated repaint happens. The center marker makes ready glanceable.
+    const center = Math.floor(railWidth / 2);
+    rail = Array.from({ length: railWidth }, (_, index) =>
+      paint(index === center ? (ascii ? "." : "⋄") : track, dim),
+    ).join("");
+  } else if (runtime.event === "compact") {
+    rail = renderCompactRail(runtime.tick, railWidth, ascii, headGlyph, cellColor);
   } else {
-    const pos = sweepPosition(runtime.tick, RAIL_WIDTH, true);
-    const built: string[] = [];
-    for (let i = 0; i < RAIL_WIDTH; i++) {
-      if (i === pos) built.push(`${cellColor(0)}${headGlyph(runtime.tick, 0)}${reset}`);
-      else if (i < pos) {
-        const distance = pos - i;
-        if (distance <= trailDepth) {
-          built.push(`${cellColor(distance)}${headGlyph(runtime.tick, distance)}${reset}`);
-        } else {
-          built.push(track);
-        }
-      } else {
-        built.push(track);
+    const pos = sweepPosition(runtime.tick, railWidth, true, direction);
+    rail = Array.from({ length: railWidth }, (_, index) => {
+      const distance = direction === "forward" ? pos - index : index - pos;
+      if (distance === 0) return paint(headGlyph(runtime.tick, 0), cellColor(0));
+      if (distance > 0 && distance <= trailDepth) {
+        return paint(headGlyph(runtime.tick, distance), cellColor(distance));
       }
-    }
-    railBlock = built.join("");
-  }
-  // Active state: 3-row lantern sigil ONLY for the streaming/working
-  // activity. Each row is wrapped individually with the lane color
-  // so rows 1+ don't inherit an empty ANSI state from row 0.
-  if (runtime.active && !ascii && runtime.activity === "streaming") {
-    const sigilRows = lanternSigil(runtime.tick, false);
-    const [r0, ...rest] = sigilRows;
-    const framed = `${spec.separators.left}${r0} ${label}${spec.separators.right}`;
-    const allRows = [framed, ...rest];
-    const colored = (row: string) => `${railColor}${row}${reset}`;
-    // open brackets on the first row, close on the last row, color on
-    // every row so the whole sigil reads as one amber block.
-    const rows = allRows.map((row, i) => {
-      const prefix = i === 0 ? open : "";
-      const suffix = i === allRows.length - 1 ? close : "";
-      return `${prefix}${colored(row)}${suffix}`;
-    });
-    railBlock = rows.join("\n");
-    return railBlock;
+      return paint(track, dim);
+    }).join("");
   }
-  const rail = `${spec.separators.left}${railBlock}${spec.separators.right}`;
-  return `${railColor}${open}${rail}${close}${reset} ${label}`;
+
+  const edge = runtime.active ? hot : dim;
+  const left = `${spec.caps.leftOpen ?? ""}${spec.separators.left}`;
+  const right = `${spec.separators.right}${spec.caps.leftClose ?? ""}`;
+  return `${paint(left, edge)}${rail}${paint(right, edge)} ${paint(label, runtime.active ? hot : dim)}`;
 }
 
-/**
- * Compact rail: two heads travel inward toward center, compressing the rail.
- * Gives compaction a distinct visual signature vs the generic sweep.
- */
 function renderCompactRail(
   tick: number,
   width: number,
   ascii: boolean,
-  headGlyph: (tick: number, i: number) => string,
+  headGlyph: (tick: number, distance: number) => string,
   cellColor: (distance: number) => string,
 ): string {
   const half = Math.floor(width / 2);
-  // Heads oscillate from the edges toward center and back.
-  const span = half;
-  const phase = tick % (span * 2);
-  const inward = phase < span ? phase : span * 2 - phase;
-  const leftPos = inward;
-  const rightPos = width - 1 - inward;
+  const phase = tick % (half * 2);
+  const inward = phase < half ? phase : half * 2 - phase;
+  const left = inward;
+  const right = width - 1 - inward;
   const core = ascii ? "=" : "━";
   const track = ascii ? "-" : "─";
-  const reset = colorEnabled() ? ansi.reset : "";
-  // Color the core by distance from the nearest head — hottest at the
-  // heads, cooling toward center, so the compression reads thermally.
-  let built = "";
-  for (let i = 0; i < width; i++) {
-    if (i === leftPos || i === rightPos) {
-      built += `${cellColor(0)}${headGlyph(tick, 0)}${reset}`;
-    } else if (i > leftPos && i < rightPos) {
-      const nearestHead = Math.min(Math.abs(i - leftPos), Math.abs(i - rightPos));
-      built += `${cellColor(nearestHead)}${core}${reset}`;
-    } else {
-      built += track;
+  const dim = getFgAnsiCode("sep");
+
+  return Array.from({ length: width }, (_, index) => {
+    if (index === left || index === right) {
+      return paint(headGlyph(tick, 0), cellColor(0));
     }
-  }
-  return built;
-}
+    if (index > left && index < right) {
+      const distance = Math.min(index - left, right - index);
+      return paint(core, cellColor(distance));
+    }
+    return paint(track, dim);
+  }).join("");
+}

package/src/segments/system.ts

@@ -383,15 +383,21 @@ export const tpsSegment: StatusLineSegment = {
       windowMs,
     );
     const icons = getIcons();
+    const mode = ctx.options.tps?.mode ?? "both";
     const parts: string[] = [];
-    if (outRate > 0) parts.push(`${icons.output}${formatTpsRate(outRate)}`);
-    if (inRate > 0) parts.push(`${icons.input}${formatTpsRate(inRate)}`);
-    const valueText = parts.length > 0 ? parts.join(" ") : "0";
-    const active = outRate > 0 || inRate > 0;
+    if (mode !== "in" && outRate > 0) {
+      parts.push(`${icons.output}${formatTpsRate(outRate)}`);
+    }
+    if (mode !== "out" && inRate > 0) {
+      parts.push(`${icons.input}${formatTpsRate(inRate)}`);
+    }
+    // `0` looks like a measured rate and implies broken telemetry when the
+    // agent is simply idle. `--` means no live generation sample yet.
+    const valueText = parts.length > 0 ? parts.join(" ") : "--";
     return {
       content: withIcon(
         icons.tps,
-        color(ctx, active ? "tokens" : "queue", valueText),
+        color(ctx, parts.length > 0 ? "tokens" : "queue", valueText),
       ),
       visible: true,
     };
@@ -415,7 +421,8 @@ export const openPortsSegment: StatusLineSegment = {
       entry = { at: now, count: countListeningPorts(includeUdp, host) };
       openPortsCache.set(key, entry);
     }
-    const text = entry.count < 0 ? "?" : String(entry.count);
+    const protocol = includeUdp ? "tcp+udp" : "tcp";
+    const text = entry.count < 0 ? `? ${protocol}` : `${entry.count} ${protocol}`;
     return {
       content: withIcon(getIcons().ports, color(ctx, "queue", text)),
       visible: true,

package/tsconfig.test.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noUnusedLocals": false,
+    "noUnusedParameters": false
+  }
+}