nitm-ai-dev-toolkit 3.0.15

package/src/monorepo/docs/fixes/README.md

@@ -0,0 +1,117 @@
+# Fixes & Bug Documentation
+
+This folder contains documentation for bug fixes and improvements.
+
+## Structure
+
+### Complex Fixes (Folders)
+
+Complex fixes that require detailed documentation:
+
+```
+fixes/
+├── {{ISSUE_ID}}-FIX-NAME/
+│   ├── spec.md       # Root cause analysis
+│   ├── plan.md       # Implementation plan
+│   └── [optional]    # Test cases, examples
+```
+
+### Simple Fixes (Monthly Logs)
+
+Simple fixes documented in monthly aggregated logs:
+
+```
+fixes/
+├── 2026-01.md       # January 2026 fixes
+├── 2026-02.md       # February 2026 fixes
+└── 2026-03.md       # March 2026 fixes
+```
+
+## Decision Tree: How to Document Fixes
+
+**Before documenting, ask:**
+
+1. **Is this a complex fix?** (multi-file, architectural changes, affects multiple features)
+
+   - ✅ YES → Create folder `{{ISSUE_ID}}-FIX-NAME/` with `spec.md` + `plan.md`
+   - ❌ NO → Add entry to `{{YYYY-MM}}.md` (monthly log)
+
+2. **Does the monthly log for this month exist?**
+   - ❌ NO → Create it using the template
+   - ✅ YES → Add your fix as a new section
+
+## Creating Fix Documentation
+
+### For Simple Fixes (Use Monthly Log)
+
+```bash
+# Check if current month's log exists
+ls docs/fixes/$(date +%Y-%m).md
+
+# If not, create from template
+cp templates/monthly-fix-log.template.md docs/fixes/$(date +%Y-%m).md
+
+# Edit and add your fix as a new section
+```
+
+### For Complex Fixes (Use Folder)
+
+```bash
+# Create fix folder
+mkdir -p docs/fixes/{{ISSUE_ID}}-FIX-NAME
+
+# Copy templates
+cp templates/complex-fix-spec.template.md docs/fixes/{{ISSUE_ID}}-FIX-NAME/spec.md
+cp templates/complex-fix-plan.template.md docs/fixes/{{ISSUE_ID}}-FIX-NAME/plan.md
+
+# Edit files and document root cause, solution, testing
+```
+
+## What NOT to Do
+
+**❌ DO NOT create individual `.md` files for simple fixes:**
+
+- ❌ `2025-10-database-connection-fix.md`
+- ❌ `2025-10-auth-token-refresh.md`
+- ❌ `fix-session-timeout.md`
+
+**✅ Instead, add them as sections in the monthly log:**
+
+- ✅ `2025-10.md` with a new `## [2025-10-24] - Database Connection Fix` section
+
+## Monthly Log Guidelines
+
+### File Creation
+
+- Create **NEW** file when calendar month changes
+- Do NOT append to previous month's file
+- Use YYYY-MM.md naming format (e.g., `2026-01.md`)
+
+### Content
+
+Each monthly log should contain:
+
+- **Summary** - Overview of the month's focus
+- **Fix entries** - Each with date, description, root cause, solution, impact
+- **Patterns & Learnings** - Common issues and best practices discovered
+- **Technical Debt** - Items to address in future
+
+### Format
+
+Follow [Keep a Changelog](https://keepachangelog.com/) format for consistency.
+
+## Index of Fixes
+
+### Monthly Logs
+
+- [2026-01.md](2026-01.md) - January 2026 fixes
+- [2025-12.md](2025-12.md) - December 2025 fixes
+- [2025-11.md](2025-11.md) - November 2025 fixes
+
+### Complex Fixes
+
+- [{{ISSUE_ID}}-COMPLEX-FIX]({{ISSUE_ID}}-COMPLEX-FIX/) - Brief description
+
+---
+
+**Last Updated**: {{DATE}}

package/src/monorepo/hooks/claude-codex-hooks.json

@@ -0,0 +1,31 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "command -v node >/dev/null 2>&1 && node \"${CLAUDE_PLUGIN_ROOT}/hooks/ponytail-activate.js\" || exit 0",
+            "commandWindows": "if (Get-Command node -ErrorAction SilentlyContinue) { node \"$env:CLAUDE_PLUGIN_ROOT\\hooks\\ponytail-activate.js\" }",
+            "timeout": 5,
+            "statusMessage": "Loading ponytail mode..."
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "command -v node >/dev/null 2>&1 && node \"${CLAUDE_PLUGIN_ROOT}/hooks/ponytail-mode-tracker.js\" || exit 0",
+            "commandWindows": "if (Get-Command node -ErrorAction SilentlyContinue) { node \"$env:CLAUDE_PLUGIN_ROOT\\hooks\\ponytail-mode-tracker.js\" }",
+            "timeout": 5,
+            "statusMessage": "Tracking ponytail mode..."
+          }
+        ]
+      }
+    ]
+  }
+}

package/src/monorepo/hooks/copilot-hooks.json

@@ -0,0 +1,21 @@
+{
+  "version": 1,
+  "hooks": {
+    "sessionStart": [
+      {
+        "type": "command",
+        "bash": "node \"${PLUGIN_ROOT}/hooks/ponytail-activate.js\"",
+        "powershell": "node \"${PLUGIN_ROOT}\\hooks\\ponytail-activate.js\"",
+        "timeoutSec": 5
+      }
+    ],
+    "userPromptSubmitted": [
+      {
+        "type": "command",
+        "bash": "node \"${PLUGIN_ROOT}/hooks/ponytail-mode-tracker.js\"",
+        "powershell": "node \"${PLUGIN_ROOT}\\hooks\\ponytail-mode-tracker.js\"",
+        "timeoutSec": 5
+      }
+    ]
+  }
+}

package/src/monorepo/hooks/ponytail-activate.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// ponytail — Claude Code SessionStart activation hook
+//
+// Runs on every session start:
+//   1. Writes flag file at $CLAUDE_CONFIG_DIR/.ponytail-active (defaults to ~/.claude; statusline reads this)
+//   2. Emits ponytail ruleset as hidden SessionStart context
+//   3. Detects missing statusline config and emits setup nudge
+
+const fs = require('fs');
+const path = require('path');
+const { getDefaultMode, getClaudeDir, isShellSafe } = require('./ponytail-config');
+const { getPonytailInstructions } = require('./ponytail-instructions');
+const {
+  clearMode,
+  isCodex,
+  isCopilot,
+  setMode,
+  writeHookOutput,
+} = require('./ponytail-runtime');
+
+const claudeDir = getClaudeDir();
+const settingsPath = path.join(claudeDir, 'settings.json');
+
+const mode = getDefaultMode();
+
+// "off" mode — skip activation entirely, don't write flag or emit rules
+if (mode === 'off') {
+  clearMode();
+  const hookOutput = (isCodex || isCopilot) ? '' : 'OK';
+  writeHookOutput('SessionStart', 'off', hookOutput);
+  process.exit(0);
+}
+
+// 1. Write flag file
+try {
+  setMode(mode);
+} catch (e) {
+  // Silent fail -- flag is best-effort, don't block the hook
+}
+
+// 2. Emit the ponytail ruleset, filtered to the active intensity level.
+let output = getPonytailInstructions(mode);
+
+// 3. Detect missing statusline config — nudge Claude to help set it up
+if (!isCodex && !isCopilot) try {
+  let hasStatusline = false;
+  if (fs.existsSync(settingsPath)) {
+    // Strip UTF-8 BOM some editors prepend on Windows (breaks JSON.parse)
+    const raw = fs.readFileSync(settingsPath, 'utf8').replace(/^\uFEFF/, '');
+    const settings = JSON.parse(raw);
+    if (settings.statusLine) {
+      hasStatusline = true;
+    }
+  }
+
+  if (!hasStatusline) {
+    const isWindows = process.platform === 'win32';
+    const scriptName = isWindows ? 'ponytail-statusline.ps1' : 'ponytail-statusline.sh';
+    const scriptPath = path.join(__dirname, scriptName);
+    if (isShellSafe(scriptPath)) {
+      const command = isWindows
+        ? `powershell -ExecutionPolicy Bypass -File "${scriptPath}"`
+        : `bash "${scriptPath}"`;
+      const statusLineSnippet =
+        '"statusLine": { "type": "command", "command": ' + JSON.stringify(command) + ' }';
+      output += "\n\n" +
+        "STATUSLINE SETUP NEEDED: The ponytail plugin includes a statusline badge showing active mode " +
+        "(e.g. [PONYTAIL], [PONYTAIL:ULTRA]). It is not configured yet. " +
+        "To enable, add this to ~/.claude/settings.json: " +
+        statusLineSnippet + " " +
+        "Proactively offer to set this up for the user on first interaction.";
+    } else {
+      // ponytail: install path has shell metacharacters — don't embed it in a
+      // command snippet; have the agent wire it up by hand instead.
+      output += "\n\n" +
+        "STATUSLINE SETUP NEEDED: The ponytail plugin includes a statusline badge showing active mode. " +
+        "Its install path contains characters unsafe to embed in a shell command, so configure it manually: " +
+        "add a statusLine command of type \"command\" that runs " + scriptName +
+        " from the plugin's hooks directory to ~/.claude/settings.json, quoting/escaping the path for your shell. " +
+        "Proactively offer to set this up for the user on first interaction.";
+    }
+  }
+} catch (e) {
+  // Silent fail — don't block session start over statusline detection
+}
+
+try {
+  writeHookOutput('SessionStart', mode, output);
+} catch (e) {
+  // Silent fail — stdout closed/EPIPE at hook exit must not surface as a hook failure
+}

package/src/monorepo/hooks/ponytail-config.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+// ponytail — shared configuration resolver
+//
+// Resolution order for default mode:
+//   1. PONYTAIL_DEFAULT_MODE environment variable
+//   2. Config file defaultMode field:
+//      - $XDG_CONFIG_HOME/ponytail/config.json (any platform, if set)
+//      - ~/.config/ponytail/config.json (macOS / Linux fallback)
+//      - %APPDATA%\ponytail\config.json (Windows fallback)
+//   3. 'full'
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const DEFAULT_MODE = 'full';
+const VALID_MODES = ['off', 'lite', 'full', 'ultra', 'review'];
+const RUNTIME_MODES = ['off', 'lite', 'full', 'ultra'];
+
+function normalizeMode(mode) {
+  if (typeof mode !== 'string') return null;
+  const normalized = mode.trim().toLowerCase();
+  return RUNTIME_MODES.includes(normalized) ? normalized : null;
+}
+
+function normalizeConfigMode(mode) {
+  if (typeof mode !== 'string') return null;
+  const normalized = mode.trim().toLowerCase();
+  return VALID_MODES.includes(normalized) ? normalized : null;
+}
+
+function normalizePersistedMode(mode) {
+  return normalizeMode(mode) || normalizeConfigMode(mode);
+}
+
+// "stop ponytail" / "normal mode" turn ponytail off, but only as a standalone
+// command. Matching the phrase anywhere in the message turned it off mid-task
+// for ordinary requests like "add a normal mode toggle" — so require the whole
+// message to be the command, ignoring case and trailing punctuation.
+function isDeactivationCommand(text) {
+  const t = String(text || '').trim().toLowerCase().replace(/[.!?\s]+$/, '');
+  return t === 'stop ponytail' || t === 'normal mode';
+}
+
+// ponytail: only embed the plugin install path in a statusline shell command when
+// it's made of ordinary path characters. An allowlist beats escaping every shell's
+// metacharacters; a hostile clone path (quotes, &, $, backtick, ;, etc.) falls back
+// to manual setup instead. Allows : \ / for normal Windows and POSIX paths. Full
+// per-shell escaper only if a real need appears.
+function isShellSafe(p) {
+  return typeof p === 'string' && /^[A-Za-z0-9 _.\-:/\\~]+$/.test(p);
+}
+
+function getConfigDir() {
+  if (process.env.XDG_CONFIG_HOME) {
+    return path.join(process.env.XDG_CONFIG_HOME, 'ponytail');
+  }
+  if (process.platform === 'win32') {
+    return path.join(
+      process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'),
+      'ponytail'
+    );
+  }
+  return path.join(os.homedir(), '.config', 'ponytail');
+}
+
+function getConfigPath() {
+  return path.join(getConfigDir(), 'config.json');
+}
+
+function getClaudeDir() {
+  // ponytail: CLAUDE_CONFIG_DIR overrides ~/.claude, matching Claude Code.
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+}
+
+function getDefaultMode() {
+  // 1. Environment variable (highest priority)
+  const envMode = process.env.PONYTAIL_DEFAULT_MODE;
+  if (envMode && VALID_MODES.includes(envMode.toLowerCase())) {
+    return envMode.toLowerCase();
+  }
+
+  // 2. Config file
+  try {
+    const configPath = getConfigPath();
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    if (config.defaultMode && VALID_MODES.includes(config.defaultMode.toLowerCase())) {
+      return config.defaultMode.toLowerCase();
+    }
+  } catch (e) {
+    // Config file doesn't exist or is invalid — fall through
+  }
+
+  // 3. Default
+  return DEFAULT_MODE;
+}
+
+function writeDefaultMode(mode) {
+  const normalized = normalizeConfigMode(mode);
+  if (!normalized) return null;
+
+  const configPath = getConfigPath();
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify({ defaultMode: normalized }, null, 2), 'utf8');
+  return normalized;
+}
+
+module.exports = {
+  DEFAULT_MODE,
+  VALID_MODES,
+  RUNTIME_MODES,
+  getDefaultMode,
+  getConfigDir,
+  getConfigPath,
+  getClaudeDir,
+  isShellSafe,
+  normalizeMode,
+  normalizeConfigMode,
+  normalizePersistedMode,
+  isDeactivationCommand,
+  writeDefaultMode,
+};

package/src/monorepo/hooks/ponytail-instructions.js

@@ -0,0 +1,92 @@
+#!/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, '..', '.agents', '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:\n' +
+    '1. Does this need to be built at all? (YAGNI)\n' +
+    '2. Does the standard library do this? Use it.\n' +
+    '3. Does a native platform feature cover it? Use it.\n' +
+    '4. Does an already-installed dependency solve it? Use it.\n' +
+    '5. Can this be one line? Make it one line.\n' +
+    '6. Only then: write the minimum code that works.\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: 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/src/monorepo/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/src/monorepo/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/src/monorepo/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/src/monorepo/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/src/monorepo/packages/package-template/README.md

@@ -0,0 +1,63 @@
+# @{{PROJECT_NAME}}/{{PACKAGE_NAME}}
+
+{{PACKAGE_DESCRIPTION}}
+
+## Installation
+
+This package is internal to the monorepo. Add it to an app:
+
+```bash
+{{PACKAGE_MANAGER}} add @{{PROJECT_NAME}}/{{PACKAGE_NAME}} --filter={{APP_NAME}}
+```
+
+## Usage
+
+```typescript
+import { {{PACKAGE_EXPORT}} } from "@{{PROJECT_NAME}}/{{PACKAGE_NAME}}";
+
+// Example usage
+{{PACKAGE_USAGE_EXAMPLE}}
+```
+
+## Development
+
+```bash
+# Build
+{{PACKAGE_MANAGER}} build --filter=@{{PROJECT_NAME}}/{{PACKAGE_NAME}}
+
+# Test
+{{PACKAGE_MANAGER}} test --filter=@{{PROJECT_NAME}}/{{PACKAGE_NAME}}
+
+# Watch mode
+{{PACKAGE_MANAGER}} dev --filter=@{{PROJECT_NAME}}/{{PACKAGE_NAME}}
+```
+
+## Structure
+
+```
+{{PACKAGE_NAME}}/
+├── src/
+│   ├── index.ts          # Package exports
+│   └── {{PACKAGE_SRC_STRUCTURE}}
+├── tests/
+├── package.json
+└── tsconfig.json
+```
+
+## Exports
+
+```typescript
+// Main exports
+export { {{PACKAGE_EXPORTS}} } from "./{{PACKAGE_MAIN_FILE}}";
+```
+
+## Dependencies
+
+This package has the following peer dependencies:
+
+- {{PACKAGE_PEER_DEPS}}
+
+## Related
+
+- [Monorepo README](../../README.md)
+- [Root AGENTS.md](../../AGENTS.md)