@groeponline/pi-wishcraft 0.20.0 → 0.22.0

package/src/extension/commands/commands.ts

@@ -7,6 +7,8 @@ import { PRESETS } from "../../config/presets.ts";
 import { registerCdCommand } from "../../shell/cd-command.ts";
 import { registerVibeCommand } from "./vibe-command.ts";
 import { registerQueueCommands } from "./queue-commands.ts";
+import { runPowerlineDoctor } from "./powerline-doctor.ts";
+import { runPowerlineExport } from "./powerline-export.ts";
 import { registerSkillManagerCommand } from "../skills/skill-manager.ts";
 import { registerWishcraftConfigCommand } from "../settings/wishcraft-config.ts";
 import { getRepairCounts } from "../hooks/index.ts";
@@ -14,10 +16,8 @@ import {
   writePowerlineOptionSetting,
   writePowerlinePresetSetting,
 } from "../settings/settings-io.ts";
-import {
-  showOpenPortsList,
-  showSelectOverlay,
-} from "../ui/menu-views.ts";
+import { showOpenPortsList, showSelectOverlay } from "../ui/menu-views.ts";
+import { showTpsOverlay, showUsageOverlay } from "../ui/token-overlays.ts";
 import { showPowerlineMainMenu } from "../ui/powerline-menu-view.ts";
 import { openStashHistory } from "../shortcuts/shortcuts-router.ts";
 import { ensureShellSession, setBashModeActive } from "./bash-mode-actions.ts";
@@ -27,6 +27,7 @@ import {
   requestStatusRender,
   resetLayoutCache,
 } from "../core/segment-context.ts";
+import { publishPowerlineStatuses } from "../core/status-export.ts";
 import { config, normalizePreset } from "../core/state.ts";
 import type { RuntimeState } from "../core/types.ts";
 import { getPowerlineArgumentCompletions } from "./powerline-completions.ts";
@@ -92,6 +93,14 @@ export function registerCommands(pi: ExtensionAPI, rt: RuntimeState): void {
       }
 
       const normalizedArgs = args.trim().toLowerCase();
+      if (normalizedArgs === "doctor") {
+        await runPowerlineDoctor(rt, ctx);
+        return;
+      }
+      if (normalizedArgs === "export") {
+        await runPowerlineExport(ctx);
+        return;
+      }
       const placementMatch = /^placement(?:\s+(above|below|toggle))?$/.exec(
         normalizedArgs,
       );
@@ -129,6 +138,7 @@ export function registerCommands(pi: ExtensionAPI, rt: RuntimeState): void {
       const preset = normalizePreset(args);
       if (preset) {
         config.preset = preset;
+        publishPowerlineStatuses(ctx, { preset });
         resetLayoutCache(rt);
         if (rt.enabled) {
           setupCustomEditor(pi, rt, ctx);
@@ -207,34 +217,42 @@ export function registerCommands(pi: ExtensionAPI, rt: RuntimeState): void {
     },
   });
 
+  pi.registerCommand("repairs", {
+    description: "Show tool-input repair stats (wishcraft harness layer)",
+    handler: async (_args, ctx) => {
+      const counts = getRepairCounts();
+      if (counts.size === 0) {
+        ctx.ui.notify("No tool-input repairs applied yet", "info");
+        return;
+      }
+      const summary = [...counts.entries()]
+        .map(([key, n]) => `${key}: ${n}×`)
+        .join("  ·  ");
+      ctx.ui.notify(`Repairs — ${summary}`, "info");
+    },
+  });
+
   pi.registerCommand("tps", {
-    description: "Show or set POWERLINE_TPS value",
+    description: "Show the live TPS overlay, or set POWERLINE_TPS",
     handler: async (args, ctx) => {
       rt.currentCtx = ctx;
       const value = args?.trim();
       if (!value) {
-        const current = process.env.POWERLINE_TPS || "not set";
-        ctx.ui.notify(`TPS: ${current}`, "info");
+        await showTpsOverlay(rt, ctx);
         return;
       }
       process.env.POWERLINE_TPS = value;
+      publishPowerlineStatuses(ctx, { tps: value });
       ctx.ui.notify(`TPS set to: ${value}`, "info");
       rt.tuiRef?.requestRender();
     },
   });
 
-  pi.registerCommand("repairs", {
-    description: "Show tool-input repair stats (wishcraft harness layer)",
+  pi.registerCommand("usage", {
+    description: "Show session / today / week token usage overlay",
     handler: async (_args, ctx) => {
-      const counts = getRepairCounts();
-      if (counts.size === 0) {
-        ctx.ui.notify("No tool-input repairs applied yet", "info");
-        return;
-      }
-      const summary = [...counts.entries()]
-        .map(([key, n]) => `${key}: ${n}×`)
-        .join("  ·  ");
-      ctx.ui.notify(`Repairs — ${summary}`, "info");
+      rt.currentCtx = ctx;
+      await showUsageOverlay(rt, ctx);
     },
   });
 

package/src/extension/commands/powerline-completions.ts

@@ -7,6 +7,14 @@ export const POWERLINE_SUBCOMMANDS: ReadonlyArray<{
   value: string;
   description: string;
 }> = [
+  {
+    value: "doctor",
+    description: "Run environment and settings diagnostics",
+  },
+  {
+    value: "export",
+    description: "Export the current status-line configuration",
+  },
   {
     value: "placement",
     description: "Move the primary row above or below the editor",

package/src/extension/commands/powerline-doctor.ts

@@ -0,0 +1,247 @@
+import { existsSync, readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import type { SelectItem } from "@earendil-works/pi-tui";
+
+import { PRESETS } from "../../config/presets.ts";
+import {
+  getProjectSettingsPath,
+  getSettingsPath,
+  readSettings,
+} from "../settings/settings-io.ts";
+import { getQueueStorePaths } from "../../../queue/store.ts";
+import { hasNerdFonts } from "../../theme/icons.ts";
+import { config } from "../core/state.ts";
+import type { RuntimeState } from "../core/types.ts";
+import { showSelectOverlay } from "../ui/menu-views.ts";
+
+export type DoctorStatus = "ok" | "warn" | "fail";
+
+export interface DoctorCheck {
+  status: DoctorStatus;
+  name: string;
+  detail: string;
+}
+
+function settingsFileHealth(path: string): DoctorStatus {
+  if (!existsSync(path)) return "warn";
+  try {
+    JSON.parse(readFileSync(path, "utf-8"));
+    return "ok";
+  } catch {
+    return "fail";
+  }
+}
+
+function gitPollingMode(): string {
+  const polling = config.segmentOptions?.git?.polling;
+  if (polling === "branch") return "branch-only";
+  if (polling === "off") return "off";
+  return "full";
+}
+
+/**
+ * Build the diagnostic report for `/powerline doctor`. Pure-ish: reads the
+ * filesystem/env for the checks, but performs no UI and never mutates state,
+ * so it can be unit-tested headlessly.
+ */
+export function buildDoctorReport(
+  rt: RuntimeState,
+  ctx: any,
+): DoctorCheck[] {
+  const cwd = ctx.cwd ?? process.cwd();
+  const checks: DoctorCheck[] = [];
+
+  // ── Settings ─────────────────────────────────────────────────────────────
+  const globalPath = getSettingsPath();
+  const projectPath = getProjectSettingsPath(cwd);
+  const globalHealth = settingsFileHealth(globalPath);
+  checks.push({
+    status: globalHealth,
+    name: "settings.global",
+    detail:
+      globalHealth === "fail"
+        ? `invalid JSON at ${globalPath}`
+        : globalHealth === "warn"
+          ? `not found (defaults in use) — ${globalPath}`
+          : `valid — ${globalPath}`,
+  });
+
+  const projectHealth = settingsFileHealth(projectPath);
+  checks.push({
+    status: projectHealth,
+    name: "settings.project",
+    detail:
+      projectHealth === "fail"
+        ? `invalid JSON at ${projectPath}`
+        : projectHealth === "warn"
+          ? "not present (global settings only)"
+          : `valid — ${projectPath}`,
+  });
+
+  const mergedSettings = readSettings(cwd);
+  const hasPowerlineKey =
+    typeof mergedSettings.powerline === "object" &&
+    mergedSettings.powerline !== null;
+  checks.push({
+    status: hasPowerlineKey ? "ok" : "warn",
+    name: "settings.powerline",
+    detail: hasPowerlineKey
+      ? "powerline key present"
+      : "no powerline key — defaults in use",
+  });
+
+  // ── Config validity ──────────────────────────────────────────────────────
+  const invalidEntries: string[] = [];
+  if (config.invalidPlacement)
+    invalidEntries.push(`placement "${config.invalidPlacement}"`);
+  for (const id of config.invalidDisabledSegments)
+    invalidEntries.push(`disabledSegment "${id}"`);
+  for (const id of config.invalidLayoutSegments)
+    invalidEntries.push(`layout "${id}"`);
+  checks.push({
+    status: invalidEntries.length > 0 ? "warn" : "ok",
+    name: "config",
+    detail:
+      invalidEntries.length > 0
+        ? `ignored: ${invalidEntries.join(", ")}`
+        : `no invalid entries (preset: ${config.preset})`,
+  });
+
+  const rawPowerline = mergedSettings.powerline;
+  const requestedPreset =
+    typeof rawPowerline === "object" &&
+    rawPowerline !== null &&
+    typeof (rawPowerline as Record<string, unknown>).preset === "string"
+      ? ((rawPowerline as Record<string, unknown>).preset as string).trim()
+      : null;
+  const customPresetNames = Object.keys(config.presets);
+  const unknownPreset =
+    requestedPreset &&
+    !Object.prototype.hasOwnProperty.call(PRESETS, requestedPreset) &&
+    !customPresetNames.includes(requestedPreset)
+      ? requestedPreset
+      : null;
+  checks.push({
+    status: unknownPreset ? "warn" : "ok",
+    name: "preset",
+    detail: unknownPreset
+      ? `unknown preset "${unknownPreset}" — using ${config.preset}`
+      : `active: ${config.preset}`,
+  });
+
+  // ── Nerd Fonts ───────────────────────────────────────────────────────────
+  const override = process.env.POWERLINE_NERD_FONTS;
+  const termProgram = process.env.TERM_PROGRAM || "";
+  let nerdReason = "";
+  if (override === "1") nerdReason = "forced via POWERLINE_NERD_FONTS=1";
+  else if (override === "0") nerdReason = "POWERLINE_NERD_FONTS=0 forces ASCII";
+  else if (process.env.GHOSTTY_RESOURCES_DIR)
+    nerdReason = "Ghostty detected";
+  else if (termProgram) nerdReason = `TERM_PROGRAM=${termProgram}`;
+  else nerdReason = "no known Nerd Font terminal detected";
+  checks.push({
+    status: hasNerdFonts() ? "ok" : "warn",
+    name: "nerd-fonts",
+    detail: hasNerdFonts()
+      ? `enabled (${nerdReason})`
+      : `disabled — ASCII glyphs (${nerdReason})`,
+  });
+
+  // ── Git ──────────────────────────────────────────────────────────────────
+  const gitProbe = spawnSync("git", ["--version"], {
+    encoding: "utf8",
+    timeout: 2000,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  if (gitProbe.error || gitProbe.status !== 0) {
+    checks.push({
+      status: "fail",
+      name: "git",
+      detail: "git binary not found — git segment cannot poll",
+    });
+  } else {
+    const repoProbe = spawnSync(
+      "git",
+      ["rev-parse", "--is-inside-work-tree"],
+      {
+        cwd,
+        encoding: "utf8",
+        timeout: 2000,
+        stdio: ["ignore", "pipe", "pipe"],
+      },
+    );
+    checks.push({
+      status: repoProbe.status === 0 ? "ok" : "warn",
+      name: "git",
+      detail:
+        repoProbe.status === 0
+          ? `polling: ${gitPollingMode()} — inside a git repo`
+          : `polling: ${gitPollingMode()} — not a git repo (segment hidden)`,
+    });
+  }
+
+  // ── Bash shell ───────────────────────────────────────────────────────────
+  const shell = rt.shellSession?.state;
+  const transcript = rt.bashTranscript.getSnapshot();
+  checks.push({
+    status: "ok",
+    name: "bash",
+    detail: rt.bashModeActive
+      ? `active — shell ${shell?.running ? "running" : "idle"}${shell?.shellName ? ` (${shell.shellName})` : ""}, transcript ${transcript.totalLines} lines`
+      : `inactive (ctrl+shift+b) — transcript ${transcript.totalLines} lines`,
+  });
+
+  // ── Queue store files ────────────────────────────────────────────────────
+  const { inboxPath, aliasesPath, archivePath } = getQueueStorePaths();
+  let malformed = 0;
+  let totalLines = 0;
+  if (existsSync(inboxPath)) {
+    for (const line of readFileSync(inboxPath, "utf-8").split("\n")) {
+      if (!line.trim()) continue;
+      totalLines += 1;
+      try {
+        JSON.parse(line);
+      } catch {
+        malformed += 1;
+      }
+    }
+  }
+  const staleLock = existsSync(`${inboxPath}.lock`);
+  const aliasesHealth = settingsFileHealth(aliasesPath);
+  const queueDetail = staleLock
+    ? `stale lock at ${inboxPath}.lock — a crashed writer may hold it`
+    : malformed > 0
+      ? `${malformed} malformed line${malformed === 1 ? "" : "s"} in inbox.jsonl (${totalLines} total)`
+      : totalLines === 0
+        ? "no items yet"
+        : `${totalLines} item${totalLines === 1 ? "" : "s"} in inbox.jsonl`;
+  checks.push({
+    status: staleLock || malformed > 0 || aliasesHealth === "fail"
+      ? "fail"
+      : "ok",
+    name: "queue",
+    detail: `${queueDetail}${aliasesHealth === "fail" ? ` — projects.json is invalid JSON` : ""}${existsSync(archivePath) ? ` — archive present` : ""}`,
+  });
+
+  return checks;
+}
+
+/** Render the doctor report as a scrollable overlay; enter copies a line. */
+export async function runPowerlineDoctor(
+  rt: RuntimeState,
+  ctx: any,
+): Promise<void> {
+  const checks = buildDoctorReport(rt, ctx);
+  const items: SelectItem[] = checks.map((check) => ({
+    label: `${check.status === "ok" ? "[ok]  " : check.status === "warn" ? "[warn]" : "[fail]"} ${check.name} — ${check.detail}`,
+    value: `${check.name}: ${check.detail}`,
+  }));
+  const picked = await showSelectOverlay(
+    ctx,
+    "Powerline doctor",
+    "↑↓ navigate · enter copy · esc close",
+    items,
+    Math.min(items.length, 20),
+  );
+  if (picked) ctx.ui.notify(picked.value, "info");
+}

package/src/extension/commands/powerline-export.ts

@@ -0,0 +1,94 @@
+import { copyToClipboard } from "@earendil-works/pi-coding-agent";
+import type { SelectItem } from "@earendil-works/pi-tui";
+
+import { getPreset } from "../../config/presets.ts";
+import {
+  mergeSegmentsWithCustomItems,
+  type PowerlineConfig,
+} from "../../config/powerline-config.ts";
+import type { StatusLineSegmentId } from "../../config/types.ts";
+import { config } from "../core/state.ts";
+import { showSelectOverlay } from "../ui/menu-views.ts";
+
+/**
+ * A settings-ready snapshot of the currently rendered powerline look. Pasted
+ * under `powerline` it reproduces the same preset + effective layout + labels
+ * (disabled segments are already filtered out of the layout groups).
+ */
+export interface PowerlineExportSnippet {
+  preset: string;
+  /** Included only when the user explicitly overrode the preset separator. */
+  separator?: string;
+  layout: {
+    left: StatusLineSegmentId[];
+    right: StatusLineSegmentId[];
+    secondary?: StatusLineSegmentId[];
+  };
+  /** Included only when at least one label is configured. */
+  segmentLabels?: Record<string, string>;
+}
+
+/** Resolve the effective segment layout for the current config (pure). */
+export function buildPowerlineExportSnippet(
+  cfg: PowerlineConfig,
+): PowerlineExportSnippet {
+  const presetDef = getPreset(cfg.preset);
+  const merged = mergeSegmentsWithCustomItems(presetDef, cfg.customItems, {
+    layout: cfg.layout,
+    disabledSegments: cfg.disabledSegments,
+  });
+
+  const layout: PowerlineExportSnippet["layout"] = {
+    left: [...merged.leftSegments],
+    right: [...merged.rightSegments],
+  };
+  if (merged.secondarySegments.length > 0) {
+    layout.secondary = [...merged.secondarySegments];
+  }
+
+  const snippet: PowerlineExportSnippet = { preset: cfg.preset, layout };
+  if (cfg.separator) snippet.separator = cfg.separator;
+  if (Object.keys(cfg.segmentLabels).length > 0) {
+    snippet.segmentLabels = { ...cfg.segmentLabels };
+  }
+  return snippet;
+}
+
+/** Pretty-print the export as the JSON users paste into settings.json. */
+export function formatPowerlineExport(snippet: PowerlineExportSnippet): string {
+  return JSON.stringify(snippet, null, 2);
+}
+
+/** Review the export in a scrollable overlay; Enter copies the full snippet. */
+export async function runPowerlineExport(ctx: any): Promise<void> {
+  const snippet = buildPowerlineExportSnippet(config);
+  const json = formatPowerlineExport(snippet);
+  const lines = json.split("\n");
+  const items: SelectItem[] = lines.map((line) => ({
+    label: line,
+    value: line,
+  }));
+
+  const picked = await showSelectOverlay(
+    ctx,
+    "Powerline export",
+    "↑↓ scroll · enter copy full snippet · esc close",
+    items,
+    Math.min(items.length, 24),
+  );
+  if (!picked) return;
+
+  let copied = false;
+  try {
+    await copyToClipboard(json);
+    copied = true;
+  } catch {
+    copied = false;
+  }
+  ctx.ui.notify(
+    copied
+      ? "Powerline config copied to clipboard"
+      : "Could not copy to clipboard; the snippet is shown above",
+    copied ? "info" : "warning",
+  );
+}

package/src/extension/commands/queue-commands.ts

@@ -12,6 +12,7 @@ import {
 } from "../queue/queue-integration.ts";
 import { getCurrentEditorText } from "../shortcuts/shortcuts-router.ts";
 import { getQueueContext } from "../queue/queue-context.ts";
+import { config } from "../core/state.ts";
 import type { RuntimeState } from "../core/types.ts";
 
 export function registerQueueCommands(
@@ -210,6 +211,30 @@ export function registerQueueCommands(
         return;
       }
 
+      if (action === "archive") {
+        const hoursArg = Number(parts[1]);
+        const hours =
+          Number.isFinite(hoursArg) && hoursArg > 0
+            ? Math.min(hoursArg, 24 * 365)
+            : config.queue.retentionHours;
+        const result = rt.queueStore.archiveSentItems(
+          hours * 60 * 60 * 1000,
+        );
+        if (result.archived === 0) {
+          ctx.ui.notify(
+            `Nothing to archive — ${result.remainingSent} sent item${result.remainingSent === 1 ? " is" : "s are"} newer than ${hours}h (retention: powerline.queue.retentionHours)`,
+            "info",
+          );
+        } else {
+          ctx.ui.notify(
+            `Archived ${result.archived} sent item${result.archived === 1 ? "" : "s"} older than ${hours}h to inbox.archive.jsonl`,
+            "info",
+          );
+        }
+        requestQueueRender(rt);
+        return;
+      }
+
       if (action === "target") {
         const id = parts[1];
         const spec = parts[2];
@@ -239,7 +264,10 @@ export function registerQueueCommands(
         return;
       }
 
-      ctx.ui.notify("Usage: /queue [send|retry|clear|target|alias]", "info");
+      ctx.ui.notify(
+        "Usage: /queue [send|retry|clear|target|alias|archive [hours]]",
+        "info",
+      );
     },
   });
 }

package/src/extension/commands/vibe-command.ts

@@ -1,7 +1,10 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { copyToClipboard } from "@earendil-works/pi-coding-agent";
+import type { SelectItem } from "@earendil-works/pi-tui";
 
 import {
   generateVibesBatch,
+  generateVibeSamples,
   getVibeFileCount,
   getVibeMode,
   getVibeModel,
@@ -12,6 +15,7 @@ import {
   setVibeModel,
   setVibeTheme,
 } from "../../working-vibes/index.ts";
+import { showSelectOverlay } from "../ui/menu-views.ts";
 
 export async function runVibeCommand(args: string, ctx: any): Promise<void> {
   const parts = args?.trim().split(/\s+/) || [];
@@ -114,6 +118,50 @@ export async function runVibeCommand(args: string, ctx: any): Promise<void> {
     return;
   }
 
+  // /vibe test <theme> - preview 3 sample vibes without committing the theme
+  if (subcommand === "test") {
+    const theme = parts.slice(1).join(" ").trim();
+    if (!theme) {
+      ctx.ui.notify("Usage: /vibe test <theme>", "error");
+      return;
+    }
+    ctx.ui.notify(`Previewing 3 sample vibes for "${theme}"...`, "info");
+
+    const result = await generateVibeSamples(theme, 3);
+    if (!result.success) {
+      ctx.ui.notify(`Failed to preview vibes: ${result.error}`, "error");
+      return;
+    }
+
+    const items: SelectItem[] = result.samples.map((sample, index) => ({
+      label: `${index + 1}. ${sample}`,
+      value: sample,
+    }));
+    const picked = await showSelectOverlay(
+      ctx,
+      `Vibe preview — "${result.theme}"`,
+      "↑↓ scroll · enter copy /vibe command · esc close",
+      items,
+      Math.min(items.length, 6),
+    );
+    if (!picked) return;
+
+    let copied = false;
+    try {
+      await copyToClipboard(`/vibe ${result.theme}`);
+      copied = true;
+    } catch {
+      copied = false;
+    }
+    ctx.ui.notify(
+      copied
+        ? `Copied: /vibe ${result.theme}`
+        : `Run /vibe ${result.theme} to apply this theme`,
+      copied ? "info" : "warning",
+    );
+    return;
+  }
+
   // /vibe off - disable
   if (subcommand === "off") {
     const persisted = setVibeTheme(null);
@@ -151,7 +199,7 @@ export async function runVibeCommand(args: string, ctx: any): Promise<void> {
 export function registerVibeCommand(pi: ExtensionAPI): void {
   pi.registerCommand("vibe", {
     description:
-      "Set working message theme. Usage: /vibe [theme|off|mode|model|generate]",
+      "Set working message theme. Usage: /vibe [theme|off|mode|model|generate|test]",
     handler: async (args, ctx) => {
       runVibeCommand(args, ctx);
     },

package/src/extension/core/constants.ts

@@ -22,6 +22,7 @@ export const DEFAULT_BASH_MODE_SETTINGS = {
   toggleShortcut: "ctrl+shift+b",
   transcriptMaxLines: 2000,
   transcriptMaxBytes: 512 * 1024,
+  initScript: null,
 } as const satisfies BashModeSettings;
 export const SHORTCUT_KEYS: PowerlineShortcutKey[] = [
   "stashHistory",

package/src/extension/core/segment-context.ts

@@ -7,17 +7,27 @@ import type { SegmentContext, ColorScheme } from "../../config/types.ts";
 import { getPreset } from "../../config/presets.ts";
 import {
   collectHiddenExtensionStatusKeys,
+  deriveAutoCustomItems,
   mergeSegmentOptions,
 } from "../../config/powerline-config.ts";
 import { getDefaultColors } from "../../theme/theme.ts";
 import { getGitStatus } from "../../git/status.ts";
 import { getQueueContext } from "../queue/queue-context.ts";
 import { getUsageTokenTotal } from "../../usage/ledger.ts";
+import {
+  dayKey,
+  loadUsageFileFromDisk,
+  tokenTotal,
+  totalsForRange,
+} from "../../usage/usage-store.ts";
+import { parseTokenBudget } from "../../usage/token-budget.ts";
+import { readSettings } from "../settings/settings-io.ts";
 import {
   CUSTOM_COMPACTION_STATUS_KEY,
   EDITOR_STATUS_DEFER_MS,
 } from "./constants.ts";
 import { config, customCompactionEnabled } from "./state.ts";
+import { HIDDEN_POWERLINE_STATUS_KEYS } from "./status-export.ts";
 import type { RuntimeState } from "./types.ts";
 
 /**
@@ -154,12 +164,26 @@ export function buildSegmentContext(
   const gitStatus = getGitStatus(gitBranch, segmentOptions.git?.polling);
   const extensionStatuses =
     rt.footerDataRef?.getExtensionStatuses() ?? new Map();
+  const excludedStatusKeys = new Set<string>([
+    CUSTOM_COMPACTION_STATUS_KEY,
+    "stash",
+    ...HIDDEN_POWERLINE_STATUS_KEYS,
+  ]);
+  const effectiveCustomItems = deriveAutoCustomItems(
+    config.customItems,
+    extensionStatuses,
+    config.customItemsAuto,
+    excludedStatusKeys,
+  );
   const customItemsById = new Map(
-    config.customItems.map((item) => [item.id, item]),
+    effectiveCustomItems.map((item) => [item.id, item]),
   );
   const hiddenExtensionStatusKeys = collectHiddenExtensionStatusKeys(
-    config.customItems,
+    effectiveCustomItems,
   );
+  for (const key of HIDDEN_POWERLINE_STATUS_KEYS) {
+    hiddenExtensionStatusKeys.add(key);
+  }
 
   // Check if using OAuth subscription
   const usingSubscription = ctx.model
@@ -201,8 +225,20 @@ export function buildSegmentContext(
     extensionStatuses,
     hiddenExtensionStatusKeys,
     customItemsById,
+    effectiveCustomItems,
     options: segmentOptions,
     segmentLabels: new Map(Object.entries(config.segmentLabels)),
+    tokenBudget: (() => {
+      const dailyLimit = parseTokenBudget(
+        readSettings(ctx.cwd ?? process.cwd()).wishcraft,
+      ).daily;
+      const now = Date.now();
+      const todayStart = Date.parse(`${dayKey(now)}T00:00:00`);
+      const dailyUsed = tokenTotal(
+        totalsForRange(loadUsageFileFromDisk(), todayStart, now + 1),
+      );
+      return { dailyLimit, dailyUsed };
+    })(),
     theme,
     colors,
   };