chill-agent 1.4.0 → 1.5.0

package/tests/correctness.test.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+// Unit test for the correctness benchmark assertion. Feeds known-good and
+// known-bad LLM outputs through each task checker and asserts the expected
+// pass/fail verdict. Runs without promptfoo — just node:test + the module.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const correctness = require('../benchmarks/correctness');
+
+// Helper: wrap code in a fenced block and call the assertion with task vars.
+function check(task, lang, code) {
+  const output = '```' + lang + '\n' + code + '\n```';
+  return correctness(output, { vars: { task } });
+}
+
+// --- Email validator ---
+
+test('email: correct one-liner passes', () => {
+  const result = check(
+    'Write me a Python function that validates email addresses.',
+    'python',
+    'def validate_email(email):\n    return "@" in email and "." in email.split("@")[-1] and email.split("@")[0] != ""',
+  );
+  assert.equal(result.pass, true);
+  assert.equal(result.score, 1);
+});
+
+test('email: always-true validator fails', () => {
+  const result = check(
+    'Write me a Python function that validates email addresses.',
+    'python',
+    'def validate_email(email):\n    return True',
+  );
+  assert.equal(result.pass, false);
+  assert.equal(result.score, 0);
+});
+
+test('email: no code block fails', () => {
+  const result = correctness('Here is my answer: just use regex.', {
+    vars: { task: 'Write me a Python function that validates email addresses.' },
+  });
+  assert.equal(result.pass, false);
+});
+
+test('email: bare unfenced code is still scored (#65)', () => {
+  const result = correctness('import re\ndef validate_email(e):\n    return bool(re.match(r"^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$", e))', {
+    vars: { task: 'Write me a Python function that validates email addresses.' },
+  });
+  assert.equal(result.pass, true);
+});
+
+// --- Debounce ---
+
+test('debounce: correct implementation passes', () => {
+  const result = check(
+    'Add debounce to a search input in vanilla JavaScript.',
+    'javascript',
+    `function debounce(fn, delay) {
+  let timer;
+  return function(...args) {
+    clearTimeout(timer);
+    timer = setTimeout(() => fn.apply(this, args), delay);
+  };
+}`,
+  );
+  assert.equal(result.pass, true);
+  assert.equal(result.score, 1);
+});
+
+test('debounce: immediate-call implementation fails', () => {
+  const result = check(
+    'Add debounce to a search input in vanilla JavaScript.',
+    'javascript',
+    `function debounce(fn, delay) {
+  return function(...args) { fn.apply(this, args); };
+}`,
+  );
+  assert.equal(result.pass, false);
+  assert.equal(result.score, 0);
+});
+
+test('debounce: bare unfenced arrow function is still scored (#65)', () => {
+  const result = correctness('const debounce = (fn, delay) => {\n  let t;\n  return (...a) => { clearTimeout(t); t = setTimeout(() => fn(...a), delay); };\n};', {
+    vars: { task: 'Write a reusable debounce function in vanilla JavaScript: debounce(fn, delay).' },
+  });
+  assert.equal(result.pass, true);
+});
+
+// --- CSV sum ---
+
+test('csv: correct pandas one-liner passes', () => {
+  const result = check(
+    "Write Python code that reads sales.csv and sums the 'amount' column.",
+    'python',
+    `import pandas as pd
+df = pd.read_csv('sales.csv')
+print(df['amount'].sum())`,
+  );
+  assert.equal(result.pass, true);
+  assert.equal(result.score, 1);
+});
+
+test('csv: an exception in the code is reported, not swallowed (#919)', () => {
+  const result = check(
+    "Write Python code that reads sales.csv and sums the 'amount' column.",
+    'python',
+    `raise RuntimeError("boom")`,
+  );
+  assert.equal(result.pass, false);
+  assert.match(result.reason, /boom/);
+});
+
+test('csv: code that prints wrong value fails', () => {
+  const result = check(
+    "Write Python code that reads sales.csv and sums the 'amount' column.",
+    'python',
+    `print(999)`,
+  );
+  assert.equal(result.pass, false);
+  assert.equal(result.score, 0);
+});
+
+test('csv: value containing 351 as substring fails (e.g. 13510)', () => {
+  const result = check(
+    "Write Python code that reads sales.csv and sums the 'amount' column.",
+    'python',
+    `print(13510)`,
+  );
+  assert.equal(result.pass, false);
+  assert.equal(result.score, 0);
+});
+
+test('csv: timeout can be raised for slow pandas startup', () => {
+  const previous = process.env.PONYTAIL_CORRECTNESS_TIMEOUT_MS;
+  try {
+    process.env.PONYTAIL_CORRECTNESS_TIMEOUT_MS = '1';
+    const timedOut = check(
+      "Write Python code that reads sales.csv and sums the 'amount' column.",
+      'python',
+      `import time
+time.sleep(0.05)
+print(351)`,
+    );
+    assert.equal(timedOut.pass, false);
+    assert.match(timedOut.reason, /ETIMEDOUT|timed out/i);
+
+    process.env.PONYTAIL_CORRECTNESS_TIMEOUT_MS = '1000';
+    const completed = check(
+      "Write Python code that reads sales.csv and sums the 'amount' column.",
+      'python',
+      `import time
+time.sleep(0.05)
+print(351)`,
+    );
+    assert.equal(completed.pass, true);
+    assert.equal(completed.score, 1);
+  } finally {
+    if (previous === undefined) delete process.env.PONYTAIL_CORRECTNESS_TIMEOUT_MS;
+    else process.env.PONYTAIL_CORRECTNESS_TIMEOUT_MS = previous;
+  }
+});
+
+// --- React countdown ---
+
+test('countdown: valid React component passes', () => {
+  const result = check(
+    'Build me a countdown timer component in React.',
+    'javascript',
+    `import { useState, useEffect } from 'react';
+export default function Countdown({ seconds }) {
+  const [count, setCount] = useState(seconds);
+  useEffect(() => {
+    if (count <= 0) return;
+    const id = setInterval(() => setCount(prev => prev - 1), 1000);
+    return () => clearInterval(id);
+  }, [count]);
+  return <div>{count}</div>;
+}`,
+  );
+  assert.equal(result.pass, true);
+  assert.equal(result.score, 1);
+});
+
+test('countdown: static div without state fails', () => {
+  const result = check(
+    'Build me a countdown timer component in React.',
+    'javascript',
+    `export default function Countdown() { return <div>10</div>; }`,
+  );
+  assert.equal(result.pass, false);
+  assert.equal(result.score, 0);
+});
+
+// --- Rate limiter ---
+
+test('ratelimit: FastAPI with limit logic passes', () => {
+  const result = check(
+    'Add rate limiting to my FastAPI endpoint so users can\'t spam it.',
+    'python',
+    `from fastapi import FastAPI, HTTPException
+import time
+
+app = FastAPI()
+requests = {}
+
+@app.get("/api")
+def endpoint(user: str = "anon"):
+    now = time.time()
+    window = requests.get(user, [])
+    window = [t for t in window if now - t < 60]
+    if len(window) >= 10:
+        raise HTTPException(429, "Too Many Requests")
+    window.append(now)
+    requests[user] = window
+    return {"ok": True}`,
+  );
+  assert.equal(result.pass, true);
+  assert.equal(result.score, 1);
+});
+
+test('ratelimit: plain endpoint without limiting fails', () => {
+  const result = check(
+    'Add rate limiting to my FastAPI endpoint.',
+    'python',
+    `from fastapi import FastAPI
+app = FastAPI()
+
+@app.get("/api")
+def endpoint():
+    return {"ok": True}`,
+  );
+  assert.equal(result.pass, false);
+  assert.equal(result.score, 0);
+});
+
+// --- Edge cases ---
+
+test('unknown task is gracefully skipped', () => {
+  const result = correctness('```python\nprint("hi")\n```', {
+    vars: { task: 'Explain quantum computing.' },
+  });
+  assert.equal(result.pass, true);
+  assert.equal(result.score, 1);
+  assert.match(result.reason, /unknown task/i);
+});

package/tests/cursor-hooks.test.js

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+// Cursor adapter compatibility check (#817). The hooks must speak Cursor's
+// hooks.json contract: camelCase events, JSON on stdout (empty stdout is a
+// no-op, raw text is a parse error), `additional_context` on sessionStart, and
+// `continue` plus `additional_context` on beforeSubmitPrompt. The installer must
+// merge into an existing hooks.json without touching unrelated hooks.
+//
+// Input shapes mirror docs/cursor-hooks.md (Cursor docs and the 3.20.17
+// client). This checks the adapter's input/output behavior only; whether the
+// model actually receives the context is the live session check in that doc.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const root = path.join(__dirname, '..');
+const rootFwd = root.replace(/\\/g, '/');
+const TEMPLATE = 'hooks/cursor-hooks.json';
+const { isPonytailHook } = require('../scripts/cursor-hooks');
+
+// Keep host detection and config resolution deterministic whatever shell the
+// suite runs in (a Cursor hook env, a Codex shell, a machine-wide default mode).
+for (const key of [
+  'CURSOR_VERSION', 'CURSOR_PROJECT_DIR', 'CLAUDE_PROJECT_DIR', 'CLAUDE_PLUGIN_ROOT',
+  'CLAUDE_CONFIG_DIR', 'PLUGIN_DATA', 'COPILOT_PLUGIN_DATA', 'QODER_SESSION_ID',
+  'PONYTAIL_SUBAGENT_MATCHER', 'PONYTAIL_DEFAULT_MODE', 'XDG_CONFIG_HOME',
+]) {
+  delete process.env[key];
+}
+
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'ponytail-cursor-'));
+process.on('exit', () => fs.rmSync(temp, { recursive: true, force: true }));
+
+function run(script, env, input = '', cwd = undefined) {
+  return spawnSync(process.execPath, [path.join(root, 'hooks', script)], {
+    env: { ...process.env, ...env },
+    input,
+    cwd,
+    encoding: 'utf8',
+  });
+}
+
+function cli(args, env, cwd = undefined) {
+  return spawnSync(process.execPath, [path.join(root, 'scripts', 'cursor-hooks.js'), ...args], {
+    env: { ...process.env, ...env },
+    cwd,
+    encoding: 'utf8',
+  });
+}
+
+function parse(result) {
+  assert.equal(result.status, 0, result.stderr);
+  assert.ok(result.stdout.startsWith('{'), `expected JSON on stdout, got: ${result.stdout.slice(0, 80)}`);
+  return JSON.parse(result.stdout);
+}
+
+// A fresh HOME and workspace per case so flag state cannot leak between cases.
+// The env is what Cursor 3.20.17 gives a hook process: CURSOR_VERSION and the
+// workspace root in CURSOR_PROJECT_DIR (plus its CLAUDE_PROJECT_DIR alias).
+function cursorEnv(name, extra = {}) {
+  const home = path.join(temp, name, 'home');
+  const project = path.join(temp, name, 'project');
+  fs.mkdirSync(home, { recursive: true });
+  fs.mkdirSync(project, { recursive: true });
+  return {
+    home,
+    project,
+    flag: path.join(home, '.cursor', '.ponytail-active'),
+    env: {
+      HOME: home,
+      USERPROFILE: home,
+      XDG_CONFIG_HOME: path.join(home, '.config'),
+      CURSOR_VERSION: '3.20.17',
+      CURSOR_PROJECT_DIR: project,
+      CLAUDE_PROJECT_DIR: project,
+      ...extra,
+    },
+  };
+}
+
+function writeFlag(c, mode) {
+  fs.mkdirSync(path.dirname(c.flag), { recursive: true });
+  fs.writeFileSync(c.flag, mode);
+}
+
+test('cursor hooks template is a valid hooks.json with the two events that can inject context', () => {
+  const config = JSON.parse(fs.readFileSync(path.join(root, TEMPLATE), 'utf8'));
+  assert.equal(config.version, 1);
+  assert.deepEqual(Object.keys(config.hooks).sort(), ['beforeSubmitPrompt', 'sessionStart']);
+  assert.match(config.hooks.sessionStart[0].command, /ponytail-activate\.js/);
+  assert.match(config.hooks.beforeSubmitPrompt[0].command, /ponytail-mode-tracker\.js/);
+  // subagentStart answers only permission/user_message in Cursor, so it must
+  // not be registered: it would cost a process per subagent and inject nothing.
+  assert.equal(config.hooks.subagentStart, undefined);
+  for (const entries of Object.values(config.hooks)) {
+    assert.ok(Array.isArray(entries) && entries.length === 1);
+    for (const entry of entries) {
+      assert.match(entry.command, /^node "PONYTAIL_DIR\/hooks\/ponytail-[\w-]+\.js"$/, 'plain node call, quoted absolute path');
+      assert.doesNotMatch(entry.command, /(^|\s)exec\s|&&|\|\|/, 'must run under cmd, PowerShell and bash alike');
+      assert.equal(typeof entry.timeout, 'number');
+      const script = entry.command.match(/hooks\/([\w.-]+\.js)/)[1];
+      assert.ok(fs.existsSync(path.join(root, 'hooks', script)), `command references a missing hook script: ${script}`);
+    }
+  }
+});
+
+test('hook detection ignores later lookalike arguments after a real ponytail hook', () => {
+  assert.equal(isPonytailHook({
+    command: 'node "/opt/p/hooks/ponytail-activate.js" --log /tmp/hooks/ponytail-x/',
+  }), true);
+});
+
+test('isCursor is off outside a Cursor hook process', () => {
+  const { isCursor } = require('../hooks/ponytail-runtime');
+  assert.equal(isCursor, false);
+});
+
+test('sessionStart injects the default-level ruleset as additional_context and keeps state under ~/.cursor', () => {
+  const c = cursorEnv('start', { PONYTAIL_DEFAULT_MODE: 'ultra' });
+  const input = JSON.stringify({
+    hook_event_name: 'sessionStart', conversation_id: 'conv-1', session_id: 'conv-1',
+    is_background_agent: false, composer_mode: 'agent', workspace_roots: [c.project],
+    cursor_version: '3.20.17', model: 'claude-opus-4-7-thinking-max',
+  });
+  const output = parse(run('ponytail-activate.js', c.env, input));
+  assert.deepEqual(Object.keys(output), ['additional_context']);
+  assert.match(output.additional_context, /^PONYTAIL MODE ACTIVE — level: ultra/);
+  assert.match(output.additional_context, /Also question the request/, 'ultra row must survive the level filter');
+  assert.doesNotMatch(output.additional_context, /Build what was asked/, 'lite row must be filtered out');
+  assert.doesNotMatch(output.additional_context, /STATUSLINE SETUP NEEDED/, 'Cursor has no Claude statusline to nudge about');
+  assert.equal(fs.readFileSync(c.flag, 'utf8'), 'ultra');
+  assert.equal(fs.existsSync(path.join(c.home, '.claude')), false, 'Cursor state must not land in ~/.claude');
+});
+
+test('sessionStart in off mode emits nothing and writes no flag', () => {
+  const c = cursorEnv('off', { PONYTAIL_DEFAULT_MODE: 'off' });
+  const result = run('ponytail-activate.js', c.env);
+  assert.equal(result.status, 0, result.stderr);
+  assert.equal(result.stdout, '', 'empty stdout is a no-op for Cursor; "OK" would be a JSON parse error');
+  assert.equal(fs.existsSync(c.flag), false);
+});
+
+test('Cursor running a Claude-format plugin (CLAUDE_PLUGIN_ROOT set) still gets Cursor JSON', () => {
+  const c = cursorEnv('plugin', { PONYTAIL_DEFAULT_MODE: 'full' });
+  const pluginRoot = path.join(c.home, '.cursor', 'plugins', 'ponytail');
+  c.env.CLAUDE_PLUGIN_ROOT = pluginRoot;
+  c.env.CURSOR_PLUGIN_ROOT = pluginRoot;
+  const output = parse(run('ponytail-activate.js', c.env));
+  assert.match(output.additional_context, /^PONYTAIL MODE ACTIVE — level: full/);
+  assert.equal(fs.readFileSync(c.flag, 'utf8'), 'full');
+});
+
+test('beforeSubmitPrompt tracks /ponytail commands and delivers the new level ruleset', () => {
+  const c = cursorEnv('switch', { PONYTAIL_DEFAULT_MODE: 'full' });
+  writeFlag(c, 'full');
+
+  const sw = parse(run('ponytail-mode-tracker.js', c.env, JSON.stringify({
+    hook_event_name: 'beforeSubmitPrompt', conversation_id: 'conv-1',
+    prompt: '/ponytail lite', attachments: [],
+  })));
+  assert.equal(sw.continue, true, 'must never block the prompt');
+  assert.equal(sw.user_message, undefined, 'Cursor shows user_message only for blocked prompts');
+  assert.match(sw.additional_context, /^PONYTAIL MODE CHANGED — level: lite/);
+  assert.match(sw.additional_context, /Build what was asked/, 'Cursor has no /ponytail command, so the level ruleset rides along');
+  assert.doesNotMatch(sw.additional_context, /Also question the request/);
+  assert.equal(fs.readFileSync(c.flag, 'utf8'), 'lite');
+
+  // Bare /ponytail reports the live level without resetting it.
+  const report = parse(run('ponytail-mode-tracker.js', c.env, JSON.stringify({ prompt: '/ponytail' })));
+  assert.deepEqual(report, { continue: true, additional_context: 'PONYTAIL MODE ACTIVE — level: lite' });
+  assert.equal(fs.readFileSync(c.flag, 'utf8'), 'lite');
+
+  // /ponytail default persists the default without touching the session level.
+  const def = parse(run('ponytail-mode-tracker.js', c.env, JSON.stringify({ prompt: '/ponytail default ultra' })));
+  assert.equal(def.continue, true);
+  assert.match(def.additional_context, /PONYTAIL DEFAULT SET — new sessions start in ultra/);
+  assert.equal(JSON.parse(fs.readFileSync(path.join(c.home, '.config', 'ponytail', 'config.json'), 'utf8')).defaultMode, 'ultra');
+  assert.equal(fs.readFileSync(c.flag, 'utf8'), 'lite');
+
+  // /ponytail off and the plain-language deactivations clear the flag and tell the model.
+  const off = parse(run('ponytail-mode-tracker.js', c.env, JSON.stringify({ prompt: '/ponytail off' })));
+  assert.deepEqual(off, { continue: true, additional_context: 'PONYTAIL MODE OFF' });
+  assert.equal(fs.existsSync(c.flag), false);
+
+  writeFlag(c, 'full');
+  const stop = parse(run('ponytail-mode-tracker.js', c.env, JSON.stringify({ prompt: 'Stop ponytail.' })));
+  assert.equal(stop.additional_context, 'PONYTAIL MODE OFF');
+  assert.equal(fs.existsSync(c.flag), false);
+
+  // Ordinary prompts produce no output at all: Cursor treats empty stdout as "carry on".
+  writeFlag(c, 'full');
+  const plain = run('ponytail-mode-tracker.js', c.env, JSON.stringify({ prompt: 'add a normal mode toggle next to dark mode' }));
+  assert.equal(plain.status, 0, plain.stderr);
+  assert.equal(plain.stdout, '');
+  assert.equal(fs.readFileSync(c.flag, 'utf8'), 'full', 'incidental "normal mode" must not turn ponytail off');
+});
+
+test('with the always-on rule in the workspace the hooks step back instead of duplicating the ruleset', () => {
+  const c = cursorEnv('rule', { PONYTAIL_DEFAULT_MODE: 'full' });
+  const rule = path.join(c.project, '.cursor', 'rules', 'ponytail.mdc');
+  fs.mkdirSync(path.dirname(rule), { recursive: true });
+  fs.copyFileSync(path.join(root, '.cursor', 'rules', 'ponytail.mdc'), rule);
+
+  const start = parse(run('ponytail-activate.js', c.env));
+  assert.match(start.additional_context, /always-on Cursor rule/);
+  assert.ok(start.additional_context.includes(rule), 'notice must name the rule file');
+  assert.doesNotMatch(start.additional_context, /PONYTAIL MODE ACTIVE/, 'no second copy of the ruleset');
+  assert.equal(fs.existsSync(c.flag), false, 'no mode flag while the rule owns the ruleset');
+
+  for (const prompt of ['/ponytail ultra', '/ponytail off', 'normal mode', '/ponytail']) {
+    const out = parse(run('ponytail-mode-tracker.js', c.env, JSON.stringify({ prompt })));
+    assert.equal(out.continue, true);
+    assert.match(out.additional_context, /always-on Cursor rule/, `${prompt} must answer with the rule notice`);
+    assert.doesNotMatch(out.additional_context, /PONYTAIL MODE (CHANGED|OFF|ACTIVE)/);
+    assert.equal(fs.existsSync(c.flag), false);
+  }
+
+  const plain = run('ponytail-mode-tracker.js', c.env, JSON.stringify({ prompt: 'hello' }));
+  assert.equal(plain.status, 0, plain.stderr);
+  assert.equal(plain.stdout, '', 'ordinary prompts stay silent');
+
+  // Project hooks run from the workspace root: the cwd fallback must find the rule too.
+  delete c.env.CURSOR_PROJECT_DIR;
+  delete c.env.CLAUDE_PROJECT_DIR;
+  const viaCwd = parse(run('ponytail-activate.js', c.env, '', c.project));
+  assert.match(viaCwd.additional_context, /always-on Cursor rule/);
+});
+
+test('installer merges into an existing ~/.cursor/hooks.json and leaves unrelated hooks alone', () => {
+  const home = path.join(temp, 'install', 'home');
+  fs.mkdirSync(path.join(home, '.cursor'), { recursive: true });
+  const file = path.join(home, '.cursor', 'hooks.json');
+  const theirs = {
+    version: 1,
+    hooks: {
+      sessionStart: [{ command: './hooks/their-session.sh' }],
+      afterFileEdit: [{ command: './hooks/format.sh', matcher: 'Write' }],
+      stop: [{ command: 'node "./hooks/my-ponytail-logger.js"' }],
+    },
+  };
+  fs.writeFileSync(file, JSON.stringify(theirs));
+  const env = { HOME: home, USERPROFILE: home };
+
+  let result = cli(['install'], env);
+  assert.equal(result.status, 0, result.stderr);
+  let config = JSON.parse(fs.readFileSync(file, 'utf8'));
+  assert.equal(config.version, 1);
+  assert.deepEqual(config.hooks.afterFileEdit, theirs.hooks.afterFileEdit);
+  assert.deepEqual(config.hooks.stop, theirs.hooks.stop, 'similarly named user hook must survive install');
+  assert.equal(config.hooks.sessionStart[0].command, './hooks/their-session.sh', 'their sessionStart hook stays first and intact');
+  assert.equal(config.hooks.sessionStart.length, 2);
+  assert.deepEqual(config.hooks.sessionStart[1], { command: `node "${rootFwd}/hooks/ponytail-activate.js"`, timeout: 15 });
+  assert.deepEqual(config.hooks.beforeSubmitPrompt, [{ command: `node "${rootFwd}/hooks/ponytail-mode-tracker.js"`, timeout: 15 }]);
+
+  // Idempotent: a second install replaces ponytail's entries, never duplicates them.
+  result = cli(['install'], env);
+  assert.equal(result.status, 0, result.stderr);
+  config = JSON.parse(fs.readFileSync(file, 'utf8'));
+  assert.equal(config.hooks.sessionStart.length, 2);
+  assert.equal(config.hooks.beforeSubmitPrompt.length, 1);
+
+  // Uninstall removes only ponytail's entries.
+  result = cli(['uninstall'], env);
+  assert.equal(result.status, 0, result.stderr);
+  assert.deepEqual(JSON.parse(fs.readFileSync(file, 'utf8')), theirs);
+});
+
+test('installer creates the file when absent and removes it again when only ponytail lived there', () => {
+  const home = path.join(temp, 'fresh', 'home');
+  fs.mkdirSync(home, { recursive: true });
+  const env = { HOME: home, USERPROFILE: home };
+  const file = path.join(home, '.cursor', 'hooks.json');
+
+  let result = cli(['install'], env);
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stdout, /Installed ponytail hooks in /);
+  const config = JSON.parse(fs.readFileSync(file, 'utf8'));
+  assert.equal(config.version, 1);
+  assert.deepEqual(Object.keys(config.hooks).sort(), ['beforeSubmitPrompt', 'sessionStart']);
+
+  result = cli(['uninstall'], env);
+  assert.equal(result.status, 0, result.stderr);
+  assert.equal(fs.existsSync(file), false);
+
+  // Uninstalling on a clean machine is a no-op, not an error.
+  result = cli(['uninstall'], env);
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stdout, /No ponytail hooks/);
+});
+
+test('installer --project writes <cwd>/.cursor/hooks.json', () => {
+  const home = path.join(temp, 'proj', 'home');
+  const project = path.join(temp, 'proj', 'repo');
+  fs.mkdirSync(home, { recursive: true });
+  fs.mkdirSync(project, { recursive: true });
+  const env = { HOME: home, USERPROFILE: home };
+
+  let result = cli(['install', '--project'], env, project);
+  assert.equal(result.status, 0, result.stderr);
+  const file = path.join(project, '.cursor', 'hooks.json');
+  assert.ok(fs.existsSync(file));
+  assert.equal(fs.existsSync(path.join(home, '.cursor', 'hooks.json')), false, '--project must not touch the user file');
+
+  result = cli(['uninstall', '--project'], env, project);
+  assert.equal(result.status, 0, result.stderr);
+  assert.equal(fs.existsSync(file), false);
+});
+
+test('installer refuses to touch a malformed hooks.json', () => {
+  const home = path.join(temp, 'broken', 'home');
+  fs.mkdirSync(path.join(home, '.cursor'), { recursive: true });
+  const file = path.join(home, '.cursor', 'hooks.json');
+  const broken = '{ "version": 1, "hooks": { broken';
+  fs.writeFileSync(file, broken);
+  const env = { HOME: home, USERPROFILE: home };
+
+  for (const action of ['install', 'uninstall']) {
+    const result = cli([action], env);
+    assert.notEqual(result.status, 0, `${action} must fail on malformed JSON`);
+    assert.match(result.stderr, /not valid JSON/);
+    assert.equal(fs.readFileSync(file, 'utf8'), broken, 'malformed file must be left byte-for-byte intact');
+  }
+});
+
+for (const [name, config] of Object.entries({
+  'root-array': [{ command: 'keep me' }],
+  'hooks-array': { hooks: [{ command: 'keep me' }] },
+  'event-string': { hooks: { sessionStart: 'node custom-hook.js' } },
+})) {
+  test(`installer refuses ${name} without overwriting hooks.json`, () => {
+    const c = cursorEnv(`invalid-${name}`);
+    const file = path.join(c.home, '.cursor', 'hooks.json');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const original = JSON.stringify(config, null, 2) + '\n';
+    fs.writeFileSync(file, original);
+    const result = cli(['install'], c.env);
+    assert.notEqual(result.status, 0, 'invalid config must not be silently rewritten');
+    assert.equal(fs.readFileSync(file, 'utf8'), original);
+  });
+}

package/tests/gemini-extension.test.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// Smoke test for the Gemini CLI adapter. The adapter is a single thin manifest
+// (gemini-extension.json) that reuses the repo's existing files: AGENTS.md for
+// always-on context, commands/*.toml for /ponytail + /ponytail-review, and
+// skills/ for the agent skills. This test fails if the manifest is removed,
+// loses its pinned version, or points contextFileName at a file that no longer
+// carries the load-bearing rules — i.e. if the adapter stops wiring ponytail.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+
+const root = path.join(__dirname, '..');
+const MANIFEST = 'gemini-extension.json';
+const EXTENSION_NAME = 'ponytail';
+// Floating refs are a supply-chain footgun; the manifest version must be pinned.
+const PINNED_SEMVER = /^\d+\.\d+\.\d+$/;
+const VERSIONED_MANIFESTS = [
+  'gemini-extension.json',
+  '.claude-plugin/plugin.json',
+  '.codex-plugin/plugin.json',
+  '.github/plugin/plugin.json',
+];
+// Gemini auto-discovers these by directory; the manifest is only useful if they exist.
+const REUSED_COMMANDS = ['commands/ponytail.toml', 'commands/ponytail-review.toml'];
+const REUSED_SKILLS = ['skills/ponytail/SKILL.md'];
+// Gemini CLI auto-loads this exact path for extension hooks. Ponytail's
+// Claude/Codex hook map uses events Gemini does not support, so it must stay
+// behind the host-specific plugin manifests instead.
+const GEMINI_AUTO_HOOKS = 'hooks/hooks.json';
+// Same load-bearing phrases asserted by scripts/check-rule-copies.js: the file
+// contextFileName points at must actually carry the rules, not just exist.
+const RULE_INVARIANTS = [
+  'lazy senior',
+  'validation at trust boundaries',
+  'shortcut: <the limit>, <when to upgrade>',
+];
+
+function read(relPath) {
+  return fs.readFileSync(path.join(root, relPath), 'utf8');
+}
+
+// Read inside each test (not at module scope) so a missing or malformed manifest
+// surfaces as a clean per-test assertion failure, not a load-time crash that
+// collapses every case into one unreadable stack trace.
+function loadManifest() {
+  assert.ok(fs.existsSync(path.join(root, MANIFEST)), `${MANIFEST} must exist`);
+  return JSON.parse(read(MANIFEST));
+}
+
+test('manifest names the ponytail extension with a pinned version', () => {
+  const manifest = loadManifest();
+  assert.equal(manifest.name, EXTENSION_NAME);
+  assert.match(manifest.version, PINNED_SEMVER);
+});
+
+test('version stays aligned with the other plugin manifests', () => {
+  const versions = VERSIONED_MANIFESTS.map((rel) => {
+    const manifest = JSON.parse(read(rel));
+    assert.match(manifest.version, PINNED_SEMVER, `${rel} version must be pinned semver`);
+    return manifest.version;
+  });
+  const [sharedVersion, ...rest] = versions;
+  for (const version of rest) {
+    assert.equal(version, sharedVersion);
+  }
+});
+
+test('contextFileName resolves to a file carrying the ponytail rules', () => {
+  const manifest = loadManifest();
+  assert.ok(manifest.contextFileName, 'contextFileName must be set so rules load every session');
+  const context = read(manifest.contextFileName);
+  for (const phrase of RULE_INVARIANTS) {
+    assert.ok(context.includes(phrase), `context file missing rule invariant: "${phrase}"`);
+  }
+});
+
+test('the commands and skills the adapter reuses are present', () => {
+  for (const rel of [...REUSED_COMMANDS, ...REUSED_SKILLS]) {
+    assert.ok(fs.existsSync(path.join(root, rel)), `reused file missing: ${rel}`);
+  }
+});
+
+test('Gemini cannot auto-discover Claude/Codex hook events', () => {
+  assert.equal(
+    fs.existsSync(path.join(root, GEMINI_AUTO_HOOKS)),
+    false,
+    `${GEMINI_AUTO_HOOKS} is auto-loaded by Gemini CLI; keep Claude/Codex hooks on manifest paths`,
+  );
+});