@herbertgao/pi-extensions 2026.10.0 → 2026.10.2

package/node_modules/@dietrichgebert/ponytail/hooks/ponytail-instructions.js

@@ -41,37 +41,37 @@ function filterSkillBodyForMode(body, mode) {
 }
 
 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' +
-    '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 deliberate simplifications that cut a real corner with a known ceiling, using a `ponytail:` comment that names the ceiling and upgrade path.\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.';
+    '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) {

package/node_modules/@dietrichgebert/ponytail/hooks/ponytail-map.js

@@ -0,0 +1,103 @@
+#!/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 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 {
+    const tracked = execFileSync('git', ['ls-files'], { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000 })
+      .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().split(/\s+as\s+/).pop()).filter(Boolean)) {
+        if (!n.startsWith('_') && !names.includes(n)) names.push(n);
+      }
+    }
+  }
+  return names;
+}
+
+function buildMap(root = process.cwd()) {
+  const files = listFiles(root)
+    .filter((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 { 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/node_modules/@dietrichgebert/ponytail/hooks/ponytail-mode-tracker.js

@@ -7,6 +7,7 @@ const {
   clearMode,
   cursorRuleNotice,
   cursorRulePath,
+  isCodex,
   isCursor,
   isQoder,
   readMode,
@@ -49,9 +50,10 @@ function finish() {
       let mode = null;
       let isReportOnly = false;
 
-      if (cmd === '/ponytail-review' || cmd === '/ponytail:ponytail-review') {
-        mode = 'review';
-      } else if (cmd === '/ponytail' || cmd === '/ponytail:ponytail') {
+      // /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
@@ -69,19 +71,28 @@ function finish() {
         else if (arg === 'ultra') mode = 'ultra';
         else if (arg === 'off') mode = 'off';
         else if (arg === '') {
-          isReportOnly = true;
-          mode = readMode() || getDefaultMode();
-        } else {
-          mode = getDefaultMode();
+          // 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) {
-        writeHookOutput(
-          'UserPromptSubmit',
-          mode,
-          'PONYTAIL MODE ACTIVE — level: ' + mode,
-        );
+        // 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;
@@ -89,18 +100,21 @@ function finish() {
         // switch happens we fold the confirmation into the ruleset output
         // below (one JSON on stdout) instead of emitting two separate writes.
         if (!isQoder) {
-          // Cursor has no /ponytail command that would load the skill body
-          // for the new level, so the tracker delivers that level's ruleset
-          // along with the confirmation (#817).
+          // 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,
-            isCursor ? header + '\n\n' + getPonytailInstructions(mode) : header,
+            (isCodex || isCursor) ? header + '\n\n' + getPonytailInstructions(mode) : header,
           );
         }
       } else if (mode === 'off') {
-        clearMode();
+        if (isQoder) setMode('off');
+        else clearMode();
+
         deactivated = true;
         writeHookOutput('UserPromptSubmit', 'off', 'PONYTAIL MODE OFF');
       }
@@ -108,7 +122,9 @@ function finish() {
 
     // Detect deactivation
     if (!modeSwitched && !deactivated && isDeactivationCommand(prompt)) {
-      clearMode();
+      if (isQoder) setMode('off');
+      else clearMode();
+
       deactivated = true;
       writeHookOutput('UserPromptSubmit', 'off', 'PONYTAIL MODE OFF');
     }
@@ -142,14 +158,21 @@ function finish() {
 }
 
 process.stdin.on('data', chunk => { input += chunk; });
-process.stdin.on('end', finish);
+// 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. unref() keeps the timer from adding
-// latency to the normal path, where 'end' fires first. Mirrors the best-effort,
-// never-block contract the other lifecycle hooks already follow.
+// 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).unref();
+setTimeout(() => { finish(); process.exit(0); }, 1000);

package/node_modules/@dietrichgebert/ponytail/hooks/ponytail-runtime.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { createHash } = require('crypto');
 const { getClaudeDir, getConfigDir } = require('./ponytail-config');
 
 const STATE_FILE = '.ponytail-active';
@@ -20,13 +21,16 @@ 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 && Boolean(process.env.CURSOR_VERSION);
+const isCursor = !isCopilot && !isCodex && !isQoder && !isCodeBuddy && Boolean(process.env.CURSOR_VERSION);
 
 let stateDir = getClaudeDir();
 if (isCodex) stateDir = process.env.PLUGIN_DATA;
@@ -34,23 +38,43 @@ if (isCodex) stateDir = process.env.PLUGIN_DATA;
 // getClaudeDir() rather than building a path from undefined.
 if (isCopilot) stateDir = process.env.COPILOT_PLUGIN_DATA || getClaudeDir();
 if (isQoder) stateDir = path.join(os.homedir(), '.qoder');
+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) {
-  fs.mkdirSync(path.dirname(statePath), { recursive: true });
-  fs.writeFileSync(statePath, mode);
+  for (const file of [projectStatePath, statePath]) {
+    if (!file) continue;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, mode);
+  }
 }
 
 function clearMode() {
-  try { fs.unlinkSync(statePath); } catch (e) {}
+  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(statePath, 'utf8').trim() || null;
+    return fs.readFileSync(projectStatePath || statePath, 'utf8').trim() || null;
   } catch (e) {
     return null;
   }
@@ -85,7 +109,13 @@ function writeHookOutput(event, mode, context = '') {
     return;
   }
   if (isCodex) {
-    const output = { systemMessage: `PONYTAIL:${mode.toUpperCase()}` };
+    // 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,
@@ -95,9 +125,10 @@ function writeHookOutput(event, mode, context = '') {
     process.stdout.write(JSON.stringify(output));
     return;
   }
-  if (isQoder) {
+  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 = {
@@ -134,6 +165,7 @@ module.exports = {
   clearMode,
   cursorRuleNotice,
   cursorRulePath,
+  isCodeBuddy,
   isCodex,
   isCopilot,
   isCursor,

package/node_modules/@dietrichgebert/ponytail/hooks/ponytail-subagent.js

@@ -12,6 +12,7 @@
 
 const { getPonytailInstructions } = require('./ponytail-instructions');
 const { readMode, writeHookOutput } = require('./ponytail-runtime');
+const vm = require('vm');
 
 const mode = readMode();
 
@@ -64,14 +65,30 @@ function finish() {
   } catch (e) {
     // Unparseable payload — fall through and inject to be safe.
   }
-  if (agentType && !matcherRe.test(agentType)) {
+  // .test() is synchronous, so a backtracking-heavy matcher like (a+)+$ would
+  // block the event loop and the fallback timer below could never fire (#658).
+  // Run it under a vm timeout; a timeout fails open like every other doubt.
+  let matches = true;
+  try {
+    if (agentType) {
+      matches = vm.runInNewContext('re.test(s)', { re: matcherRe, s: agentType }, { timeout: 100 });
+    }
+  } catch (e) {
+    matches = true;
+  }
+  if (!matches) {
     process.exit(0);
   }
   inject();
 }
 
 process.stdin.on('data', chunk => { input += chunk; });
-process.stdin.on('end', finish);
+// Exit on 'end' (not just finish()) so the ref'd fallback timer below can't
+// add its full 1000ms to the normal fast path.
+process.stdin.on('end', () => { finish(); process.exit(0); });
 // Never block the session (#443): recover on stdin error or a short fallback.
+// The fallback stays ref'd: on Windows a stuck ref'd stdin keeps the loop
+// alive and an unref'd timer is never scheduled, so the hook hung to the
+// external watchdog instead of exiting at 1s (#790).
 process.stdin.on('error', () => { finish(); process.exit(0); });
-setTimeout(() => { finish(); process.exit(0); }, 1000).unref();
+setTimeout(() => { finish(); process.exit(0); }, 1000);

package/node_modules/@dietrichgebert/ponytail/hooks/qoder-hooks.json

@@ -1,12 +1,12 @@
 {
-  "_comment": "Reference template — copy the 'hooks' object into your .qoder/settings.json or ~/.qoder/settings.json. Replace PONYTAIL_DIR with the path to your ponytail checkout (e.g. ~/.qoder/plugins/ponytail or the npm global install path).",
+  "_comment": "Loaded live by .qoder-plugin/plugin.json (\"hooks\": \"./hooks/qoder-hooks.json\"). Qoder expands ${QODER_PLUGIN_ROOT} (the plugin install root) at runtime; see https://docs.qoder.com/en/cli/plugins#writing-plugin-hooks.",
   "hooks": {
     "UserPromptSubmit": [
       {
         "hooks": [
           {
             "type": "command",
-            "command": "node PONYTAIL_DIR/hooks/ponytail-mode-tracker.js"
+            "command": "node \"${QODER_PLUGIN_ROOT}/hooks/ponytail-mode-tracker.js\""
           }
         ]
       }
@@ -17,7 +17,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node PONYTAIL_DIR/hooks/ponytail-subagent.js"
+            "command": "node \"${QODER_PLUGIN_ROOT}/hooks/ponytail-subagent.js\""
           }
         ]
       }

package/node_modules/@dietrichgebert/ponytail/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dietrichgebert/ponytail",
-  "version": "4.10.0",
+  "version": "5.1.0",
   "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", "qoder"],
   "license": "MIT",
@@ -29,13 +29,13 @@
     ".qoder/",
     ".qoder-plugin/",
     "pi-extension/",
+    "!pi-extension/test/",
     "scripts/uninstall.js",
     "scripts/cursor-hooks.js",
-    "assets/",
     "LICENSE"
   ],
   "scripts": {
-    "test": "node --test tests/*.test.js && npm test --prefix pi-extension && npm test --prefix ponytail-mcp"
+    "test": "node --test tests/*.test.js && npm test --prefix pi-extension"
   },
   "pi": {
     "extensions": ["./pi-extension/index.js"],