chill-agent 1.4.0 → 1.5.0

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

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "chill-agent",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Zero-bloat Anti-Slop 2.0 Engine & Pragmatic Senior Developer Standard. Fuses Anti-Slop visual craftsmanship with Ponytail YAGNI minimalism across all coding agents.",
   "type": "module",
   "bin": {
-    "chill-agent": "bin/chill-agent.js"
+    "chill-agent": "bin/chill-agent.js",
+    "ponytail": "bin/chill-agent.js"
   },
   "main": "./src/index.js",
   "scripts": {
     "start": "node ./bin/chill-agent.js",
-    "test": "node --test tests/*.test.js test/*.test.js",
+    "test": "node --test tests/manifests.test.js tests/rules.test.js test/auditor.test.js",
     "audit": "node ./bin/chill-agent.js audit",
     "lint": "node ./bin/chill-agent.js audit"
   },
@@ -45,6 +46,8 @@
     "hooks/",
     "i18n/",
     "tests/",
+    "scripts/",
+    "pi-extension/",
     ".agents/",
     ".claude-plugin/",
     ".cursor/",
@@ -58,8 +61,11 @@
     ".devin-plugin/",
     ".grok-plugin/",
     ".qoder-plugin/",
+    ".kiro/",
     ".openclaw/",
     ".opencode/",
+    "__init__.py",
+    "AGENTS.md",
     "chillslop.md",
     "antislop.md",
     "GUIDE.md",

package/pi-extension/index.js

@@ -0,0 +1,254 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const {
+  DEFAULT_MODE,
+  RUNTIME_MODES,
+  getDefaultMode,
+  getQuietStartup,
+  getHideStatus,
+  normalizeMode,
+  normalizePersistedMode,
+  isDeactivationCommand,
+  writeDefaultMode,
+} = require("../hooks/ponytail-config.js");
+const { getPonytailInstructions, filterSkillBodyForMode } = require("../hooks/ponytail-instructions.js");
+
+export { filterSkillBodyForMode };
+export const readDefaultMode = getDefaultMode;
+export const readQuietStartup = getQuietStartup;
+
+const RUNTIME_MODE_LIST = RUNTIME_MODES.join("|");
+const PONYTAIL_COMMAND_DESCRIPTION = `Set mode: ${RUNTIME_MODE_LIST}. Commands: status, default <mode>`;
+
+// Every item is a complete command: pi submits on Enter, so a bare "default" would run without a mode.
+// Values only: per-level descriptions would be a second copy of the Levels table in SKILL.md.
+export function completePonytailArgs(prefix) {
+  const typed = String(prefix || "").trimStart();
+  const values = [...RUNTIME_MODES, "status", ...RUNTIME_MODES.map((m) => `default ${m}`)].filter((v) => v.startsWith(typed));
+  return values.length ? values.map((value) => ({ value, label: value })) : null;
+}
+
+export function resolveSessionMode(entries, fallbackMode = DEFAULT_MODE) {
+  const fallback = normalizePersistedMode(fallbackMode) || DEFAULT_MODE;
+  if (!Array.isArray(entries)) return fallback;
+
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i];
+    if (entry?.type !== "custom" || entry?.customType !== "ponytail-mode") continue;
+
+    const mode = normalizePersistedMode(entry?.data?.mode);
+    if (mode) return mode;
+  }
+
+  return fallback;
+}
+
+export function parsePonytailCommand(text, defaultMode = DEFAULT_MODE, currentMode = null) {
+  const fallback = normalizePersistedMode(defaultMode) || DEFAULT_MODE;
+  const normalizedText = String(text || "").trim().toLowerCase();
+
+  if (!normalizedText) {
+    // Bare /ponytail switches ponytail on, or reports the level when it already is (#639).
+    if (currentMode && currentMode !== "off") return { type: "status" };
+    return { type: "set-mode", mode: fallback === "off" ? "full" : fallback };
+  }
+
+  const [primary, secondary] = normalizedText.split(/\s+/);
+
+  if (primary === "status") return { type: "status" };
+
+  if (primary === "default") {
+    // ponytail: a default must be a runtime level; review is session-only (#377).
+    const mode = normalizeMode(secondary);
+    return mode ? { type: "set-default", mode } : { type: "invalid", reason: "invalid-default-mode" };
+  }
+
+  const mode = normalizeMode(primary);
+  return mode ? { type: "set-mode", mode } : { type: "invalid", reason: "invalid-mode", mode: primary };
+}
+
+export { writeDefaultMode };
+
+export default function ponytailExtension(pi) {
+  let currentMode = DEFAULT_MODE;
+  let configuredDefaultMode = getDefaultMode();
+  let hideStatus = getHideStatus();
+  let isActive = false;
+  let lastCtx = null;
+
+  // -- Status bar --
+  function syncStatus(ctx) {
+    if (ctx) lastCtx = ctx;
+    const c = ctx || lastCtx;
+    // ponytail: hide the indicator but keep the ruleset active (#324).
+    if (hideStatus) return;
+    if (!c?.ui?.setStatus) return;
+    // ponytail: try/catch guards against pi-web theme proxy throwing before initTheme
+    let theme;
+    try { theme = c.ui.theme; if (!theme?.fg) return; } catch { return; }
+    if (currentMode === "off") {
+      c.ui.setStatus("ponytail", undefined);
+      return;
+    }
+    const levelIcons = { lite: "🌿", full: "⚡", ultra: "🔥" };
+    const icon = levelIcons[currentMode] || "";
+    const label = currentMode.toUpperCase();
+    const indicator = isActive ? theme.fg("accent", "●") : theme.fg("dim", "○");
+    c.ui.setStatus("ponytail", indicator + " 🐴 " + theme.fg("muted", "ponytail: ") + theme.fg("text", icon + " " + label));
+  }
+
+  const setMode = (mode, ctx) => {
+    const normalized = normalizePersistedMode(mode);
+    if (!normalized) return;
+
+    currentMode = normalized;
+    pi.appendEntry("ponytail-mode", { mode: normalized });
+    syncStatus(ctx);
+    ctx?.ui?.notify?.(`Ponytail mode set to ${normalized}.`, "info");
+  };
+
+  const sendAlias = (skillName, args, ctx) => {
+    const normalized = String(args || "").trim();
+    const message = normalized ? `${skillName} ${normalized}` : skillName;
+
+    // pi.sendUserMessage does not expand skill commands on its own, so without
+    // expandPromptTemplates the alias lands as the literal text
+    // "/skill:ponytail-review" and the skill body never reaches the agent.
+    if (ctx?.isIdle?.() === false) {
+      pi.sendUserMessage(message, { expandPromptTemplates: true, deliverAs: "followUp" });
+      ctx?.ui?.notify?.(`${skillName} queued as follow-up.`, "info");
+      return;
+    }
+
+    pi.sendUserMessage(message, { expandPromptTemplates: true });
+  };
+
+  pi.registerCommand("ponytail", {
+    description: PONYTAIL_COMMAND_DESCRIPTION,
+    getArgumentCompletions: (prefix) => completePonytailArgs(prefix),
+    handler: async (args, ctx) => {
+      const parsed = parsePonytailCommand(args, configuredDefaultMode, currentMode);
+
+      if (parsed.type === "status") {
+        ctx?.ui?.notify?.(`Ponytail: current ${currentMode} • default ${configuredDefaultMode}`, "info");
+        return;
+      }
+
+      if (parsed.type === "set-default") {
+        try {
+          const written = writeDefaultMode(parsed.mode);
+          if (written) {
+            configuredDefaultMode = getDefaultMode();
+            const message = configuredDefaultMode === written
+              ? `Default Ponytail mode set to ${written}.`
+              : `Saved default ${written}, but env override keeps default at ${configuredDefaultMode}.`;
+            ctx?.ui?.notify?.(message, "info");
+          }
+        } catch (e) {
+          ctx?.ui?.notify?.(`Failed to save default mode: ${e.message}`, "error");
+        }
+        return;
+      }
+
+      if (parsed.type === "set-mode") {
+        setMode(parsed.mode, ctx);
+        return;
+      }
+
+      ctx?.ui?.notify?.("Unknown or unsupported /ponytail mode.", "warning");
+    },
+  });
+
+  pi.registerCommand("ponytail-review", {
+    description: "Run /skill:ponytail-review",
+    handler: (args, ctx) => sendAlias("/skill:ponytail-review", args, ctx),
+  });
+
+  pi.registerCommand("ponytail-audit", {
+    description: "Run /skill:ponytail-audit",
+    handler: (args, ctx) => sendAlias("/skill:ponytail-audit", args, ctx),
+  });
+
+  pi.registerCommand("ponytail-gain", {
+    description: "Run /skill:ponytail-gain",
+    handler: (args, ctx) => sendAlias("/skill:ponytail-gain", args, ctx),
+  });
+
+  pi.registerCommand("ponytail-debt", {
+    description: "Run /skill:ponytail-debt",
+    handler: (args, ctx) => sendAlias("/skill:ponytail-debt", args, ctx),
+  });
+
+  pi.registerCommand("ponytail-help", {
+    description: "Run /skill:ponytail-help",
+    handler: (args, ctx) => sendAlias("/skill:ponytail-help", args, ctx),
+  });
+
+  pi.on("input", async (event, ctx) => {
+    if (event?.source === "extension") return;
+
+    const text = String(event?.text || "");
+    if (currentMode !== "off" && isDeactivationCommand(text)) {
+      setMode("off", ctx);
+    }
+  });
+
+  const restoreSessionMode = (ctx) => {
+    const entries = ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
+    currentMode = resolveSessionMode(entries, configuredDefaultMode);
+    syncStatus(ctx);
+  };
+
+  pi.on("session_start", async (_event, ctx) => {
+    configuredDefaultMode = getDefaultMode();
+    hideStatus = getHideStatus();
+    restoreSessionMode(ctx);
+    if (!getQuietStartup()) {
+      ctx?.ui?.notify?.(`Ponytail loaded: ${currentMode}`, "info");
+    }
+  });
+
+  // Both hosts emit session_tree. Pi re-emits session_start on /new, /resume and
+  // /fork; OMP emits session_switch and session_branch instead.
+  for (const eventName of ["session_tree", "session_switch", "session_branch"]) {
+    pi.on(eventName, async (_event, ctx) => {
+      restoreSessionMode(ctx);
+    });
+  }
+
+  pi.on("agent_start", async (_event, ctx) => {
+    isActive = true;
+    syncStatus(ctx);
+  });
+
+  pi.on("agent_end", async (_event, ctx) => {
+    isActive = false;
+    syncStatus(ctx);
+  });
+
+  pi.on("before_agent_start", async (event) => {
+    if (!currentMode || currentMode === "off") {
+      // Clear a stale section when the mode is off so a previous turn does not linger (#953).
+      if (event?.systemPromptOptions?.sections) delete event.systemPromptOptions.sections.ponytail;
+      return;
+    }
+    const instructions = getPonytailInstructions(currentMode);
+    // Prefer structured sections so Pi can keep the cached prefix when other
+    // extensions change their own section (#953). Fall back to replacement
+    // for older Pi versions without systemPromptOptions.sections.
+    const sections = event?.systemPromptOptions?.sections;
+    if (sections && typeof sections === "object") {
+      sections.ponytail = instructions;
+      return;
+    }
+    // OMP passes the system prompt as an array of parts; keep it one (#776).
+    if (Array.isArray(event?.systemPrompt)) {
+      return { systemPrompt: [...event.systemPrompt, instructions] };
+    }
+    // Guard a null/undefined event or a missing systemPrompt: don't crash, and
+    // don't prepend the literal string "undefined" to the prompt (#439, #440).
+    const base = event?.systemPrompt ? `${event.systemPrompt}\n\n` : "";
+    return { systemPrompt: `${base}${instructions}` };
+  });
+}

package/pi-extension/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "ponytail-pi-extension-dev",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "node --test ./test/*.test.js"
+  }
+}

package/scripts/check-rule-copies.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+
+const root = path.join(__dirname, '..');
+
+function read(relPath) {
+  return fs.readFileSync(path.join(root, relPath), 'utf8').replace(/\r\n/g, '\n').trim();
+}
+
+function stripFrontmatter(text) {
+  return text.replace(/^---\n[\s\S]*?\n---\n*/, '').trim();
+}
+
+const agents = read('AGENTS.md');
+const canonical = agents.replace(/\n\n\(Yes, this file also applies[\s\S]*?\)$/, '').trim();
+
+// Compact copies: same body as AGENTS.md, host-specific frontmatter stripped.
+const copies = [
+  ['.cursor/rules/ponytail.mdc', stripFrontmatter],
+  ['.windsurf/rules/ponytail.md', text => text.trim()],
+  ['.clinerules/ponytail.md', text => text.trim()],
+  ['.agents/rules/ponytail.md', text => text.trim()],
+  ['.qoder/rules/ponytail.md', text => text.trim()],
+  ['.github/copilot-instructions.md', text => text.trim()],
+  ['.kiro/steering/ponytail.md', stripFrontmatter],
+];
+
+let failed = false;
+
+for (const [relPath, normalize] of copies) {
+  const actual = normalize(read(relPath));
+  if (actual !== canonical) {
+    console.error(`${relPath} drifted from AGENTS.md`);
+    failed = true;
+  }
+}
+
+// SKILL.md is the runtime source of truth and is longer than the compact body,
+// so it cannot be byte-compared. ponytail: canary, not full equality. Assert the
+// load-bearing rules survive verbatim in both the source and AGENTS.md. Changing
+// a rule's wording trips this, which is the reminder to propagate it everywhere.
+// Upgrade path: generate the copies from SKILL.md if this ever misses a real drift.
+const INVARIANTS = [
+  'in this codebase',                      // ladder rung: reuse what already exists (#217)
+  'grep every caller',                     // root-cause bug fix (#245)
+  'never about the change itself',         // scope: callers, tests and fixtures the change breaks
+  'shortcut: <the limit>, <when to upgrade>',   // shortcut marker comment
+  'correct on edge cases',                 // robust-variant rule
+  'Lazy code without its check is unfinished', // test reflex
+  // the "never cut" carve-outs: pin each so a reword in either file can't silently drop one.
+  'validation at trust boundaries',
+  'prevents data loss',
+  'security',
+  'accessibility',
+];
+
+const skill = read('skills/ponytail/SKILL.md');
+const sources = [['skills/ponytail/SKILL.md', skill], ['AGENTS.md', agents]];
+for (const phrase of INVARIANTS) {
+  for (const [label, text] of sources) {
+    if (!text.includes(phrase)) {
+      console.error(`${label} is missing rule invariant: "${phrase}"`);
+      failed = true;
+    }
+  }
+}
+
+if (failed) {
+  console.error('Update the copied rule text, AGENTS.md, or SKILL.md so the shared rules match.');
+  process.exit(1);
+}
+
+console.log(`Rule copies match AGENTS.md; ${INVARIANTS.length} rule invariants present in SKILL.md and AGENTS.md.`);

package/scripts/check-versions.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+// Version-consistency guard. Ponytail declares its version in seven files across
+// five host ecosystems, and every release bumps all of them by hand.
+//
+// tests/gemini-extension.test.js already checks the four plugin manifests agree
+// with each other, but that can't catch the failure mode that shipped in v4.8.0:
+// every manifest stayed stale at 4.7.0 *together* while the release moved on, so
+// they "agreed" and the test passed (#260, #262). It also ignores the two
+// package.json files. This check closes both gaps:
+//   1. every version-bearing file must share one pinned X.Y.Z version, and
+//   2. on a release-tag CI run, that shared version must equal the tag.
+
+const fs = require('fs');
+const path = require('path');
+
+const root = path.join(__dirname, '..');
+const PINNED_SEMVER = /^\d+\.\d+\.\d+$/;
+
+// Every file that declares the project version, and who reads it. Add new host
+// manifests here so a future ecosystem can't drift unnoticed.
+const VERSION_FILES = [
+  '.claude-plugin/plugin.json',  // Claude Code plugin — what users install
+  '.codex-plugin/plugin.json',   // Codex plugin
+  '.devin-plugin/plugin.json',   // Devin CLI plugin
+  '.github/plugin/plugin.json',  // Copilot plugin
+  '.qoder-plugin/plugin.json',   // Qoder plugin
+  'gemini-extension.json',       // Gemini CLI extension
+  'package.json',                // pi-package / repo root
+];
+
+function readVersion(relPath) {
+  try {
+    // Strip a UTF-8 BOM some Windows editors prepend (breaks JSON.parse).
+    const raw = fs.readFileSync(path.join(root, relPath), 'utf8').replace(/^\uFEFF/, '');
+    return JSON.parse(raw).version;
+  } catch (e) {
+    throw new Error(`${relPath}: ${e.message}`);
+  }
+}
+
+let failed = false;
+const versions = VERSION_FILES.map((relPath) => {
+  const version = readVersion(relPath);
+  if (typeof version !== 'string' || !PINNED_SEMVER.test(version)) {
+    console.error(`${relPath}: version must be a pinned X.Y.Z semver, got ${JSON.stringify(version)}`);
+    failed = true;
+  }
+  return [relPath, version];
+});
+
+// Every file must declare the same version.
+const distinct = [...new Set(versions.map(([, v]) => v))];
+if (distinct.length > 1) {
+  console.error('Version mismatch — every manifest must share one version:');
+  for (const [relPath, version] of versions) console.error(`  ${version}\t${relPath}`);
+  failed = true;
+}
+const shared = distinct.length === 1 ? distinct[0] : null;
+
+// On a release-tag push CI sets GITHUB_REF_TYPE=tag and GITHUB_REF_NAME=vX.Y.Z.
+// The shared version must equal the tag — this catches tagging a release whose
+// version files were never bumped, which mutual agreement alone cannot.
+if (shared && process.env.GITHUB_REF_TYPE === 'tag') {
+  const tag = process.env.GITHUB_REF_NAME || '';
+  const tagVersion = tag.replace(/^v/, '');
+  if (PINNED_SEMVER.test(tagVersion) && tagVersion !== shared) {
+    console.error(`release tag ${tag} does not match version ${shared}; bump the version files before tagging`);
+    failed = true;
+  }
+}
+
+if (failed) {
+  console.error('Align the version fields (see issue #260) so every manifest shares one version.');
+  process.exit(1);
+}
+
+console.log(`All ${VERSION_FILES.length} version files pinned at ${shared}.`);