nitm-ai-dev-toolkit 3.0.15

package/src/repo/docs/architecture/README.md

@@ -0,0 +1,56 @@
+# Architecture Decision Records
+
+This folder contains Architecture Decision Records (ADRs) documenting significant technical decisions made in this project.
+
+## What is an ADR?
+
+An ADR is a short document describing a significant software design choice along with its context and consequences.
+
+## Structure
+
+```
+architecture/
+├── 0001-initial-architecture.md
+├── 0002-database-choice.md
+├── 0003-api-design.md
+└── README.md
+```
+
+## Creating an ADR
+
+1. Copy the template:
+
+   ```bash
+   cp templates/adr.template.md docs/architecture/{{ADR_NUMBER}}-{{DECISION_TITLE}}.md
+   ```
+
+2. Fill in the template with:
+   - Context and problem statement
+   - Considered options
+   - Decision outcome and rationale
+   - Consequences
+
+## Naming Convention
+
+ADRs are numbered sequentially: `NNNN-short-title.md`
+
+- `0001-initial-project-structure.md`
+- `0002-authentication-strategy.md`
+- `0003-database-migration-approach.md`
+
+## Status
+
+ADRs can have the following statuses:
+
+- **Proposed** - Under discussion
+- **Accepted** - Decision made and being implemented
+- **Deprecated** - No longer relevant
+- **Superseded** - Replaced by another ADR
+
+## Index
+
+<!-- Add your ADRs here as you create them -->
+
+| ADR  | Title                                          | Status   | Date     |
+| ---- | ---------------------------------------------- | -------- | -------- |
+| 0001 | [Example Decision](./0001-example-decision.md) | Accepted | {{DATE}} |

package/src/repo/docs/features/README.md

@@ -0,0 +1,82 @@
+# Features Documentation
+
+This folder contains documentation for all features implemented in this project.
+
+## Structure
+
+Each feature gets its own folder named after the issue ID and feature name:
+
+```
+features/
+├── {{ISSUE_ID}}-FEATURE-NAME/
+│   ├── spec.md       # Functional specification
+│   ├── plan.md       # Implementation plan
+│   └── [optional]    # Additional files (diagrams, examples)
+└── README.md         # This file
+```
+
+## Creating Feature Documentation
+
+### 1. Create Feature Folder
+
+```bash
+mkdir -p docs/features/{{ISSUE_ID}}-FEATURE-NAME
+```
+
+### 2. Generate Specification
+
+Use the `/spec` command or copy the template:
+
+```bash
+cp templates/feature-spec.template.md docs/features/{{ISSUE_ID}}-FEATURE-NAME/spec.md
+```
+
+### 3. Generate Implementation Plan
+
+Use the `/plan` command or copy the template:
+
+```bash
+cp templates/feature-plan.template.md docs/features/{{ISSUE_ID}}-FEATURE-NAME/plan.md
+```
+
+### 4. Update During Implementation
+
+Keep documentation updated as:
+
+- Requirements change
+- Implementation details emerge
+- New decisions are made
+
+## Naming Conventions
+
+**Folder names** should follow this pattern:
+
+- `{{ISSUE_ID}}-FEATURE-NAME`
+- Issue ID from your issue tracker (e.g., `ISSUE-123`, `JIRA-456`)
+- Feature name in kebab-case (e.g., `user-authentication`, `data-export`)
+
+**Examples:**
+
+- `ISSUE-123-user-authentication/`
+- `JIRA-456-data-export-api/`
+- `GH-789-dark-mode-support/`
+
+## Index of Features
+
+<!-- Auto-generated or manually maintained list of features -->
+
+### Active Features
+
+- [{{ISSUE_ID}}-FEATURE-NAME]({{ISSUE_ID}}-FEATURE-NAME/) - Brief description
+
+### Completed Features
+
+- [{{ISSUE_ID}}-COMPLETED-FEATURE]({{ISSUE_ID}}-COMPLETED-FEATURE/) - Brief description
+
+### Deprecated Features
+
+- [{{ISSUE_ID}}-DEPRECATED-FEATURE]({{ISSUE_ID}}-DEPRECATED-FEATURE/) - Deprecated on {{DATE}}
+
+---
+
+**Last Updated**: {{DATE}}

package/src/repo/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/repo/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/repo/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/repo/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/repo/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/repo/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/repo/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
+  }
+});