chill-agent 1.3.0 → 1.5.0

package/.openclaw/skills/ponytail-help/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: ponytail-help
+description: >
+  Quick reference for ponytail levels, skills and commands. One-shot display.
+  Use for /ponytail-help, "ponytail help", "how do I use ponytail".
+---
+
+# Ponytail Help
+
+Display this reference card when invoked. One-shot, do NOT change mode,
+write flag files, or persist anything.
+
+## Levels
+
+| Level | Trigger | What change |
+|-------|---------|-------------|
+| **Lite** | `/ponytail lite` | Build what was asked, name the smaller option in one line. |
+| **Full** | `/ponytail` | The smallest complete change, a check where the logic needs one, and a reply that names what was skipped and any risk. Default. |
+| **Ultra** | `/ponytail ultra` | Also questions the request and pushes back before building. |
+
+Level sticks until changed or session end.
+
+## Skills
+
+| Skill | Trigger | What it does |
+|-------|---------|--------------|
+| **ponytail** | `/ponytail` | Lazy mode itself: least new code, clear replies that name skipped work and risks. |
+| **ponytail-review** | `/ponytail-review` | Quality review of a diff: bugs, security, load, missing tests, speed, what to cut. Each finding says what goes wrong and how to fix it. |
+| **ponytail-audit** | `/ponytail-audit` | The same quality review for the whole repo, ranked. |
+| **ponytail-debt** | `/ponytail-debt` | Harvest `shortcut:` comments into a tracked ledger. |
+| **ponytail-gain** | `/ponytail-gain` | Measured-impact scoreboard: less code, less cost, more speed. |
+| **ponytail-help** | `/ponytail-help` | This card. |
+
+In Codex CLI and the IDE extension, invoke skills with `$ponytail:ponytail`,
+`$ponytail:ponytail-review`, or `$ponytail:ponytail-help`. Claude Code and OpenCode use the
+slash-command forms above (OpenCode ships all six as slash commands).
+
+## Deactivate
+
+Say "stop ponytail" or "normal mode". Resume anytime with `/ponytail`.
+`/ponytail off` also works.
+
+## Band (Claude Code)
+
+`/ponytail band` hides the band above the prompt, the same command brings it back.
+`/ponytail band on` and `/ponytail band off` set it directly. The level stays.
+`/ponytail band import` adds your past Claude Code sessions (cost, agent time, tokens) to the board.
+
+## Configure Default Mode
+
+Default mode = `full`, auto-active every session. Change it:
+
+**Environment variable** (highest priority):
+```bash
+export PONYTAIL_DEFAULT_MODE=ultra
+```
+
+**Config file** (`~/.config/ponytail/config.json`, Windows: `%APPDATA%\ponytail\config.json`):
+```json
+{ "defaultMode": "lite" }
+```
+
+Set `"off"` to disable auto-activation on session start, activate manually
+with `/ponytail` when wanted.
+
+Resolution: env var > config file > `full`.
+
+## Update
+
+Enable auto-update once: open `/plugin`, go to Marketplaces, pick ponytail, Enable auto-update. Claude Code then pulls new versions at startup (run `/reload-plugins` when it prompts). Manual refresh: `/plugin marketplace update ponytail` then `/reload-plugins`.
+
+If `/plugin` is not recognized, your Claude Code is out of date. Update it (`npm install -g @anthropic-ai/claude-code@latest`, or `brew upgrade claude-code`) and restart. Other hosts use their own update flow.
+
+## More
+
+Full docs + examples: https://github.com/DietrichGebert/ponytail

package/.openclaw/skills/ponytail-review/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: ponytail-review
+description: >
+  Quality review of a change: is the logic right, is it safe, does it hold
+  under real load, is risky code tested, is it fast enough, and is every line
+  needed. Reads the connected code, not only the diff. Each finding is
+  explained in plain English. Use for "review this", "code review", "review
+  the last commit", "review my PR", "is this over-engineered", /ponytail-review.
+---
+
+Review a change like the senior developer who will be paged when it breaks.
+Order of importance: correct, safe, holds under load, tested, fast, lean.
+Lean still matters: every extra line must be read, tested and fixed later.
+This is a report the user asked for, so give it in full.
+
+## 1. Understand first
+
+- Review what the user names: uncommitted or staged changes, a branch, a PR
+  link, or files. Nothing named: the uncommitted changes, or the last commit
+  if there are none.
+- Read the diff, then the code it touches: callers of every changed function,
+  the functions it calls, the tests, the README.
+- Trace the real flow: where data comes in, what is stored, what goes out.
+- A change can break code it does not touch. When a signature, return value
+  or behavior changes, grep every caller.
+- Find the expected load in the repo (README, deploy config): one person
+  running a script, or many users and processes at once. Judge scale against
+  that, and say which load you assumed.
+
+## 2. Look for
+
+1. **Bug:** wrong result, crash, missed edge case (empty, zero, last item,
+   rounding, time zones), a caller broken by the change, a fix applied in one
+   caller while the shared function stays broken.
+2. **Risk:** security holes (injection, weak randomness, secrets, missing
+   checks on input from users), data loss (errors swallowed, writes in the
+   wrong order, no transaction).
+3. **Scale:** fine for one user, wrong for many: check-then-write races, the
+   same work done by every process, memory or lists that only grow, a query
+   per item, O(n^2) on big input, per-process state that must be shared.
+4. **Missing test:** risky new logic (a branch, a parser, money, security,
+   data writes, a bug fix) with no test that fails when it breaks. One good
+   test, not coverage.
+5. **Speed:** big slowdowns are problems. Small wins (work repeated in a hot
+   loop) are suggestions; some software counts every millisecond.
+6. **Lean:** code that should not exist or should be smaller.
+   - delete: dead code, unused options, speculative features
+   - reuse: the repo already has this helper (name the path)
+   - stdlib / native: the standard library or platform already does it; a
+     new dependency for a few lines
+   - yagni: abstraction with one implementation, config nobody sets
+   - merge: near-copies that must change together
+   - split: one function doing several unrelated jobs, so it is hard to read
+     or test. Split by job, never by line count, and never into helpers that
+     exist only to make a function shorter.
+
+## 3. Check before you report
+
+- Every finding needs a concrete case: "this input or situation leads to this
+  wrong result". No case, no finding.
+- Re-read the lines and confirm: the caller exists, the value can really be
+  empty, the code really is unused.
+- A shortcut marked with a `shortcut:` (or older `ponytail:`) comment that names its limit is a
+  decision, not a finding, unless the expected load already crosses it.
+- Propose the smallest fix that works. Prefer fixes that delete code. Never
+  add layers, frameworks or config the problem does not need.
+- No style taste, no "consider", no vague worries.
+
+## 4. Output
+
+Very simple English: short sentences, everyday words. Explain a technical
+term the first time you use it. The reader may never have seen this code.
+
+Start with `What this change does:` in two or three sentences.
+
+Then the findings in three groups, skip empty groups:
+- **Must fix:** bug, security, data loss, breaks at the expected load.
+- **Should fix:** risky code without a test, real slowness, duplication, a
+  function that mixes jobs, code that should not exist.
+- **Nice to have:** small speed-ups, shorter forms.
+
+Number findings across all groups, so the user can say "fix 2 and 5".
+Every finding has all four parts, each one or two short sentences:
+
+2. **Orders land on the wrong day** (`billing/close_day.py:L40-52`)
+   - **What this is:** At midnight this job closes the day and bills all orders of that day.
+   - **Problem:** It takes "today" from the server clock, which runs in UTC. An order placed
+     at 00:30 in Berlin is billed on the day before.
+   - **Fix:** Compute the day once in the shop's time zone:
+     `datetime.now(ZoneInfo("Europe/Berlin")).date()`. One line, nothing else changes.
+   - **If we skip it:** Late orders show the wrong date, and accounting fixes them by hand.
+
+End with:
+- `Verdict: Ship.` or `Verdict: fix 1 and 3 first.`
+- `Lean: -<N> lines possible.` when lean findings exist.
+- `Not checked:` one line, if something mattered and you could not check it.
+
+Nothing found: `What this change does:`, then `Looks good. Ship.` and one line
+on what you checked.
+
+Lists findings, changes no code.

package/.opencode/command/chill-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 chill:) 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/.opencode/command/chill-debt.toml

@@ -0,0 +1,2 @@
+description = "Harvest shortcut: comments into a tracked debt ledger"
+prompt = "Harvest every `shortcut:` comment (and older `chill:` 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|chill):', 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/.opencode/command/chill-gain.toml

@@ -0,0 +1,2 @@
+description = "Show chill's measured impact scoreboard (less code, cost, time)"
+prompt = "Show the chill gain scoreboard. One shot, change nothing: do not switch mode, write flag files, or persist anything. Render the published agentic benchmark of ChillAgent 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, chill 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 /chill-debt (the counted shortcut ledger) and /chill-audit (what is still cuttable). Report only."

package/.opencode/command/chill-help.toml

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

package/.opencode/command/chill-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 chill:) 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/chill.toml

@@ -0,0 +1,2 @@
+description = "Switch chill intensity level (lite/full/ultra/off)"
+prompt = "Switch to chill {{args}} mode. With no level, keep the current level, or switch on at the default level if chill 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/command/ponytail-audit.md

@@ -0,0 +1,5 @@
+---
+description: Quality audit of the whole repo: bugs, security, load, tests, speed, bloat
+---
+
+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/.opencode/command/ponytail-debt.md

@@ -0,0 +1,5 @@
+---
+description: "Harvest shortcut: comments into a tracked debt ledger"
+---
+
+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/.opencode/command/ponytail-gain.md

@@ -0,0 +1,5 @@
+---
+description: Show ponytail's measured impact scoreboard (less code, cost, time)
+---
+
+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/.opencode/command/ponytail-help.md

@@ -0,0 +1,5 @@
+---
+description: Quick reference for ponytail levels, skills, and commands
+---
+
+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/.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/.qoder-plugin/plugin.json

@@ -0,0 +1,35 @@
+{
+  "name": "chill-agent",
+  "displayName": "ChillAgent (Anti-Slop 2.0 + Ponytail Senior Dev)",
+  "version": "1.2.0",
+  "description": "Master Negative Filter, Anti-Slop, and Pragmatic Senior Dev Standard. Combines ruthless YAGNI minimalism with Linear-grade visual engineering.",
+  "author": {
+    "name": "sann"
+  },
+  "homepage": "https://github.com/sann/chill-agent",
+  "repository": "https://github.com/sann/chill-agent",
+  "license": "MIT",
+  "keywords": [
+    "anti-slop",
+    "ponytail",
+    "design-rules",
+    "minimalism",
+    "agent-skills",
+    "yagni",
+    "ui",
+    "accessibility"
+  ],
+  "skills": [
+    "./skills/chill-slop/",
+    "./skills/chill-slop-ui/",
+    "./skills/chill-slop-code/",
+    "./skills/chill-slop-copywriting/",
+    "./skills/chill-slop-human/",
+    "./skills/chill-slop-mobile/",
+    "./skills/chill-audit/",
+    "./skills/chill-review/",
+    "./skills/chill-debt/",
+    "./skills/chill-gain/",
+    "./skills/chill-help/"
+  ]
+}