chill-agent 1.4.0 → 1.5.0

package/hooks/ponytail-activate.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+// ponytail — Claude Code SessionStart activation hook (also Codex, Copilot,
+// Grok, CodeBuddy and Cursor sessionStart)
+//
+// 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 { execFileSync } = require('child_process');
+const { getDefaultMode, getClaudeDir, isShellSafe } = require('./ponytail-config');
+const { getPonytailInstructions } = require('./ponytail-instructions');
+const {
+  clearMode,
+  cursorRuleNotice,
+  cursorRulePath,
+  isCodeBuddy,
+  isCodex,
+  isCopilot,
+  isCursor,
+  readMode,
+  setMode,
+  writeHookOutput,
+} = require('./ponytail-runtime');
+
+const claudeDir = getClaudeDir();
+const settingsPath = path.join(claudeDir, 'settings.json');
+
+function activate(mode) {
+  // "off" mode — skip activation entirely, don't write flag or emit rules
+  if (mode === 'off') {
+    clearMode();
+    process.exit(0);
+  }
+
+  // Cursor with the always-on rule in the workspace: the rule already carries the
+  // ruleset and would contradict any other level, so leave the flag alone and
+  // hand the model a one-line notice instead of a second copy (#817).
+  if (isCursor) {
+    const rule = cursorRulePath();
+    if (rule) {
+      try {
+        writeHookOutput('SessionStart', mode, cursorRuleNotice(rule));
+      } catch (e) {
+        // Silent fail — stdout closed/EPIPE at hook exit must not surface as a hook failure
+      }
+      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);
+
+  // 2b. Codebase map: what already exists, so "reuse first" costs no search. Fail open: the map
+  // gets 3 s, well inside the 15 s hook limit, so a stalled map never costs the rules (#1079, #1157).
+  // shortcut: a map slower than 3 s is still dropped; a cached per-repo map would lift that if it shows up.
+  if (mode !== 'review' && process.env.PONYTAIL_MAP !== '0') try {
+    const map = execFileSync(process.execPath, [path.join(__dirname, 'ponytail-map.js')], {
+      encoding: 'utf8', timeout: 3000, maxBuffer: 64 * 1024, stdio: ['ignore', 'pipe', 'ignore'],
+    }).trimEnd();
+    if (map) output += '\n\n' + map;
+  } catch (e) { /* no map */ }
+
+  // 3. Detect missing statusline config — nudge Claude to help set it up
+  if (!isCodex && !isCopilot && !isCursor && !isCodeBuddy) try {
+    const isWindows = process.platform === 'win32';
+    let statusCommand = null;
+    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) {
+        statusCommand = String(settings.statusLine.command || '');
+      }
+    }
+
+    // A statusLine already set up before #1032 can still run a script from a
+    // plugin version that has since been deleted. Only absolute paths are checked,
+    // so ~ or $HOME forms are never mistaken for missing files.
+    const ref = statusCommand &&
+      statusCommand.match(/"([^"]*ponytail-statusline\.(?:sh|ps1))"|(\S*ponytail-statusline\.(?:sh|ps1))/);
+    const refPath = ref ? (ref[1] || ref[2]) : null;
+    // isShellSafe keeps quotes, newlines and shell metacharacters from
+    // settings.json out of the model context.
+    // On Windows only drive-letter or UNC paths count: a Git Bash path such as
+    // /c/Users/... is absolute to Node but does not resolve, so it would be
+    // flagged as broken while it works.
+    const checkable = refPath && isShellSafe(refPath) && path.isAbsolute(refPath) &&
+      (!isWindows || /^([A-Za-z]:[\\/]|\\\\)/.test(refPath));
+    const stalePath = checkable && !fs.existsSync(refPath) ? refPath : null;
+
+    // The plugin root is a versioned cache dir (.../ponytail/4.12.0/) that Claude
+    // Code deletes on update, so a statusLine pointing into it goes blank after the
+    // next update (#1032). Point it at a copy in the config dir instead. A statusLine
+    // that already runs ponytail keeps its script type, so its copy stays fresh.
+    const usePs1 = refPath ? refPath.endsWith('.ps1') : isWindows;
+    const scriptName = usePs1 ? 'ponytail-statusline.ps1' : 'ponytail-statusline.sh';
+    const scriptPath = path.join(claudeDir, scriptName);
+
+    // Nudge at most once — the flag file marks that the user has already seen
+    // (and implicitly declined) the statusline setup offer. Repeating it every
+    // session start turns a helpful hint into a nag. A broken path is nudged once
+    // per path: the flag records it.
+    const nudgeFlagPath = path.join(claudeDir, '.ponytail-statusline-nudged');
+    let nudged = null;
+    try { nudged = fs.readFileSync(nudgeFlagPath, 'utf8'); } catch (e) { /* not nudged yet */ }
+    const nudge = stalePath ? nudged !== stalePath : statusCommand === null && nudged === null;
+
+    // Refresh the copy every session so script fixes ship with plugin updates.
+    // Copy to a new temp file, then rename: the rename replaces a symlink at
+    // scriptPath instead of writing through it, and a concurrent session never
+    // runs a half-written script.
+    if (nudge || fs.existsSync(scriptPath)) {
+      const tmpPath = scriptPath + '.' + process.pid + '.tmp';
+      try {
+        fs.copyFileSync(path.join(__dirname, scriptName), tmpPath, fs.constants.COPYFILE_EXCL);
+        fs.chmodSync(tmpPath, 0o644);
+        fs.renameSync(tmpPath, scriptPath);
+      } finally {
+        try { fs.unlinkSync(tmpPath); } catch (e) { /* renamed */ }
+      }
+    }
+
+    if (nudge) {
+      try { fs.writeFileSync(nudgeFlagPath, stalePath || ''); } catch (e) { /* best-effort */ }
+      if (stalePath) {
+        output += "\n\n" +
+          "STATUSLINE BROKEN: The statusLine in " + settingsPath + " runs " + stalePath +
+          ", which no longer exists (the ponytail plugin was updated and its old version removed), " +
+          "so the ponytail badge is blank. Replace that path with " + scriptPath + ", which survives updates, " +
+          "quoting it for your shell. Keep the rest of the command. " +
+          "Proactively offer to fix this for the user on first interaction.";
+      } else 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 " + settingsPath + ": " +
+          statusLineSnippet + " " +
+          "Proactively offer to set this up for the user on first interaction.";
+      } else {
+        // ponytail: config dir 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 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 " + claudeDir + " to " + settingsPath + ", 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
+  }
+}
+
+// Compaction re-runs SessionStart inside the same conversation, so it keeps the
+// live level (or stays off after "stop ponytail") instead of resetting to the
+// default. Claude Code and Codex pass the trigger as `source` on stdin; reading
+// it there keeps the hook entry, and the trust Codex gave it, unchanged.
+let input = '';
+let done = false;
+
+function finish() {
+  if (done) return;
+  done = true;
+  let source = '';
+  try {
+    // Strip UTF-8 BOM some shells prepend when piping (breaks JSON.parse)
+    source = JSON.parse(input.replace(/^\uFEFF/, '')).source;
+  } catch (e) {
+    // No payload, or an unparseable one: treat it as a fresh session
+  }
+  activate(source === 'compact' ? (readMode() || 'off') : getDefaultMode());
+}
+
+process.stdin.on('data', chunk => { input += chunk; });
+// Never hang the session start (#443, #790): like the mode tracker, recover on a
+// stdin error or after a short ref'd fallback, and start at the default level.
+process.stdin.on('end', () => { finish(); process.exit(0); });
+process.stdin.on('error', () => { finish(); process.exit(0); });
+setTimeout(() => { finish(); process.exit(0); }, 1000);

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-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);