@groeponline/pi-wishcraft 0.20.0 → 0.22.0

package/docs/stash-and-shortcuts.md

@@ -0,0 +1,64 @@
+# Stash & shortcuts
+
+## Editor stash
+
+Use `Alt+S` / `Option+S` as a quick stash toggle while drafting. It keeps one active stash and clears the editor when stashing. Powerline listens for unambiguous Alt/Meta-S escape encodings by default. If your old terminal setup only emits the printable German sharp-S character for Option+S and you still want that to trigger stash, set `"stashSharpSShortcut": true` under `powerline`.
+
+| Editor | Stash | `Alt+S` result |
+|--------|-------|----------------|
+| Has text | Empty | Stash current text, clear editor |
+| Empty | Has stash | Restore stash into editor |
+| Has text | Has stash | Update stash with current text, clear editor |
+| Empty | Empty | Show "Nothing to stash" |
+
+Auto-restore after an agent run only happens when the editor is still empty. If you typed meanwhile, the stash is preserved.
+
+The `stash` indicator appears in the powerline bar (on presets with `extension_statuses`). Active stash is still session-local and resets on session switch / disable, but stash history is persisted to the agent dir at `powerline-footer/stash-history.json` so it survives restarts. By default the agent dir is `~/.pi/agent`; set `PI_CODING_AGENT_DIR` to move global powerline settings, stash history, sessions, vibes, skills, commands, and extension discovery with Pi.
+
+## Stash history
+
+Open prompt history with either:
+
+- `ctrl+alt+h`
+- `/stash-history`
+
+Prompt history now has two sources:
+
+- stashed prompts: up to 12 recent stashed prompts (newest first)
+- recent project prompts: up to 50 recent user-submitted prompts pulled from pi sessions in the current project folder
+
+Selecting a stashed entry lets you insert it or promote it to an idea. Project prompt history entries insert into the editor. If the editor already has text, you can choose `Replace`, `Append`, or `Cancel`.
+
+## Editor clipboard and navigation shortcuts
+
+- `ctrl+alt+c`: copy full editor content
+- `ctrl+alt+x`: cut full editor content (copy, then clear)
+- `ctrl+alt+q`: open the queued-prompt picker
+- `cmd+shift+up`: move the editor cursor to the start of the first line
+- `cmd+shift+down`: move the editor cursor to the end of the last line
+
+Copy/cut actions do not modify stash state or stash history. Dragging files, folders, images, or screenshots from Finder into the custom editor inserts their path strings. Pi owns chat scrolling, selection, and fixed input behavior natively.
+
+## Shortcut configuration
+
+You can override shortcut keys in the agent settings file:
+
+```json
+{
+  "powerlineShortcuts": {
+    "stashHistory": "ctrl+alt+h",
+    "copyEditor": "ctrl+alt+c",
+    "cutEditor": "ctrl+alt+x",
+    "ideaCapture": null,
+    "queueOpen": "ctrl+alt+q",
+    "editorStart": "cmd+shift+up",
+    "editorEnd": "cmd+shift+down"
+  }
+}
+```
+
+After changing bindings, run `/reload`. Invalid bindings, reserved key conflicts like `Alt+S`, or duplicate conflicts fall back to safe defaults. Set a binding to `null` or `""` to disable that action. `cmd` and `command` are accepted aliases for Pi's `super` modifier for the documented Command navigation keys.
+
+## Editor autocomplete composition
+
+Powerline wraps Pi's autocomplete provider so bash mode can add shell-aware suggestions. When another editor extension was already installed, powerline now passes Pi's provider through that previous editor's `setAutocompleteProvider()` first and then wraps the resulting provider. This preserves prior autocomplete-provider wrappers where possible, but it is not full render/input composition between custom editors.

package/docs/working-vibes.md

@@ -0,0 +1,71 @@
+# Working vibes
+
+Transform boring "Working..." messages into themed phrases that match your style:
+
+```text
+/vibe star trek    → "Running diagnostics...", "Engaging warp drive..."
+/vibe pirate       → "Hoisting the sails...", "Charting course..."
+/vibe zen          → "Breathing deeply...", "Finding balance..."
+/vibe noir         → "Following the trail...", "Checking the angles..."
+/vibe              → Shows current theme, mode, and model
+/vibe off          → Disables (back to "Working...")
+/vibe model        → Shows current model
+/vibe model openai/gpt-4o-mini → Use a different model
+/vibe mode         → Shows current mode (generate or file)
+/vibe mode file    → Switch to file-based mode (instant, no API calls)
+/vibe mode generate → Switch to on-demand generation (contextual)
+/vibe generate mafia 200 → Pre-generate 200 vibes and save to file
+/vibe test mafia          → Preview 3 sample vibes without committing the theme
+```
+
+## Configuration
+
+In the agent settings file:
+
+```json
+{
+  "workingVibe": "star trek",                              // Theme phrase
+  "workingVibeMode": "generate",                           // "generate" (on-demand) or "file" (pre-generated)
+  "workingVibeModel": "openai-codex/gpt-5.4-mini",         // Optional: model to use (default)
+  "workingVibeFallback": "Working",                        // Optional: fallback message
+  "workingVibeRefreshInterval": 30,                        // Optional: seconds between refreshes (default 30)
+  "workingVibePrompt": "Generate a {theme} loading message for: {task}",  // Optional: custom prompt template
+  "workingVibeMaxLength": 65                         // Optional: max message length (default 65)
+}
+```
+
+## Modes
+
+| Mode | Description | Pros | Cons |
+|------|-------------|------|------|
+| `generate` | On-demand AI generation (default) | Contextual, hints at actual task | Model-dependent cost and latency |
+| `file` | Pull from pre-generated file | Instant, zero cost, works offline | Not contextual |
+
+**File mode setup:**
+
+```bash
+/vibe generate mafia 200    # Generate 200 vibes, save to the agent dir
+/vibe mode file             # Switch to file mode
+/vibe mafia                 # Now uses the file
+```
+
+**How file mode works:**
+
+1. Vibes are loaded from `vibes/{theme}.txt` in the agent dir into memory
+2. Uses seeded shuffle (Mulberry32 PRNG): cycles through all vibes before repeating
+3. New seed each session: different order every time you restart pi
+4. Zero latency, zero cost, works offline
+
+**Prompt template variables (generate mode only):**
+
+- `{theme}`: the current vibe theme (e.g., "star trek", "mafia")
+- `{task}`: context hint (user prompt initially, then agent's response text or tool info on refresh)
+- `{exclude}`: recent vibes to avoid (auto-populated, e.g., "Don't use: vibe1, vibe2...")
+
+**How it works:**
+
+1. When you send a message, shows "Channeling {theme}..." placeholder
+2. AI generates a themed message in the background (3s timeout)
+3. Message updates to the themed version (e.g., "Engaging warp drive...")
+4. During long tasks, refreshes on tool calls (rate-limited, default 30s)
+5. Cost and latency depend on your configured `workingVibeModel`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groeponline/pi-wishcraft",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "Wishcraft cockpit for the pi coding agent — powerline status, vibes, idea inbox, bash mode, and full customization.",
   "type": "module",
   "files": [
@@ -8,6 +8,7 @@
     "*.md",
     "*.json",
     "banner.png",
+    "docs/**/*.md",
     "src/**/*.ts",
     "src/**/*.txt",
     "bash-mode/**/*.ts",

package/queue/store.ts

@@ -23,7 +23,9 @@ import { ACTIVE_QUEUE_STATUSES } from "./types.ts";
 
 const STORE_DIR = "powerline-footer";
 const INBOX_FILE = "inbox.jsonl";
+const ARCHIVE_FILE = "inbox.archive.jsonl";
 const ALIASES_FILE = "projects.json";
+const DEFAULT_SENT_RETENTION_MS = 24 * 60 * 60 * 1000;
 const LOCK_RETRY_MS = 25;
 const LOCK_TIMEOUT_MS = 2000;
 
@@ -126,10 +128,12 @@ function sleepSync(ms: number): void {
 export function getQueueStorePaths(): {
   inboxPath: string;
   aliasesPath: string;
+  archivePath: string;
 } {
   return {
     inboxPath: getAgentPath(STORE_DIR, INBOX_FILE),
     aliasesPath: getAgentPath(STORE_DIR, ALIASES_FILE),
+    archivePath: getAgentPath(STORE_DIR, ARCHIVE_FILE),
   };
 }
 
@@ -155,13 +159,23 @@ export function createQueueItem(
 export class PowerlineQueueStore {
   private readonly inboxPath: string;
   private readonly aliasesPath: string;
+  private readonly archivePath: string;
+  /** How long completed (sent) items stay in the inbox before pruning/archiving. */
+  private sentRetentionMs: number = DEFAULT_SENT_RETENTION_MS;
 
   constructor(
     inboxPath: string = getQueueStorePaths().inboxPath,
     aliasesPath: string = getQueueStorePaths().aliasesPath,
+    archivePath: string = getQueueStorePaths().archivePath,
   ) {
     this.inboxPath = inboxPath;
     this.aliasesPath = aliasesPath;
+    this.archivePath = archivePath;
+  }
+
+  /** Configure the retention window for completed items (clamped to >= 1 hour). */
+  setSentRetentionMs(ms: number): void {
+    this.sentRetentionMs = Math.max(60 * 60 * 1000, Number.isFinite(ms) ? ms : DEFAULT_SENT_RETENTION_MS);
   }
 
   list(): PowerlineQueueItem[] {
@@ -323,13 +337,16 @@ export class PowerlineQueueStore {
     }
   }
 
-  private writeItems(items: readonly PowerlineQueueItem[]): void {
+  private writeItems(
+    items: readonly PowerlineQueueItem[],
+    now: number = Date.now(),
+  ): void {
     mkdirSync(dirname(this.inboxPath), { recursive: true });
+    const retentionCutoff = now - this.sentRetentionMs;
     const activeOrRecent = items
       .filter(
         (item) =>
-          item.status !== "sent" ||
-          Date.now() - item.updatedAt < 24 * 60 * 60 * 1000,
+          item.status !== "sent" || item.updatedAt >= retentionCutoff,
       )
       .map((item) => JSON.stringify(item))
       .join("\n");
@@ -339,6 +356,58 @@ export class PowerlineQueueStore {
     );
   }
 
+  /**
+   * Move completed (sent) items older than the retention window out of the
+   * inbox into the archive file, keeping the inbox lean. Returns how many
+   * items were archived and how many sent items remain in the inbox.
+   *
+   * `archiveSentItems` and `writeItems` share one `now` snapshot so a sent
+   * item counted as remaining cannot be pruned on the same write.
+   */
+  archiveSentItems(olderThanMs: number = this.sentRetentionMs): {
+    archived: number;
+    remainingSent: number;
+  } {
+    return this.withStoreLock(() => {
+      const now = Date.now();
+      const items = this.list();
+      // writeItems prunes sent items older than sentRetentionMs on every write.
+      // If the requested archive window were wider than that, items in the gap
+      // would be silently dropped (neither archived nor kept) while still being
+      // reported as "remaining". Clamp the cutoff so anything past the inbox
+      // retention window is archived rather than lost.
+      const effectiveOlderThanMs = Math.min(olderThanMs, this.sentRetentionMs);
+      const cutoff = now - effectiveOlderThanMs;
+      const archived: PowerlineQueueItem[] = [];
+      const kept: PowerlineQueueItem[] = [];
+      let remainingSent = 0;
+
+      for (const item of items) {
+        if (item.status === "sent" && item.updatedAt < cutoff) {
+          archived.push(item);
+        } else {
+          kept.push(item);
+          if (item.status === "sent") remainingSent += 1;
+        }
+      }
+
+      if (archived.length > 0) {
+        mkdirSync(dirname(this.archivePath), { recursive: true });
+        const existing = existsSync(this.archivePath)
+          ? readFileSync(this.archivePath, "utf-8")
+          : "";
+        const lines = archived.map((item) => JSON.stringify(item)).join("\n");
+        this.writeAtomic(
+          this.archivePath,
+          `${existing.trimEnd() ? `${existing.trimEnd()}\n` : ""}${lines}\n`,
+        );
+        this.writeItems(kept, now);
+      }
+
+      return { archived: archived.length, remainingSent };
+    });
+  }
+
   private writeJson(path: string, value: unknown): void {
     mkdirSync(dirname(path), { recursive: true });
     this.writeAtomic(path, `${JSON.stringify(value, null, 2)}\n`);

package/src/config/custom-items.ts

@@ -9,6 +9,7 @@ import {
 } from "./primitives.ts";
 import { normalizeSegmentOptions } from "./segment-options.ts";
 import { normalizeStatusLineSegmentId } from "./segment-ids.ts";
+import { isNotificationExtensionStatus } from "./extension-statuses.ts";
 import type {
   ColorScheme,
   CustomSegmentConfig,
@@ -180,3 +181,47 @@ export function normalizeCustomItems(raw: unknown): CustomStatusItem[] {
 
   return [...deduped.values()];
 }
+
+/**
+ * `powerline.customItems.auto` — when `customItems` is an object/record with
+ * an `auto: true` key, offer live extension status keys as segments without
+ * listing each one explicitly (the ChefBar status bridge).
+ */
+export function normalizeCustomItemsAuto(raw: unknown): boolean {
+  if (isRecord(raw)) return raw.auto === true;
+  return false;
+}
+
+/**
+ * Build the effective custom item list at render time. When `enabled`, every
+ * non-notification extension status key becomes an implicit right-aligned
+ * custom item unless it is already claimed by an explicit item, is an
+ * excluded internal key, or is not a valid segment id. Auto items are marked
+ * `excludeFromExtensionStatuses` so each status renders exactly once.
+ */
+export function deriveAutoCustomItems(
+  customItems: readonly CustomStatusItem[],
+  extensionStatuses: ReadonlyMap<string, string>,
+  enabled: boolean,
+  excludedStatusKeys: ReadonlySet<string>,
+): CustomStatusItem[] {
+  if (!enabled) return [...customItems];
+
+  const claimed = new Set(customItems.map((item) => item.statusKey));
+  const auto: CustomStatusItem[] = [];
+  for (const [statusKey, value] of extensionStatuses) {
+    if (claimed.has(statusKey) || excludedStatusKeys.has(statusKey)) continue;
+    if (!normalizeCustomItemId(statusKey)) continue;
+    if (isNotificationExtensionStatus(value)) continue;
+
+    auto.push({
+      id: statusKey,
+      statusKey,
+      position: "right",
+      hideWhenMissing: true,
+      excludeFromExtensionStatuses: true,
+    });
+  }
+
+  return [...customItems, ...auto];
+}

package/src/config/parse.ts

@@ -1,13 +1,16 @@
 import {
   normalizeCustomItems,
+  normalizeCustomItemsAuto,
   normalizeCustomPresets,
   normalizeCustomSegments,
 } from "./custom-items.ts";
 import {
   isRecord,
   normalizeCaptureSigil,
+  normalizeCostAlert,
   normalizePlacement,
   normalizePreset,
+  normalizeRetentionHours,
   normalizeSegmentLabels,
   normalizeSeparator,
 } from "./primitives.ts";
@@ -37,7 +40,11 @@ export interface PowerlineConfig {
   invalidPlacement: string | null;
   welcome: boolean;
   stashSharpSShortcut: boolean;
-  queue: { captureSigil: string | false };
+  /** Session cost threshold (USD) for a once-per-session warning. */
+  costAlert: number | null;
+  /** Auto-promote live extension status keys into `custom:<key>` segments. */
+  customItemsAuto: boolean;
+  queue: { captureSigil: string | false; retentionHours: number };
   /** User-defined computed segments (command/env/static), keyed by id */
   segments: Record<string, CustomSegmentConfig>;
   /** User-defined presets, keyed by name */
@@ -63,7 +70,9 @@ export function parsePowerlineConfig(
     invalidPlacement: null,
     welcome: true,
     stashSharpSShortcut: false,
-    queue: { captureSigil: "#" },
+    costAlert: null,
+    customItemsAuto: false,
+    queue: { captureSigil: "#", retentionHours: 24 },
     segments: {},
     presets: {},
     segmentLabels: {},
@@ -90,7 +99,10 @@ export function parsePowerlineConfig(
   );
   const { placement, invalidPlacement } = normalizePlacement(value.placement);
   const queue = isRecord(value.queue)
-    ? { captureSigil: normalizeCaptureSigil(value.queue.captureSigil) }
+    ? {
+        captureSigil: normalizeCaptureSigil(value.queue.captureSigil),
+        retentionHours: normalizeRetentionHours(value.queue.retentionHours),
+      }
     : defaultConfig.queue;
   const customItemIds = new Set(customItems.map((item) => item.id));
   const customPresetDefs = normalizeCustomPresets(
@@ -119,6 +131,10 @@ export function parsePowerlineConfig(
     invalidPlacement,
     welcome: value.welcome !== false,
     stashSharpSShortcut: value.stashSharpSShortcut === true,
+    costAlert: normalizeCostAlert(value.costAlert),
+    customItemsAuto:
+      normalizeCustomItemsAuto(value.customItems) ||
+      value.customItemsAuto === true,
     queue,
     segments: customSegments,
     presets: customPresetDefs,

package/src/config/powerline-config.ts

@@ -6,6 +6,11 @@ export { parsePowerlineConfig } from "./parse.ts";
 export { mergeSegmentOptions } from "./segment-options.ts";
 export { mergeSegmentsWithCustomItems } from "./layout.ts";
 export {
+  deriveAutoCustomItems,
+  normalizeCustomItemsAuto,
+} from "./custom-items.ts";
+export {
+  nextPowerlineSettingWithCustomPreset,
   nextPowerlineSettingWithPreset,
   nextPowerlineSettingWithOptions,
 } from "./settings-patch.ts";

package/src/config/primitives.ts

@@ -40,7 +40,7 @@ export function normalizePlacement(value: unknown): {
   };
 }
 
-const SEPARATOR_STYLES = [
+export const SEPARATOR_STYLES = [
   "powerline",
   "powerline-thin",
   "slash",
@@ -97,6 +97,18 @@ export function normalizeCaptureSigil(value: unknown): string | false {
   return normalized && !/\s/.test(normalized) ? normalized : "#";
 }
 
+export function normalizeRetentionHours(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 24;
+  return Math.min(24 * 365, Math.max(1, Math.floor(value)));
+}
+
+export function normalizeCostAlert(value: unknown): number | null {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return null;
+  }
+  return Math.round(value * 100) / 100;
+}
+
 export function normalizeCustomSegmentType(
   value: unknown,
 ): "command" | "env" | "static" | null {

package/src/config/segment-options.ts

@@ -115,41 +115,46 @@ export function normalizeSegmentOptions(
       ...(typeof raw.openPorts.includeUdp === "boolean"
         ? { includeUdp: raw.openPorts.includeUdp }
         : {}),
+      ...(typeof raw.openPorts.host === "string" && raw.openPorts.host.trim()
+        ? { host: raw.openPorts.host.trim() }
+        : {}),
     };
   }
 
   if (isRecord(raw.tps)) {
     options.tps = {
-      // De lookback gebruikt [0.5·windowMs, 2·windowMs] binnen een 5s-ring, dus
-      // windowMs boven 2500 zou nooit een sample vinden. Afkappen op 2500.
       ...(typeof raw.tps.windowMs === "number" &&
-      Number.isFinite(raw.tps.windowMs) &&
-      raw.tps.windowMs > 0
-        ? { windowMs: Math.min(raw.tps.windowMs, 2500) }
-        : {}),
-      ...(raw.tps.mode === "both" ||
-      raw.tps.mode === "out" ||
-      raw.tps.mode === "in"
-        ? { mode: raw.tps.mode }
-        : {}),
-      ...(typeof raw.tps.hideIdle === "boolean"
-        ? { hideIdle: raw.tps.hideIdle }
+      Number.isFinite(raw.tps.windowMs)
+        ? { windowMs: Math.min(5000, Math.max(500, Math.floor(raw.tps.windowMs))) }
         : {}),
     };
   }
 
-  // GR: Generic per-segment template override (segmentOptions.<seg>.template) that
-  // applies to any segment id (incl. custom items). Kept alongside the typed fields
-  // above; read centrally at render time via the options record.
-  const optionsAsRecord = options as unknown as Record<
-    string,
-    { template?: string }
+  // Generic `template` override for every segment option group:
+  // segmentOptions.<id>.template: "{value} tok/s" replaces the value text.
+  const TEMPLATE_OPTION_KEYS = [
+    "model",
+    "path",
+    "git",
+    "time",
+    "cost",
+    "context",
+    "cache_read",
+    "openPorts",
+    "tps",
+  ] as const;
+  const genericOptions = options as Record<
+    (typeof TEMPLATE_OPTION_KEYS)[number],
+    { template?: string } | undefined
   >;
-  for (const [seg, segRaw] of Object.entries(raw)) {
-    if (!isRecord(segRaw)) continue;
-    if (typeof segRaw.template !== "string" || !segRaw.template.trim()) continue;
-    const holder = isRecord(optionsAsRecord[seg]) ? optionsAsRecord[seg] : {};
-    optionsAsRecord[seg] = { ...holder, template: segRaw.template.trim() };
+  for (const key of TEMPLATE_OPTION_KEYS) {
+    const rawOpt = raw[key];
+    if (isRecord(rawOpt) && typeof rawOpt.template === "string") {
+      const template = rawOpt.template.trim();
+      if (template) {
+        genericOptions[key] = { ...genericOptions[key], template };
+      }
+    }
   }
 
   return options;

package/src/config/settings-patch.ts

@@ -1,6 +1,6 @@
 import { isRecord } from "./primitives.ts";
 import type { PowerlineConfig } from "./parse.ts";
-import type { StatusLinePreset } from "./types.ts";
+import type { CustomPresetConfig, StatusLinePreset } from "./types.ts";
 
 export function nextPowerlineSettingWithPreset(
   existingPowerlineSetting: unknown,
@@ -12,10 +12,31 @@ export function nextPowerlineSettingWithPreset(
   return { ...existingPowerlineSetting, preset };
 }
 
+export function nextPowerlineSettingWithCustomPreset(
+  existingPowerlineSetting: unknown,
+  name: string,
+  presetDef: CustomPresetConfig,
+): unknown {
+  if (!isRecord(existingPowerlineSetting)) {
+    return { preset: name, presets: { [name]: presetDef } };
+  }
+  const existingPresets = isRecord(existingPowerlineSetting.presets)
+    ? existingPowerlineSetting.presets
+    : {};
+  return {
+    ...existingPowerlineSetting,
+    preset: name,
+    presets: { ...existingPresets, [name]: presetDef },
+  };
+}
+
 export function nextPowerlineSettingWithOptions(
   existingPowerlineSetting: unknown,
   updates: Partial<
-    Pick<PowerlineConfig, "welcome" | "stashSharpSShortcut" | "placement">
+    Pick<
+      PowerlineConfig,
+      "welcome" | "stashSharpSShortcut" | "placement" | "disabledSegments"
+    >
   >,
   currentPreset: StatusLinePreset,
 ): unknown {

package/src/config/types.ts

@@ -80,14 +80,23 @@ export type PowerlinePlacement = "above" | "below";
 export type StatusLinePreset =
   "default" | "minimal" | "compact" | "full" | "nerd" | "ascii" | "chef";
 
+// Optional `{value}` template override shared by all segment option groups.
+// Replaces `{value}` in the rendered value text (e.g. "{value} tok/s").
+export interface SegmentFormatOption {
+  template?: string;
+}
+
 // Per-segment options
 export interface StatusLineSegmentOptions {
-  model?: { showThinkingLevel?: boolean; display?: "name" | "qualified" };
-  path?: {
+  model?: SegmentFormatOption & {
+    showThinkingLevel?: boolean;
+    display?: "name" | "qualified";
+  };
+  path?: SegmentFormatOption & {
     mode?: "basename" | "abbreviated" | "full";
     maxLength?: number;
   };
-  git?: {
+  git?: SegmentFormatOption & {
     showBranch?: boolean;
     showStaged?: boolean;
     showUnstaged?: boolean;
@@ -103,25 +112,26 @@ export interface StatusLineSegmentOptions {
     /** Max length of the commit subject before truncation. Default 24. */
     maxCommitSubjectLength?: number;
   };
-  time?: { format?: "12h" | "24h"; showSeconds?: boolean };
-  cost?: {
+  time?: SegmentFormatOption & { format?: "12h" | "24h"; showSeconds?: boolean };
+  cost?: SegmentFormatOption & {
     subscriptionDisplay?: "subscription" | "reported-cost" | "both";
     currency?: CostCurrencyCode;
   };
-  context?: { format?: "full" | "percent" };
-  cache_read?: { format?: "tokens" | "percent" | "both" };
-  openPorts?: {
-    /** Include UDP listeners (mDNS/DHCP/ephemeral) in the count. Default false. */ includeUdp?: boolean;
+  context?: SegmentFormatOption & { format?: "full" | "percent" };
+  cache_read?: SegmentFormatOption & { format?: "tokens" | "percent" | "both" };
+  openPorts?: SegmentFormatOption & {
+    /** Include UDP listeners (mDNS/DHCP/ephemeral) in the count. Default false. */
+    includeUdp?: boolean;
+    /**
+     * SSH host to probe instead of the local machine (fleet open-ports).
+     * Best-effort, opt-in: requires passwordless/agent SSH to that host and
+     * falls back to `?` when the probe cannot run.
+     */
+    host?: string;
   };
-  tps?: {
-    /** Rolling window length (ms) for the tokens/sec lookback. Default 1000. */
+  tps?: SegmentFormatOption & {
+    /** Sliding rate window length in ms (default 1000; wider = smoother, e.g. 2000 for fast models). */
     windowMs?: number;
-    /** Which rates to show. Default "both". */
-    mode?: "both" | "out" | "in";
-    /** Hide the segment entirely when idle (both rates 0). Default false (show dim "0"). */
-    hideIdle?: boolean;
-    /** Render template applied centrally; {value} is the plain segment content. Overrides segmentLabels. */
-    template?: string;
   };
 }
 
@@ -241,12 +251,17 @@ export interface SegmentContext {
   extensionStatuses: ReadonlyMap<string, string>;
   hiddenExtensionStatusKeys: ReadonlySet<string>;
   customItemsById: ReadonlyMap<string, CustomStatusItem>;
+  /** Explicit custom items + auto-promoted status items (customItems.auto). */
+  effectiveCustomItems: readonly CustomStatusItem[];
 
   // Options
   options: StatusLineSegmentOptions;
   /** Per-segment custom text labels (from powerline.segmentLabels). */
   segmentLabels: ReadonlyMap<string, string>;
 
+  /** Daily token budget progress (wishcraft.tokenBudget.daily). */
+  tokenBudget?: { dailyLimit: number | null; dailyUsed: number };
+
   // Theming
   theme: ThemeLike;
   colors: ColorScheme;

package/src/extension/commands/bash-mode-actions.ts

@@ -43,6 +43,7 @@ export const ensureShellSession = async (
       () => requestStatusRender(rt),
       (command, cwd) =>
         appendProjectHistory(rt.currentCtx?.cwd ?? process.cwd(), command, cwd),
+      rt.bashModeSettings.initScript,
     );
   }
   await rt.shellSession.ensureReady();