chill-agent 1.5.0 → 1.6.0

package/pi-extension/test/extension.test.js

@@ -0,0 +1,367 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import ponytailExtension, { parsePonytailCommand } from "../index.js";
+
+function createPiHarness() {
+  const events = new Map();
+  const commands = new Map();
+  const appendedEntries = [];
+  const sentUserMessages = [];
+
+  const pi = {
+    on(eventName, handler) {
+      events.set(eventName, handler);
+    },
+    registerCommand(name, options) {
+      commands.set(name, options);
+    },
+    appendEntry(customType, data) {
+      appendedEntries.push({ customType, data });
+    },
+    sendUserMessage(text, options) {
+      sentUserMessages.push({ text, options });
+    },
+  };
+
+  ponytailExtension(pi);
+  return { events, commands, appendedEntries, sentUserMessages };
+}
+
+function createCommandContext(overrides = {}) {
+  return {
+    isIdle: () => true,
+    sessionManager: { getEntries: () => [] },
+    ui: { notify() {} },
+    ...overrides,
+  };
+}
+
+function withTempConfig(fn) {
+  const tempConfigHome = mkdtempSync(join(tmpdir(), "ponytail-test-"));
+  const previousXdg = process.env.XDG_CONFIG_HOME;
+  const previousHide = process.env.PONYTAIL_HIDE_STATUS;
+  const previousDefault = process.env.PONYTAIL_DEFAULT_MODE;
+  process.env.XDG_CONFIG_HOME = tempConfigHome;
+  delete process.env.PONYTAIL_HIDE_STATUS;
+  delete process.env.PONYTAIL_DEFAULT_MODE;
+
+  return Promise.resolve()
+    .then(fn)
+    .finally(() => {
+      if (previousXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+      else process.env.XDG_CONFIG_HOME = previousXdg;
+      if (previousHide === undefined) delete process.env.PONYTAIL_HIDE_STATUS;
+      else process.env.PONYTAIL_HIDE_STATUS = previousHide;
+      if (previousDefault === undefined) delete process.env.PONYTAIL_DEFAULT_MODE;
+      else process.env.PONYTAIL_DEFAULT_MODE = previousDefault;
+      rmSync(tempConfigHome, { recursive: true, force: true });
+    });
+}
+
+test("extension registers Ponytail commands", () => {
+  const { commands } = createPiHarness();
+
+  assert.deepEqual([...commands.keys()].sort(), ["ponytail", "ponytail-audit", "ponytail-debt", "ponytail-gain", "ponytail-help", "ponytail-review"]);
+});
+
+test("/ponytail updates session mode and injects instructions", async () => withTempConfig(async () => {
+  const { commands, events, appendedEntries } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await commands.get("ponytail").handler("ultra", ctx);
+
+  assert.deepEqual(appendedEntries.at(-1), {
+    customType: "ponytail-mode",
+    data: { mode: "ultra" },
+  });
+
+  const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+  assert.ok(result.systemPrompt.includes("PONYTAIL MODE ACTIVE"));
+  assert.ok(result.systemPrompt.includes("ultra"));
+}));
+
+test("before_agent_start guards missing event and missing systemPrompt (#439, #440)", async () => withTempConfig(async () => {
+  const { events } = createPiHarness();
+  const ctx = createCommandContext();
+  await events.get("session_start")({ reason: "startup" }, ctx); // currentMode -> default (full)
+
+  // #439: a null/undefined event must not crash, and still injects the ruleset.
+  for (const bad of [undefined, null]) {
+    const r = await events.get("before_agent_start")(bad, ctx);
+    assert.ok(r.systemPrompt.includes("PONYTAIL MODE ACTIVE"));
+    assert.ok(!r.systemPrompt.includes("undefined"), "must not contain the literal 'undefined'");
+  }
+
+  // #440: an event without a systemPrompt must not prepend the literal "undefined".
+  const empty = await events.get("before_agent_start")({}, ctx);
+  assert.ok(empty.systemPrompt.includes("PONYTAIL MODE ACTIVE"));
+  assert.ok(!empty.systemPrompt.startsWith("undefined"), "must not start with 'undefined'");
+
+  // A real base prompt is still preserved and prepended.
+  const withBase = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+  assert.ok(withBase.systemPrompt.startsWith("BASE\n\n"));
+  assert.ok(withBase.systemPrompt.includes("PONYTAIL MODE ACTIVE"));
+}));
+
+test("before_agent_start keeps OMP prompt parts and uses Pi sections (#776, #953)", async () => withTempConfig(async () => {
+  const { commands, events } = createPiHarness();
+  const ctx = createCommandContext();
+  await events.get("session_start")({ reason: "startup" }, ctx);
+
+  // OMP: systemPrompt is an array of parts; they must stay separate, not comma-joined.
+  const omp = await events.get("before_agent_start")({ systemPrompt: ["A", "B"] }, ctx);
+  assert.deepEqual(omp.systemPrompt.slice(0, 2), ["A", "B"]);
+  assert.match(omp.systemPrompt[2], /PONYTAIL MODE ACTIVE/);
+
+  // Pi >= 0.86: write a section and leave the prompt alone; off removes it again.
+  const event = { systemPrompt: "BASE", systemPromptOptions: { sections: {} } };
+  assert.equal(await events.get("before_agent_start")(event, ctx), undefined);
+  assert.match(event.systemPromptOptions.sections.ponytail, /PONYTAIL MODE ACTIVE/);
+  await commands.get("ponytail").handler("off", ctx);
+  await events.get("before_agent_start")(event, ctx);
+  assert.equal(event.systemPromptOptions.sections.ponytail, undefined);
+}));
+
+test("session_start restores latest persisted mode", async () => withTempConfig(async () => {
+  const { events } = createPiHarness();
+  const ctx = createCommandContext({
+    sessionManager: {
+      getEntries: () => [
+        { type: "custom", customType: "ponytail-mode", data: { mode: "lite" } },
+      ],
+    },
+  });
+
+  await events.get("session_start")({ reason: "resume" }, ctx);
+  const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+
+  assert.ok(result.systemPrompt.includes("lite"));
+}));
+
+test("session_tree restores the selected branch's mode without persisting it", async () => withTempConfig(async () => {
+  const { events, commands, appendedEntries } = createPiHarness();
+  const lite = { type: "custom", customType: "ponytail-mode", data: { mode: "lite" } };
+  const off = { type: "custom", customType: "ponytail-mode", data: { mode: "off" } };
+  let branch = [lite, off];
+  const statusWrites = [];
+  const notifications = [];
+  const ctx = createCommandContext({
+    sessionManager: { getBranch: () => branch, getEntries: () => [lite, off] },
+    ui: {
+      notify: (text) => notifications.push(text),
+      setStatus: (_key, text) => statusWrites.push(text),
+      theme: { fg: (_color, text) => text },
+    },
+  });
+
+  await events.get("session_start")({ reason: "resume" }, ctx);
+  await commands.get("ponytail").handler("default ultra", ctx);
+  assert.equal(await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx), undefined);
+  const notificationCount = notifications.length;
+
+  for (const [entries, mode] of [[[lite], "lite"], [[lite, off], "off"], [[], "ultra"]]) {
+    branch = entries;
+    await events.get("session_tree")?.({ type: "session_tree" }, ctx);
+    const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+    if (mode === "off") {
+      assert.equal(result, undefined);
+      assert.equal(statusWrites.at(-1), undefined);
+    } else {
+      assert.ok(result?.systemPrompt.startsWith(`BASE\n\nPONYTAIL MODE ACTIVE — level: ${mode}\n`), `expected ${mode} instructions`);
+      assert.ok(statusWrites.at(-1).includes(mode.toUpperCase()));
+    }
+  }
+
+  assert.deepEqual(appendedEntries, [], "navigation must not append a new mode entry");
+  assert.equal(notifications.length, notificationCount, "navigation must not repeat the startup toast");
+}));
+
+test("OMP session_switch and session_branch restore the target session's mode", async () => withTempConfig(async () => {
+  // OMP keeps the legacy Pi events instead of re-emitting session_start on /new, /resume, /fork and /branch.
+  const { events, appendedEntries } = createPiHarness();
+  const lite = { type: "custom", customType: "ponytail-mode", data: { mode: "lite" } };
+  const off = { type: "custom", customType: "ponytail-mode", data: { mode: "off" } };
+  let branch = [off];
+  const ctx = createCommandContext({ sessionManager: { getBranch: () => branch } });
+
+  await events.get("session_start")({ type: "session_start" }, ctx);
+  for (const [type, entries, mode] of [["session_switch", [lite], "lite"], ["session_branch", [off], "off"], ["session_switch", [], "full"]]) {
+    branch = entries;
+    await events.get(type)?.({ type }, ctx);
+    const result = await events.get("before_agent_start")({ systemPrompt: ["BASE"] }, ctx);
+    if (mode === "off") assert.equal(result, undefined, `${type} should restore off`);
+    else assert.ok(result?.systemPrompt.at(-1).startsWith(`PONYTAIL MODE ACTIVE — level: ${mode}\n`), `${type} should restore ${mode}`);
+  }
+  assert.deepEqual(appendedEntries, [], "restoring must not append a new mode entry");
+}));
+
+test("skill alias commands delegate to Pi skill commands", async () => {
+  const { commands, sentUserMessages } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await commands.get("ponytail-review").handler("", ctx);
+  await commands.get("ponytail-audit").handler("", ctx);
+  await commands.get("ponytail-debt").handler("", ctx);
+  await commands.get("ponytail-gain").handler("", ctx);
+  await commands.get("ponytail-help").handler("", ctx);
+
+  assert.deepEqual(sentUserMessages.map((entry) => entry.text), [
+    "/skill:ponytail-review",
+    "/skill:ponytail-audit",
+    "/skill:ponytail-debt",
+    "/skill:ponytail-gain",
+    "/skill:ponytail-help",
+  ]);
+});
+
+test("skill alias commands expand the skill and forward their arguments", async () => {
+  const { commands, sentUserMessages } = createPiHarness();
+
+  await commands.get("ponytail-review").handler("staged", createCommandContext());
+  await commands.get("ponytail-audit").handler("src/api", createCommandContext({ isIdle: () => false }));
+
+  assert.deepEqual(sentUserMessages, [
+    { text: "/skill:ponytail-review staged", options: { expandPromptTemplates: true } },
+    { text: "/skill:ponytail-audit src/api", options: { expandPromptTemplates: true, deliverAs: "followUp" } },
+  ]);
+});
+
+test("normal mode disables persistent instructions", async () => withTempConfig(async () => {
+  const { commands, events } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await commands.get("ponytail").handler("ultra", ctx);
+  await events.get("input")({ text: "normal mode", source: "interactive" }, ctx);
+
+  const disabled = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+  assert.equal(disabled, undefined);
+}));
+
+test("a request mentioning normal mode stays active", async () => withTempConfig(async () => {
+  const { commands, events } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await commands.get("ponytail").handler("ultra", ctx);
+  await events.get("input")({ text: "add a normal mode toggle next to dark mode", source: "interactive" }, ctx);
+
+  const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+  assert.match(result.systemPrompt, /PONYTAIL MODE ACTIVE/);
+}));
+
+test("status bar renders the mode and flips active on agent_start", async () => withTempConfig(async () => {
+  const { events } = createPiHarness();
+  const statusWrites = [];
+  const ctx = createCommandContext({
+    sessionManager: { getEntries: () => [{ type: "custom", customType: "ponytail-mode", data: { mode: "ultra" } }] },
+    ui: { notify() {}, setStatus: (key, text) => statusWrites.push({ key, text }), theme: { fg: (_color, text) => text } },
+  });
+
+  await events.get("session_start")({ reason: "resume" }, ctx);
+  await events.get("agent_start")({}, ctx);
+
+  assert.equal(statusWrites.at(-2).key, "ponytail");
+  assert.match(statusWrites.at(-2).text, /○.*ULTRA/);
+  assert.match(statusWrites.at(-1).text, /●.*ULTRA/);
+}));
+
+test("off mode clears the status bar entry", async () => withTempConfig(async () => {
+  const { events } = createPiHarness();
+  const statusWrites = [];
+  const ctx = createCommandContext({
+    sessionManager: { getEntries: () => [{ type: "custom", customType: "ponytail-mode", data: { mode: "off" } }] },
+    ui: { notify() {}, setStatus: (key, text) => statusWrites.push({ key, text }), theme: { fg: (_color, text) => text } },
+  });
+
+  await events.get("session_start")({ reason: "resume" }, ctx);
+
+  assert.deepEqual(statusWrites.at(-1), { key: "ponytail", text: undefined });
+}));
+
+test("status bar stays silent when ui lacks a theme", async () => withTempConfig(async () => {
+  const { events } = createPiHarness();
+  const calls = [];
+  const ctx = createCommandContext({
+    sessionManager: { getEntries: () => [{ type: "custom", customType: "ponytail-mode", data: { mode: "ultra" } }] },
+    ui: { notify() {}, setStatus: (_key, text) => calls.push(text) }, // setStatus present, theme absent
+  });
+
+  await events.get("session_start")({ reason: "resume" }, ctx);
+  await events.get("agent_start")({}, ctx);
+
+  assert.deepEqual(calls, []);
+}));
+
+test("PONYTAIL_HIDE_STATUS hides the indicator but keeps ponytail active (#324)", async () => withTempConfig(async () => {
+  process.env.PONYTAIL_HIDE_STATUS = "1";
+  const { events } = createPiHarness();
+  const statusWrites = [];
+  const ctx = createCommandContext({
+    sessionManager: { getEntries: () => [{ type: "custom", customType: "ponytail-mode", data: { mode: "ultra" } }] },
+    ui: { notify() {}, setStatus: (key, text) => statusWrites.push({ key, text }), theme: { fg: (_c, t) => t } },
+  });
+
+  await events.get("session_start")({ reason: "resume" }, ctx);
+  await events.get("agent_start")({}, ctx);
+  const injected = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+
+  assert.deepEqual(statusWrites, [], "status bar must not be drawn when hidden");
+  assert.match(injected.systemPrompt, /PONYTAIL MODE ACTIVE/, "ruleset must still inject while status is hidden");
+}));
+
+test("config.hideStatus hides the indicator but keeps ponytail active (#324)", async () => withTempConfig(async () => {
+  mkdirSync(join(process.env.XDG_CONFIG_HOME, "ponytail"), { recursive: true });
+  writeFileSync(join(process.env.XDG_CONFIG_HOME, "ponytail", "config.json"), JSON.stringify({ hideStatus: true }));
+  const { events } = createPiHarness();
+  const statusWrites = [];
+  const ctx = createCommandContext({
+    ui: { notify() {}, setStatus: (key, text) => statusWrites.push({ key, text }), theme: { fg: (_c, t) => t } },
+  });
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await events.get("agent_start")({}, ctx);
+  const injected = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+
+  assert.deepEqual(statusWrites, [], "config.hideStatus must suppress the status bar");
+  assert.match(injected.systemPrompt, /PONYTAIL MODE ACTIVE/, "ruleset must still inject while status is hidden");
+}));
+
+test("PONYTAIL_HIDE_STATUS=0 does not hide the indicator", async () => withTempConfig(async () => {
+  process.env.PONYTAIL_HIDE_STATUS = "0";
+  const { events } = createPiHarness();
+  const statusWrites = [];
+  const ctx = createCommandContext({
+    sessionManager: { getEntries: () => [{ type: "custom", customType: "ponytail-mode", data: { mode: "ultra" } }] },
+    ui: { notify() {}, setStatus: (key, text) => statusWrites.push({ key, text }), theme: { fg: (_c, t) => t } },
+  });
+
+  await events.get("session_start")({ reason: "resume" }, ctx);
+  await events.get("agent_start")({}, ctx);
+
+  assert.ok(statusWrites.length > 0, "0 must be treated as 'do not hide'");
+}));
+
+test("/ponytail autocompletes modes, commands and default <mode>", () => {
+  const { commands } = createPiHarness();
+  const complete = (prefix) => commands.get("ponytail").getArgumentCompletions(prefix);
+
+  assert.deepEqual(complete("").map((item) => item.value),
+    ["off", "lite", "full", "ultra", "status", "default off", "default lite", "default full", "default ultra"]);
+  assert.deepEqual(complete("fu").map((item) => item.value), ["full"]);
+  assert.deepEqual(complete("default ").map((item) => item.value), ["default off", "default lite", "default full", "default ultra"]);
+  assert.deepEqual(complete("default l").map((item) => item.value), ["default lite"]);
+  assert.deepEqual(complete("default").map((item) => item.value),
+    ["default off", "default lite", "default full", "default ultra"], "never a bare default: Enter would submit it without a mode");
+  assert.equal(complete("status x"), null, "no command takes a second word after status");
+  assert.equal(complete("lite x"), null);
+  assert.equal(complete("bogus"), null, "nothing matches an unknown prefix");
+  for (const { value } of complete("")) {
+    assert.notEqual(parsePonytailCommand(value).type, "invalid", `Enter on "${value}" must run a valid command`);
+  }
+});

package/pi-extension/test/helpers.test.js

@@ -0,0 +1,179 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import {
+  filterSkillBodyForMode,
+  parsePonytailCommand,
+  readDefaultMode,
+  readQuietStartup,
+  resolveSessionMode,
+  writeDefaultMode,
+} from "../index.js";
+
+test("parsePonytailCommand falls back to full when invoked bare and default is off", () => {
+  assert.deepEqual(parsePonytailCommand("", "off"), { type: "set-mode", mode: "full" });
+  // #639: when ponytail is already on, a bare command reports instead of resetting the level.
+  assert.deepEqual(parsePonytailCommand("", "full", "ultra"), { type: "status" });
+  assert.deepEqual(parsePonytailCommand("", "full", "off"), { type: "set-mode", mode: "full" });
+});
+
+test("parsePonytailCommand parses modes, status, and default subcommand", () => {
+  assert.deepEqual(parsePonytailCommand("ultra", "full"), { type: "set-mode", mode: "ultra" });
+  assert.deepEqual(parsePonytailCommand("status", "full"), { type: "status" });
+  assert.deepEqual(parsePonytailCommand("default lite", "full"), { type: "set-default", mode: "lite" });
+});
+
+test("parsePonytailCommand rejects review as a default (session-only mode, #377)", () => {
+  assert.deepEqual(parsePonytailCommand("default review", "full"), { type: "invalid", reason: "invalid-default-mode" });
+});
+
+test("resolveSessionMode still honors review as a session mode (not a default)", () => {
+  const entries = [{ type: "custom", customType: "ponytail-mode", data: { mode: "review" } }];
+  assert.equal(resolveSessionMode(entries, "full"), "review");
+});
+
+test("resolveSessionMode prefers latest persisted session mode", () => {
+  const entries = [
+    { type: "custom", customType: "ponytail-mode", data: { mode: "lite" } },
+    { type: "custom", customType: "ponytail-mode", data: { mode: "ultra" } },
+  ];
+
+  assert.equal(resolveSessionMode(entries, "full"), "ultra");
+});
+
+test("resolveSessionMode returns fallback when entries is not an array", () => {
+  assert.equal(resolveSessionMode(null, "ultra"), "ultra");
+  assert.equal(resolveSessionMode(undefined, "lite"), "lite");
+  assert.equal(resolveSessionMode({}, "full"), "full");
+  assert.equal(resolveSessionMode("not an array"), "full"); // DEFAULT_MODE fallback
+});
+
+test("readDefaultMode and writeDefaultMode use XDG config path", () => {
+  const tempDir = mkdtempSync(join(tmpdir(), "ponytail-config-"));
+  const previousXdg = process.env.XDG_CONFIG_HOME;
+  const previousDefault = process.env.PONYTAIL_DEFAULT_MODE;
+  const configPath = join(tempDir, "ponytail", "config.json");
+  process.env.XDG_CONFIG_HOME = tempDir;
+  delete process.env.PONYTAIL_DEFAULT_MODE;
+
+  try {
+    assert.equal(readDefaultMode(), "full");
+    assert.equal(writeDefaultMode("ultra"), "ultra");
+    assert.equal(readDefaultMode(), "ultra");
+    assert.ok(existsSync(configPath));
+    assert.deepEqual(JSON.parse(readFileSync(configPath, "utf8")), { defaultMode: "ultra" });
+  } finally {
+    if (previousXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+    else process.env.XDG_CONFIG_HOME = previousXdg;
+    if (previousDefault === undefined) delete process.env.PONYTAIL_DEFAULT_MODE;
+    else process.env.PONYTAIL_DEFAULT_MODE = previousDefault;
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("readDefaultMode trims and normalizes whitespace in env and config values", () => {
+  const tempDir = mkdtempSync(join(tmpdir(), "ponytail-default-normalize-"));
+  const previousXdg = process.env.XDG_CONFIG_HOME;
+  const previousDefault = process.env.PONYTAIL_DEFAULT_MODE;
+  const configDir = join(tempDir, "ponytail");
+  const configPath = join(configDir, "config.json");
+  mkdirSync(configDir, { recursive: true });
+  process.env.XDG_CONFIG_HOME = tempDir;
+  process.env.PONYTAIL_DEFAULT_MODE = "  FULL  ";
+  writeFileSync(configPath, JSON.stringify({ defaultMode: "\tultra\n" }), "utf8");
+
+  try {
+    assert.equal(readDefaultMode(), "full");
+    process.env.PONYTAIL_DEFAULT_MODE = "\n lite \r\n";
+    assert.equal(readDefaultMode(), "lite");
+    delete process.env.PONYTAIL_DEFAULT_MODE;
+    assert.equal(readDefaultMode(), "ultra");
+  } finally {
+    if (previousXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+    else process.env.XDG_CONFIG_HOME = previousXdg;
+    if (previousDefault === undefined) delete process.env.PONYTAIL_DEFAULT_MODE;
+    else process.env.PONYTAIL_DEFAULT_MODE = previousDefault;
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("readQuietStartup resolves env var, config file, and default in that order", () => {
+  const tempDir = mkdtempSync(join(tmpdir(), "ponytail-quiet-"));
+  const previousXdg = process.env.XDG_CONFIG_HOME;
+  const previousEnv = process.env.PONYTAIL_QUIET_STARTUP;
+  const configDir = join(tempDir, "ponytail");
+  const configPath = join(configDir, "config.json");
+  process.env.XDG_CONFIG_HOME = tempDir;
+  delete process.env.PONYTAIL_QUIET_STARTUP;
+
+  try {
+    // No env, no config -> default false (toast still shows)
+    assert.equal(readQuietStartup(), false);
+
+    // Config file true -> respected
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(configPath, JSON.stringify({ quietStartup: true }), "utf8");
+    assert.equal(readQuietStartup(), true);
+
+    // Env var overrides config
+    process.env.PONYTAIL_QUIET_STARTUP = "false";
+    assert.equal(readQuietStartup(), false);
+    process.env.PONYTAIL_QUIET_STARTUP = "1";
+    assert.equal(readQuietStartup(), true);
+  } finally {
+    if (previousXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+    else process.env.XDG_CONFIG_HOME = previousXdg;
+    if (previousEnv === undefined) delete process.env.PONYTAIL_QUIET_STARTUP;
+    else process.env.PONYTAIL_QUIET_STARTUP = previousEnv;
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("filterSkillBodyForMode keeps only requested intensity examples and rows", () => {
+  // Examples are quoted in the real SKILL.md (`- lite: "..."`) — match that
+  // shape here too; see the next test for why the quote is load-bearing.
+  const body = `---\nname: ponytail\n---\n| **lite** | keep lite |\n| **full** | keep full |\n| **ultra** | keep ultra |\n- lite: "Lite example"\n- full: "Full example"\n- ultra: "Ultra example"\nOther line`;
+
+  const filtered = filterSkillBodyForMode(body, "ultra");
+
+  assert.ok(!filtered.includes("keep lite"));
+  assert.ok(!filtered.includes("keep full"));
+  assert.ok(filtered.includes("keep ultra"));
+  assert.ok(!filtered.includes("Lite example"));
+  assert.ok(filtered.includes("Ultra example"));
+  assert.ok(filtered.includes("Other line"));
+});
+
+test("filterSkillBodyForMode does not drop a rule bullet whose label matches a mode name", () => {
+  // A rule bullet like "- Full: ..." has the same "label: text" shape as a
+  // worked example, but isn't one — it must survive in every mode. Only the
+  // quoted, `- lite: "..."`-style bullets are real per-mode examples.
+  const body = `- Full: do not confuse this rule label with the mode name.\n- Lite: same risk, this is a real rule bullet.\n- lite: "real worked example"\n- ultra: "real worked example"`;
+
+  const filtered = filterSkillBodyForMode(body, "ultra");
+
+  assert.ok(filtered.includes("Full: do not confuse"), "an unquoted rule bullet must not be treated as a mode example");
+  assert.ok(filtered.includes("Lite: same risk"), "an unquoted rule bullet must not be treated as a mode example");
+  assert.ok(!filtered.includes("- lite:"), "the real quoted lite example must still be filtered out in ultra mode");
+  assert.ok(filtered.includes('ultra: "real worked example"'));
+});
+
+test("filterSkillBodyForMode keeps rule bullets that contain a colon", () => {
+  // Regression: rule bullets outside the Intensity section (e.g. the
+  // "No unrequested abstractions:" rule or the `shortcut:` comment convention)
+  // contain a colon and must not be mistaken for mode-example lines.
+  const skillPath = new URL("../../skills/ponytail/SKILL.md", import.meta.url);
+  const body = readFileSync(skillPath, "utf8");
+
+  const filtered = filterSkillBodyForMode(body, "full");
+
+  assert.ok(filtered.includes("Bug fix: before you edit, grep every caller"));
+  assert.ok(filtered.includes("Never cut: validation at trust boundaries"));
+  assert.ok(filtered.includes("code comment in this form: `shortcut: <the limit>, <when to upgrade>`"));
+  // The level rows are still filtered down to the active mode.
+  assert.ok(filtered.includes("| **full** |"));
+  assert.ok(!filtered.includes("| **lite** |"));
+});

package/plugin.yaml

@@ -1,12 +1,21 @@
-name: chill-agent
-version: 1.2.0
-description: ChillAgent Anti-Slop 2.0 & Pragmatic Senior Dev Standard
-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/
+name: ponytail
+version: 1.6.0
+description: Lazy senior dev mode for Hermes Agent, always-on context, bundled skills, and slash commands.
+author: sann
+provides_hooks:
+  - pre_llm_call
+  - pre_gateway_dispatch
+provides_commands:
+  - ponytail
+  - ponytail-review
+  - ponytail-audit
+  - ponytail-debt
+  - ponytail-gain
+  - ponytail-help
+provides_skills:
+  - ponytail
+  - ponytail-review
+  - ponytail-audit
+  - ponytail-debt
+  - ponytail-gain
+  - ponytail-help

package/rules/antislop.mdc

@@ -0,0 +1,18 @@
+---
+description: Always-on antislop pointer for Cursor sessions. Loads the matching skills and saved usage mode.
+globs: **/*
+alwaysApply: true
+---
+
+<EXTREMELY_IMPORTANT>
+You use antislop (Anti Slop: Rules for AI Coding Agents). It is a filter, not a style guide: it stops generic AI slop in generated UI, copy, and code, without prescribing aesthetics.
+
+For UI, copy, people, mobile layout, or code comments work, load the matching antislop skill before starting. Each skill is a folder in this plugin's skills/ directory (read its SKILL.md):
+- Core filter, always on: skills/antislop/SKILL.md
+- UI / visual: skills/antislop-ui/SKILL.md
+- Copy & text: skills/antislop-copywriting/SKILL.md
+- People: skills/antislop-human/SKILL.md
+- Mobile / responsive: skills/antislop-layoutmobile/SKILL.md
+- Code comments: skills/antislop-code/SKILL.md
+Before starting, follow the core's "Two Usage Modes" section: explicit session instruction first, then global preference, then ask. For a resolved mode, announce `antislop active: <mode> (session override).` or `antislop active: <mode> (global preference).` once, using the actual mode and source. Ask only when no mode is resolved.
+</EXTREMELY_IMPORTANT>

package/scripts/build-openclaw-skills.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+// Generate the OpenClaw / ClawHub skill package (.openclaw/skills/) from the
+// canonical skills/. OpenClaw skills are SKILL.md (frontmatter + body), the same
+// format ponytail already uses, with one difference: `description` must be a
+// single line under 160 chars. The canonical descriptions are long (tuned for
+// Claude's skill picker), so each ships a short one here. The body is copied
+// verbatim from skills/<name>/SKILL.md so the ruleset never drifts; only the
+// frontmatter is rewritten.
+//
+// Run:  node scripts/build-openclaw-skills.js
+// tests/openclaw-skills.test.js fails if the committed copies are stale.
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..');
+const HOMEPAGE = 'https://github.com/DietrichGebert/ponytail';
+
+const DESCRIPTIONS = {
+  'ponytail': 'Lazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.',
+  'ponytail-review': 'Quality review of a diff: bugs, security, real load, missing tests, speed, and what to delete. Each finding says what goes wrong and how to fix it.',
+  'ponytail-audit': 'Quality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first.',
+  'ponytail-debt': 'Harvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.',
+  'ponytail-gain': 'Show ponytail measured impact as a scoreboard: less code, less cost, more speed, from the agentic benchmark averages. One-shot display.',
+  'ponytail-help': "Quick reference for ponytail's modes, skills, and commands. One-shot display.",
+};
+
+const NAMES = Object.keys(DESCRIPTIONS);
+
+function sourceBody(name) {
+  const src = fs.readFileSync(path.join(ROOT, 'skills', name, 'SKILL.md'), 'utf8').replace(/\r\n/g, '\n');
+  const fm = src.match(/^---\n[\s\S]*?\n---\n?/);
+  if (!fm) throw new Error(`skills/${name}/SKILL.md has no frontmatter`);
+  return src.slice(fm[0].length);
+}
+
+function render(name) {
+  const desc = DESCRIPTIONS[name];
+  if (desc.length > 160 || desc.includes('\n') || desc.includes('"')) {
+    throw new Error(`description for ${name} must be one line, no quotes, under 160 chars`);
+  }
+  const frontmatter =
+    `---\nname: ${name}\ndescription: "${desc}"\nhomepage: ${HOMEPAGE}\nlicense: MIT\n---\n`;
+  return frontmatter + sourceBody(name);
+}
+
+function outPath(name) {
+  return path.join(ROOT, '.openclaw', 'skills', name, 'SKILL.md');
+}
+
+module.exports = { DESCRIPTIONS, NAMES, render, outPath, sourceBody };
+
+if (require.main === module) {
+  for (const name of NAMES) {
+    const p = outPath(name);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, render(name));
+    console.log('wrote', path.relative(ROOT, p).replace(/\\/g, '/'));
+  }
+}