@cocasts/pi-status-line 0.0.0-stage → 0.1.0

package/extensions/status-line/modules.ts

@@ -0,0 +1,366 @@
+/**
+ * The module registry: what the status line can show, how each module reads by default, and which
+ * modules give up their seat first when the terminal narrows.
+ *
+ * A module is deliberately inert data plus one pure `value()` function. Layout, labels, colours, and
+ * overflow live elsewhere, so adding a module is a registry entry rather than a branch in the row
+ * renderer. Nothing here imports the pi runtime — only its types — so the whole registry is
+ * exercised in tests with plain objects.
+ */
+
+import type { Theme, ThemeColor } from '@earendil-works/pi-coding-agent';
+
+import { formatCost, formatExact, formatTokens, modelShortId, pathTail, percentColor } from './format.ts';
+
+/** Everything the modules can read. Collected once per turn by the wiring layer. */
+export interface StatusLineParts {
+  /** Model id, or the empty string when no model is selected. */
+  model: string;
+  /**
+   * The model's provider, shown only when the session can route to more than one provider — the
+   * same rule the native footer uses before it writes `(provider) model`.
+   */
+  provider: string | null;
+  /** Thinking level (`off`…`max`), or null when the session is not thinking. */
+  effort: string | null;
+  /** Home-shortened working directory; empty when the path module is disabled. */
+  path: string;
+  branch: string | null;
+  /** Explicit session name, or null when the session has none. */
+  session: string | null;
+  /** Session prompt tokens that were neither read from nor written to cache. */
+  input: number;
+  output: number;
+  /** Cache hit rate as a share of prompt tokens, 0–100; null before the first turn. */
+  cacheHitRate: number | null;
+  /** Decode rate already formatted by formatTps, without a unit; null before the first turn. */
+  tps: string | null;
+  /** Tokens currently occupying the context window. */
+  contextTokens: number;
+  /** The model's window size, 0 when unknown. */
+  contextWindow: number;
+  /** The share of the window in use, 0–100, or null when it is not known yet. */
+  contextPercent: number | null;
+  /** Session spend in USD, or null when pi has not priced anything yet. */
+  cost: number | null;
+}
+
+/** A module's value for the current frame. */
+export interface ModuleValue {
+  text: string;
+  color: ThemeColor;
+}
+
+/** How a module's label reads. `none` is for modules whose value is self-describing (a model id). */
+export type LabelStyle = 'none' | 'glyph' | 'word';
+
+export type ModuleId =
+  | 'model'
+  | 'provider'
+  | 'effort'
+  | 'path'
+  | 'branch'
+  | 'session'
+  | 'input'
+  | 'output'
+  | 'cache-hit'
+  | 'tps'
+  | 'context'
+  | 'cost';
+
+export interface ModuleDef {
+  id: ModuleId;
+  /**
+   * Shrink rank: the lowest priority is dropped first when the line does not fit, and the highest
+   * is dropped last. Floor modules are never dropped by the shrink pass.
+   */
+  priority: number;
+  /** Kept even at the narrowest width (only `context`). */
+  floor: boolean;
+  /** One cell wide, drawn by the terminal's own monospace font, no emoji presentation. */
+  glyph: string;
+  /** The word form of the label. */
+  word: string;
+  defaultLabel: LabelStyle;
+  formats: readonly string[];
+  defaultFormat: string;
+  /** The colour used when no `color` is configured. Reports show this for static modules. */
+  defaultColor: ThemeColor;
+  /**
+   * Set when the module picks its colour per frame instead of using `defaultColor`. The
+   * `/statusline` report prints this instead, so it never claims a static colour for a dynamic one.
+   */
+  colorNote?: string;
+  /** The rendered value, or null when the module has nothing to say this frame. */
+  value(parts: StatusLineParts, format: string): ModuleValue | null;
+}
+
+/**
+ * The module table, ordered by the default left-to-right reading order of a session.
+ *
+ * Colours follow pi's own footer: every reading is `dim`, except context pressure, which borrows the
+ * `warning` / `error` tokens above the same 70 % / 90 % thresholds. Identity modules are dim too, so
+ * a configured accent is an opt-in rather than the default.
+ */
+export const MODULES: Readonly<Record<ModuleId, ModuleDef>> = {
+  model: {
+    id: 'model',
+    priority: 90,
+    floor: false,
+    glyph: '◈',
+    word: 'model',
+    // A model id needs no label: it is the one value that identifies itself.
+    defaultLabel: 'none',
+    formats: ['id', 'short'],
+    defaultFormat: 'id',
+    defaultColor: 'dim',
+    value: (parts, format) => ({
+      text: format === 'short' ? modelShortId(parts.model) : parts.model,
+      color: 'dim',
+    }),
+  },
+  provider: {
+    id: 'provider',
+    priority: 85,
+    floor: false,
+    glyph: '◇',
+    word: 'provider',
+    defaultLabel: 'none',
+    formats: ['paren', 'name'],
+    defaultFormat: 'paren',
+    defaultColor: 'dim',
+    value: (parts, format) => {
+      if (parts.provider === null || parts.provider === '') return null;
+      return { text: format === 'name' ? parts.provider : `(${parts.provider})`, color: 'dim' };
+    },
+  },
+  effort: {
+    id: 'effort',
+    priority: 40,
+    floor: false,
+    glyph: '◐',
+    word: 'effort',
+    defaultLabel: 'none',
+    // `native` spells the disabled level out, the way the native footer writes `• thinking off`.
+    formats: ['native', 'word', 'initial'],
+    defaultFormat: 'native',
+    defaultColor: 'dim',
+    value: (parts, format) => {
+      if (parts.effort === null || parts.effort === '') return null;
+      if (format === 'native' && parts.effort === 'off') return { text: 'thinking off', color: 'dim' };
+      const text = format === 'initial' ? parts.effort.slice(0, 1).toUpperCase() : parts.effort;
+      return { text, color: 'dim' };
+    },
+  },
+  path: {
+    id: 'path',
+    // Above the branch and session tail: a narrow terminal keeps the directory and drops what
+    // follows it, the way the native footer truncates the directory line from the right.
+    priority: 20,
+    floor: false,
+    glyph: '⌂',
+    word: 'path',
+    defaultLabel: 'none',
+    formats: ['full', 'tail'],
+    defaultFormat: 'full',
+    defaultColor: 'dim',
+    value: (parts, format) => {
+      if (parts.path === '') return null;
+      return { text: format === 'tail' ? pathTail(parts.path) : parts.path, color: 'dim' };
+    },
+  },
+  branch: {
+    id: 'branch',
+    priority: 15,
+    floor: false,
+    glyph: '⎇',
+    word: 'branch',
+    defaultLabel: 'none',
+    // Parenthesised is how the native footer writes the branch next to the cwd.
+    formats: ['paren', 'name'],
+    defaultFormat: 'paren',
+    defaultColor: 'dim',
+    value: (parts, format) => {
+      if (parts.branch === null || parts.branch === '') return null;
+      return { text: format === 'name' ? parts.branch : `(${parts.branch})`, color: 'dim' };
+    },
+  },
+  session: {
+    id: 'session',
+    priority: 10,
+    floor: false,
+    glyph: '❯',
+    word: 'session',
+    defaultLabel: 'none',
+    formats: ['name'],
+    defaultFormat: 'name',
+    defaultColor: 'dim',
+    value: (parts) => (parts.session === null || parts.session === '' ? null : { text: parts.session, color: 'dim' }),
+  },
+  input: {
+    id: 'input',
+    priority: 80,
+    floor: false,
+    glyph: '↑',
+    word: 'input',
+    defaultLabel: 'glyph',
+    formats: ['tokens', 'exact'],
+    defaultFormat: 'tokens',
+    defaultColor: 'dim',
+    value: (parts, format) =>
+      parts.input > 0
+        ? { text: format === 'exact' ? formatExact(parts.input) : formatTokens(parts.input), color: 'dim' }
+        : null,
+  },
+  output: {
+    id: 'output',
+    priority: 60,
+    floor: false,
+    glyph: '↓',
+    word: 'output',
+    defaultLabel: 'glyph',
+    formats: ['tokens', 'exact'],
+    defaultFormat: 'tokens',
+    defaultColor: 'dim',
+    value: (parts, format) =>
+      parts.output > 0
+        ? { text: format === 'exact' ? formatExact(parts.output) : formatTokens(parts.output), color: 'dim' }
+        : null,
+  },
+  'cache-hit': {
+    id: 'cache-hit',
+    priority: 50,
+    floor: false,
+    // A bullseye: the reading itself is a hit rate.
+    glyph: '◎',
+    word: 'cache',
+    defaultLabel: 'glyph',
+    formats: ['percent', 'hit'],
+    defaultFormat: 'percent',
+    defaultColor: 'dim',
+    value: (parts, format) => {
+      if (parts.cacheHitRate === null) return null;
+      const rate = `${parts.cacheHitRate.toFixed(1)}%`;
+      return { text: format === 'hit' ? `${rate} hit` : rate, color: 'dim' };
+    },
+  },
+  tps: {
+    id: 'tps',
+    priority: 30,
+    floor: false,
+    // The Greek lightning mark: speed as a single monospace cell, with no emoji presentation.
+    glyph: 'ϟ',
+    word: 'speed',
+    defaultLabel: 'glyph',
+    formats: ['rate', 'long'],
+    defaultFormat: 'rate',
+    defaultColor: 'dim',
+    value: (parts, format) =>
+      parts.tps === null ? null : { text: format === 'long' ? `${parts.tps} tok/s` : `${parts.tps}/s`, color: 'dim' },
+  },
+  context: {
+    id: 'context',
+    priority: 1000,
+    floor: true,
+    // Context is the one reading with no unit in its number, so it carries a glyph like the rest.
+    glyph: '▤',
+    word: 'ctx',
+    // The native footer writes the context reading without a label: `17.0%/200k`.
+    defaultLabel: 'none',
+    formats: ['native', 'window', 'tokens', 'percent'],
+    defaultFormat: 'native',
+    defaultColor: 'dim',
+    colorNote: 'pressure colour (70% / 90%)',
+    value: (parts, format) => {
+      const used = formatTokens(parts.contextTokens);
+      const window = formatTokens(parts.contextWindow);
+      if (format === 'percent') {
+        return {
+          text: parts.contextPercent === null ? '--' : `${Math.round(parts.contextPercent)}%`,
+          color: percentColor(parts.contextPercent),
+        };
+      }
+      if (format === 'tokens') return { text: used, color: percentColor(parts.contextPercent) };
+      if (format === 'window') {
+        return {
+          text: parts.contextWindow > 0 ? `${used}/${window}` : used,
+          color: percentColor(parts.contextPercent),
+        };
+      }
+      // Native: one decimal of pressure over the abbreviated window, `?` when pi has no reading.
+      const share = parts.contextPercent === null ? '?' : `${parts.contextPercent.toFixed(1)}%`;
+      return { text: `${share}/${window}`, color: percentColor(parts.contextPercent) };
+    },
+  },
+  cost: {
+    id: 'cost',
+    priority: 70,
+    floor: false,
+    // A currency mark for the rare case someone wants a label; the value is already self-describing.
+    glyph: '¤',
+    word: 'cost',
+    defaultLabel: 'none',
+    formats: ['usd', 'exact'],
+    defaultFormat: 'usd',
+    defaultColor: 'dim',
+    value: (parts, format) => {
+      if (parts.cost === null || parts.cost <= 0) return null;
+      return { text: format === 'exact' ? `$${parts.cost.toFixed(4)}` : formatCost(parts.cost), color: 'dim' };
+    },
+  },
+};
+
+/** Every module id, in registry order. Used by validation and by the `/statusline` report. */
+export const MODULE_IDS: readonly ModuleId[] = Object.keys(MODULES) as ModuleId[];
+
+export function isModuleId(value: unknown): value is ModuleId {
+  return typeof value === 'string' && Object.hasOwn(MODULES, value);
+}
+
+export function moduleDef(id: ModuleId): ModuleDef {
+  return MODULES[id];
+}
+
+/**
+ * One module instance as configured: the definition plus the per-entry overrides that survived
+ * validation. `null` colour means "use whatever the module chose for this frame", which is how the
+ * context reading keeps its pressure colour unless the user insists otherwise.
+ */
+export interface ResolvedEntry {
+  def: ModuleDef;
+  label: LabelStyle;
+  format: string;
+  color: ThemeColor | null;
+  prefix: string;
+  suffix: string;
+}
+
+/**
+ * `label value`, with the key quiet and the value bright.
+ *
+ * Both label styles keep a space before the value, so `↑ 132` and `input 132` read at the same
+ * rhythm; a self-describing value has no label at all.
+ */
+function labelled(theme: Theme, entry: ResolvedEntry, value: ModuleValue): string {
+  const text = theme.fg(entry.color ?? value.color, value.text);
+  const label =
+    entry.label === 'none'
+      ? ''
+      : entry.label === 'glyph'
+        ? `${theme.fg('dim', entry.def.glyph)} `
+        : `${theme.fg('dim', entry.def.word)} `;
+  const prefix = entry.prefix === '' ? '' : theme.fg('dim', entry.prefix);
+  const suffix = entry.suffix === '' ? '' : theme.fg('dim', entry.suffix);
+  return `${prefix}${label}${text}${suffix}`;
+}
+
+/**
+ * Renders one module, or returns null when it has nothing to show this frame.
+ *
+ * A module that is empty (no branch, no output yet, no rate yet) contributes no divider either, so
+ * the row never shows a dangling `·`.
+ */
+export function renderModule(theme: Theme, entry: ResolvedEntry, parts: StatusLineParts): string | null {
+  const value = entry.def.value(parts, entry.format);
+  return value === null ? null : labelled(theme, entry, value);
+}

package/extensions/status-line/render.ts

@@ -0,0 +1,160 @@
+/**
+ * The layout engine: one or more rows, each split into a left and a right group, and a fixed order
+ * in which modules give up their seat as the terminal narrows.
+ *
+ * The reference footer hard-coded both its two rows and the shrink ladder inside one function. Here
+ * the rows are configuration and the ladder is data — each module's registry `priority` — so the
+ * renderer only has to drop the lowest priority on the row that overflows and re-measure it. Each
+ * row shrinks on its own, so a long working directory never costs the metrics their seats. Floor
+ * modules (context) are never dropped by that pass; when even they do not fit, the row degrades to a
+ * plain truncation instead of a half-rendered module.
+ */
+
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+
+import { type ResolvedEntry, renderModule, type StatusLineParts } from './modules.ts';
+
+/** Minimum air between the left and right groups of one row. */
+const GROUP_GAP = 2;
+
+/** One row of the footer: a left group and a right group, each with its own separator. */
+export interface Row {
+  left: ResolvedEntry[];
+  right: ResolvedEntry[];
+  divider: string;
+  rightDivider: string;
+}
+
+/** A layout is the rows after config resolution. */
+export interface Layout {
+  rows: Row[];
+}
+
+interface Placed {
+  entry: ResolvedEntry;
+  side: 'left' | 'right';
+}
+
+interface ComposedRow {
+  left: string;
+  right: string;
+  /** The width the row needs; zero when the row has nothing to show. */
+  needed: number;
+  /** How many modules actually rendered this frame. */
+  count: number;
+}
+
+/** Joins one group's module strings, skipping modules that have nothing to show this frame. */
+function composeGroup(
+  theme: Theme,
+  entries: readonly ResolvedEntry[],
+  parts: StatusLineParts,
+  divider: string,
+): { text: string; count: number } {
+  const sep = divider === '' ? '' : theme.fg('dim', divider);
+  const rendered = entries
+    .map((entry) => renderModule(theme, entry, parts))
+    .filter((text): text is string => text !== null);
+  return { text: rendered.join(sep), count: rendered.length };
+}
+
+/** The row as it currently reads, with visible modules only. */
+function composeRow(
+  theme: Theme,
+  configRow: Row,
+  placed: readonly Placed[],
+  parts: StatusLineParts,
+  dropped: ReadonlySet<Placed>,
+): ComposedRow {
+  const visible = placed.filter((item) => !dropped.has(item));
+  const left = composeGroup(
+    theme,
+    visible.filter((item) => item.side === 'left').map((item) => item.entry),
+    parts,
+    configRow.divider,
+  );
+  const right = composeGroup(
+    theme,
+    visible.filter((item) => item.side === 'right').map((item) => item.entry),
+    parts,
+    configRow.rightDivider,
+  );
+  const needed =
+    left.text === '' && right.text === ''
+      ? 0
+      : visibleWidth(left.text) + (right.text === '' ? 0 : GROUP_GAP + visibleWidth(right.text));
+  return { left: left.text, right: right.text, needed, count: left.count + right.count };
+}
+
+/** Left group and right group on one line, padded to `width`. */
+export function row(theme: Theme, width: number, left: string, right: string): string {
+  const leftWidth = visibleWidth(left);
+  const rightWidth = right === '' ? 0 : visibleWidth(right);
+  if (leftWidth > 0 && rightWidth > 0) {
+    if (leftWidth + rightWidth <= width) {
+      return left + ' '.repeat(width - leftWidth - rightWidth) + right;
+    }
+    // Both groups exist but the row is too wide even after shrinking: keep the left group and
+    // cut the right one, which is how the native footer spends its last columns.
+    const available = width - leftWidth - GROUP_GAP;
+    if (available > 0) {
+      const truncated = truncateToWidth(right, available, '');
+      const truncatedWidth = visibleWidth(truncated);
+      return left + ' '.repeat(Math.max(0, width - leftWidth - truncatedWidth)) + truncated;
+    }
+    return truncateToWidth(left, width, theme.fg('dim', '…'));
+  }
+  if (rightWidth > 0) {
+    return truncateToWidth(' '.repeat(Math.max(0, width - rightWidth)) + right, width, theme.fg('dim', '…'));
+  }
+  return truncateToWidth(left, width, theme.fg('dim', '…'));
+}
+
+/**
+ * Shrinks one row until it fits, then paints it.
+ *
+ * Modules render in the order the user listed them on their side. When the row overflows, its
+ * lowest-priority non-floor module is removed, whichever side it sits on, and the row is measured
+ * again — so a right-side module can outlive a left-side one if its priority says so.
+ */
+function renderRow(theme: Theme, width: number, configRow: Row, parts: StatusLineParts): string | null {
+  const placed: Placed[] = [
+    ...configRow.left.map((entry): Placed => ({ entry, side: 'left' })),
+    ...configRow.right.map((entry): Placed => ({ entry, side: 'right' })),
+  ];
+  const droppable = placed
+    .filter((item) => !item.entry.def.floor)
+    .sort((a, b) => a.entry.def.priority - b.entry.def.priority);
+
+  const dropped = new Set<Placed>();
+  let composed = composeRow(theme, configRow, placed, parts, dropped);
+  for (const item of droppable) {
+    if (composed.needed <= width) break;
+    // The last module on a row truncates rather than vanishing: a narrow footer still names the
+    // directory, and a lone context reading still shows its percentage.
+    if (composed.count <= 1) break;
+    dropped.add(item);
+    composed = composeRow(theme, configRow, placed, parts, dropped);
+  }
+
+  if (composed.needed === 0) return null;
+  return row(theme, width, composed.left, composed.right);
+}
+
+/**
+ * The whole status line, one string per configured row.
+ *
+ * Rows with nothing to show are omitted rather than rendered blank. A footer component must return
+ * at least one line, so an explicitly cleared layout renders one blank row.
+ */
+export function renderStatusLine(theme: Theme, width: number, layout: Layout, parts: StatusLineParts): string[] {
+  const lines: string[] = [];
+  for (const row of layout.rows) {
+    const line = renderRow(theme, width, row, parts);
+    if (line !== null) lines.push(line);
+  }
+  return lines.length === 0 ? [''] : lines;
+}
+
+export { GROUP_GAP };

package/extensions/status-line/session-metrics.ts

@@ -0,0 +1,77 @@
+/**
+ * Session accounting for the status line: token volumes, cache reuse, and spend.
+ *
+ * The rules follow the reference footer, which followed pi's own usage records: every assistant
+ * message and every tool result carries `usage`, and compaction and branch-summary entries bill a
+ * model call of their own. The cache hit rate is the most recent assistant turn's share of prompt
+ * tokens served from cache — the latest reading, not a session average that folds in cold starts.
+ *
+ * Entries arrive as `unknown` and are narrowed structurally, so a truncated or hand-edited session
+ * file degrades to a missing number instead of a thrown footer.
+ */
+
+export interface SessionTotals {
+  input: number;
+  output: number;
+  /** Share of the last assistant prompt served from cache, 0–100; null before any prompt. */
+  cacheHitRate: number | null;
+  /** Session spend in USD. */
+  cost: number;
+}
+
+interface UsageLike {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: { total: number };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function num(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
+/** A structurally valid usage record, or null when the entry has none. */
+function usageOf(value: unknown): UsageLike | null {
+  if (!isRecord(value)) return null;
+  const cost = isRecord(value.cost) ? value.cost : {};
+  return {
+    input: num(value.input),
+    output: num(value.output),
+    cacheRead: num(value.cacheRead),
+    cacheWrite: num(value.cacheWrite),
+    cost: { total: num(cost.total) },
+  };
+}
+
+export function collectTotals(entries: readonly unknown[]): SessionTotals {
+  const totals: SessionTotals = { input: 0, output: 0, cacheHitRate: null, cost: 0 };
+
+  const add = (usage: UsageLike | null, assistant: boolean): void => {
+    if (usage === null) return;
+    totals.input += usage.input;
+    totals.output += usage.output;
+    totals.cost += usage.cost.total;
+    if (!assistant) return;
+    const prompt = usage.input + usage.cacheRead + usage.cacheWrite;
+    if (prompt > 0) totals.cacheHitRate = (usage.cacheRead / prompt) * 100;
+  };
+
+  for (const entry of entries) {
+    if (!isRecord(entry)) continue;
+    if (entry.type === 'message' && isRecord(entry.message)) {
+      const role = entry.message.role;
+      if (role === 'assistant') add(usageOf(entry.message.usage), true);
+      else if (role === 'toolResult') add(usageOf(entry.message.usage), false);
+      continue;
+    }
+    // Compaction and branch summaries bill a model call of their own.
+    if (entry.type === 'compaction' || entry.type === 'branch_summary') add(usageOf(entry.usage), false);
+  }
+
+  return totals;
+}

package/extensions/status-line/throughput.ts

@@ -0,0 +1,36 @@
+/**
+ * The decode-rate contract: when a throughput number is honest and when it is absent.
+ *
+ * Follows the deepseek-harness turn-metrics definitions the reference footer used —
+ * `ttftMs = firstTokenTime - requestTime`, `decodeMs = completedTime - firstTokenTime`,
+ * `tok/s = output / (decodeMs / 1000)` — because those are the definitions pi's own metrics
+ * consumers understand. Everything takes its clocks as arguments, so the rules are testable and
+ * the renderer never reads the time itself.
+ */
+
+/** The window between dispatching a request and the first streamed delta. */
+export function ttftMs(requestAt: number | null, firstTokenAt: number | null): number | null {
+  if (requestAt === null || firstTokenAt === null) return null;
+  return firstTokenAt > requestAt ? firstTokenAt - requestAt : null;
+}
+
+/**
+ * The frozen whole-message rate once a message finishes.
+ *
+ * A decode window below the sample floor is a burst arrival — the message landed in one or two
+ * chunks — so there is no decode phase to measure. Reporting absence beats printing a confident
+ * `82000 tok/s` for an 82-token greeting.
+ */
+export function frozenThroughput(decodeMs: number, tokens: number, minSampleMs: number): number | null {
+  if (decodeMs < minSampleMs) return null;
+  return (tokens / decodeMs) * 1000;
+}
+
+/**
+ * The in-flight rate over a trailing window: how many tokens the stream added since the last
+ * sample, over the elapsed window. A zero-length window has no rate.
+ */
+export function windowThroughput(tokens: number, previousTokens: number, windowMs: number): number | null {
+  if (windowMs <= 0) return null;
+  return Math.max(0, ((tokens - previousTokens) / windowMs) * 1000);
+}

package/package.json

@@ -1,6 +1,46 @@
 {
   "name": "@cocasts/pi-status-line",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Modular multi-row status line for the pi coding agent — pick which modules sit on each row's left and right, and how each one is labelled and formatted",
+  "author": "moecasts <moecasts.caster@gmail.com>",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi-coding-agent",
+    "pi",
+    "status-line",
+    "statusline",
+    "footer",
+    "status",
+    "modular"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "files": [
+    "extensions/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions/status-line/index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "vitest": "^4.1.9"
+  }
+}