chill-agent 1.3.0 → 1.5.0

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}.`);

package/scripts/cursor-hooks.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+// ponytail — install or remove the Cursor hooks (hooks/cursor-hooks.json) in
+// ~/.cursor/hooks.json (default) or <cwd>/.cursor/hooks.json (--project),
+// merging with whatever hooks are already there. Only entries that run one of
+// ponytail's own hooks/ponytail-*.js scripts are added or removed; every other
+// hook stays as it was.
+//
+//   node scripts/cursor-hooks.js install [--project]
+//   node scripts/cursor-hooks.js uninstall [--project]
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { isShellSafe } = require('../hooks/ponytail-config');
+
+const ROOT = path.join(__dirname, '..');
+const TEMPLATE = path.join(ROOT, 'hooks', 'cursor-hooks.json');
+const PONYTAIL_HOOK = /[\\/]hooks[\\/]ponytail-[\w-]+\.js(?=["'\s]|$)/;
+
+function isPonytailHook(entry) {
+  return Boolean(entry && typeof entry.command === 'string' && PONYTAIL_HOOK.test(entry.command));
+}
+
+function hooksPath(scope) {
+  return scope === 'project'
+    ? path.join(process.cwd(), '.cursor', 'hooks.json')
+    : path.join(os.homedir(), '.cursor', 'hooks.json');
+}
+
+// Missing file → empty config. Malformed JSON throws a SyntaxError so the
+// caller can refuse to touch the file rather than overwrite it.
+function readConfig(file) {
+  let config = {};
+  try {
+    config = JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, ''));
+  } catch (e) {
+    if (e.code !== 'ENOENT') throw e;
+  }
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    throw new Error(file + ' must contain a JSON object; nothing was changed');
+  }
+  if (config.hooks === undefined) config.hooks = {};
+  if (!config.hooks || typeof config.hooks !== 'object' || Array.isArray(config.hooks)) {
+    throw new Error(file + ': hooks must be an object; nothing was changed');
+  }
+  for (const [event, entries] of Object.entries(config.hooks)) {
+    if (!Array.isArray(entries)) {
+      throw new Error(file + ': hooks.' + event + ' must be an array; nothing was changed');
+    }
+  }
+  return config;
+}
+
+function writeConfig(file, config) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}
+
+// The template's PONYTAIL_DIR placeholder becomes this checkout's absolute
+// path. Forward slashes run unchanged under cmd, PowerShell and bash, and the
+// same allowlist that guards the statusline snippet keeps shell metacharacters
+// out of the command string.
+function ponytailEntries() {
+  const root = ROOT.replace(/\\/g, '/');
+  if (!isShellSafe(root)) {
+    throw new Error('ponytail is checked out at a path with shell metacharacters (' + ROOT +
+      '); move it, or copy hooks/cursor-hooks.json by hand and quote the path for your shell');
+  }
+  const template = JSON.parse(fs.readFileSync(TEMPLATE, 'utf8'));
+  const hooks = {};
+  for (const [event, entries] of Object.entries(template.hooks)) {
+    hooks[event] = entries.map((entry) => ({ ...entry, command: entry.command.replace(/PONYTAIL_DIR/g, root) }));
+  }
+  return hooks;
+}
+
+function stripPonytail(config) {
+  for (const [event, entries] of Object.entries(config.hooks)) {
+    if (!Array.isArray(entries)) continue;
+    const kept = entries.filter((entry) => !isPonytailHook(entry));
+    if (kept.length) config.hooks[event] = kept;
+    else delete config.hooks[event];
+  }
+}
+
+function install(scope) {
+  const file = hooksPath(scope);
+  const config = readConfig(file);
+  if (config.version === undefined) config.version = 1;
+  // Re-running replaces stale ponytail entries instead of duplicating them.
+  stripPonytail(config);
+  for (const [event, entries] of Object.entries(ponytailEntries())) {
+    config.hooks[event] = [...(config.hooks[event] || []), ...entries];
+  }
+  writeConfig(file, config);
+  return file;
+}
+
+// Returns the file it changed, or null when there was nothing of ponytail's in it.
+function uninstall(scope) {
+  const file = hooksPath(scope);
+  if (!fs.existsSync(file)) return null;
+  const config = readConfig(file);
+  const before = JSON.stringify(config);
+  stripPonytail(config);
+  if (JSON.stringify(config) === before) return null;
+  const otherKeys = Object.keys(config).filter((k) => k !== 'version' && k !== 'hooks');
+  if (Object.keys(config.hooks).length === 0 && otherKeys.length === 0) {
+    // Only ponytail lived here: drop the file rather than leave an empty husk.
+    fs.unlinkSync(file);
+  } else {
+    writeConfig(file, config);
+  }
+  return file;
+}
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const action = args[0];
+  const scope = args.includes('--project') ? 'project' : 'user';
+  try {
+    if (action === 'install') {
+      const file = install(scope);
+      console.log('Installed ponytail hooks in ' + file);
+      console.log('Cursor reloads hooks.json on save; start a new chat to activate.');
+    } else if (action === 'uninstall') {
+      const file = uninstall(scope);
+      console.log(file
+        ? 'Removed ponytail hooks from ' + file
+        : 'No ponytail hooks in ' + hooksPath(scope));
+    } else {
+      console.error('usage: node scripts/cursor-hooks.js install|uninstall [--project]');
+      process.exit(1);
+    }
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      console.error(hooksPath(scope) + ' is not valid JSON; nothing was changed, fix it by hand (' + e.message + ')');
+    } else {
+      console.error(e.message);
+    }
+    process.exit(1);
+  }
+}
+
+module.exports = { hooksPath, install, isPonytailHook, uninstall };

package/scripts/generate-chillslop.mjs

@@ -0,0 +1,42 @@
+// scripts/generate-chillslop.mjs
+import fs from 'node:fs';
+
+let text = fs.readFileSync('antislop.raw.md', 'utf8');
+
+text = text.replace(
+  /# antislop\n\n> Anti Slop: Rules for AI Coding Agents/g,
+  '# ChillSlop 2.0: Anti-Slop & Pragmatic Senior Dev Standard\n\n> Dual Core: Anti-Slop (miqdadbadjuber) + Ponytail (dietrichgebert) + ChillRewind Time-Travel'
+);
+
+text = text.replace(/antislop/g, 'chill-agent');
+text = text.replace(/Anti Slop/g, 'ChillAgent Anti-Slop & Ponytail Core');
+
+const ponytailHeader = `
+## The Pragmatic Senior Dev Creed (Ponytail Synthesis)
+
+> **"The best code is the code you never wrote. The best design is the interface that gets out of the user's way."**
+
+Active for the whole session until the user says "stop chill" or "normal mode".
+Switch intensity mode: \`/chill [lite|full|ultra]\`.
+
+### The 6-Step Minimalist Execution Ladder
+Take the first option that completely solves the problem:
+1. **Does it need to exist?** Skip features, options, and flexibility nobody asked for.
+2. **Already in this codebase?** Use existing helpers, components, and services.
+3. **Standard library or native platform?** Reach for \`node:*\`, native \`fetch\`, CSS Grid, native \`<dialog>\`.
+4. **Already-installed dependency?** Use what exists in \`package.json\`. Never add an npm package for 10 lines.
+5. **Can it be a single readable line?** Write the single line.
+6. **Otherwise:** The minimum code that works reliably.
+
+Be lazy about the solution, never about the change itself: finish every caller, test, fixture, and edge case your change touches. Deletion beats addition.
+`;
+
+text = text.replace('## Core Principle', ponytailHeader + '\n## Core Principle');
+
+fs.writeFileSync('chillslop.md', text, 'utf8');
+fs.writeFileSync('antislop.md', text, 'utf8');
+fs.writeFileSync('rules/chillslop.md', text, 'utf8');
+fs.writeFileSync('rules/antislop.md', text, 'utf8');
+fs.writeFileSync('rules/chillslop.mdc', text, 'utf8');
+
+console.log('Successfully generated full-length master rules (chars: ' + text.length + ')');