chill-agent 1.4.0 → 1.6.0

package/hooks/ponytail-instructions.js

@@ -0,0 +1,98 @@
+#!/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;
+      }
+
+      // Require a quoted value: every worked example is `- lite: "..."`. Without
+      // this, an ordinary rule bullet that happens to start with a mode word
+      // (e.g. "- Full: ...") is silently dropped in every other mode — it looks
+      // like a worked example but is really prose meant to survive verbatim.
+      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) {
+  // Used only when SKILL.md cannot be read: the same rules as AGENTS.md.
+  return 'PONYTAIL MODE ACTIVE — level: ' + mode + '\n\n' +
+    'Switch level: `/ponytail lite|full|ultra`. Off: "stop ponytail" or "normal mode".\n\n' +
+    "You are a lazy senior developer. The best code is the code never written. You solve the whole problem with the least new code. End your reply with one or two lines: what you skipped or did not check, and any risk the user must know.\n" +
+    "\n" +
+    "## Before you write\n" +
+    "\n" +
+    "Read the task and the code it touches. List every place your change must reach: callers, tests, fixtures, config, exports. Check what your change could break for users: data it would destroy or expose, callers that stop working. That is scope. Extra features are not.\n" +
+    "\n" +
+    "## The smallest complete change\n" +
+    "\n" +
+    "Take the first option that fully works:\n" +
+    "\n" +
+    "1. Does it need to exist? Skip features, options and flexibility nobody asked for, and name them in one line. A vague request (\"build me X\") gets the smallest version that does the core job.\n" +
+    "2. Already in this codebase (a helper, component, service, pattern)? Use it the way the surrounding code does.\n" +
+    "3. Standard library or a platform feature? Use it, unless the project has its own. A house component beats a native widget.\n" +
+    "4. An installed dependency? Use it. Never add a dependency for a few lines.\n" +
+    "5. Can it be one line a reader gets at a glance? One line.\n" +
+    "6. Otherwise: the minimum code that works.\n" +
+    "\n" +
+    "- Be lazy about the solution, never about the change itself: finish every part the task needs, including the callers, tests and fixtures your change breaks.\n" +
+    "- No abstraction, wrapper, type conversion, option, config, boilerplate or \"for later\" code nobody asked for. Keep values in the form the platform already gives you. Deletion beats addition. Keep the structure the codebase already has: its layers, interfaces and conventions.\n" +
+    "- The shortest working diff wins, once you know everything it must touch. A one-liner that needs decoding is not short.\n" +
+    "- Comment only the why the code cannot show, in one line.\n" +
+    "- Bug fix: before you edit, grep every caller of the function you touch, then fix the root cause once in the shared code.\n" +
+    "- Code you move or merge keeps its error handling and validation.\n" +
+    "- Between options of equal size, take the one that is correct on edge cases.\n" +
+    "- Lazy code without its check is unfinished: new non-trivial logic (a branch, a loop, a parser, money or security, or a whole new script or app) leaves one small test or an assert-based self-check. Trivial changes need none.\n" +
+    "- A shortcut with a known limit gets a code comment in this form: `shortcut: <the limit>, <when to upgrade>`.\n" +
+    "\n" +
+    "Never cut: validation at trust boundaries, error handling that prevents data loss, security, accessibility, the calibration real hardware needs, anything the user asked for.\n";
+}
+
+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-map.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// ponytail — codebase map: what already exists, so "reuse first" costs no search.
+//
+// Lists the top-level functions, classes and exports of the project's source files, one line
+// per folder, inside a character budget. No model, no dependencies: `git ls-files` (or a short
+// directory walk) plus a regex per language. Tests, generated and vendored files are skipped;
+// shared code (utils, lib, services, components, hooks) is listed first when the budget is tight.
+//
+// ponytail: regex, not a parser. Misses nested or dynamic definitions; a tree-sitter index is the
+// upgrade if the map ever needs to be exact.
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const BUDGET = Number(process.env.PONYTAIL_MAP_CHARS || 2000);
+const MAX_FILES = 4000;
+const SRC = /\.(py|js|jsx|mjs|cjs|ts|tsx|go|rs|rb|java|kt|php|swift|cs)$/;
+const SKIP_DIR = /(^|\/)(node_modules|\.git|dist|build|out|vendor|venv|\.venv|__pycache__|coverage|\.next|target|migrations|versions|fixtures|tests?|__tests__|spec)(\/|$)/;
+const SKIP_FILE = /(^|\/)(test_[^/]*|[^/]*(_test|\.test|\.spec|\.gen|\.min|\.d)\.[a-z]+)$/;
+const NAME = /^(?:type\s+)?(?:[\w$]+\s+as\s+)?([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)?)$/;
+const SAFE_PATH = /^[\w.@+$()[\]\/-]+$/;
+const SHARED = /(util|helper|lib|common|shared|service|component|hook|core|model|schema|api)/i;
+
+const PATTERNS = {
+  py: [/^(?:async\s+)?def\s+([A-Za-z]\w*)/gm, /^class\s+([A-Za-z]\w*)/gm],
+  js: [/^export\s+(?:default\s+)?(?:async\s+)?(?:function\*?|class|const|let|var|interface|type|enum)\s+([A-Za-z_$][\w$]*)/gm,
+       /^export\s*\{([^}]*)\}/gm],
+  go: [/^func\s+(?:\([^)]*\)\s*)?([A-Z]\w*)/gm, /^type\s+([A-Z]\w*)/gm],
+  rs: [/^pub\s+(?:async\s+)?(?:fn|struct|enum|trait|type)\s+(\w+)/gm],
+  rb: [/^\s*(?:def|class|module)\s+([A-Za-z][\w.]*)/gm],
+  jvm: [/^\s*(?:public\s+)?(?:static\s+)?(?:final\s+)?(?:class|interface|enum|record)\s+(\w+)/gm],
+};
+const LANG = { py: 'py', js: 'js', jsx: 'js', mjs: 'js', cjs: 'js', ts: 'js', tsx: 'js', go: 'go', rs: 'rs',
+               rb: 'rb', java: 'jvm', kt: 'jvm', swift: 'jvm', cs: 'jvm', php: 'jvm' };
+
+function listFiles(root) {
+  try {
+    // 64 MiB: in repos with many tracked files `git ls-files` overflows Node's 1 MiB
+    // default, and the catch below reads that as "not a git repo" and falls back to a
+    // walk that ignores .gitignore. The list is capped at MAX_FILES * 5 lines anyway.
+    const tracked = execFileSync('git', ['ls-files'], { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000, maxBuffer: 64 * 1024 * 1024 })
+      .split('\n').filter(Boolean).slice(0, MAX_FILES * 5);
+    if (tracked.length) return tracked;
+  } catch (e) { /* not a git repo: walk below */ }
+  {
+    // No git, or an untracked folder inside a parent repo (git ls-files is then empty, not an error).
+    const out = [];
+    (function walk(dir, depth) {
+      if (depth > 6 || out.length > MAX_FILES * 5) return;
+      for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (ent.name.startsWith('.')) continue;
+        const rel = path.relative(root, path.join(dir, ent.name)).replace(/\\/g, '/');
+        if (ent.isDirectory()) { if (!SKIP_DIR.test(rel + '/')) walk(path.join(dir, ent.name), depth + 1); }
+        else out.push(rel);
+      }
+    })(root, 0);
+    return out;
+  }
+}
+
+function namesIn(file, text) {
+  const lang = LANG[path.extname(file).slice(1)];
+  const names = [];
+  for (const re of PATTERNS[lang] || []) {
+    for (const m of text.matchAll(re)) {
+      for (const n of m[1].split(',').map((s) => (s.trim().match(NAME) || [])[1]).filter(Boolean)) {
+        if (!n.startsWith('_') && !names.includes(n)) names.push(n);
+      }
+    }
+  }
+  return names;
+}
+
+function buildMap(root = process.cwd()) {
+  const files = listFiles(root)
+    .filter((f) => SAFE_PATH.test(f) && SRC.test(f) && !SKIP_DIR.test(f) && !SKIP_FILE.test(f))
+    .slice(0, MAX_FILES)
+    .sort((a, b) => (SHARED.test(b) - SHARED.test(a)) || a.localeCompare(b));
+  // One line per directory: names are enough to know something exists; grep finds the file.
+  const dirs = new Map();
+  for (const f of files) {
+    let text;
+    try {
+      if (!fs.lstatSync(path.join(root, f)).isFile()) continue;
+      text = fs.readFileSync(path.join(root, f), 'utf8').slice(0, 65536);
+    } catch (e) { continue; }
+    const names = namesIn(f, text);
+    if (!names.length) continue;
+    const dir = path.dirname(f) === '.' ? '.' : path.dirname(f);
+    dirs.set(dir, [...(dirs.get(dir) || []), names]);
+  }
+  const lines = [];
+  let used = 0;
+  let skipped = 0;
+  for (const [dir, perFile] of dirs) {
+    // The first exports say what a file is; in a folder of many files (a UI kit) one name each.
+    const names = [...new Set(perFile.flatMap((n) => n.slice(0, perFile.length > 8 ? 1 : 3)))];
+    const line = `${dir}/: ${names.slice(0, 30).join(', ')}${names.length > 30 ? ', ...' : ''}`;
+    if (used + line.length > BUDGET) { skipped++; continue; }
+    lines.push(line);
+    used += line.length + 1;
+  }
+  if (!lines.length) return '';
+  return 'Codebase map (what already exists; reuse it, read a file only when you need its details):\n' +
+    lines.join('\n') + (skipped ? `\n(${skipped} more folders not listed)` : '');
+}
+
+module.exports = { buildMap };
+
+if (require.main === module) process.stdout.write(buildMap(process.argv[2] || process.cwd()) + '\n');

package/hooks/ponytail-mode-tracker.js

@@ -0,0 +1,216 @@
+#!/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 fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { getClaudeDir, getDefaultMode, isDeactivationCommand, writeDefaultMode } = require('./ponytail-config');
+const {
+  clearMode,
+  cursorRuleNotice,
+  cursorRulePath,
+  isCodeBuddy,
+  isCodex,
+  isCopilot,
+  isCursor,
+  isQoder,
+  readMode,
+  setMode,
+  writeHookOutput,
+} = require('./ponytail-runtime');
+const { getPonytailInstructions } = require('./ponytail-instructions');
+
+let input = '';
+let done = false;
+
+function finish() {
+  if (done) return;
+  done = true;
+  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();
+
+    // Cursor with the always-on rule in the workspace: no hook can change or
+    // switch off a rule, so answer the command with the notice instead of
+    // writing a mode the rule would contradict (#817). Ordinary prompts
+    // stay silent as usual.
+    if (isCursor && (/^[/@$]ponytail/.test(prompt) || isDeactivationCommand(prompt))) {
+      const rule = cursorRulePath();
+      if (rule) {
+        writeHookOutput('UserPromptSubmit', readMode() || 'off', cursorRuleNotice(rule));
+        return;
+      }
+    }
+
+    // Match /ponytail commands
+    let modeSwitched = false;
+    let deactivated = false;
+    let defaultNotice = '';
+    if (/^[/@$]ponytail/.test(prompt)) {
+      const parts = prompt.split(/\s+/);
+      const cmd = parts[0].replace(/^[@$]/, '/');
+      const arg = parts[1] || '';
+
+      let mode = null;
+      let isReportOnly = false;
+
+      // /ponytail-review is a one-shot skill, not a session level (#736).
+      // Matching it here used to setMode('review'), which latched
+      // INDEPENDENT_MODES for the rest of the session.
+      if (cmd === '/ponytail' || cmd === '/ponytail:ponytail') {
+        // `/ponytail default <mode>` persists the default to config (survives
+        // restarts). Plain switches stay session-scoped ("sticks until session
+        // end"), so this is the only path that writes config. review is not a
+        // valid default (#377), so only off/lite/full/ultra are accepted.
+        if (arg === 'default') {
+          const dmode = parts[2];
+          if (dmode === 'off' || dmode === 'lite' || dmode === 'full' || dmode === 'ultra') {
+            writeDefaultMode(dmode);
+            defaultNotice = 'PONYTAIL DEFAULT SET — new sessions start in ' + dmode + '.';
+            if (!isQoder) writeHookOutput('UserPromptSubmit', dmode, defaultNotice);
+          }
+          // Qoder still needs this turn's ruleset: the block below folds the
+          // notice into it. mode stays null, so the session level is untouched.
+          if (!isQoder) return; // don't fall through to the session-mode switch
+        }
+        // `/ponytail band [on|off]` shows or hides the band above the Claude Code
+        // prompt (hooks/band reads this flag). It outlives the session; absent = shown.
+        // Other hosts have no band, so there the word stays an unknown argument.
+        if (arg === 'band' && !isCopilot && !isCodex && !isQoder && !isCodeBuddy && !isCursor) {
+          // `/ponytail band import`: past sessions into the board, in the background, so the prompt
+          // is answered right away while the transcripts are read. Detached, it outlives this hook's
+          // process.exit below.
+          if (parts[2] === 'import') {
+            spawn(process.execPath, [path.join(__dirname, 'ponytail-band-import.js')], { detached: true, stdio: 'ignore' });
+            writeHookOutput('UserPromptSubmit', readMode() || 'off', 'PONYTAIL BAND IMPORT: past Claude Code sessions (cost, agent time, tokens) are being added to the board in the background. Open the board in a minute. Confirm in one short line.');
+            return;
+          }
+          const flag = path.join(getClaudeDir(), '.ponytail-band');
+          let hidden = false;
+          try { hidden = fs.readFileSync(flag, 'utf8').trim() === 'off'; } catch (e) {}
+          const show = parts[2] === 'on' ? true : parts[2] === 'off' ? false : hidden;
+          if (show) {
+            try { fs.unlinkSync(flag); } catch (e) {}
+          } else {
+            fs.mkdirSync(path.dirname(flag), { recursive: true });
+            fs.writeFileSync(flag, 'off');
+          }
+          writeHookOutput('UserPromptSubmit', readMode() || 'off', show
+            ? 'PONYTAIL BAND ON: the band shows above the prompt again. The ponytail level is unchanged. Confirm in one short line.'
+            : 'PONYTAIL BAND OFF: the band above the prompt is hidden, `/ponytail band` brings it back. The ponytail level is unchanged. Confirm in one short line.');
+          return;
+        }
+        if (arg === 'lite') mode = 'lite';
+        else if (arg === 'full') mode = 'full';
+        else if (arg === 'ultra') mode = 'ultra';
+        else if (arg === 'off') mode = 'off';
+        else if (arg === '') {
+          // Bare /ponytail switches ponytail on: off → the default level (full if
+          // the default is off too); already on → keep the level, report it (#639).
+          const live = readMode();
+          if (live && live !== 'off') {
+            isReportOnly = true;
+            mode = live;
+          } else {
+            mode = getDefaultMode() === 'off' ? 'full' : getDefaultMode();
+          }
+        }
+      }
+
+      if (isReportOnly) {
+        // On Qoder the ruleset block below already reports; a second write
+        // here would put two JSON objects on stdout.
+        if (!isQoder) {
+          writeHookOutput(
+            'UserPromptSubmit',
+            mode,
+            'PONYTAIL MODE ACTIVE — level: ' + mode,
+          );
+        }
+      } else if (mode && mode !== 'off') {
+        setMode(mode);
+        modeSwitched = true;
+        // ponytail: Qoder needs the full ruleset every turn, so when a mode
+        // switch happens we fold the confirmation into the ruleset output
+        // below (one JSON on stdout) instead of emitting two separate writes.
+        if (!isQoder) {
+          // Cursor (#817) and Codex have no /ponytail command that would load
+          // the skill body for the new level, and the SessionStart ruleset is
+          // filtered to the start level, so the tracker delivers that level's
+          // ruleset along with the confirmation.
+          const header = 'PONYTAIL MODE CHANGED — level: ' + mode;
+          writeHookOutput(
+            'UserPromptSubmit',
+            mode,
+            (isCodex || isCursor) ? header + '\n\n' + getPonytailInstructions(mode) : header,
+          );
+        }
+      } else if (mode === 'off') {
+        if (isQoder) setMode('off');
+        else clearMode();
+
+        deactivated = true;
+        writeHookOutput('UserPromptSubmit', 'off', 'PONYTAIL MODE OFF');
+      }
+    }
+
+    // Detect deactivation
+    if (!modeSwitched && !deactivated && isDeactivationCommand(prompt)) {
+      if (isQoder) setMode('off');
+      else clearMode();
+
+      deactivated = true;
+      writeHookOutput('UserPromptSubmit', 'off', 'PONYTAIL MODE OFF');
+    }
+
+    // Qoder has no SessionStart event, so UserPromptSubmit does double duty:
+    // activate the default mode on first prompt (if no flag exists yet), then
+    // inject the ruleset on every prompt. Claude Code/Codex do this in
+    // SessionStart via ponytail-activate.js; Qoder can't, so we do it here.
+    // Skip when deactivated — user just turned ponytail off.
+    if (isQoder && !deactivated) {
+      let currentMode = readMode();
+      if (!currentMode) {
+        // First prompt in session — initialize from config/env default
+        currentMode = getDefaultMode();
+        if (currentMode !== 'off') {
+          try { setMode(currentMode); } catch (e) {}
+        }
+      }
+      if (currentMode && currentMode !== 'off') {
+        // ponytail: one JSON per invocation — mode-switch confirmation is
+        // folded into the ruleset header so Qoder gets both in one write.
+        const header = (defaultNotice ? defaultNotice + '\n\n' : '') + (modeSwitched
+          ? 'PONYTAIL MODE CHANGED — level: ' + currentMode + '\n\n'
+          : '');
+        writeHookOutput('UserPromptSubmit', currentMode, header + getPonytailInstructions(currentMode));
+      } else if (defaultNotice) {
+        writeHookOutput('UserPromptSubmit', currentMode, defaultNotice);
+      }
+    }
+  } catch (e) {
+    // Silent fail
+  }
+}
+
+process.stdin.on('data', chunk => { input += chunk; });
+// Exit on 'end', not just finish(): the fallback timer below must stay ref'd
+// (see #790) so it can actually fire when stdin is stuck, and a ref'd timer
+// would otherwise keep the process alive for its full 1000ms on this normal
+// fast path.
+process.stdin.on('end', () => { finish(); process.exit(0); });
+
+// Never hang the session. On Windows, Claude Code runs this hook through a
+// PowerShell `if {}` wrapper that can swallow the piped prompt JSON, so stdin
+// 'end' never fires and the hook blocks forever — freezing the session (#443).
+// On error, or after a short fallback, process whatever arrived (recovering the
+// mode if data came without EOF) and exit. The fallback timer MUST stay ref'd:
+// on Windows a stuck ref'd stdin handle keeps the event loop alive, and an
+// unref'd timer competing with it is never scheduled — so the fallback was
+// dead code in exactly the #443/#790 case it exists for, and the hook hung
+// until Claude Code's external 5s watchdog killed it (#790). Mirrors the
+// best-effort, never-block contract the other lifecycle hooks already follow.
+process.stdin.on('error', () => { finish(); process.exit(0); });
+setTimeout(() => { finish(); process.exit(0); }, 1000);

package/hooks/ponytail-runtime.js

@@ -0,0 +1,182 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { createHash } = require('crypto');
+const { getClaudeDir, getQoderDir } = require('./ponytail-config');
+
+const STATE_FILE = '.ponytail-active';
+
+// ponytail: VS Code Copilot never sets COPILOT_PLUGIN_DATA — it only injects
+// CLAUDE_PLUGIN_ROOT, pointed at an install path under .vscode/agent-plugins/
+// (#528). Without this fallback isCopilot was false, so ponytail assumed
+// native Claude Code and emitted the statusline nudge, which VS Code Copilot
+// doesn't read.
+function isVsCodeCopilotRoot(pluginRoot) {
+  if (!pluginRoot) return false;
+  return pluginRoot.split(/[\\/]+/).includes('agent-plugins') &&
+    pluginRoot.toLowerCase().includes('.vscode');
+}
+
+const isCopilot = Boolean(process.env.COPILOT_PLUGIN_DATA) ||
+  isVsCodeCopilotRoot(process.env.CLAUDE_PLUGIN_ROOT);
+const isCodex = !isCopilot && Boolean(process.env.PLUGIN_DATA);
+const isQoder = !isCopilot && !isCodex && Boolean(process.env.QODER_SESSION_ID);
+// CodeBuddy (#854) loads the Claude-format plugin and sets CLAUDE_PLUGIN_ROOT
+// too, but adds CODEBUDDY_PLUGIN_ROOT only for its own plugin hook processes.
+const isCodeBuddy = !isCopilot && !isCodex && !isQoder && Boolean(process.env.CODEBUDDY_PLUGIN_ROOT);
+// Cursor (#817): CURSOR_VERSION is set only in the environment Cursor builds
+// for hook processes (Cursor 3.20.17 assigns it in exactly one place, the hook
+// env builder), so it never leaks into a Claude Code session running inside
+// Cursor's terminal. Cursor also sets it when it runs a Claude-format plugin's
+// hooks next to CLAUDE_PLUGIN_ROOT, and it needs Cursor-shaped JSON either
+// way, so this check comes after the hosts with their own data dirs.
+const isCursor = !isCopilot && !isCodex && !isQoder && !isCodeBuddy && Boolean(process.env.CURSOR_VERSION);
+
+let stateDir = getClaudeDir();
+if (isCodex) stateDir = process.env.PLUGIN_DATA;
+// COPILOT_PLUGIN_DATA is unset under VS Code Copilot, so fall back to
+// getClaudeDir() rather than building a path from undefined.
+if (isCopilot) stateDir = process.env.COPILOT_PLUGIN_DATA || getClaudeDir();
+if (isQoder) stateDir = getQoderDir();
+if (isCodeBuddy) stateDir = process.env.CODEBUDDY_CONFIG_DIR || path.join(os.homedir(), '.codebuddy');
+if (isCursor) stateDir = path.join(os.homedir(), '.cursor');
+
+const statePath = path.join(stateDir, STATE_FILE);
+
+// Claude Code hands every hook its project dir, so the live mode is kept per
+// project and concurrent sessions in different repos stop overwriting each other
+// (#662, #809). Hosts without it keep the single shared flag.
+// ponytail: sessions in the SAME repo still share one mode, and the statusline
+// scripts read the shared flag (last write wins); key by session_id if either matters.
+const projectDir = (process.env.CLAUDE_PROJECT_DIR || '').trim();
+// Replacing separators with '_' aliases e.g. /work/a/b and /work/a_b (#662).
+// Do not read old sanitized keys: they cannot be assigned to one project safely.
+const projectStatePath = projectDir
+  ? path.join(stateDir, 'ponytail-modes',
+    createHash('sha256').update(path.normalize(projectDir)).digest('hex'))
+  : null;
+
+// The shared flag is still written, for the statusline and project-less hosts.
+function setMode(mode) {
+  for (const file of [projectStatePath, statePath]) {
+    if (!file) continue;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, mode);
+  }
+}
+
+function clearMode() {
+  for (const file of [projectStatePath, statePath]) {
+    if (file) try { fs.unlinkSync(file); } catch (e) {}
+  }
+}
+
+// Live mode written by activate/mode-tracker. Absent flag = ponytail off.
+function readMode() {
+  try {
+    return fs.readFileSync(projectStatePath || statePath, 'utf8').trim() || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+// Cursor's always-on project rule (.cursor/rules/ponytail.mdc) already puts the
+// ruleset in front of every prompt and no hook can switch a rule off, so while
+// it is in the workspace the hooks step back instead of injecting a second,
+// possibly contradicting, copy (#817). Cursor hands every hook the workspace
+// root as CURSOR_PROJECT_DIR; project hooks also run from that directory.
+// ponytail: first workspace root only, a rule in a secondary folder of a
+// multi-root workspace goes undetected.
+function cursorRulePath() {
+  const root = process.env.CURSOR_PROJECT_DIR || process.cwd();
+  const rule = path.join(root, '.cursor', 'rules', 'ponytail.mdc');
+  return fs.existsSync(rule) ? rule : null;
+}
+
+function cursorRuleNotice(rule) {
+  return 'PONYTAIL: the always-on Cursor rule ' + rule + ' is active in this workspace and ' +
+    'already carries the ponytail ruleset, so the ponytail hooks injected nothing further. ' +
+    'Mode switching (/ponytail lite|full|ultra|off, "stop ponytail") is unavailable while ' +
+    'that rule exists. When the user tries to switch or turn off ponytail, tell them to ' +
+    'delete that rule so hooks.json can manage the level.';
+}
+
+// Synchronous: every hook calls process.exit() right after this, and on macOS a pipe
+// write is async, so a pending write died with the process (#1043).
+function writeOut(text) {
+  fs.writeSync(1, text);
+}
+
+function writeHookOutput(event, mode, context = '') {
+  if (isCopilot) {
+    // Copilot reads additionalContext on SessionStart; ignores output elsewhere.
+    writeOut(JSON.stringify(
+      event === 'SessionStart' && context ? { additionalContext: context } : {}));
+    return;
+  }
+  if (isCodex) {
+    // No systemMessage: Codex maps it to a yellow `warning:` entry (and de-greens the
+    // completed-hook bullet), reading as an error every session (#605). The mode still
+    // shows via the additionalContext "hook context:" line — active level when on,
+    // "PONYTAIL MODE OFF" when off (that path passes context too).
+    // ponytail: if openai/codex#16933 lands and hides additionalContext, restore a
+    // non-warning mode signal here.
+    const output = {};
+    if (context) {
+      output.hookSpecificOutput = {
+        hookEventName: event,
+        additionalContext: context,
+      };
+    }
+    writeOut(JSON.stringify(output));
+    return;
+  }
+  if (isQoder || isCodeBuddy) {
+    // Qoder: hookSpecificOutput JSON, same shape as Codex minus systemMessage.
+    // UserPromptSubmit additionalContext is injected into the Agent's conversation.
+    // CodeBuddy would take raw stdout too, but also echoes it into the chat.
+    const output = {};
+    if (context) {
+      output.hookSpecificOutput = {
+        hookEventName: event,
+        additionalContext: context,
+      };
+    }
+    writeOut(JSON.stringify(output));
+    return;
+  }
+  if (isCursor) {
+    // Cursor parses stdout as JSON and treats empty stdout as "nothing to
+    // say"; raw text would be logged as a parse error. sessionStart takes
+    // additional_context into the conversation's system context;
+    // beforeSubmitPrompt needs continue:true and, in Cursor 3.20.17, injects
+    // additional_context into that turn (docs/cursor-hooks.md).
+    if (!context) return;
+    const output = { additional_context: context };
+    if (event === 'UserPromptSubmit') output.continue = true;
+    writeOut(JSON.stringify(output));
+    return;
+  }
+  // Native Claude: SessionStart accepts raw stdout, but SubagentStart needs the
+  // hookSpecificOutput JSON form or the context is dropped.
+  if (event === 'SubagentStart') {
+    writeOut(JSON.stringify(
+      { hookSpecificOutput: { hookEventName: event, additionalContext: context } }));
+    return;
+  }
+  writeOut(context);
+}
+
+module.exports = {
+  clearMode,
+  cursorRuleNotice,
+  cursorRulePath,
+  isCodeBuddy,
+  isCodex,
+  isCopilot,
+  isCursor,
+  isQoder,
+  readMode,
+  setMode,
+  writeHookOutput,
+};

package/hooks/ponytail-statusline.ps1

@@ -0,0 +1,24 @@
+# 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
+# ultra is the high-intensity mode; flag it amber so it stands out from the
+# default green. The level is still in the text, so color is a redundant cue.
+$Color = if ($Mode -eq "ultra") { "173" } else { "108" }
+if ([string]::IsNullOrEmpty($Mode) -or $Mode -eq "full") {
+    [Console]::Write("${Esc}[38;5;${Color}m[PONYTAIL]${Esc}[0m")
+} else {
+    $Suffix = $Mode.ToUpperInvariant()
+    [Console]::Write("${Esc}[38;5;${Color}m[PONYTAIL:$Suffix]${Esc}[0m")
+}

package/hooks/ponytail-statusline.sh

@@ -0,0 +1,18 @@
+#!/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:]')
+
+# ultra is the high-intensity mode; flag it amber so it stands out from the
+# default green at a glance. The level is still in the text, so color is a
+# redundant cue, not the only one.
+color=108
+[ "$mode" = "ultra" ] && color=173
+
+if [ -z "$mode" ] || [ "$mode" = "full" ]; then
+    printf '\033[38;5;%sm[PONYTAIL]\033[0m' "$color"
+else
+    printf '\033[38;5;%sm[PONYTAIL:%s]\033[0m' "$color" "$(printf '%s' "$mode" | tr '[:lower:]' '[:upper:]')"
+fi