@dietrichgebert/ponytail 4.8.1

package/hooks/ponytail-instructions.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+// Shared Ponytail instruction builder for Claude hooks and Pi extension.
+
+const fs = require('fs');
+const path = require('path');
+const { DEFAULT_MODE, normalizeMode, normalizePersistedMode } = require('./ponytail-config');
+
+const INDEPENDENT_MODES = new Set(['review']);
+const SKILL_PATH = path.join(__dirname, '..', 'skills', 'ponytail', 'SKILL.md');
+
+function filterSkillBodyForMode(body, mode) {
+  const effectiveMode = normalizeMode(mode) || DEFAULT_MODE;
+  const withoutFrontmatter = String(body || '').replace(/^---[\s\S]*?---\s*/, '');
+
+  // Only the intensity table rows and worked examples are mode-specific, and
+  // both are keyed by a mode name (lite/full/ultra). A bullet whose label is
+  // not a mode — e.g. "No unrequested abstractions: ..." — is a normal rule
+  // and must be kept verbatim.
+  return withoutFrontmatter
+    .split(/\r?\n/)
+    .filter((line) => {
+      const tableLabel = line.match(/^\|\s*\*\*(.+?)\*\*\s*\|/);
+      if (tableLabel) {
+        const labelMode = normalizeMode(tableLabel[1].trim());
+        if (labelMode) return labelMode === effectiveMode;
+      }
+
+      const exampleLabel = line.match(/^-\s*([^:]+):\s*/);
+      if (exampleLabel) {
+        const labelMode = normalizeMode(exampleLabel[1].trim());
+        if (labelMode) return labelMode === effectiveMode;
+      }
+
+      return true;
+    })
+    .join('\n');
+}
+
+function getFallbackInstructions(mode) {
+  return 'PONYTAIL MODE ACTIVE — level: ' + mode + '\n\n' +
+    'You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.\n\n' +
+    '## Persistence\n\n' +
+    'ACTIVE EVERY RESPONSE. No drift back to over-building. Still active if unsure. Off only: "stop ponytail" / "normal mode".\n\n' +
+    'Current level: **' + mode + '**. Switch: `/ponytail lite|full|ultra`.\n\n' +
+    '## The ladder\n\n' +
+    'Before any code, stop at the first rung that holds (the ladder runs after you understand the problem, not instead of it — read the code it touches and trace the real flow first):\n' +
+    '1. Does this need to be built at all? (YAGNI)\n' +
+    '2. Does it already exist in this codebase? Reuse what is already here, do not re-write it.\n' +
+    '3. Does the standard library do this? Use it.\n' +
+    '4. Does a native platform feature cover it? Use it.\n' +
+    '5. Does an already-installed dependency solve it? Use it.\n' +
+    '6. Can this be one line? Make it one line.\n' +
+    '7. Only then: write the minimum code that works.\n\n' +
+    'Bug fix = root cause, not symptom: grep every caller of the function you touch and fix the shared function once (a smaller diff than one guard per caller); patching only the path the ticket names leaves a sibling caller broken.\n\n' +
+    '## Rules\n\n' +
+    'No abstractions that were not requested. No avoidable dependencies. No boilerplate nobody asked for. ' +
+    'Deletion over addition. Boring over clever. Fewest files possible. ' +
+    'Ship the lazy version and question the complex request in the same response — never stall. ' +
+    'Between two same-size stdlib options, pick the one correct on edge cases. ' +
+    'Mark intentional simplifications with a `ponytail:` comment — a shortcut with a known ceiling names the ceiling and the upgrade path in the comment.\n\n' +
+    '## Output\n\n' +
+    'Code first. Then at most three short lines: what was skipped, when to add it. ' +
+    'If the explanation is longer than the code, delete the explanation. ' +
+    'Explanation the user explicitly asked for is not debt, give it in full.\n\n' +
+    '## When NOT to be lazy\n\n' +
+    'Never simplify away: understanding the problem (read it fully and trace the real flow before picking a rung — a small diff you do not understand is just laziness dressed up as efficiency), input validation at trust boundaries, error handling that prevents data loss, ' +
+    'security measures, accessibility basics, the calibration real hardware needs (the platform is never the spec ideal), anything the user explicitly asked to keep. ' +
+    'Lazy code without its check is unfinished: non-trivial logic leaves ONE runnable check behind (assert-based demo/self-check or one small test file; no frameworks). Trivial one-liners need no test.\n\n' +
+    '## Boundaries\n\n' +
+    'Ponytail governs what you build, not how you talk. "stop ponytail" or "normal mode": revert. Level persists until changed or session end.';
+}
+
+function getPonytailInstructions(mode) {
+  const configuredMode = normalizePersistedMode(mode) || DEFAULT_MODE;
+
+  if (INDEPENDENT_MODES.has(configuredMode)) {
+    return 'PONYTAIL MODE ACTIVE — level: ' + configuredMode + '. Behavior defined by /ponytail-' + configuredMode + ' skill.';
+  }
+
+  const effectiveMode = normalizeMode(configuredMode) || DEFAULT_MODE;
+
+  try {
+    return 'PONYTAIL MODE ACTIVE — level: ' + effectiveMode + '\n\n' +
+      filterSkillBodyForMode(fs.readFileSync(SKILL_PATH, 'utf8'), effectiveMode);
+  } catch (e) {
+    return getFallbackInstructions(effectiveMode);
+  }
+}
+
+module.exports = {
+  filterSkillBodyForMode,
+  getFallbackInstructions,
+  getPonytailInstructions,
+};

package/hooks/ponytail-mode-tracker.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+// ponytail — UserPromptSubmit hook to track which ponytail mode is active
+// Inspects user input for /ponytail commands and writes mode to flag file
+
+const { getDefaultMode, isDeactivationCommand } = require('./ponytail-config');
+const { clearMode, setMode, writeHookOutput } = require('./ponytail-runtime');
+
+let input = '';
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    // Strip UTF-8 BOM some shells prepend when piping (breaks JSON.parse)
+    const data = JSON.parse(input.replace(/^\uFEFF/, ''));
+    const prompt = (data.prompt || '').trim().toLowerCase();
+
+    // Match /ponytail commands
+    if (/^[/@$]ponytail/.test(prompt)) {
+      const parts = prompt.split(/\s+/);
+      const cmd = parts[0].replace(/^[@$]/, '/');
+      const arg = parts[1] || '';
+
+      let mode = null;
+
+      if (cmd === '/ponytail-review' || cmd === '/ponytail:ponytail-review') {
+        mode = 'review';
+      } else if (cmd === '/ponytail' || cmd === '/ponytail:ponytail') {
+        if (arg === 'lite') mode = 'lite';
+        else if (arg === 'full') mode = 'full';
+        else if (arg === 'ultra') mode = 'ultra';
+        else if (arg === 'off') mode = 'off';
+        else mode = getDefaultMode();
+      }
+
+      if (mode && mode !== 'off') {
+        setMode(mode);
+        writeHookOutput(
+          'UserPromptSubmit',
+          mode,
+          'PONYTAIL MODE CHANGED — level: ' + mode,
+        );
+      } else if (mode === 'off') {
+        clearMode();
+        writeHookOutput('UserPromptSubmit', 'off', 'PONYTAIL MODE OFF');
+      }
+    }
+
+    // Detect deactivation
+    if (isDeactivationCommand(prompt)) {
+      clearMode();
+      writeHookOutput('UserPromptSubmit', 'off', 'PONYTAIL MODE OFF');
+    }
+  } catch (e) {
+    // Silent fail
+  }
+});

package/hooks/ponytail-runtime.js

@@ -0,0 +1,51 @@
+const fs = require('fs');
+const path = require('path');
+const { getClaudeDir } = require('./ponytail-config');
+
+const STATE_FILE = '.ponytail-active';
+const isCopilot = Boolean(process.env.COPILOT_PLUGIN_DATA);
+const isCodex = !isCopilot && Boolean(process.env.PLUGIN_DATA);
+
+let stateDir = getClaudeDir();
+if (isCodex) stateDir = process.env.PLUGIN_DATA;
+if (isCopilot) stateDir = process.env.COPILOT_PLUGIN_DATA;
+
+const statePath = path.join(stateDir, STATE_FILE);
+
+function setMode(mode) {
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  fs.writeFileSync(statePath, mode);
+}
+
+function clearMode() {
+  try { fs.unlinkSync(statePath); } catch (e) {}
+}
+
+function writeHookOutput(event, mode, context = '') {
+  if (isCopilot) {
+    // Copilot reads additionalContext on SessionStart; ignores output elsewhere.
+    process.stdout.write(JSON.stringify(
+      event === 'SessionStart' && context ? { additionalContext: context } : {}));
+    return;
+  }
+  if (isCodex) {
+    const output = { systemMessage: `PONYTAIL:${mode.toUpperCase()}` };
+    if (context) {
+      output.hookSpecificOutput = {
+        hookEventName: event,
+        additionalContext: context,
+      };
+    }
+    process.stdout.write(JSON.stringify(output));
+    return;
+  }
+  process.stdout.write(context);
+}
+
+module.exports = {
+  clearMode,
+  isCodex,
+  isCopilot,
+  setMode,
+  writeHookOutput,
+};

package/hooks/ponytail-statusline.ps1

@@ -0,0 +1,21 @@
+# CLAUDE_CONFIG_DIR overrides ~/.claude, matching where the hooks write the flag (issue #34)
+$ClaudeDir = if ($env:CLAUDE_CONFIG_DIR) { $env:CLAUDE_CONFIG_DIR } else { Join-Path $HOME ".claude" }
+$Flag = Join-Path $ClaudeDir ".ponytail-active"
+if (-not (Test-Path $Flag)) {
+    exit 0
+}
+
+$Mode = ""
+try {
+    $Mode = (Get-Content $Flag -ErrorAction Stop | Select-Object -First 1).Trim()
+} catch {
+    exit 0
+}
+
+$Esc = [char]27
+if ([string]::IsNullOrEmpty($Mode) -or $Mode -eq "full") {
+    [Console]::Write("${Esc}[38;5;108m[PONYTAIL]${Esc}[0m")
+} else {
+    $Suffix = $Mode.ToUpperInvariant()
+    [Console]::Write("${Esc}[38;5;108m[PONYTAIL:$Suffix]${Esc}[0m")
+}

package/hooks/ponytail-statusline.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+# CLAUDE_CONFIG_DIR overrides ~/.claude, matching where the hooks write the flag (issue #34)
+flag="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/.ponytail-active"
+[ -f "$flag" ] || exit 0
+
+mode=$(head -n1 "$flag" | tr -d '[:space:]')
+
+if [ -z "$mode" ] || [ "$mode" = "full" ]; then
+    printf '\033[38;5;108m[PONYTAIL]\033[0m'
+else
+    printf '\033[38;5;108m[PONYTAIL:%s]\033[0m' "$(printf '%s' "$mode" | tr '[:lower:]' '[:upper:]')"
+fi

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@dietrichgebert/ponytail",
+  "version": "4.8.1",
+  "description": "Lazy senior dev mode for AI agents. The best code is the code you never wrote.",
+  "keywords": ["opencode-plugin", "opencode", "ponytail", "pi-package", "pi", "skills"],
+  "license": "MIT",
+  "author": {
+    "name": "Dietrich Gebert",
+    "url": "https://github.com/DietrichGebert"
+  },
+  "homepage": "https://github.com/DietrichGebert/ponytail",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DietrichGebert/ponytail.git"
+  },
+  "bugs": {
+    "url": "https://github.com/DietrichGebert/ponytail/issues"
+  },
+  "main": "./.opencode/plugins/ponytail.mjs",
+  "exports": {
+    ".": "./.opencode/plugins/ponytail.mjs",
+    "./plugin": "./.opencode/plugins/ponytail.mjs"
+  },
+  "files": [
+    "AGENTS.md",
+    "hooks/",
+    "skills/",
+    ".opencode/",
+    "pi-extension/",
+    "assets/",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test tests/*.test.js && npm test --prefix pi-extension"
+  },
+  "pi": {
+    "extensions": ["./pi-extension/index.js"],
+    "skills": ["./skills"]
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/pi-extension/index.js

@@ -0,0 +1,189 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const {
+  DEFAULT_MODE,
+  getDefaultMode,
+  normalizeMode,
+  normalizeConfigMode,
+  normalizePersistedMode,
+  isDeactivationCommand,
+  writeDefaultMode,
+} = require("../hooks/ponytail-config.js");
+const { getPonytailInstructions, filterSkillBodyForMode } = require("../hooks/ponytail-instructions.js");
+
+export { filterSkillBodyForMode };
+export const readDefaultMode = getDefaultMode;
+
+export function resolveSessionMode(entries, fallbackMode = DEFAULT_MODE) {
+  const fallback = normalizePersistedMode(fallbackMode) || DEFAULT_MODE;
+  if (!Array.isArray(entries)) return fallback;
+
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i];
+    if (entry?.type !== "custom" || entry?.customType !== "ponytail-mode") continue;
+
+    const mode = normalizePersistedMode(entry?.data?.mode);
+    if (mode) return mode;
+  }
+
+  return fallback;
+}
+
+export function parsePonytailCommand(text, defaultMode = DEFAULT_MODE) {
+  const fallback = normalizePersistedMode(defaultMode) || DEFAULT_MODE;
+  const normalizedText = String(text || "").trim().toLowerCase();
+
+  if (!normalizedText) {
+    return { type: "set-mode", mode: fallback === "off" ? "full" : fallback };
+  }
+
+  const [primary, secondary] = normalizedText.split(/\s+/);
+
+  if (primary === "status") return { type: "status" };
+
+  if (primary === "default") {
+    const mode = normalizeConfigMode(secondary);
+    return mode ? { type: "set-default", mode } : { type: "invalid", reason: "invalid-default-mode" };
+  }
+
+  const mode = normalizeMode(primary);
+  return mode ? { type: "set-mode", mode } : { type: "invalid", reason: "invalid-mode", mode: primary };
+}
+
+export { writeDefaultMode };
+
+export default function ponytailExtension(pi) {
+  let currentMode = DEFAULT_MODE;
+  let configuredDefaultMode = getDefaultMode();
+  let isActive = false;
+  let lastCtx = null;
+
+  // -- Status bar --
+  function syncStatus(ctx) {
+    if (ctx) lastCtx = ctx;
+    const c = ctx || lastCtx;
+    if (!c?.ui?.setStatus || !c.ui.theme?.fg) return;
+    const theme = c.ui.theme;
+    if (currentMode === "off") {
+      c.ui.setStatus("ponytail", "");
+      return;
+    }
+    const levelIcons = { lite: "🌿", full: "⚡", ultra: "🔥" };
+    const icon = levelIcons[currentMode] || "";
+    const label = currentMode.toUpperCase();
+    const indicator = isActive ? theme.fg("accent", "●") : theme.fg("dim", "○");
+    c.ui.setStatus("ponytail", indicator + " 🐴 " + theme.fg("muted", "ponytail: ") + theme.fg("text", icon + " " + label));
+  }
+
+  const setMode = (mode, ctx) => {
+    const normalized = normalizePersistedMode(mode);
+    if (!normalized) return;
+
+    currentMode = normalized;
+    pi.appendEntry("ponytail-mode", { mode: normalized });
+    syncStatus(ctx);
+    ctx?.ui?.notify?.(`Ponytail mode set to ${normalized}.`, "info");
+  };
+
+  const sendAlias = (skillName, args, ctx) => {
+    const normalized = String(args || "").trim();
+    const message = normalized ? `${skillName} ${normalized}` : skillName;
+
+    if (ctx?.isIdle?.() === false) {
+      pi.sendUserMessage(message, { deliverAs: "followUp" });
+      ctx?.ui?.notify?.(`${skillName} queued as follow-up.`, "info");
+      return;
+    }
+
+    pi.sendUserMessage(message);
+  };
+
+  pi.registerCommand("ponytail", {
+    description: "Set or report Ponytail mode",
+    handler: async (args, ctx) => {
+      const parsed = parsePonytailCommand(args, configuredDefaultMode);
+
+      if (parsed.type === "status") {
+        ctx?.ui?.notify?.(`Ponytail: current ${currentMode} • default ${configuredDefaultMode}`, "info");
+        return;
+      }
+
+      if (parsed.type === "set-default") {
+        const written = writeDefaultMode(parsed.mode);
+        if (written) {
+          configuredDefaultMode = getDefaultMode();
+          const message = configuredDefaultMode === written
+            ? `Default Ponytail mode set to ${written}.`
+            : `Saved default ${written}, but env override keeps default at ${configuredDefaultMode}.`;
+          ctx?.ui?.notify?.(message, "info");
+        }
+        return;
+      }
+
+      if (parsed.type === "set-mode") {
+        setMode(parsed.mode, ctx);
+        return;
+      }
+
+      ctx?.ui?.notify?.("Unknown or unsupported /ponytail mode.", "warning");
+    },
+  });
+
+  pi.registerCommand("ponytail-review", {
+    description: "Run /skill:ponytail-review",
+    handler: (_args, ctx) => sendAlias("/skill:ponytail-review", "", ctx),
+  });
+
+  pi.registerCommand("ponytail-audit", {
+    description: "Run /skill:ponytail-audit",
+    handler: (_args, ctx) => sendAlias("/skill:ponytail-audit", "", ctx),
+  });
+
+  pi.registerCommand("ponytail-gain", {
+    description: "Run /skill:ponytail-gain",
+    handler: (_args, ctx) => sendAlias("/skill:ponytail-gain", "", ctx),
+  });
+
+  pi.registerCommand("ponytail-debt", {
+    description: "Run /skill:ponytail-debt",
+    handler: (_args, ctx) => sendAlias("/skill:ponytail-debt", "", ctx),
+  });
+
+  pi.registerCommand("ponytail-help", {
+    description: "Run /skill:ponytail-help",
+    handler: (_args, ctx) => sendAlias("/skill:ponytail-help", "", ctx),
+  });
+
+  pi.on("input", async (event) => {
+    if (event?.source === "extension") return;
+
+    const text = String(event?.text || "");
+    if (currentMode !== "off" && isDeactivationCommand(text)) {
+      setMode("off");
+    }
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    const entries = ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
+    configuredDefaultMode = getDefaultMode();
+    currentMode = resolveSessionMode(entries, configuredDefaultMode);
+    syncStatus(ctx);
+    ctx?.ui?.notify?.(`Ponytail loaded: ${currentMode}`, "info");
+  });
+
+  pi.on("agent_start", async (_event, ctx) => {
+    isActive = true;
+    syncStatus(ctx);
+  });
+
+  pi.on("agent_end", async (_event, ctx) => {
+    isActive = false;
+    syncStatus(ctx);
+  });
+
+  pi.on("before_agent_start", async (event) => {
+    if (!currentMode || currentMode === "off") return;
+    return { systemPrompt: `${event.systemPrompt}\n\n${getPonytailInstructions(currentMode)}` };
+  });
+}

package/pi-extension/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "ponytail-pi-extension-dev",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "node --test ./test/*.test.js"
+  }
+}

package/pi-extension/test/extension.test.js

@@ -0,0 +1,167 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import ponytailExtension from "../index.js";
+
+function createPiHarness() {
+  const events = new Map();
+  const commands = new Map();
+  const appendedEntries = [];
+  const sentUserMessages = [];
+
+  const pi = {
+    on(eventName, handler) {
+      events.set(eventName, handler);
+    },
+    registerCommand(name, options) {
+      commands.set(name, options);
+    },
+    appendEntry(customType, data) {
+      appendedEntries.push({ customType, data });
+    },
+    sendUserMessage(text, options) {
+      sentUserMessages.push({ text, options });
+    },
+  };
+
+  ponytailExtension(pi);
+  return { events, commands, appendedEntries, sentUserMessages };
+}
+
+function createCommandContext(overrides = {}) {
+  return {
+    isIdle: () => true,
+    sessionManager: { getEntries: () => [] },
+    ui: { notify() {} },
+    ...overrides,
+  };
+}
+
+function withTempConfig(fn) {
+  const tempConfigHome = mkdtempSync(join(tmpdir(), "ponytail-test-"));
+  const previousXdg = process.env.XDG_CONFIG_HOME;
+  process.env.XDG_CONFIG_HOME = tempConfigHome;
+
+  return Promise.resolve()
+    .then(fn)
+    .finally(() => {
+      if (previousXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+      else process.env.XDG_CONFIG_HOME = previousXdg;
+      rmSync(tempConfigHome, { recursive: true, force: true });
+    });
+}
+
+test("extension registers Ponytail commands", () => {
+  const { commands } = createPiHarness();
+
+  assert.deepEqual([...commands.keys()].sort(), ["ponytail", "ponytail-audit", "ponytail-debt", "ponytail-gain", "ponytail-help", "ponytail-review"]);
+});
+
+test("/ponytail updates session mode and injects instructions", async () => withTempConfig(async () => {
+  const { commands, events, appendedEntries } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await commands.get("ponytail").handler("ultra", ctx);
+
+  assert.deepEqual(appendedEntries.at(-1), {
+    customType: "ponytail-mode",
+    data: { mode: "ultra" },
+  });
+
+  const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+  assert.ok(result.systemPrompt.includes("PONYTAIL MODE ACTIVE"));
+  assert.ok(result.systemPrompt.includes("ultra"));
+}));
+
+test("session_start restores latest persisted mode", async () => withTempConfig(async () => {
+  const { events } = createPiHarness();
+  const ctx = createCommandContext({
+    sessionManager: {
+      getEntries: () => [
+        { type: "custom", customType: "ponytail-mode", data: { mode: "lite" } },
+      ],
+    },
+  });
+
+  await events.get("session_start")({ reason: "resume" }, ctx);
+  const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+
+  assert.ok(result.systemPrompt.includes("lite"));
+}));
+
+test("skill alias commands delegate to Pi skill commands", async () => {
+  const { commands, sentUserMessages } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await commands.get("ponytail-review").handler("", ctx);
+  await commands.get("ponytail-audit").handler("", ctx);
+  await commands.get("ponytail-debt").handler("", ctx);
+  await commands.get("ponytail-gain").handler("", ctx);
+  await commands.get("ponytail-help").handler("", ctx);
+
+  assert.deepEqual(sentUserMessages.map((entry) => entry.text), [
+    "/skill:ponytail-review",
+    "/skill:ponytail-audit",
+    "/skill:ponytail-debt",
+    "/skill:ponytail-gain",
+    "/skill:ponytail-help",
+  ]);
+});
+
+test("normal mode disables persistent instructions", async () => withTempConfig(async () => {
+  const { commands, events } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await commands.get("ponytail").handler("ultra", ctx);
+  await events.get("input")({ text: "normal mode", source: "interactive" }, ctx);
+
+  const disabled = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+  assert.equal(disabled, undefined);
+}));
+
+test("a request mentioning normal mode stays active", async () => withTempConfig(async () => {
+  const { commands, events } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await commands.get("ponytail").handler("ultra", ctx);
+  await events.get("input")({ text: "add a normal mode toggle next to dark mode", source: "interactive" }, ctx);
+
+  const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+  assert.match(result.systemPrompt, /PONYTAIL MODE ACTIVE/);
+}));
+
+test("status bar renders the mode and flips active on agent_start", async () => withTempConfig(async () => {
+  const { events } = createPiHarness();
+  const statusWrites = [];
+  const ctx = createCommandContext({
+    sessionManager: { getEntries: () => [{ type: "custom", customType: "ponytail-mode", data: { mode: "ultra" } }] },
+    ui: { notify() {}, setStatus: (key, text) => statusWrites.push({ key, text }), theme: { fg: (_color, text) => text } },
+  });
+
+  await events.get("session_start")({ reason: "resume" }, ctx);
+  await events.get("agent_start")({}, ctx);
+
+  assert.equal(statusWrites.at(-2).key, "ponytail");
+  assert.match(statusWrites.at(-2).text, /○.*ULTRA/);
+  assert.match(statusWrites.at(-1).text, /●.*ULTRA/);
+}));
+
+test("status bar stays silent when ui lacks a theme", async () => withTempConfig(async () => {
+  const { events } = createPiHarness();
+  const calls = [];
+  const ctx = createCommandContext({
+    sessionManager: { getEntries: () => [{ type: "custom", customType: "ponytail-mode", data: { mode: "ultra" } }] },
+    ui: { notify() {}, setStatus: (_key, text) => calls.push(text) }, // setStatus present, theme absent
+  });
+
+  await events.get("session_start")({ reason: "resume" }, ctx);
+  await events.get("agent_start")({}, ctx);
+
+  assert.deepEqual(calls, []);
+}));