chill-agent 1.4.0 → 1.5.0

package/.opencode/command/ponytail-review.md

@@ -0,0 +1,5 @@
+---
+description: Quality review of the current changes: bugs, security, load, tests, speed, bloat
+---
+
+Review the current code changes like the senior developer who will be paged when they break. Review what the user names (uncommitted or staged changes, a branch, a PR link, files); nothing named: the uncommitted changes, or the last commit if there are none. First read the code the change touches: callers of every changed function, the functions it calls, the tests, the README (find the expected load: one person or many users and processes). A change can break code it does not touch. Look for, in this order: bugs (wrong result, crash, missed edge case, a caller broken by the change, a fix in one caller while the shared function stays broken), risk (security holes, data loss), scale (check-then-write races, the same work done by every process, memory that only grows, a query per item, O(n^2) on big input), risky logic without a test, slow code (big = problem, small = suggestion), lean (dead code, a helper the repo already has, stdlib or native instead of custom code or a new dependency, abstractions with one implementation, near-copies to merge, a function doing several unrelated jobs to split, never split by line count). Every finding needs a concrete case; re-read the lines to confirm it. A shortcut marked with a shortcut: (or older ponytail:) comment that names its limit is a decision, not a finding. Propose the smallest fix, prefer deleting code, never add layers. No style taste, no vague worries. Very simple English, explain technical terms. Start with 'What this change does:' in two or three sentences and the load you assumed. Then numbered findings grouped Must fix / Should fix / Nice to have; each finding: a bold title with file:lines, then four bullets: What this is, Problem, Fix, If we skip it (one or two short sentences each). End with 'Verdict:', 'Lean: -N lines possible.' when lean findings exist, and 'Not checked:' if something mattered and you could not check it. Nothing found: 'Looks good. Ship.' Change no code.

package/.opencode/command/ponytail.md

@@ -0,0 +1,5 @@
+---
+description: Switch ponytail intensity level (lite/full/ultra/off)
+---
+
+Switch to ponytail $ARGUMENTS mode. With no level, keep the current level, or switch on at the default level if ponytail was off. Lazy senior dev mode, before any code: does it need to exist at all (YAGNI)? Does the standard library do it? A native platform feature? Can it be one line? Build the minimum that works. No unrequested abstractions, no avoidable dependencies, no boilerplate. Mark deliberate simplifications that cut a real corner with a known ceiling using a shortcut: comment that names the ceiling and upgrade path.

package/.opencode/plugins/index.js

@@ -0,0 +1,4 @@
+// OpenCode 2 loads this file automatically from .opencode/plugins/ and does not
+// read ponytail.mjs next to it, so keep the one-line entry here. npm consumers
+// never see it: package.json main/exports still point at ponytail.mjs.
+export { default } from './ponytail.mjs'

package/.opencode/plugins/ponytail-frontmatter.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+// ponytail command-file and SKILL.md frontmatter parser.
+//
+// Pulled out of ponytail.mjs so the plugin module's only top-level export is
+// the plugin definition itself. OpenCode's legacy plugin loader (the one that
+// runs before v1 plugins are detected) treats every function exported from a
+// plugin module as a plugin; calling the frontmatter parser as one threw
+// "path must be a string or a file descriptor" because it got the plugin
+// context object as its first argument. Keeping the parser in its own module
+// leaves exactly one plugin-shaped export on ponytail.mjs.
+
+function parseCommandFile(filePath) {
+  const fs = require('fs');
+  const content = fs.readFileSync(filePath, 'utf8');
+  // Tolerate CRLF: a Windows checkout (autocrlf) delivers \r\n, npm ships \n.
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (!match) return null;
+  const description = match[1].match(/description:\s*(.+)/)?.[1]?.trim();
+  return { description, template: match[2].trim() };
+}
+
+// ponytail: flat frontmatter only — the shape every shipped SKILL.md uses. A
+// nested key or an anchor is not interpreted, and a real YAML parser is the
+// upgrade path if a skill ever needs one.
+function frontmatterField(frontmatter, key) {
+  const lines = frontmatter.split(/\r?\n/);
+  const at = lines.findIndex((line) => line.startsWith(key + ':'));
+  if (at === -1) return undefined;
+  const value = lines[at].slice(key.length + 1).trim();
+  if (value[0] !== '>' && value[0] !== '|') return value;
+
+  // Block scalar: `>` folds the lines into one, `|` keeps them. Indented lines
+  // continue the block, the next unindented key ends it (skills/ponytail has
+  // `argument-hint` after its description), and a trailing `-` drops the
+  // newline YAML would otherwise close the scalar with.
+  const block = [];
+  for (const line of lines.slice(at + 1)) {
+    if (line.trim() && !/^\s/.test(line)) break;
+    block.push(line.trim());
+  }
+  while (block.length && !block[block.length - 1]) block.pop();
+  const joined = block.join(value[0] === '|' ? '\n' : ' ');
+  return value.endsWith('-') ? joined : joined + '\n';
+}
+
+// OpenCode's V2 skill transform takes the resolved fields, not the file: the
+// skill id is the directory name, and `content` is the body with its
+// frontmatter stripped. Matches what OpenCode itself derives from a discovered
+// .opencode/skills/<id>/SKILL.md.
+function parseSkillFile(filePath) {
+  const fs = require('fs');
+  const content = fs.readFileSync(filePath, 'utf8');
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---[^\S\n]*\r?\n?([\s\S]*)$/);
+  if (!match) return null;
+  return {
+    name: frontmatterField(match[1], 'name'),
+    description: frontmatterField(match[1], 'description'),
+    body: match[2],
+  };
+}
+
+module.exports = { parseCommandFile, parseSkillFile };

package/.opencode/plugins/ponytail.mjs

@@ -0,0 +1,206 @@
+// ponytail — OpenCode plugin.
+//
+// Injects the ponytail ruleset into every chat's system prompt at the active
+// intensity, persists /ponytail mode switches, and registers the /ponytail
+// commands and skills so they work when the package is installed from npm.
+// Reuses the shared instruction builder so Claude Code, Codex, pi, and OpenCode
+// all read one source of truth.
+//
+// OpenCode loads this as a server plugin — add it to your opencode.json:
+//   { "plugins": ["@dietrichgebert/ponytail"] }
+//
+// One default export serves both plugin APIs: V2 reads `id` + `setup`, V1 calls
+// `server()`.
+
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// The shared instruction builder is CommonJS; bridge to it from this ES module.
+const require = createRequire(import.meta.url);
+const { getPonytailInstructions } = require('../../hooks/ponytail-instructions');
+const { getDefaultMode, normalizeMode, writeDefaultMode } = require('../../hooks/ponytail-config');
+const { parseCommandFile, parseSkillFile } = require('./ponytail-frontmatter.cjs');
+
+// OpenCode has no flag-file convention of its own; keep mode beside its config.
+// Shared with the V1 path, so a level set under either API is read by both.
+const statePath = path.join(
+  process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'),
+  'opencode',
+  '.ponytail-active',
+);
+
+function readMode() {
+  try {
+    // review is a one-shot command, never a level (#736); an old saved review falls back.
+    return normalizeMode(fs.readFileSync(statePath, 'utf8')) || getDefaultMode();
+  } catch (e) {
+    return getDefaultMode();
+  }
+}
+
+function writeMode(mode) {
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  fs.writeFileSync(statePath, mode);
+}
+
+// `off` is persisted like any mode; the injection reads it and stays silent.
+// An unrecognized level leaves the current one alone. The write lands before
+// the next turn's injection, not the current one — good enough; switch to a
+// synchronous store if same-turn switching ever matters.
+function persistMode(args) {
+  const wanted = String(args == null ? '' : args).trim();
+  // `/ponytail default <level>` saves the default for new sessions, like the Claude hook.
+  const [first, second] = wanted.toLowerCase().split(/\s+/);
+  if (first === 'default') {
+    const saved = writeDefaultMode(second);
+    if (saved) console.log('ponytail default ' + saved);
+    return;
+  }
+  // Bare /ponytail switches ponytail on, or keeps the level when it already is (#639).
+  if (!wanted && readMode() !== 'off') return;
+  const mode = wanted ? normalizeMode(wanted) : (getDefaultMode() === 'off' ? 'full' : getDefaultMode());
+  if (!mode) return;
+  writeMode(mode);
+  console.log('ponytail ' + mode);
+}
+
+// V2 has no `config` hook: the domains that own these definitions own them now,
+// so the command and skill files are read once here and handed to the
+// transforms that register them.
+function readCommands() {
+  const dir = path.join(__dirname, '..', 'command');
+  try {
+    return fs.readdirSync(dir)
+      .filter((file) => file.endsWith('.md'))
+      .map((file) => {
+        const parsed = parseCommandFile(path.join(dir, file));
+        return parsed && { name: path.basename(file, '.md'), ...parsed };
+      })
+      .filter(Boolean);
+  } catch (e) {
+    return [];
+  }
+}
+
+function readSkills() {
+  const dir = path.resolve(__dirname, '../../skills');
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => {
+        const file = path.join(dir, entry.name, 'SKILL.md');
+        const parsed = parseSkillFile(file);
+        return parsed && {
+          id: entry.name,
+          name: parsed.name || entry.name,
+          description: parsed.description,
+          path: file,
+          content: parsed.body,
+        };
+      })
+      .filter(Boolean);
+  } catch (e) {
+    return [];
+  }
+}
+
+// Templates without $ARGUMENTS would drop what the user typed after the
+// command (/ponytail-review feature/login), so append it instead.
+function withArguments(template, input) {
+  const text = String(input == null ? '' : input);
+  if (template.includes('$ARGUMENTS')) return template.replaceAll('$ARGUMENTS', text);
+  return text.trim() ? template + '\n\n' + text.trim() : template;
+}
+
+export default {
+  id: 'ponytail',
+
+  async setup(ctx) {
+    const commands = readCommands();
+    const skills = readSkills();
+
+    await ctx.skill.transform((editor) => {
+      for (const skill of skills) editor.add(skill);
+    });
+
+    await ctx.command.transform((editor) => {
+      for (const command of commands) {
+        editor.add({
+          name: command.name,
+          description: command.description,
+          execute: async ({ sessionID, prompt, delivery }) => {
+            if (command.name === 'ponytail') persistMode(prompt.text);
+            const withoutMentions = (items) => items?.map(({ mention, ...item }) => item);
+            await ctx.session.prompt({
+              ...prompt,
+              sessionID,
+              text: withArguments(command.template, prompt.text),
+              files: withoutMentions(prompt.files),
+              agents: withoutMentions(prompt.agents),
+              skills: withoutMentions(prompt.skills),
+              delivery,
+            });
+          },
+        });
+      }
+    });
+
+    // Append the ruleset to the system prompt every turn. V2 hands over owned
+    // system parts, so push one instead of rewriting the tail of another.
+    // Summary compaction runs its own hook with the same event shape; without
+    // it the compaction request misses the ruleset and the provider prompt cache.
+    const addRuleset = (event) => {
+      const mode = readMode();
+      if (mode === 'off') return;
+      event.system.push({ type: 'text', text: getPonytailInstructions(mode) });
+    };
+    await ctx.session.hook('context', addRuleset);
+    await ctx.session.hook('compaction', addRuleset);
+  },
+
+  // OpenCode V1: same three behaviors, as hooks on the V1 hook names.
+  async server({ client } = {}) {
+    const log = (level, message) => {
+      try { client && client.app && client.app.log({ body: { service: 'ponytail', level, message } }); } catch (e) {}
+    };
+
+    return {
+      // Register slash commands + skills directory.
+      config: async (config) => {
+        if (!config.command) config.command = {};
+        for (const command of readCommands()) {
+          config.command[command.name] = { description: command.description, template: command.template };
+        }
+
+        config.skills = config.skills || {};
+        config.skills.paths = config.skills.paths || [];
+        const ponytailSkillsDir = path.resolve(__dirname, '../../skills');
+        if (!config.skills.paths.includes(ponytailSkillsDir)) {
+          config.skills.paths.push(ponytailSkillsDir);
+        }
+      },
+
+      'experimental.chat.system.transform': async (_input, output) => {
+        const mode = readMode();
+        if (mode === 'off') return;
+        const instructions = getPonytailInstructions(mode);
+        if (output.system.length > 0) {
+          output.system[output.system.length - 1] += '\n\n' + instructions;
+        } else {
+          output.system.push(instructions);
+        }
+      },
+
+      'command.execute.before': async (input) => {
+        if (!input || input.command !== 'ponytail') return;
+        persistMode(input.arguments);
+        log('info', 'ponytail ' + readMode());
+      },
+    };
+  },
+};

package/.windsurf/rules/ponytail.md

@@ -0,0 +1,30 @@
+# Ponytail, lazy senior dev mode
+
+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.
+
+## Before you write
+
+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.
+
+## The smallest complete change
+
+Take the first option that fully works:
+
+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.
+2. Already in this codebase (a helper, component, service, pattern)? Use it the way the surrounding code does.
+3. Standard library or a platform feature? Use it, unless the project has its own. A house component beats a native widget.
+4. An installed dependency? Use it. Never add a dependency for a few lines.
+5. Can it be one line a reader gets at a glance? One line.
+6. Otherwise: the minimum code that works.
+
+- 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.
+- 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.
+- The shortest working diff wins, once you know everything it must touch. A one-liner that needs decoding is not short.
+- Comment only the why the code cannot show, in one line.
+- Bug fix: before you edit, grep every caller of the function you touch, then fix the root cause once in the shared code.
+- Code you move or merge keeps its error handling and validation.
+- Between options of equal size, take the one that is correct on edge cases.
+- 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.
+- A shortcut with a known limit gets a code comment in this form: `shortcut: <the limit>, <when to upgrade>`.
+
+Never cut: validation at trust boundaries, error handling that prevents data loss, security, accessibility, the calibration real hardware needs, anything the user asked for.

package/AGENTS.md

@@ -0,0 +1,19 @@
+<!-- chill-agent:start -->
+## ChillAgent Anti-Slop 2.0 & Pragmatic Senior Dev Standard (Ponytail + Anti-Slop)
+Active Mode: `full` (Options: lite | full | ultra). Switch anytime with `/chill <mode>`.
+
+Before generating or editing any code, interface, copy, or architecture in this workspace, follow these active skills:
+- `skills/chill-slop/SKILL.md`
+- `skills/chill-slop-code/SKILL.md`
+- `skills/chill-slop-ui/SKILL.md`
+- `skills/chill-slop-copywriting/SKILL.md`
+- `skills/chill-slop-human/SKILL.md`
+- `skills/chill-slop-mobile/SKILL.md`
+
+### Core Operating Rules:
+1. **The Smallest Complete Change (Ponytail):** Take the shortest path that solves the whole task: standard library > existing codebase helper > installed dependency > minimum new code. No premature abstractions or wrapper factories.
+2. **Purpose Test (Anti-Slop):** Every visual decision, color accent, layout structure, and copy phrase must name a specific domain purpose. AI defaults (purple gradients, rounded-3xl cards, generic cards) are forbidden.
+3. **Liveliness Bar:** Avoid sterile defaults by reading `DESIGN.md`. If `DESIGN.md` is missing, adhere strictly to Linear/Geist carbon monochromatic standards.
+4. **Context Hygiene & Time-Travel:** Strip conversational fluff and emojis. When debugging stochastic agent loops, route upstream LLM calls through `chillrewind run` (deterministic SQLite WAL replay + SlopSieve circuit breaker).
+5. **Delivery Disclosure:** End non-trivial deliveries with a 1-line disclosure: what was skipped and known limits/trade-offs.
+<!-- chill-agent:end -->

package/__init__.py

@@ -0,0 +1,228 @@
+"""Hermes plugin for Ponytail."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from pathlib import Path
+from typing import Any, Callable
+
+DEFAULT_MODE = "full"
+RUNTIME_MODES = {"off", "lite", "full", "ultra"}
+SKILL_COMMANDS = {
+    "ponytail-review": "Review the current diff or provided target: bugs, security, load, missing tests, speed, and what to cut.",
+    "ponytail-audit": "Audit the whole repo: bugs, security, load, missing tests, speed, and what to cut.",
+    "ponytail-debt": "List every deliberate `shortcut:` comment and its upgrade path.",
+    "ponytail-gain": "Show the measured-impact scoreboard (less code, less cost, more speed).",
+    "ponytail-help": "Show the Ponytail command reference.",
+}
+
+ROOT = Path(__file__).resolve().parent
+SKILLS_DIR = ROOT / "skills"
+PONYTAIL_SKILL = SKILLS_DIR / "ponytail" / "SKILL.md"
+
+_current_mode = None
+
+
+def _normalize_runtime_mode(mode: str | None) -> str | None:
+    if not isinstance(mode, str):
+        return None
+    mode = mode.strip().lower()
+    return mode if mode in RUNTIME_MODES else None
+
+
+def _config_dir() -> Path:
+    if os.environ.get("XDG_CONFIG_HOME"):
+        return Path(os.environ["XDG_CONFIG_HOME"]) / "ponytail"
+    if os.name == "nt":
+        return Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming")) / "ponytail"
+    return Path.home() / ".config" / "ponytail"
+
+
+def _default_mode() -> str:
+    env_mode = _normalize_runtime_mode(os.environ.get("PONYTAIL_DEFAULT_MODE"))
+    if env_mode:
+        return env_mode
+    try:
+        data = json.loads((_config_dir() / "config.json").read_text(encoding="utf-8-sig"))
+        file_mode = _normalize_runtime_mode(data.get("defaultMode"))
+        if file_mode:
+            return file_mode
+    except Exception:
+        pass
+    return DEFAULT_MODE
+
+
+def _strip_frontmatter(text: str) -> str:
+    return re.sub(r"^---[\s\S]*?---\s*", "", text or "", count=1)
+
+
+def _filter_skill_body_for_mode(body: str, mode: str) -> str:
+    effective = _normalize_runtime_mode(mode) or DEFAULT_MODE
+    lines = []
+    # str.splitlines() drops a trailing line terminator instead of yielding a
+    # trailing empty element, so a body ending in "\n" loses that newline on
+    # rejoin. re.split keeps it, matching the JS filter's split(/\r?\n/).
+    for line in re.split(r"\r?\n", _strip_frontmatter(body)):
+        table_label = re.match(r"^\|\s*\*\*(.+?)\*\*\s*\|", line)
+        if table_label:
+            label_mode = _normalize_runtime_mode(table_label.group(1))
+            if label_mode and label_mode != effective:
+                continue
+
+        # 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.
+        # Mirrors the fix in hooks/ponytail-instructions.js (#571).
+        example_label = re.match(r'^-\s*([^:]+):\s*"', line)
+        if example_label:
+            label_mode = _normalize_runtime_mode(example_label.group(1))
+            if label_mode and label_mode != effective:
+                continue
+
+        lines.append(line)
+    return "\n".join(lines)
+
+
+def _fallback_instructions(mode: str) -> str:
+    return (
+        f"PONYTAIL MODE ACTIVE — level: {mode}\n\n"
+        "You are a lazy senior developer. The best code is the code never written. "
+        "Before you write, list every place your change must reach (callers, tests, "
+        "fixtures) and what it could break for users. First rung that works: skip what "
+        "is not needed, reuse what the codebase has, stdlib or platform, installed "
+        "dependency, one readable line, then minimum code. No unrequested abstractions, "
+        "wrappers, options or boilerplate. Never cut trust-boundary validation, "
+        "data-loss handling, security, accessibility or anything asked for."
+    )
+
+
+def build_injected_context(mode: str | None = None) -> str:
+    """Return the mode-filtered Ponytail context injected before LLM turns."""
+    effective = _normalize_runtime_mode(mode) or _default_mode()
+    if effective == "off":
+        return ""
+    try:
+        body = PONYTAIL_SKILL.read_text(encoding="utf-8")
+        return f"PONYTAIL MODE ACTIVE — level: {effective}\n\n{_filter_skill_body_for_mode(body, effective)}"
+    except OSError:
+        return _fallback_instructions(effective)
+
+
+def _pre_llm_call(
+    session_id: str = "", conversation_history: Any = None, **_: Any
+) -> dict[str, str] | None:
+    mode = _current_mode or _default_mode()
+    # Off is injected too: the ruleset from an earlier turn is replayed every turn,
+    # and the /ponytail off reply goes to the user, never to the model.
+    context = build_injected_context(mode) or "PONYTAIL MODE OFF"
+
+    # Hermes persists hook context in api_content for cache-stable replay.
+    # Re-inject only when the active mode changed or compaction removed it.
+    for message in reversed(conversation_history or []):
+        if not isinstance(message, dict):
+            continue
+        api_content = message.get("api_content")
+        if not isinstance(api_content, str):
+            continue
+        matches = re.findall(r"PONYTAIL MODE (?:ACTIVE — level: ([a-z]+)|OFF)", api_content)
+        if matches:
+            return None if (matches[-1] or "off") == mode else {"context": context}
+
+    # Nothing persisted, so off has nothing to switch off.
+    return None if mode == "off" else {"context": context}
+
+
+def _skill_prompt(command: str, args: str = "") -> str:
+    tail = args.strip()
+    target = f"\n\nUser arguments: {tail}" if tail else ""
+    return (
+        f"Load and follow the Hermes plugin skill `ponytail:{command}`. "
+        f"{SKILL_COMMANDS[command]}{target}"
+    )
+
+
+def _slash_access_denied(event: Any, gateway: Any, command: str) -> bool:
+    if gateway is None or event is None:
+        return False
+    checker = getattr(gateway, "_check_slash_access", None)
+    source = getattr(event, "source", None)
+    if checker is None or source is None:
+        return False
+    try:
+        return checker(source, command) is not None
+    except Exception:
+        return True
+
+
+def rewrite_gateway_command(event: Any = None, gateway: Any = None, **_: Any) -> dict[str, str] | None:
+    """Rewrite authorized gateway /ponytail-* commands into normal agent prompts."""
+    text = str(getattr(event, "text", "") or "").strip()
+    if not text.startswith("/"):
+        return None
+    head, _, rest = text[1:].partition(" ")
+    command = head.replace("_", "-").lower()
+    if command not in SKILL_COMMANDS:
+        return None
+    if _slash_access_denied(event, gateway, command):
+        return None
+    return {"action": "rewrite", "text": _skill_prompt(command, rest)}
+
+
+def _handle_mode_command(raw_args: str) -> str:
+    global _current_mode
+    arg = (raw_args or "").strip().lower()
+    if not arg:
+        # Bare /ponytail switches ponytail on, or reports the level when it already is (#639).
+        mode = _current_mode or _default_mode()
+        if mode != "off":
+            return f"Ponytail mode: {mode}. Use `/ponytail lite|full|ultra|off`."
+        _current_mode = "full" if _default_mode() == "off" else _default_mode()
+        return f"Ponytail mode set to {_current_mode}."
+    mode = _normalize_runtime_mode(arg)
+    if not mode:
+        return "Usage: /ponytail [lite|full|ultra|off]"
+    _current_mode = mode
+    return f"Ponytail mode set to {mode}."
+
+
+def _make_skill_command_handler(ctx: Any, command: str) -> Callable[[str], str]:
+    def handler(raw_args: str) -> str:
+        prompt = _skill_prompt(command, raw_args or "")
+        injected = False
+        try:
+            injected = bool(ctx.inject_message(prompt))
+        except Exception:
+            injected = False
+        if injected:
+            return f"Queued `{command}` for the agent."
+        return prompt
+
+    return handler
+
+
+def register(ctx: Any) -> None:
+    """Register Ponytail hooks, skills, and slash commands with Hermes."""
+    for child in sorted(SKILLS_DIR.iterdir() if SKILLS_DIR.exists() else []):
+        skill_md = child / "SKILL.md"
+        if child.is_dir() and skill_md.exists():
+            ctx.register_skill(child.name, skill_md)
+
+    ctx.register_hook("pre_llm_call", _pre_llm_call)
+    ctx.register_hook("pre_gateway_dispatch", rewrite_gateway_command)
+
+    ctx.register_command(
+        "ponytail",
+        _handle_mode_command,
+        description="Set Ponytail lazy senior dev mode: lite, full, ultra, or off.",
+        args_hint="[lite|full|ultra|off]",
+    )
+    for command, description in SKILL_COMMANDS.items():
+        ctx.register_command(
+            command,
+            _make_skill_command_handler(ctx, command),
+            description=description,
+            args_hint="[target or notes]",
+        )

package/commands/ponytail-audit.toml

@@ -0,0 +1,2 @@
+description = "Quality audit of the whole repo: bugs, security, load, tests, speed, bloat"
+prompt = "Audit the whole repository (or the folder the user names) like the senior developer who just inherited it. Map first: README, deploy and build config, dependencies, entry points, tests; find the expected load (one person or many users and processes); trace the main flows and read fully the paths with user input, money, auth, data writes, background jobs and shared state. Look for, in this order: bugs, risk (security holes, data loss), scale (races, the same work done by every process, memory that only grows, a query per item, O(n^2)), risky logic without a test, slow code (big = problem, small = suggestion), lean (dead code, duplicate helpers, stdlib or native instead of custom code or a dependency, abstractions with one implementation, near-copies to merge, a function doing several unrelated jobs to split, never split by line count). Before calling code unused, grep the whole tree including tests, fixtures, config and string references. Every finding needs a concrete case. A shortcut marked with a shortcut: (or older ponytail:) comment that names its limit is a decision, not a finding. Propose the smallest fix, prefer deleting code, never add layers. Very simple English. Start with 'What this repo does:' and the load you assumed. Then at most 20 numbered findings grouped Must fix / Should fix / Nice to have, most important first; each: a bold title with file:lines, then four bullets: What this is, Problem, Fix, If we skip it. End with 'Verdict:', 'Lean: -N lines, -M dependencies possible.' and 'Not checked:' for the parts you did not read. Change no code."

package/commands/ponytail-debt.toml

@@ -0,0 +1,2 @@
+description = "Harvest shortcut: comments into a tracked debt ledger"
+prompt = "Harvest every `shortcut:` comment (and older `ponytail:` ones) in this repository into a debt ledger so deferrals do not rot into 'later means never'. Grep the whole tree for comment markers (git grep --no-index --exclude-standard -nE '(#|//|/[*]) ?(shortcut|ponytail):', skipping .git and everything .gitignore ignores; if the user names their own marker word, grep for that instead; skip hits that are not a deferral, like a keyboard-shortcut note). One row per marker, grouped by file: <file>:<line> — <what was simplified>. ceiling: <the limit named in the comment>. upgrade: <the trigger to revisit>. Tag any marker that names no upgrade path or trigger as no-trigger, those rot silently. End with the count of markers and how many lack a trigger. If none: 'No shortcut debt. Clean ledger.' Report only, change nothing."

package/commands/ponytail-gain.toml

@@ -0,0 +1,2 @@
+description = "Show ponytail's measured impact scoreboard (less code, cost, time)"
+prompt = "Show the ponytail gain scoreboard. One shot, change nothing: do not switch mode, write flag files, or persist anything. Render the published agentic benchmark of Ponytail 5 (39 tasks on a real FastAPI + React repo plus bug fixes, security and privacy cases and small apps, Opus 5.5, 5 runs each, against the same agent without the skill; geometric mean of per-task medians; source benchmarks/results/2026-10-07-agentic.md and the README) as plain ASCII bars, ponytail as a share of the no-skill baseline (100%): Lines of code 47% (down 53%); Output tokens 55% (down 45%); Cost 74% (down 26%); Time 59% (down 41%); Hidden checks passed 97% (no-skill 96%; 18 of the tasks have hidden checks for correctness and safety); Tests where the logic needs one 98% (no-skill 68%). The bar length shows the share, the label carries the exact figure. These are benchmark averages, not this repo. NEVER print a per-repo savings number: the unbuilt version was never written, so there is no real baseline to subtract from in a live repo. For real per-repo figures, point to /ponytail-debt (the counted shortcut ledger) and /ponytail-audit (what is still cuttable). Report only."

package/commands/ponytail-help.toml

@@ -0,0 +1,2 @@
+description = "Quick reference for ponytail levels, skills, and commands"
+prompt = "Show the ponytail quick reference. One shot, change nothing: do not switch mode, write flag files, or persist anything. Levels: /ponytail lite (build what's asked, name the lazier alternative in one line), /ponytail (full, the default ladder: YAGNI then stdlib then native then one line then minimum), /ponytail ultra (deletion before addition, challenges the requirement before building). Commands: /ponytail-review (over-engineering review of the current changes), /ponytail-audit (whole-repo over-engineering audit), /ponytail-debt (harvest shortcut: comments into a tracked ledger), /ponytail-gain (measured-impact scoreboard from the benchmark), /ponytail-help (this card). Deactivate with 'stop ponytail', 'normal mode', or /ponytail off; resume anytime with /ponytail. Default mode is full; change it with the PONYTAIL_DEFAULT_MODE environment variable (off|lite|full|ultra) or a config file at ~/.config/ponytail/config.json (Windows: %APPDATA%\\ponytail\\config.json) with {\"defaultMode\": \"lite\"}. Resolution order: env var, then config file, then full."

package/commands/ponytail-review.toml

@@ -0,0 +1,2 @@
+description = "Quality review of the current changes: bugs, security, load, tests, speed, bloat"
+prompt = "Review the current code changes like the senior developer who will be paged when they break. Review what the user names (uncommitted or staged changes, a branch, a PR link, files); nothing named: the uncommitted changes, or the last commit if there are none. First read the code the change touches: callers of every changed function, the functions it calls, the tests, the README (find the expected load: one person or many users and processes). A change can break code it does not touch. Look for, in this order: bugs (wrong result, crash, missed edge case, a caller broken by the change, a fix in one caller while the shared function stays broken), risk (security holes, data loss), scale (check-then-write races, the same work done by every process, memory that only grows, a query per item, O(n^2) on big input), risky logic without a test, slow code (big = problem, small = suggestion), lean (dead code, a helper the repo already has, stdlib or native instead of custom code or a new dependency, abstractions with one implementation, near-copies to merge, a function doing several unrelated jobs to split, never split by line count). Every finding needs a concrete case; re-read the lines to confirm it. A shortcut marked with a shortcut: (or older ponytail:) comment that names its limit is a decision, not a finding. Propose the smallest fix, prefer deleting code, never add layers. No style taste, no vague worries. Very simple English, explain technical terms. Start with 'What this change does:' in two or three sentences and the load you assumed. Then numbered findings grouped Must fix / Should fix / Nice to have; each finding: a bold title with file:lines, then four bullets: What this is, Problem, Fix, If we skip it (one or two short sentences each). End with 'Verdict:', 'Lean: -N lines possible.' when lean findings exist, and 'Not checked:' if something mattered and you could not check it. Nothing found: 'Looks good. Ship.' Change no code."

package/commands/ponytail.toml

@@ -0,0 +1,2 @@
+description = "Switch ponytail intensity level (lite/full/ultra/off)"
+prompt = "Switch to ponytail {{args}} mode. With no level, keep the current level, or switch on at the default level if ponytail was off. Lazy senior dev mode, before any code: does it need to exist at all (YAGNI)? Does the standard library do it? A native platform feature? Can it be one line? Build the minimum that works. No unrequested abstractions, no avoidable dependencies, no boilerplate. Mark deliberate simplifications that cut a real corner with a known ceiling using a shortcut: comment that names the ceiling and upgrade path."

package/hooks/chill-statusline.ps1

@@ -1,4 +1,4 @@
-# chill-agent PowerShell statusline indicator
+# chill-agent PowerShell statusline indicator
 $flag = Join-Path $HOME ".chill-agent-active"
 if (Test-Path $flag) {
   try {